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

add mtls dialer

Browse Source
This commit is contained in:
ginuerzh 2021-12-17 11:02:39 +08:00
parent 965c6846dd
commit bfe5eae172
21 changed files with 457 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/gost/register.go
View File

@ -21,6 +21,8 @@ import (
_ "github.com/go-gost/gost/pkg/dialer/obfs/tls"
_ "github.com/go-gost/gost/pkg/dialer/quic"
_ "github.com/go-gost/gost/pkg/dialer/tcp"
_ "github.com/go-gost/gost/pkg/dialer/tls"
_ "github.com/go-gost/gost/pkg/dialer/tls/mux"
_ "github.com/go-gost/gost/pkg/dialer/udp"
// Register handlers

2
go.mod
View File

@ -44,7 +44,7 @@ require (
github.com/templexxx/xorsimd v0.4.1 // indirect
github.com/tjfoc/gmsm v1.3.2 // indirect
github.com/xtaci/kcp-go/v5 v5.6.1
github.com/xtaci/smux v1.5.15
github.com/xtaci/smux v1.5.16
github.com/xtaci/tcpraw v1.2.25
golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
golang.org/x/mod v0.4.2 // indirect

2
go.sum
View File

@ -399,6 +399,8 @@ github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae h1:J0GxkO96kL4WF+A
github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae/go.mod h1:gXtu8J62kEgmN++bm9BVICuT/e8yiLI2KFobd/TRFsE=
github.com/xtaci/smux v1.5.15 h1:6hMiXswcleXj5oNfcJc+DXS8Vj36XX2LaX98udog6Kc=
github.com/xtaci/smux v1.5.15/go.mod h1:OMlQbT5vcgl2gb49mFkYo6SMf+zP3rcjcwQz7ZU7IGY=
github.com/xtaci/smux v1.5.16 h1:FBPYOkW8ZTjLKUM4LI4xnnuuDC8CQ/dB04HD519WoEk=
github.com/xtaci/smux v1.5.16/go.mod h1:OMlQbT5vcgl2gb49mFkYo6SMf+zP3rcjcwQz7ZU7IGY=
github.com/xtaci/tcpraw v1.2.25 h1:VDlqo0op17JeXBM6e2G9ocCNLOJcw9mZbobMbJjo0vk=
github.com/xtaci/tcpraw v1.2.25/go.mod h1:dKyZ2V75s0cZ7cbgJYdxPvms7af0joIeOyx1GgJQbLk=
github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

2
pkg/chain/chain.go
View File

@ -31,7 +31,7 @@ func (c *Chain) GetRouteFor(network, address string) (r *Route) {
break
}
if node.transport.IsMultiplex() {
if node.transport.Multiplex() {
tr := node.transport.Copy().
WithRoute(r)
node = node.Copy().

4
pkg/chain/transport.go
View File

@ -75,9 +75,9 @@ func (tr *Transport) Bind(ctx context.Context, conn net.Conn, network, address s
return nil, connector.ErrBindUnsupported
}
func (tr *Transport) IsMultiplex() bool {
func (tr *Transport) Multiplex() bool {
if mux, ok := tr.dialer.(dialer.Multiplexer); ok {
return mux.IsMultiplex()
return mux.Multiplex()
}
return false
}

2
pkg/dialer/dialer.go
View File

@ -18,5 +18,5 @@ type Handshaker interface {
}
type Multiplexer interface {
IsMultiplex() bool
Multiplex() bool
}

4
pkg/dialer/http2/dialer.go
View File

@ -45,8 +45,8 @@ func (d *http2Dialer) Init(md md.Metadata) (err error) {
return nil
}
// IsMultiplex implements dialer.Multiplexer interface.
func (d *http2Dialer) IsMultiplex() bool {
// Multiplex implements dialer.Multiplexer interface.
func (d *http2Dialer) Multiplex() bool {
return true
}

4
pkg/dialer/http2/h2/dialer.go
View File

@ -65,8 +65,8 @@ func (d *h2Dialer) Init(md md.Metadata) (err error) {
return nil
}
// IsMultiplex implements dialer.Multiplexer interface.
func (d *h2Dialer) IsMultiplex() bool {
// Multiplex implements dialer.Multiplexer interface.
func (d *h2Dialer) Multiplex() bool {
return true
}

11
pkg/dialer/kcp/dialer.go
View File

@ -50,8 +50,8 @@ func (d *kcpDialer) Init(md md.Metadata) (err error) {
return nil
}
// IsMultiplex implements dialer.Multiplexer interface.
func (d *kcpDialer) IsMultiplex() bool {
// Multiplex implements dialer.Multiplexer interface.
func (d *kcpDialer) Multiplex() bool {
return true
}
@ -103,7 +103,6 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia
for _, option := range options {
option(opts)
}
config := d.md.config
d.sessionMutex.Lock()
defer d.sessionMutex.Unlock()
@ -120,7 +119,7 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia
}
if !ok || session.session == nil {
s, err := d.initSession(opts.Addr, conn, config)
s, err := d.initSession(ctx, opts.Addr, conn)
if err != nil {
d.logger.Error(err)
conn.Close()
@ -140,12 +139,14 @@ func (d *kcpDialer) Handshake(ctx context.Context, conn net.Conn, options ...dia
return cc, nil
}
func (d *kcpDialer) initSession(addr string, conn net.Conn, config *kcp_util.Config) (*muxSession, error) {
func (d *kcpDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*muxSession, error) {
pc, ok := conn.(net.PacketConn)
if !ok {
return nil, errors.New("kcp: wrong connection type")
}
config := d.md.config
kcpconn, err := kcp.NewConn(addr,
kcp_util.BlockCrypt(config.Key, config.Crypt, kcp_util.DefaultSalt),
config.DataShard, config.ParityShard, pc)

4
pkg/dialer/quic/dialer.go
View File

@ -46,8 +46,8 @@ func (d *quicDialer) Init(md md.Metadata) (err error) {
return nil
}
// IsMultiplex implements dialer.Multiplexer interface.
func (d *quicDialer) IsMultiplex() bool {
// Multiplex implements dialer.Multiplexer interface.
func (d *quicDialer) Multiplex() bool {
return true
}

67
pkg/dialer/tls/dialer.go Normal file
View File

@ -0,0 +1,67 @@
package tls
import (
"context"
"crypto/tls"
"net"
"time"
"github.com/go-gost/gost/pkg/dialer"
"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.RegisterDialer("tls", NewDialer)
}
type tlsDialer struct {
md metadata
logger logger.Logger
}
func NewDialer(opts ...dialer.Option) dialer.Dialer {
options := &dialer.Options{}
for _, opt := range opts {
opt(options)
}
return &tlsDialer{
logger: options.Logger,
}
}
func (d *tlsDialer) Init(md md.Metadata) (err error) {
return d.parseMetadata(md)
}
func (d *tlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (net.Conn, error) {
var options dialer.DialOptions
for _, opt := range opts {
opt(&options)
}
var netd net.Dialer
conn, err := netd.DialContext(ctx, "tcp", addr)
if err != nil {
d.logger.Error(err)
}
return conn, err
}
// Handshake implements dialer.Handshaker
func (d *tlsDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
if d.md.handshakeTimeout > 0 {
conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
defer conn.SetDeadline(time.Time{})
}
tlsConn := tls.Client(conn, d.md.tlsConfig)
if err := tlsConn.HandshakeContext(ctx); err != nil {
conn.Close()
return nil, err
}
return tlsConn, nil
}

43
pkg/dialer/tls/metadata.go Normal file
View File

@ -0,0 +1,43 @@
package tls
import (
"crypto/tls"
"net"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
md "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
tlsConfig *tls.Config
handshakeTimeout time.Duration
}
func (d *tlsDialer) parseMetadata(md md.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
secure = "secure"
serverName = "serverName"
handshakeTimeout = "handshakeTimeout"
)
sn, _, _ := net.SplitHostPort(md.GetString(serverName))
if sn == "" {
sn = "localhost"
}
d.md.tlsConfig, err = tls_util.LoadClientConfig(
md.GetString(certFile),
md.GetString(keyFile),
md.GetString(caFile),
md.GetBool(secure),
sn,
)
d.md.handshakeTimeout = md.GetDuration(handshakeTimeout)
return
}

38
pkg/dialer/tls/mux/conn.go Normal file
View File

@ -0,0 +1,38 @@
package mux
import (
"net"
"github.com/xtaci/smux"
)
type muxSession struct {
conn net.Conn
session *smux.Session
}
func (session *muxSession) GetConn() (net.Conn, error) {
return session.session.OpenStream()
}
func (session *muxSession) Accept() (net.Conn, error) {
return session.session.AcceptStream()
}
func (session *muxSession) Close() error {
if session.session == nil {
return nil
}
return session.session.Close()
}
func (session *muxSession) IsClosed() bool {
if session.session == nil {
return true
}
return session.session.IsClosed()
}
func (session *muxSession) NumStreams() int {
return session.session.NumStreams()
}

182
pkg/dialer/tls/mux/dialer.go Normal file
View File

@ -0,0 +1,182 @@
package mux
import (
"context"
"crypto/tls"
"errors"
"net"
"sync"
"time"
"github.com/go-gost/gost/pkg/dialer"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
"github.com/go-gost/gost/pkg/registry"
"github.com/xtaci/smux"
)
func init() {
registry.RegisterDialer("mtls", NewDialer)
}
type mtlsDialer struct {
sessions map[string]*muxSession
sessionMutex sync.Mutex
logger logger.Logger
md metadata
}
func NewDialer(opts ...dialer.Option) dialer.Dialer {
options := &dialer.Options{}
for _, opt := range opts {
opt(options)
}
return &mtlsDialer{
sessions: make(map[string]*muxSession),
logger: options.Logger,
}
}
func (d *mtlsDialer) Init(md md.Metadata) (err error) {
if err = d.parseMetadata(md); err != nil {
return
}
return nil
}
// Multiplex implements dialer.Multiplexer interface.
func (d *mtlsDialer) Multiplex() bool {
return true
}
func (d *mtlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) {
var options dialer.DialOptions
for _, opt := range opts {
opt(&options)
}
d.sessionMutex.Lock()
defer d.sessionMutex.Unlock()
session, ok := d.sessions[addr]
if session != nil && session.IsClosed() {
delete(d.sessions, addr) // session is dead
ok = false
}
if !ok {
conn, err = d.dial(ctx, "tcp", addr, &options)
if err != nil {
return
}
session = &muxSession{conn: conn}
d.sessions[addr] = session
}
return session.conn, err
}
// Handshake implements dialer.Handshaker
func (d *mtlsDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
opts := &dialer.HandshakeOptions{}
for _, option := range options {
option(opts)
}
d.sessionMutex.Lock()
defer d.sessionMutex.Unlock()
if d.md.handshakeTimeout > 0 {
conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
defer conn.SetDeadline(time.Time{})
}
session, ok := d.sessions[opts.Addr]
if session != nil && session.conn != conn {
conn.Close()
return nil, errors.New("mtls: unrecognized connection")
}
if !ok || session.session == nil {
s, err := d.initSession(ctx, conn)
if err != nil {
d.logger.Error(err)
conn.Close()
delete(d.sessions, opts.Addr)
return nil, err
}
session = s
d.sessions[opts.Addr] = session
}
cc, err := session.GetConn()
if err != nil {
session.Close()
delete(d.sessions, opts.Addr)
return nil, err
}
return cc, nil
}
func (d *mtlsDialer) dial(ctx context.Context, network, addr string, opts *dialer.DialOptions) (net.Conn, error) {
dial := opts.DialFunc
if dial != nil {
conn, err := dial(ctx, addr)
if err != nil {
d.logger.Error(err)
} else {
d.logger.WithFields(map[string]interface{}{
"src": conn.LocalAddr().String(),
"dst": addr,
}).Debug("dial with dial func")
}
return conn, err
}
var netd net.Dialer
conn, err := netd.DialContext(ctx, network, addr)
if err != nil {
d.logger.Error(err)
} else {
d.logger.WithFields(map[string]interface{}{
"src": conn.LocalAddr().String(),
"dst": addr,
}).Debugf("dial direct %s/%s", addr, network)
}
return conn, err
}
func (d *mtlsDialer) initSession(ctx context.Context, conn net.Conn) (*muxSession, error) {
tlsConn := tls.Client(conn, d.md.tlsConfig)
if err := tlsConn.HandshakeContext(ctx); err != nil {
return nil, err
}
conn = tlsConn
// stream multiplex
smuxConfig := smux.DefaultConfig()
smuxConfig.KeepAliveDisabled = d.md.muxKeepAliveDisabled
if d.md.muxKeepAliveInterval > 0 {
smuxConfig.KeepAliveInterval = d.md.muxKeepAliveInterval
}
if d.md.muxKeepAliveTimeout > 0 {
smuxConfig.KeepAliveTimeout = d.md.muxKeepAliveTimeout
}
if d.md.muxMaxFrameSize > 0 {
smuxConfig.MaxFrameSize = d.md.muxMaxFrameSize
}
if d.md.muxMaxReceiveBuffer > 0 {
smuxConfig.MaxReceiveBuffer = d.md.muxMaxReceiveBuffer
}
if d.md.muxMaxStreamBuffer > 0 {
smuxConfig.MaxStreamBuffer = d.md.muxMaxStreamBuffer
}
session, err := smux.Client(conn, smuxConfig)
if err != nil {
return nil, err
}
return &muxSession{conn: conn, session: session}, nil
}

63
pkg/dialer/tls/mux/metadata.go Normal file
View File

@ -0,0 +1,63 @@
package mux
import (
"crypto/tls"
"net"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
md "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
tlsConfig *tls.Config
handshakeTimeout time.Duration
muxKeepAliveDisabled bool
muxKeepAliveInterval time.Duration
muxKeepAliveTimeout time.Duration
muxMaxFrameSize int
muxMaxReceiveBuffer int
muxMaxStreamBuffer int
}
func (d *mtlsDialer) parseMetadata(md md.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
secure = "secure"
serverName = "serverName"
handshakeTimeout = "handshakeTimeout"
muxKeepAliveDisabled = "muxKeepAliveDisabled"
muxKeepAliveInterval = "muxKeepAliveInterval"
muxKeepAliveTimeout = "muxKeepAliveTimeout"
muxMaxFrameSize = "muxMaxFrameSize"
muxMaxReceiveBuffer = "muxMaxReceiveBuffer"
muxMaxStreamBuffer = "muxMaxStreamBuffer"
)
sn, _, _ := net.SplitHostPort(md.GetString(serverName))
if sn == "" {
sn = "localhost"
}
d.md.tlsConfig, err = tls_util.LoadClientConfig(
md.GetString(certFile),
md.GetString(keyFile),
md.GetString(caFile),
md.GetBool(secure),
sn,
)
d.md.handshakeTimeout = md.GetDuration(handshakeTimeout)
d.md.muxKeepAliveDisabled = md.GetBool(muxKeepAliveDisabled)
d.md.muxKeepAliveInterval = md.GetDuration(muxKeepAliveInterval)
d.md.muxKeepAliveTimeout = md.GetDuration(muxKeepAliveTimeout)
d.md.muxMaxFrameSize = md.GetInt(muxMaxFrameSize)
d.md.muxMaxReceiveBuffer = md.GetInt(muxMaxReceiveBuffer)
d.md.muxMaxStreamBuffer = md.GetInt(muxMaxStreamBuffer)
return
}

4
pkg/dialer/udp/dialer.go
View File

@ -48,7 +48,3 @@ func (d *udpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp
UDPConn: c,
}, nil
}
func (d *udpDialer) parseMetadata(md md.Metadata) (err error) {
return
}

10
pkg/dialer/udp/metadata.go
View File

@ -1,6 +1,10 @@
package udp
import "time"
import (
"time"
md "github.com/go-gost/gost/pkg/metadata"
)
const (
dialTimeout = "dialTimeout"
@ -13,3 +17,7 @@ const (
type metadata struct {
dialTimeout time.Duration
}
func (d *udpDialer) parseMetadata(md md.Metadata) (err error) {
return
}

12
pkg/listener/tls/listener.go
View File

@ -4,7 +4,6 @@ import (
"crypto/tls"
"net"
"github.com/go-gost/gost/pkg/common/util"
"github.com/go-gost/gost/pkg/listener"
"github.com/go-gost/gost/pkg/logger"
md "github.com/go-gost/gost/pkg/metadata"
@ -17,9 +16,9 @@ func init() {
type tlsListener struct {
addr string
md metadata
net.Listener
logger logger.Logger
md metadata
}
func NewListener(opts ...listener.Option) listener.Listener {
@ -43,14 +42,7 @@ func (l *tlsListener) Init(md md.Metadata) (err error) {
return
}
ln = tls.NewListener(
&util.TCPKeepAliveListener{
TCPListener: ln.(*net.TCPListener),
KeepAlivePeriod: l.md.keepAlivePeriod,
},
l.md.tlsConfig,
)
l.Listener = tls.NewListener(ln, l.md.tlsConfig)
l.Listener = ln
return
}

12
pkg/listener/tls/metadata.go
View File

@ -2,23 +2,20 @@ package tls
import (
"crypto/tls"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
md "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
tlsConfig *tls.Config
keepAlivePeriod time.Duration
tlsConfig *tls.Config
}
func (l *tlsListener) parseMetadata(md md.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
keepAlivePeriod = "keepAlivePeriod"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
@ -30,6 +27,5 @@ func (l *tlsListener) parseMetadata(md md.Metadata) (err error) {
return
}
l.md.keepAlivePeriod = md.GetDuration(keepAlivePeriod)
return
}

24
pkg/listener/tls/mux/listener.go
View File

@ -17,11 +17,11 @@ func init() {
type mtlsListener struct {
addr string
md metadata
net.Listener
connChan chan net.Conn
errChan chan error
logger logger.Logger
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
}
func NewListener(opts ...listener.Option) listener.Listener {
@ -46,11 +46,7 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) {
}
l.Listener = tls.NewListener(ln, l.md.tlsConfig)
queueSize := l.md.connQueueSize
if queueSize <= 0 {
queueSize = defaultQueueSize
}
l.connChan = make(chan net.Conn, queueSize)
l.cqueue = make(chan net.Conn, l.md.backlog)
l.errChan = make(chan error, 1)
go l.listenLoop()
@ -73,8 +69,8 @@ func (l *mtlsListener) listenLoop() {
func (l *mtlsListener) mux(conn net.Conn) {
smuxConfig := smux.DefaultConfig()
smuxConfig.KeepAliveDisabled = l.md.muxKeepAliveDisabled
if l.md.muxKeepAlivePeriod > 0 {
smuxConfig.KeepAliveInterval = l.md.muxKeepAlivePeriod
if l.md.muxKeepAliveInterval > 0 {
smuxConfig.KeepAliveInterval = l.md.muxKeepAliveInterval
}
if l.md.muxKeepAliveTimeout > 0 {
smuxConfig.KeepAliveTimeout = l.md.muxKeepAliveTimeout
@ -103,12 +99,12 @@ func (l *mtlsListener) mux(conn net.Conn) {
}
select {
case l.connChan <- stream:
case l.cqueue <- stream:
case <-stream.GetDieCh():
stream.Close()
default:
stream.Close()
l.logger.Error("connection queue is full")
l.logger.Warnf("connection queue is full, client %s discarded", stream.RemoteAddr())
}
}
}
@ -116,7 +112,7 @@ func (l *mtlsListener) mux(conn net.Conn) {
func (l *mtlsListener) Accept() (conn net.Conn, err error) {
var ok bool
select {
case conn = <-l.connChan:
case conn = <-l.cqueue:
case err, ok = <-l.errChan:
if !ok {
err = listener.ErrClosed

22
pkg/listener/tls/mux/metadata.go
View File

@ -9,20 +9,20 @@ import (
)
const (
defaultQueueSize = 128
defaultBacklog = 128
)
type metadata struct {
tlsConfig *tls.Config
muxKeepAliveDisabled bool
muxKeepAlivePeriod time.Duration
muxKeepAliveInterval time.Duration
muxKeepAliveTimeout time.Duration
muxMaxFrameSize int
muxMaxReceiveBuffer int
muxMaxStreamBuffer int
connQueueSize int
backlog int
}
func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) {
@ -31,8 +31,10 @@ func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) {
keyFile = "keyFile"
caFile = "caFile"
backlog = "backlog"
muxKeepAliveDisabled = "muxKeepAliveDisabled"
muxKeepAlivePeriod = "muxKeepAlivePeriod"
muxKeepAliveInterval = "muxKeepAliveInterval"
muxKeepAliveTimeout = "muxKeepAliveTimeout"
muxMaxFrameSize = "muxMaxFrameSize"
muxMaxReceiveBuffer = "muxMaxReceiveBuffer"
@ -48,5 +50,17 @@ func (l *mtlsListener) parseMetadata(md md.Metadata) (err error) {
return
}
l.md.backlog = md.GetInt(backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog
}
l.md.muxKeepAliveDisabled = md.GetBool(muxKeepAliveDisabled)
l.md.muxKeepAliveInterval = md.GetDuration(muxKeepAliveInterval)
l.md.muxKeepAliveTimeout = md.GetDuration(muxKeepAliveTimeout)
l.md.muxMaxFrameSize = md.GetInt(muxMaxFrameSize)
l.md.muxMaxReceiveBuffer = md.GetInt(muxMaxReceiveBuffer)
l.md.muxMaxStreamBuffer = md.GetInt(muxMaxStreamBuffer)
return
}