initial commit

dialer/ssh/conn.go

@@ -0,0 +1,31 @@
+package ssh
+
+import (
+	"net"
+
+	"golang.org/x/crypto/ssh"
+)
+
+type sshSession struct {
+	addr   string
+	conn   net.Conn
+	client *ssh.Client
+	closed chan struct{}
+	dead   chan struct{}
+}
+
+func (s *sshSession) IsClosed() bool {
+	select {
+	case <-s.dead:
+		return true
+	case <-s.closed:
+		return true
+	default:
+	}
+	return false
+}
+
+func (s *sshSession) wait() error {
+	defer close(s.closed)
+	return s.client.Wait()
+}

dialer/ssh/dialer.go

@@ -0,0 +1,165 @@
+package ssh
+
+import (
+	"context"
+	"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"
+	ssh_util "github.com/go-gost/x/internal/util/ssh"
+	"golang.org/x/crypto/ssh"
+)
+
+func init() {
+	registry.DialerRegistry().Register("ssh", NewDialer)
+}
+
+type sshDialer struct {
+	sessions     map[string]*sshSession
+	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 &sshDialer{
+		sessions: make(map[string]*sshSession),
+		logger:   options.Logger,
+	}
+}
+
+func (d *sshDialer) Init(md md.Metadata) (err error) {
+	if err = d.parseMetadata(md); err != nil {
+		return
+	}
+
+	return nil
+}
+
+// Multiplex implements dialer.Multiplexer interface.
+func (d *sshDialer) Multiplex() bool {
+	return true
+}
+
+func (d *sshDialer) 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 = &sshSession{
+			addr: addr,
+			conn: conn,
+		}
+		d.sessions[addr] = session
+	}
+
+	return session.conn, err
+}
+
+// Handshake implements dialer.Handshaker
+func (d *sshDialer) 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 {
+		err := errors.New("ssh: unrecognized connection")
+		d.logger.Error(err)
+		conn.Close()
+		delete(d.sessions, opts.Addr)
+		return nil, err
+	}
+
+	if !ok || session.client == nil {
+		s, err := d.initSession(ctx, opts.Addr, conn)
+		if err != nil {
+			d.logger.Error(err)
+			conn.Close()
+			delete(d.sessions, opts.Addr)
+			return nil, err
+		}
+		session = s
+		go func() {
+			s.wait()
+			d.logger.Debug("session closed")
+		}()
+		d.sessions[opts.Addr] = session
+	}
+	if session.IsClosed() {
+		delete(d.sessions, opts.Addr)
+		return nil, ssh_util.ErrSessionDead
+	}
+
+	channel, reqs, err := session.client.OpenChannel(ssh_util.GostSSHTunnelRequest, nil)
+	if err != nil {
+		return nil, err
+	}
+	go ssh.DiscardRequests(reqs)
+
+	return ssh_util.NewConn(conn, channel), nil
+}
+
+func (d *sshDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*sshSession, error) {
+	config := ssh.ClientConfig{
+		Timeout:         30 * time.Second,
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+	}
+	if d.md.user != nil {
+		config.User = d.md.user.Username()
+		if password, _ := d.md.user.Password(); password != "" {
+			config.Auth = []ssh.AuthMethod{
+				ssh.Password(password),
+			}
+		}
+	}
+	if d.md.signer != nil {
+		config.Auth = append(config.Auth, ssh.PublicKeys(d.md.signer))
+	}
+
+	sshConn, chans, reqs, err := ssh.NewClientConn(conn, addr, &config)
+	if err != nil {
+		return nil, err
+	}
+
+	return &sshSession{
+		conn:   conn,
+		client: ssh.NewClient(sshConn, chans, reqs),
+		closed: make(chan struct{}),
+		dead:   make(chan struct{}),
+	}, nil
+}

dialer/ssh/metadata.go

@@ -0,0 +1,56 @@
+package ssh
+
+import (
+	"io/ioutil"
+	"net/url"
+	"strings"
+	"time"
+
+	mdata "github.com/go-gost/gost/v3/pkg/metadata"
+	"golang.org/x/crypto/ssh"
+)
+
+type metadata struct {
+	handshakeTimeout time.Duration
+	user             *url.Userinfo
+	signer           ssh.Signer
+}
+
+func (d *sshDialer) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		handshakeTimeout = "handshakeTimeout"
+		user             = "user"
+		privateKeyFile   = "privateKeyFile"
+		passphrase       = "passphrase"
+	)
+
+	if v := mdata.GetString(md, user); v != "" {
+		ss := strings.SplitN(v, ":", 2)
+		if len(ss) == 1 {
+			d.md.user = url.User(ss[0])
+		} else {
+			d.md.user = url.UserPassword(ss[0], ss[1])
+		}
+	}
+
+	if key := mdata.GetString(md, privateKeyFile); key != "" {
+		data, err := ioutil.ReadFile(key)
+		if err != nil {
+			return err
+		}
+
+		pp := mdata.GetString(md, passphrase)
+		if pp == "" {
+			d.md.signer, err = ssh.ParsePrivateKey(data)
+		} else {
+			d.md.signer, err = ssh.ParsePrivateKeyWithPassphrase(data, []byte(pp))
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	d.md.handshakeTimeout = mdata.GetDuration(md, handshakeTimeout)
+
+	return
+}