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

add ssu connector

Browse Source
This commit is contained in:
ginuerzh
2021-11-09 23:34:19 +08:00
parent 92dc87830f
commit cae199dbd9
29 changed files with 1031 additions and 678 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
pkg/connector/http/connector.go
View File

@ -43,6 +43,21 @@ func (c *httpConnector) Init(md md.Metadata) (err error) {
}
func (c *httpConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
c.logger = c.logger.WithFields(map[string]interface{}{
"local": conn.LocalAddr().String(),
"remote": conn.RemoteAddr().String(),
"network": network,
"address": address,
})
switch network {
case "tcp", "tcp4", "tcp6":
default:
err := fmt.Errorf("network %s unsupported, should be tcp, tcp4 or tcp6", network)
c.logger.Error(err)
return nil, err
}
req := &http.Request{
Method: http.MethodConnect,
URL: &url.URL{Host: address},
@ -56,11 +71,6 @@ func (c *httpConnector) Connect(ctx context.Context, conn net.Conn, network, add
}
req.Header.Set("Proxy-Connection", "keep-alive")
c.logger = c.logger.WithFields(map[string]interface{}{
"local": conn.LocalAddr().String(),
"remote": conn.RemoteAddr().String(),
"target": address,
})
c.logger.Infof("connect: ", address)
if user := c.md.User; user != nil {

25
pkg/connector/socks/v4/connector.go
View File

@ -42,10 +42,20 @@ func (c *socks4Connector) Init(md md.Metadata) (err error) {
func (c *socks4Connector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
c.logger = c.logger.WithFields(map[string]interface{}{
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
"target": address,
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
"network": network,
"address": address,
})
switch network {
case "tcp", "tcp4", "tcp6":
default:
err := fmt.Errorf("network %s unsupported, should be tcp, tcp4 or tcp6", network)
c.logger.Error(err)
return nil, err
}
c.logger.Info("connect: ", address)
var addr *gosocks4.Addr
@ -87,19 +97,14 @@ func (c *socks4Connector) Connect(ctx context.Context, conn net.Conn, network, a
c.logger.Error(err)
return nil, err
}
if c.logger.IsLevelEnabled(logger.DebugLevel) {
c.logger.Debug(req)
}
c.logger.Debug(req)
reply, err := gosocks4.ReadReply(conn)
if err != nil {
c.logger.Error(err)
return nil, err
}
if c.logger.IsLevelEnabled(logger.DebugLevel) {
c.logger.Debug(reply)
}
c.logger.Debug(reply)
if reply.Code != gosocks4.Granted {
return nil, fmt.Errorf("error: %d", reply.Code)

30
pkg/connector/socks/v5/connector.go
View File

@ -4,6 +4,7 @@ import (
"context"
"crypto/tls"
"errors"
"fmt"
"net"
"net/url"
"strings"
@ -79,6 +80,7 @@ func (c *socks5Connector) Handshake(ctx context.Context, conn net.Conn) (net.Con
cc := gosocks5.ClientConn(conn, c.selector)
if err := cc.Handleshake(); err != nil {
c.logger.Error(err)
return nil, err
}
@ -87,12 +89,22 @@ func (c *socks5Connector) Handshake(ctx context.Context, conn net.Conn) (net.Con
func (c *socks5Connector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
c.logger = c.logger.WithFields(map[string]interface{}{
"target": address,
"network": network,
"address": address,
})
switch network {
case "tcp", "tcp4", "tcp6":
default:
err := fmt.Errorf("network %s unsupported, should be tcp, tcp4 or tcp6", network)
c.logger.Error(err)
return nil, err
}
c.logger.Info("connect: ", address)
addr, err := gosocks5.NewAddr(address)
if err != nil {
addr := gosocks5.Addr{}
if err := addr.ParseFrom(address); err != nil {
c.logger.Error(err)
return nil, err
}
@ -102,25 +114,19 @@ func (c *socks5Connector) Connect(ctx context.Context, conn net.Conn, network, a
defer conn.SetDeadline(time.Time{})
}
req := gosocks5.NewRequest(gosocks5.CmdConnect, addr)
req := gosocks5.NewRequest(gosocks5.CmdConnect, &addr)
if err := req.Write(conn); err != nil {
c.logger.Error(err)
return nil, err
}
if c.logger.IsLevelEnabled(logger.DebugLevel) {
c.logger.Debug(req)
}
c.logger.Debug(req)
reply, err := gosocks5.ReadReply(conn)
if err != nil {
c.logger.Error(err)
return nil, err
}
if c.logger.IsLevelEnabled(logger.DebugLevel) {
c.logger.Debug(reply)
}
c.logger.Debug(reply)
if reply.Rep != gosocks5.Succeeded {
return nil, errors.New("service unavailable")

16
pkg/connector/socks/v5/selector.go
View File

@ -18,9 +18,7 @@ type clientSelector struct {
}
func (s *clientSelector) Methods() []uint8 {
if s.logger.IsLevelEnabled(logger.DebugLevel) {
s.logger.Debug("methods: ", s.methods)
}
s.logger.Debug("methods: ", s.methods)
return s.methods
}
@ -33,9 +31,7 @@ func (s *clientSelector) Select(methods ...uint8) (method uint8) {
}
func (s *clientSelector) OnSelected(method uint8, conn net.Conn) (net.Conn, error) {
if s.logger.IsLevelEnabled(logger.DebugLevel) {
s.logger.Debug("method selected: ", method)
}
s.logger.Debug("method selected: ", method)
switch method {
case socks.MethodTLS:
@ -57,18 +53,14 @@ func (s *clientSelector) OnSelected(method uint8, conn net.Conn) (net.Conn, erro
s.logger.Error(err)
return nil, err
}
if s.logger.IsLevelEnabled(logger.DebugLevel) {
s.logger.Debug(req)
}
s.logger.Debug(req)
resp, err := gosocks5.ReadUserPassResponse(conn)
if err != nil {
s.logger.Error(err)
return nil, err
}
if s.logger.IsLevelEnabled(logger.DebugLevel) {
s.logger.Debug(resp)
}
s.logger.Debug(resp)
if resp.Status != gosocks5.Succeeded {
return nil, gosocks5.ErrAuthFailure

24
pkg/connector/ss/connector.go
View File

@ -2,6 +2,7 @@ package ss
import (
"context"
"fmt"
"net"
"time"
@ -40,21 +41,30 @@ func (c *ssConnector) Init(md md.Metadata) (err error) {
func (c *ssConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
c.logger = c.logger.WithFields(map[string]interface{}{
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
"target": address,
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
"network": network,
"address": address,
})
switch network {
case "tcp", "tcp4", "tcp6":
default:
err := fmt.Errorf("network %s unsupported, should be tcp, tcp4 or tcp6", network)
c.logger.Error(err)
return nil, err
}
c.logger.Infof("connect: ", address)
socksAddr, err := gosocks5.NewAddr(address)
if err != nil {
c.logger.Error("parse addr: ", err)
addr := gosocks5.Addr{}
if err := addr.ParseFrom(address); err != nil {
c.logger.Error(err)
return nil, err
}
rawaddr := bufpool.Get(512)
defer bufpool.Put(rawaddr)
n, err := socksAddr.Encode(rawaddr)
n, err := addr.Encode(rawaddr)
if err != nil {
c.logger.Error("encoding addr: ", err)
return nil, err

105
pkg/connector/ssu/connector.go Normal file
View File

@ -0,0 +1,105 @@
package ssu
import (
"context"
"fmt"
"net"
"time"
"github.com/go-gost/gost/pkg/connector"
"github.com/go-gost/gost/pkg/internal/utils/socks"
"github.com/go-gost/gost/pkg/internal/utils/ss"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
"github.com/go-gost/gost/pkg/registry"
)
func init() {
registry.RegiserConnector("ssu", NewConnector)
}
type ssuConnector struct {
md metadata
logger logger.Logger
}
func NewConnector(opts ...connector.Option) connector.Connector {
options := &connector.Options{}
for _, opt := range opts {
opt(options)
}
return &ssuConnector{
logger: options.Logger,
}
}
func (c *ssuConnector) Init(md md.Metadata) (err error) {
return c.parseMetadata(md)
}
func (c *ssuConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
c.logger = c.logger.WithFields(map[string]interface{}{
"remote": conn.RemoteAddr().String(),
"local": conn.LocalAddr().String(),
"network": network,
"address": address,
})
switch network {
case "udp", "udp4", "udp6":
default:
err := fmt.Errorf("network %s unsupported, should be udp, udp4 or udp6", network)
c.logger.Error(err)
return nil, err
}
c.logger.Info("connect: ", address)
if c.md.connectTimeout > 0 {
conn.SetDeadline(time.Now().Add(c.md.connectTimeout))
defer conn.SetDeadline(time.Time{})
}
taddr, _ := net.ResolveUDPAddr(network, address)
if taddr == nil {
taddr = &net.UDPAddr{}
}
pc, ok := conn.(net.PacketConn)
if ok {
if c.md.cipher != nil {
pc = c.md.cipher.PacketConn(pc)
}
return ss.UDPClientConn(pc, conn.RemoteAddr(), taddr, c.md.bufferSize), nil
}
return socks.UDPTunClientConn(conn, taddr), nil
}
func (c *ssuConnector) parseMetadata(md md.Metadata) (err error) {
c.md.cipher, err = ss.ShadowCipher(
md.GetString(method),
md.GetString(password),
md.GetString(key),
)
if err != nil {
return
}
c.md.connectTimeout = md.GetDuration(connectTimeout)
c.md.bufferSize = md.GetInt(bufferSize)
if c.md.bufferSize > 0 {
if c.md.bufferSize < 512 {
c.md.bufferSize = 512
}
if c.md.bufferSize > 65*1024 {
c.md.bufferSize = 65 * 1024
}
} else {
c.md.bufferSize = 4096
}
return
}

21
pkg/connector/ssu/metadata.go Normal file
View File

@ -0,0 +1,21 @@
package ssu
import (
"time"
"github.com/shadowsocks/go-shadowsocks2/core"
)
const (
method = "method"
password = "password"
key = "key"
connectTimeout = "timeout"
bufferSize = "bufferSize"
)
type metadata struct {
cipher core.Cipher
connectTimeout time.Duration
bufferSize int
}