go-gost/gost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add tun/tap

Browse Source
This commit is contained in:
ginuerzh
2021-12-20 22:00:08 +08:00
parent a853d99d92
commit e21c35a47f
73 changed files with 1867 additions and 614 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
pkg/handler/forward/local/metadata.go
View File

@ -3,7 +3,7 @@ package local
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -11,13 +11,13 @@ type metadata struct {
retryCount int
}
func (h *forwardHandler) parseMetadata(md md.Metadata) (err error) {
func (h *forwardHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
readTimeout = "readTimeout"
retryCount = "retry"
)
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

8
pkg/handler/forward/remote/metadata.go
View File

@ -3,7 +3,7 @@ package remote
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -11,13 +11,13 @@ type metadata struct {
retryCount int
}
func (h *forwardHandler) parseMetadata(md md.Metadata) (err error) {
func (h *forwardHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
readTimeout = "readTimeout"
retryCount = "retry"
)
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

26
pkg/handler/forward/ssh/metadata.go
View File

@ -7,7 +7,7 @@ import (
"github.com/go-gost/gost/pkg/auth"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
ssh_util "github.com/go-gost/gost/pkg/internal/util/ssh"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
"golang.org/x/crypto/ssh"
)
@ -17,7 +17,7 @@ type metadata struct {
authorizedKeys map[string]bool
}
func (h *forwardHandler) parseMetadata(md md.Metadata) (err error) {
func (h *forwardHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
authorizedKeys = "authorizedKeys"
@ -25,28 +25,26 @@ func (h *forwardHandler) parseMetadata(md md.Metadata) (err error) {
passphrase = "passphrase"
)
if v, _ := md.Get(users).([]interface{}); len(v) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range v {
if s, _ := auth.(string); s != "" {
ss := strings.SplitN(s, ":", 2)
if len(ss) == 1 {
authenticator.Add(ss[0], "")
} else {
authenticator.Add(ss[0], ss[1])
}
for _, auth := range auths {
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
authenticator.Add(ss[0], "")
} else {
authenticator.Add(ss[0], ss[1])
}
}
h.md.authenticator = authenticator
}
if key := md.GetString(privateKeyFile); key != "" {
if key := mdata.GetString(md, privateKeyFile); key != "" {
data, err := ioutil.ReadFile(key)
if err != nil {
return err
}
pp := md.GetString(passphrase)
pp := mdata.GetString(md, passphrase)
if pp == "" {
h.md.signer, err = ssh.ParsePrivateKey(data)
} else {
@ -64,7 +62,7 @@ func (h *forwardHandler) parseMetadata(md md.Metadata) (err error) {
h.md.signer = signer
}
if name := md.GetString(authorizedKeys); name != "" {
if name := mdata.GetString(md, authorizedKeys); name != "" {
m, err := ssh_util.ParseAuthorizedKeysFile(name)
if err != nil {
return err

16
pkg/handler/http/metadata.go
View File

@ -28,7 +28,7 @@ func (h *httpHandler) parseMetadata(md mdata.Metadata) error {
enableUDP = "udp"
)
if auths := md.GetStrings(users); len(auths) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range auths {
ss := strings.SplitN(auth, ":", 2)
@ -41,26 +41,26 @@ func (h *httpHandler) parseMetadata(md mdata.Metadata) error {
h.md.authenticator = authenticator
}
if mm := mdata.GetStringMapString(md, header); len(mm) > 0 {
if m := mdata.GetStringMapString(md, header); len(m) > 0 {
hd := http.Header{}
for k, v := range mm {
for k, v := range m {
hd.Add(k, v)
}
h.md.header = hd
}
if v := md.GetString(probeResistKey); v != "" {
if v := mdata.GetString(md, probeResistKey); v != "" {
if ss := strings.SplitN(v, ":", 2); len(ss) == 2 {
h.md.probeResist = &probeResist{
Type: ss[0],
Value: ss[1],
Knock: md.GetString(knock),
Knock: mdata.GetString(md, knock),
}
}
}
h.md.retryCount = md.GetInt(retryCount)
h.md.sni = md.GetBool(sni)
h.md.enableUDP = md.GetBool(enableUDP)
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.sni = mdata.GetBool(md, sni)
h.md.enableUDP = mdata.GetBool(md, enableUDP)
return nil
}

18
pkg/handler/http2/metadata.go
View File

@ -4,7 +4,7 @@ import (
"strings"
"github.com/go-gost/gost/pkg/auth"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -16,7 +16,7 @@ type metadata struct {
enableUDP bool
}
func (h *http2Handler) parseMetadata(md md.Metadata) error {
func (h *http2Handler) parseMetadata(md mdata.Metadata) error {
const (
proxyAgent = "proxyAgent"
users = "users"
@ -27,9 +27,9 @@ func (h *http2Handler) parseMetadata(md md.Metadata) error {
enableUDP = "udp"
)
h.md.proxyAgent = md.GetString(proxyAgent)
h.md.proxyAgent = mdata.GetString(md, proxyAgent)
if auths := md.GetStrings(users); len(auths) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range auths {
ss := strings.SplitN(auth, ":", 2)
@ -42,18 +42,18 @@ func (h *http2Handler) parseMetadata(md md.Metadata) error {
h.md.authenticator = authenticator
}
if v := md.GetString(probeResistKey); v != "" {
if v := mdata.GetString(md, probeResistKey); v != "" {
if ss := strings.SplitN(v, ":", 2); len(ss) == 2 {
h.md.probeResist = &probeResist{
Type: ss[0],
Value: ss[1],
Knock: md.GetString(knock),
Knock: mdata.GetString(md, knock),
}
}
}
h.md.retryCount = md.GetInt(retryCount)
h.md.sni = md.GetBool(sni)
h.md.enableUDP = md.GetBool(enableUDP)
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.sni = mdata.GetBool(md, sni)
h.md.enableUDP = mdata.GetBool(md, enableUDP)
return nil
}

6
pkg/handler/redirect/metadata.go
View File

@ -1,18 +1,18 @@
package redirect
import (
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
retryCount int
}
func (h *redirectHandler) parseMetadata(md md.Metadata) (err error) {
func (h *redirectHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
retryCount = "retry"
)
h.md.retryCount = md.GetInt(retryCount)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

28
pkg/handler/relay/metadata.go
View File

@ -1,11 +1,12 @@
package relay
import (
"math"
"strings"
"time"
"github.com/go-gost/gost/pkg/auth"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -17,7 +18,7 @@ type metadata struct {
noDelay bool
}
func (h *relayHandler) parseMetadata(md md.Metadata) (err error) {
func (h *relayHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
readTimeout = "readTimeout"
@ -27,7 +28,7 @@ func (h *relayHandler) parseMetadata(md md.Metadata) (err error) {
noDelay = "nodelay"
)
if auths := md.GetStrings(users); len(auths) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range auths {
ss := strings.SplitN(auth, ":", 2)
@ -40,20 +41,15 @@ func (h *relayHandler) parseMetadata(md md.Metadata) (err error) {
h.md.authenticator = authenticator
}
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.enableBind = md.GetBool(enableBind)
h.md.noDelay = md.GetBool(noDelay)
h.md.udpBufferSize = md.GetInt(udpBufferSize)
if h.md.udpBufferSize > 0 {
if h.md.udpBufferSize < 512 {
h.md.udpBufferSize = 512 // min buffer size
}
if h.md.udpBufferSize > 65*1024 {
h.md.udpBufferSize = 65 * 1024 // max buffer size
}
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.enableBind = mdata.GetBool(md, enableBind)
h.md.noDelay = mdata.GetBool(md, noDelay)
if bs := mdata.GetInt(md, udpBufferSize); bs > 0 {
h.md.udpBufferSize = int(math.Min(math.Max(float64(bs), 512), 64*1024))
} else {
h.md.udpBufferSize = 1024 // default buffer size
h.md.udpBufferSize = 1024
}
return
}

8
pkg/handler/sni/metadata.go
View File

@ -3,7 +3,7 @@ package sni
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -11,13 +11,13 @@ type metadata struct {
retryCount int
}
func (h *sniHandler) parseMetadata(md md.Metadata) (err error) {
func (h *sniHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
readTimeout = "readTimeout"
retryCount = "retry"
)
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

16
pkg/handler/socks/v4/metadata.go
View File

@ -4,7 +4,7 @@ import (
"time"
"github.com/go-gost/gost/pkg/auth"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -13,24 +13,24 @@ type metadata struct {
retryCount int
}
func (h *socks4Handler) parseMetadata(md md.Metadata) (err error) {
func (h *socks4Handler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
readTimeout = "readTimeout"
retryCount = "retry"
)
if v, _ := md.Get(users).([]interface{}); len(v) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range v {
if v, _ := auth.(string); v != "" {
authenticator.Add(v, "")
for _, auth := range auths {
if auth != "" {
authenticator.Add(auth, "")
}
}
h.md.authenticator = authenticator
}
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

53
pkg/handler/socks/v5/metadata.go
View File

@ -2,12 +2,13 @@ package v5
import (
"crypto/tls"
"math"
"strings"
"time"
"github.com/go-gost/gost/pkg/auth"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
@ -23,7 +24,7 @@ type metadata struct {
compatibilityMode bool
}
func (h *socks5Handler) parseMetadata(md md.Metadata) (err error) {
func (h *socks5Handler) parseMetadata(md mdata.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
@ -40,49 +41,41 @@ func (h *socks5Handler) parseMetadata(md md.Metadata) (err error) {
)
h.md.tlsConfig, err = tls_util.LoadServerConfig(
md.GetString(certFile),
md.GetString(keyFile),
md.GetString(caFile),
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
if v, _ := md.Get(users).([]interface{}); len(v) > 0 {
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
authenticator := auth.NewLocalAuthenticator(nil)
for _, auth := range v {
if s, _ := auth.(string); s != "" {
ss := strings.SplitN(s, ":", 2)
if len(ss) == 1 {
authenticator.Add(ss[0], "")
} else {
authenticator.Add(ss[0], ss[1])
}
for _, auth := range auths {
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
authenticator.Add(ss[0], "")
} else {
authenticator.Add(ss[0], ss[1])
}
}
h.md.authenticator = authenticator
}
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.timeout = md.GetDuration(timeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.noTLS = md.GetBool(noTLS)
h.md.enableBind = md.GetBool(enableBind)
h.md.enableUDP = md.GetBool(enableUDP)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.timeout = mdata.GetDuration(md, timeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.noTLS = mdata.GetBool(md, noTLS)
h.md.enableBind = mdata.GetBool(md, enableBind)
h.md.enableUDP = mdata.GetBool(md, enableUDP)
h.md.udpBufferSize = md.GetInt(udpBufferSize)
if h.md.udpBufferSize > 0 {
if h.md.udpBufferSize < 512 {
h.md.udpBufferSize = 512 // min buffer size
}
if h.md.udpBufferSize > 65*1024 {
h.md.udpBufferSize = 65 * 1024 // max buffer size
}
if bs := mdata.GetInt(md, udpBufferSize); bs > 0 {
h.md.udpBufferSize = int(math.Min(math.Max(float64(bs), 512), 64*1024))
} else {
h.md.udpBufferSize = 1024 // default buffer size
h.md.udpBufferSize = 1024
}
h.md.compatibilityMode = md.GetBool(compatibilityMode)
h.md.compatibilityMode = mdata.GetBool(md, compatibilityMode)
return nil
}

6
pkg/handler/ss/handler.go
View File

@ -76,7 +76,7 @@ func (h *ssHandler) Handle(ctx context.Context, conn net.Conn) {
addr := &gosocks5.Addr{}
if _, err := addr.ReadFrom(conn); err != nil {
h.logger.Error(err)
h.discard(conn)
io.Copy(ioutil.Discard, conn)
return
}
@ -110,7 +110,3 @@ func (h *ssHandler) Handle(ctx context.Context, conn net.Conn) {
}).
Infof("%s >-< %s", conn.RemoteAddr(), addr)
}
func (h *ssHandler) discard(conn net.Conn) {
io.Copy(ioutil.Discard, conn)
}

28
pkg/handler/ss/metadata.go
View File

@ -5,7 +5,7 @@ import (
"time"
"github.com/go-gost/gost/pkg/common/util/ss"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
"github.com/shadowsocks/go-shadowsocks2/core"
)
@ -15,7 +15,7 @@ type metadata struct {
retryCount int
}
func (h *ssHandler) parseMetadata(md md.Metadata) (err error) {
func (h *ssHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
key = "key"
@ -24,26 +24,22 @@ func (h *ssHandler) parseMetadata(md md.Metadata) (err error) {
)
var method, password string
if v, _ := md.Get(users).([]interface{}); len(v) > 0 {
h.logger.Info(v)
for _, auth := range v {
if s, _ := auth.(string); s != "" {
ss := strings.SplitN(s, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
auth := auths[0]
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
h.md.cipher, err = ss.ShadowCipher(method, password, md.GetString(key))
h.md.cipher, err = ss.ShadowCipher(method, password, mdata.GetString(md, key))
if err != nil {
return
}
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
return
}

40
pkg/handler/ss/udp/metadata.go
View File

@ -1,11 +1,12 @@
package ss
import (
"math"
"strings"
"time"
"github.com/go-gost/gost/pkg/common/util/ss"
md "github.com/go-gost/gost/pkg/metadata"
mdata "github.com/go-gost/gost/pkg/metadata"
"github.com/shadowsocks/go-shadowsocks2/core"
)
@ -16,7 +17,7 @@ type metadata struct {
bufferSize int
}
func (h *ssuHandler) parseMetadata(md md.Metadata) (err error) {
func (h *ssuHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
key = "key"
@ -26,36 +27,27 @@ func (h *ssuHandler) parseMetadata(md md.Metadata) (err error) {
)
var method, password string
if v, _ := md.Get(users).([]interface{}); len(v) > 0 {
for _, auth := range v {
if s, _ := auth.(string); s != "" {
ss := strings.SplitN(s, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
auth := auths[0]
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
h.md.cipher, err = ss.ShadowCipher(method, password, md.GetString(key))
h.md.cipher, err = ss.ShadowCipher(method, password, mdata.GetString(md, key))
if err != nil {
return
}
h.md.readTimeout = md.GetDuration(readTimeout)
h.md.retryCount = md.GetInt(retryCount)
h.md.readTimeout = mdata.GetDuration(md, readTimeout)
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.bufferSize = md.GetInt(bufferSize)
if h.md.bufferSize > 0 {
if h.md.bufferSize < 512 {
h.md.bufferSize = 512 // min buffer size
}
if h.md.bufferSize > 65*1024 {
h.md.bufferSize = 65 * 1024 // max buffer size
}
if bs := mdata.GetInt(md, bufferSize); bs > 0 {
h.md.bufferSize = int(math.Min(math.Max(float64(bs), 512), 64*1024))
} else {
h.md.bufferSize = 1024 // default buffer size
h.md.bufferSize = 1024
}
return
}

17
pkg/handler/tap/conn.go Normal file
View File

@ -0,0 +1,17 @@
package tap
import "net"
type packetConn struct {
net.Conn
}
func (c *packetConn) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
n, err = c.Read(b)
addr = c.Conn.RemoteAddr()
return
}
func (c *packetConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return c.Write(b)
}

331
pkg/handler/tap/handler.go Normal file
View File

@ -0,0 +1,331 @@
package tap
import (
"context"
"fmt"
"io"
"net"
"os"
"sync"
"time"
"github.com/go-gost/gost/pkg/bypass"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/common/bufpool"
"github.com/go-gost/gost/pkg/handler"
tap_util "github.com/go-gost/gost/pkg/internal/util/tap"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
"github.com/go-gost/gost/pkg/registry"
"github.com/shadowsocks/go-shadowsocks2/shadowaead"
"github.com/songgao/water/waterutil"
"github.com/xtaci/tcpraw"
)
func init() {
registry.RegisterHandler("tap", NewHandler)
}
type tapHandler struct {
group *chain.NodeGroup
chain *chain.Chain
bypass bypass.Bypass
routes sync.Map
exit chan struct{}
logger logger.Logger
md metadata
}
func NewHandler(opts ...handler.Option) handler.Handler {
options := &handler.Options{}
for _, opt := range opts {
opt(options)
}
return &tapHandler{
bypass: options.Bypass,
exit: make(chan struct{}, 1),
logger: options.Logger,
}
}
func (h *tapHandler) Init(md md.Metadata) (err error) {
return h.parseMetadata(md)
}
// implements chain.Chainable interface
func (h *tapHandler) WithChain(chain *chain.Chain) {
h.chain = chain
}
// Forward implements handler.Forwarder.
func (h *tapHandler) Forward(group *chain.NodeGroup) {
h.group = group
}
func (h *tapHandler) Handle(ctx context.Context, conn net.Conn) {
defer os.Exit(0)
defer conn.Close()
cc, ok := conn.(*tap_util.Conn)
if !ok || cc.Config() == nil {
h.logger.Error("invalid connection")
return
}
start := time.Now()
h.logger = h.logger.WithFields(map[string]interface{}{
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
})
h.logger.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
defer func() {
h.logger.WithFields(map[string]interface{}{
"duration": time.Since(start),
}).Infof("%s >< %s", conn.RemoteAddr(), conn.LocalAddr())
}()
network := "udp"
var raddr net.Addr
var err error
target := h.group.Next()
if target != nil {
raddr, err = net.ResolveUDPAddr(network, target.Addr())
if err != nil {
h.logger.Error(err)
return
}
h.logger = h.logger.WithFields(map[string]interface{}{
"dst": fmt.Sprintf("%s/%s", raddr.String(), raddr.Network()),
})
h.logger.Infof("%s >> %s", conn.RemoteAddr(), target.Addr())
}
h.handleLoop(ctx, conn, raddr, cc.Config())
}
func (h *tapHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Addr, config *tap_util.Config) {
var tempDelay time.Duration
for {
err := func() error {
var err error
var pc net.PacketConn
// fake tcp mode will be ignored when the client specifies a chain.
if addr != nil && !h.chain.IsEmpty() {
r := (&chain.Router{}).
WithChain(h.chain).
WithRetry(h.md.retryCount).
WithLogger(h.logger)
cc, err := r.Dial(ctx, addr.Network(), addr.String())
if err != nil {
return err
}
pc = &packetConn{cc}
} else {
if h.md.tcpMode {
if addr != nil {
pc, err = tcpraw.Dial("tcp", addr.String())
} else {
pc, err = tcpraw.Listen("tcp", conn.LocalAddr().String())
}
} else {
laddr, _ := net.ResolveUDPAddr("udp", conn.LocalAddr().String())
pc, err = net.ListenUDP("udp", laddr)
}
}
if err != nil {
return err
}
if h.md.cipher != nil {
pc = h.md.cipher.PacketConn(pc)
}
return h.transport(conn, pc, addr)
}()
if err != nil {
h.logger.Error(err)
}
select {
case <-h.exit:
return
default:
}
if err != nil {
if tempDelay == 0 {
tempDelay = 1000 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 6 * time.Second; tempDelay > max {
tempDelay = max
}
time.Sleep(tempDelay)
continue
}
tempDelay = 0
}
}
func (h *tapHandler) transport(tap net.Conn, conn net.PacketConn, raddr net.Addr) error {
errc := make(chan error, 1)
go func() {
for {
err := func() error {
b := bufpool.Get(h.md.bufferSize)
defer bufpool.Put(b)
n, err := tap.Read(b)
if err != nil {
select {
case h.exit <- struct{}{}:
default:
}
return err
}
src := waterutil.MACSource(b[:n])
dst := waterutil.MACDestination(b[:n])
eType := etherType(waterutil.MACEthertype(b[:n]))
h.logger.Debugf("%s >> %s %s %d", src, dst, eType, n)
// client side, deliver frame directly.
if raddr != nil {
_, err := conn.WriteTo(b[:n], raddr)
return err
}
// server side, broadcast.
if waterutil.IsBroadcast(dst) {
go h.routes.Range(func(k, v interface{}) bool {
conn.WriteTo(b[:n], v.(net.Addr))
return true
})
return nil
}
var addr net.Addr
if v, ok := h.routes.Load(hwAddrToTapRouteKey(dst)); ok {
addr = v.(net.Addr)
}
if addr == nil {
h.logger.Warnf("no route for %s -> %s %s %d", src, dst, eType, n)
return nil
}
if _, err := conn.WriteTo(b[:n], addr); err != nil {
return err
}
return nil
}()
if err != nil {
errc <- err
return
}
}
}()
go func() {
for {
err := func() error {
b := bufpool.Get(h.md.bufferSize)
defer bufpool.Put(b)
n, addr, err := conn.ReadFrom(b)
if err != nil &&
err != shadowaead.ErrShortPacket {
return err
}
src := waterutil.MACSource(b[:n])
dst := waterutil.MACDestination(b[:n])
eType := etherType(waterutil.MACEthertype(b[:n]))
h.logger.Debugf("%s >> %s %s %d", src, dst, eType, n)
// client side, deliver frame to tap device.
if raddr != nil {
_, err := tap.Write(b[:n])
return err
}
// server side, record route.
rkey := hwAddrToTapRouteKey(src)
if actual, loaded := h.routes.LoadOrStore(rkey, addr); loaded {
if actual.(net.Addr).String() != addr.String() {
h.logger.Debugf("update route: %s -> %s (old %s)",
src, addr, actual.(net.Addr))
h.routes.Store(rkey, addr)
}
} else {
h.logger.Debugf("new route: %s -> %s", src, addr)
}
if waterutil.IsBroadcast(dst) {
go h.routes.Range(func(k, v interface{}) bool {
if k.(tapRouteKey) != rkey {
conn.WriteTo(b[:n], v.(net.Addr))
}
return true
})
}
if v, ok := h.routes.Load(hwAddrToTapRouteKey(dst)); ok {
h.logger.Debugf("find route: %s -> %s", dst, v)
_, err := conn.WriteTo(b[:n], v.(net.Addr))
return err
}
if _, err := tap.Write(b[:n]); err != nil {
select {
case h.exit <- struct{}{}:
default:
}
return err
}
return nil
}()
if err != nil {
errc <- err
return
}
}
}()
err := <-errc
if err != nil && err == io.EOF {
err = nil
}
return err
}
var mEtherTypes = map[waterutil.Ethertype]string{
waterutil.IPv4: "ip",
waterutil.ARP: "arp",
waterutil.RARP: "rarp",
waterutil.IPv6: "ip6",
}
func etherType(et waterutil.Ethertype) string {
if s, ok := mEtherTypes[et]; ok {
return s
}
return fmt.Sprintf("unknown(%v)", et)
}
type tapRouteKey [6]byte
func hwAddrToTapRouteKey(addr net.HardwareAddr) (key tapRouteKey) {
copy(key[:], addr)
return
}

50
pkg/handler/tap/metadata.go Normal file
View File

@ -0,0 +1,50 @@
package tap
import (
"strings"
"github.com/go-gost/gost/pkg/common/util/ss"
mdata "github.com/go-gost/gost/pkg/metadata"
"github.com/shadowsocks/go-shadowsocks2/core"
)
type metadata struct {
cipher core.Cipher
retryCount int
tcpMode bool
bufferSize int
}
func (h *tapHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
key = "key"
readTimeout = "readTimeout"
retryCount = "retry"
tcpMode = "tcp"
bufferSize = "bufferSize"
)
var method, password string
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
auth := auths[0]
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
h.md.cipher, err = ss.ShadowCipher(method, password, mdata.GetString(md, key))
if err != nil {
return
}
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.tcpMode = mdata.GetBool(md, tcpMode)
h.md.bufferSize = mdata.GetInt(md, bufferSize)
if h.md.bufferSize <= 0 {
h.md.bufferSize = 1024
}
return
}

17
pkg/handler/tun/conn.go Normal file
View File

@ -0,0 +1,17 @@
package tun
import "net"
type packetConn struct {
net.Conn
}
func (c *packetConn) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
n, err = c.Read(b)
addr = c.Conn.RemoteAddr()
return
}
func (c *packetConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return c.Write(b)
}

380
pkg/handler/tun/handler.go Normal file
View File

@ -0,0 +1,380 @@
package tun
import (
"context"
"fmt"
"io"
"net"
"os"
"sync"
"time"
"github.com/go-gost/gost/pkg/bypass"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/common/bufpool"
"github.com/go-gost/gost/pkg/handler"
tun_util "github.com/go-gost/gost/pkg/internal/util/tun"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
"github.com/go-gost/gost/pkg/registry"
"github.com/shadowsocks/go-shadowsocks2/shadowaead"
"github.com/songgao/water/waterutil"
"github.com/xtaci/tcpraw"
"golang.org/x/net/ipv4"
"golang.org/x/net/ipv6"
)
func init() {
registry.RegisterHandler("tun", NewHandler)
}
type tunHandler struct {
group *chain.NodeGroup
chain *chain.Chain
bypass bypass.Bypass
routes sync.Map
exit chan struct{}
logger logger.Logger
md metadata
}
func NewHandler(opts ...handler.Option) handler.Handler {
options := &handler.Options{}
for _, opt := range opts {
opt(options)
}
return &tunHandler{
bypass: options.Bypass,
exit: make(chan struct{}, 1),
logger: options.Logger,
}
}
func (h *tunHandler) Init(md md.Metadata) (err error) {
return h.parseMetadata(md)
}
// implements chain.Chainable interface
func (h *tunHandler) WithChain(chain *chain.Chain) {
h.chain = chain
}
// Forward implements handler.Forwarder.
func (h *tunHandler) Forward(group *chain.NodeGroup) {
h.group = group
}
func (h *tunHandler) Handle(ctx context.Context, conn net.Conn) {
defer os.Exit(0)
defer conn.Close()
cc, ok := conn.(*tun_util.Conn)
if !ok || cc.Config() == nil {
h.logger.Error("invalid connection")
return
}
start := time.Now()
h.logger = h.logger.WithFields(map[string]interface{}{
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
})
h.logger.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
defer func() {
h.logger.WithFields(map[string]interface{}{
"duration": time.Since(start),
}).Infof("%s >< %s", conn.RemoteAddr(), conn.LocalAddr())
}()
network := "udp"
var raddr net.Addr
var err error
target := h.group.Next()
if target != nil {
raddr, err = net.ResolveUDPAddr(network, target.Addr())
if err != nil {
h.logger.Error(err)
return
}
h.logger = h.logger.WithFields(map[string]interface{}{
"dst": fmt.Sprintf("%s/%s", raddr.String(), raddr.Network()),
})
h.logger.Infof("%s >> %s", conn.RemoteAddr(), target.Addr())
}
h.handleLoop(ctx, conn, raddr, cc.Config())
}
func (h *tunHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Addr, config *tun_util.Config) {
var tempDelay time.Duration
for {
err := func() error {
var err error
var pc net.PacketConn
// fake tcp mode will be ignored when the client specifies a chain.
if addr != nil && !h.chain.IsEmpty() {
r := (&chain.Router{}).
WithChain(h.chain).
WithRetry(h.md.retryCount).
WithLogger(h.logger)
cc, err := r.Dial(ctx, addr.Network(), addr.String())
if err != nil {
return err
}
pc = &packetConn{cc}
} else {
if h.md.tcpMode {
if addr != nil {
pc, err = tcpraw.Dial("tcp", addr.String())
} else {
pc, err = tcpraw.Listen("tcp", conn.LocalAddr().String())
}
} else {
laddr, _ := net.ResolveUDPAddr("udp", conn.LocalAddr().String())
pc, err = net.ListenUDP("udp", laddr)
}
}
if err != nil {
return err
}
if h.md.cipher != nil {
pc = h.md.cipher.PacketConn(pc)
}
return h.transport(conn, pc, addr)
}()
if err != nil {
h.logger.Error(err)
}
select {
case <-h.exit:
return
default:
}
if err != nil {
if tempDelay == 0 {
tempDelay = 1000 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 6 * time.Second; tempDelay > max {
tempDelay = max
}
time.Sleep(tempDelay)
continue
}
tempDelay = 0
}
}
func (h *tunHandler) transport(tun net.Conn, conn net.PacketConn, raddr net.Addr) error {
errc := make(chan error, 1)
go func() {
for {
err := func() error {
b := bufpool.Get(h.md.bufferSize)
defer bufpool.Put(b)
n, err := tun.Read(b)
if err != nil {
select {
case h.exit <- struct{}{}:
default:
}
return err
}
var src, dst net.IP
if waterutil.IsIPv4(b[:n]) {
header, err := ipv4.ParseHeader(b[:n])
if err != nil {
h.logger.Error(err)
return nil
}
h.logger.Debugf("%s >> %s %-4s %d/%-4d %-4x %d",
header.Src, header.Dst, ipProtocol(waterutil.IPv4Protocol(b[:n])),
header.Len, header.TotalLen, header.ID, header.Flags)
src, dst = header.Src, header.Dst
} else if waterutil.IsIPv6(b[:n]) {
header, err := ipv6.ParseHeader(b[:n])
if err != nil {
h.logger.Warn(err)
return nil
}
h.logger.Debugf("%s >> %s %s %d %d",
header.Src, header.Dst,
ipProtocol(waterutil.IPProtocol(header.NextHeader)),
header.PayloadLen, header.TrafficClass)
src, dst = header.Src, header.Dst
} else {
h.logger.Warn("unknown packet, discarded")
return nil
}
// client side, deliver packet directly.
if raddr != nil {
_, err := conn.WriteTo(b[:n], raddr)
return err
}
addr := h.findRouteFor(dst)
if addr == nil {
h.logger.Warnf("no route for %s -> %s", src, dst)
return nil
}
h.logger.Debugf("find route: %s -> %s", dst, addr)
if _, err := conn.WriteTo(b[:n], addr); err != nil {
return err
}
return nil
}()
if err != nil {
errc <- err
return
}
}
}()
go func() {
for {
err := func() error {
b := bufpool.Get(h.md.bufferSize)
defer bufpool.Put(b)
n, addr, err := conn.ReadFrom(b)
if err != nil &&
err != shadowaead.ErrShortPacket {
return err
}
var src, dst net.IP
if waterutil.IsIPv4(b[:n]) {
header, err := ipv4.ParseHeader(b[:n])
if err != nil {
h.logger.Warn(err)
return nil
}
h.logger.Debugf("%s >> %s %-4s %d/%-4d %-4x %d",
header.Src, header.Dst, ipProtocol(waterutil.IPv4Protocol(b[:n])),
header.Len, header.TotalLen, header.ID, header.Flags)
src, dst = header.Src, header.Dst
} else if waterutil.IsIPv6(b[:n]) {
header, err := ipv6.ParseHeader(b[:n])
if err != nil {
h.logger.Warn(err)
return nil
}
h.logger.Debugf("%s > %s %s %d %d",
header.Src, header.Dst,
ipProtocol(waterutil.IPProtocol(header.NextHeader)),
header.PayloadLen, header.TrafficClass)
src, dst = header.Src, header.Dst
} else {
h.logger.Warn("unknown packet, discarded")
return nil
}
// client side, deliver packet to tun device.
if raddr != nil {
_, err := tun.Write(b[:n])
return err
}
rkey := ipToTunRouteKey(src)
if actual, loaded := h.routes.LoadOrStore(rkey, addr); loaded {
if actual.(net.Addr).String() != addr.String() {
h.logger.Debugf("update route: %s -> %s (old %s)",
src, addr, actual.(net.Addr))
h.routes.Store(rkey, addr)
}
} else {
h.logger.Warnf("no route for %s -> %s", src, addr)
}
if addr := h.findRouteFor(dst); addr != nil {
h.logger.Debugf("find route: %s -> %s", dst, addr)
_, err := conn.WriteTo(b[:n], addr)
return err
}
if _, err := tun.Write(b[:n]); err != nil {
select {
case h.exit <- struct{}{}:
default:
}
return err
}
return nil
}()
if err != nil {
errc <- err
return
}
}
}()
err := <-errc
if err != nil && err == io.EOF {
err = nil
}
return err
}
func (h *tunHandler) findRouteFor(dst net.IP, routes ...tun_util.Route) net.Addr {
if v, ok := h.routes.Load(ipToTunRouteKey(dst)); ok {
return v.(net.Addr)
}
for _, route := range routes {
if route.Net.Contains(dst) && route.Gateway != nil {
if v, ok := h.routes.Load(ipToTunRouteKey(route.Gateway)); ok {
return v.(net.Addr)
}
}
}
return nil
}
var mIPProts = map[waterutil.IPProtocol]string{
waterutil.HOPOPT: "HOPOPT",
waterutil.ICMP: "ICMP",
waterutil.IGMP: "IGMP",
waterutil.GGP: "GGP",
waterutil.TCP: "TCP",
waterutil.UDP: "UDP",
waterutil.IPv6_Route: "IPv6-Route",
waterutil.IPv6_Frag: "IPv6-Frag",
waterutil.IPv6_ICMP: "IPv6-ICMP",
}
func ipProtocol(p waterutil.IPProtocol) string {
if v, ok := mIPProts[p]; ok {
return v
}
return fmt.Sprintf("unknown(%d)", p)
}
type tunRouteKey [16]byte
func ipToTunRouteKey(ip net.IP) (key tunRouteKey) {
copy(key[:], ip.To16())
return
}

50
pkg/handler/tun/metadata.go Normal file
View File

@ -0,0 +1,50 @@
package tun
import (
"strings"
"github.com/go-gost/gost/pkg/common/util/ss"
mdata "github.com/go-gost/gost/pkg/metadata"
"github.com/shadowsocks/go-shadowsocks2/core"
)
type metadata struct {
cipher core.Cipher
retryCount int
tcpMode bool
bufferSize int
}
func (h *tunHandler) parseMetadata(md mdata.Metadata) (err error) {
const (
users = "users"
key = "key"
readTimeout = "readTimeout"
retryCount = "retry"
tcpMode = "tcp"
bufferSize = "bufferSize"
)
var method, password string
if auths := mdata.GetStrings(md, users); len(auths) > 0 {
auth := auths[0]
ss := strings.SplitN(auth, ":", 2)
if len(ss) == 1 {
method = ss[0]
} else {
method, password = ss[0], ss[1]
}
}
h.md.cipher, err = ss.ShadowCipher(method, password, mdata.GetString(md, key))
if err != nil {
return
}
h.md.retryCount = mdata.GetInt(md, retryCount)
h.md.tcpMode = mdata.GetBool(md, tcpMode)
h.md.bufferSize = mdata.GetInt(md, bufferSize)
if h.md.bufferSize <= 0 {
h.md.bufferSize = 1024
}
return
}