glider/proxy/anytls/client.go

package anytls

import (
	"crypto/tls"
	"fmt"
	"net"

	"github.com/nadoo/glider/pkg/log"
	"github.com/nadoo/glider/pkg/socks"
	"github.com/nadoo/glider/proxy"
)

func init() {
	proxy.RegisterDialer("anytls", NewAnyTLSDialer)
}

func NewAnyTLSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
	a, err := NewAnyTLS(s, d, nil)
	if err != nil {
		return nil, fmt.Errorf("[anytls] create instance error: %s", err)
	}
	a.tlsConfig, err = loadClientTLSConfig(a.serverName, a.certFile, a.skipVerify)
	return a, err
}

func (s *AnyTLS) Dial(network, addr string) (net.Conn, error) {
	if network != "tcp" && network != "tcp4" && network != "tcp6" {
		return nil, proxy.ErrNotSupported
	}
	raw := socks.ParseAddr(addr)
	if raw == nil {
		return nil, fmt.Errorf("[anytls] invalid target address: %s", addr)
	}
	ss, err := s.newClientSession()
	if err != nil {
		return nil, err
	}
	st, err := ss.openStream()
	if err != nil {
		_ = ss.Close()
		return nil, err
	}
	if _, err := st.Write(raw); err != nil {
		_ = st.Close()
		_ = ss.Close()
		return nil, err
	}
	if err := ss.waitSYNACK(st.id, s.synackTimeout); err != nil {
		_ = st.Close()
		_ = ss.Close()
		return nil, err
	}
	return &clientConn{Conn: st, session: ss}, nil
}

func (s *AnyTLS) DialUDP(network, addr string) (net.PacketConn, error) {
	return nil, proxy.ErrNotSupported
}

func (s *AnyTLS) newClientSession() (*session, error) {
	rc, err := s.dialer.Dial("tcp", s.addr)
	if err != nil {
		log.F("[anytls] dial to %s error: %s", s.addr, err)
		return nil, err
	}
	tc := tls.Client(rc, s.tlsConfig)
	if err := tc.Handshake(); err != nil {
		_ = rc.Close()
		return nil, err
	}
	if err := writeAuth(tc, s.password, s.padding.authPaddingLen()); err != nil {
		_ = tc.Close()
		return nil, err
	}
	ss := newSession(tc)
	if err := ss.writeFrame(frame{command: cmdSettings, data: clientSettings(s.padding)}); err != nil {
		_ = tc.Close()
		return nil, err
	}
	ss.start()
	return ss, nil
}

type clientConn struct {
	net.Conn
	session *session
}

func (c *clientConn) Close() error {
	err := c.Conn.Close()
	_ = c.session.Close()
	return err
}