initial commit

dialer/mtls/conn.go

@@ -0,0 +1,38 @@
+package mtls
+
+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()
+}

dialer/mtls/dialer.go

@@ -0,0 +1,156 @@
+package mtls
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/go-gost/gost/v3/pkg/dialer"
+	"github.com/go-gost/gost/v3/pkg/logger"
+	md "github.com/go-gost/gost/v3/pkg/metadata"
+	"github.com/go-gost/gost/v3/pkg/registry"
+	"github.com/xtaci/smux"
+)
+
+func init() {
+	registry.DialerRegistry().Register("mtls", NewDialer)
+}
+
+type mtlsDialer struct {
+	sessions     map[string]*muxSession
+	sessionMutex sync.Mutex
+	logger       logger.Logger
+	md           metadata
+	options      dialer.Options
+}
+
+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,
+		options:  options,
+	}
+}
+
+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) {
+	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 {
+		var options dialer.DialOptions
+		for _, opt := range opts {
+			opt(&options)
+		}
+
+		conn, err = options.NetDialer.Dial(ctx, "tcp", addr)
+		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) initSession(ctx context.Context, conn net.Conn) (*muxSession, error) {
+	tlsConn := tls.Client(conn, d.options.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
+}

dialer/mtls/metadata.go

@@ -0,0 +1,42 @@
+package mtls
+
+import (
+	"time"
+
+	mdata "github.com/go-gost/gost/v3/pkg/metadata"
+)
+
+type metadata struct {
+	handshakeTimeout time.Duration
+
+	muxKeepAliveDisabled bool
+	muxKeepAliveInterval time.Duration
+	muxKeepAliveTimeout  time.Duration
+	muxMaxFrameSize      int
+	muxMaxReceiveBuffer  int
+	muxMaxStreamBuffer   int
+}
+
+func (d *mtlsDialer) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		handshakeTimeout = "handshakeTimeout"
+
+		muxKeepAliveDisabled = "muxKeepAliveDisabled"
+		muxKeepAliveInterval = "muxKeepAliveInterval"
+		muxKeepAliveTimeout  = "muxKeepAliveTimeout"
+		muxMaxFrameSize      = "muxMaxFrameSize"
+		muxMaxReceiveBuffer  = "muxMaxReceiveBuffer"
+		muxMaxStreamBuffer   = "muxMaxStreamBuffer"
+	)
+
+	d.md.handshakeTimeout = mdata.GetDuration(md, handshakeTimeout)
+
+	d.md.muxKeepAliveDisabled = mdata.GetBool(md, muxKeepAliveDisabled)
+	d.md.muxKeepAliveInterval = mdata.GetDuration(md, muxKeepAliveInterval)
+	d.md.muxKeepAliveTimeout = mdata.GetDuration(md, muxKeepAliveTimeout)
+	d.md.muxMaxFrameSize = mdata.GetInt(md, muxMaxFrameSize)
+	d.md.muxMaxReceiveBuffer = mdata.GetInt(md, muxMaxReceiveBuffer)
+	d.md.muxMaxStreamBuffer = mdata.GetInt(md, muxMaxStreamBuffer)
+
+	return
+}