新增dnst隧道

dialer/dns/conn.go

@@ -0,0 +1,54 @@
+package dns
+
+import (
+	"context"
+	"net"
+	"time"
+
+	"github.com/quic-go/quic-go"
+)
+
+type quicSession struct {
+	session *quic.Conn
+}
+
+func (session *quicSession) GetConn() (*quicConn, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	stream, err := session.session.OpenStreamSync(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &quicConn{
+		Stream: stream,
+		laddr:  session.session.LocalAddr(),
+		raddr:  session.session.RemoteAddr(),
+	}, nil
+}
+
+func (session *quicSession) IsClosed() bool {
+	select {
+	case <-session.session.Context().Done():
+		return true
+	default:
+		return false
+	}
+}
+
+func (session *quicSession) Close() error {
+	return session.session.CloseWithError(quic.ApplicationErrorCode(0), "closed")
+}
+
+type quicConn struct {
+	*quic.Stream
+	laddr net.Addr
+	raddr net.Addr
+}
+
+func (c *quicConn) LocalAddr() net.Addr {
+	return c.laddr
+}
+
+func (c *quicConn) RemoteAddr() net.Addr {
+	return c.raddr
+}

dialer/dns/dialer.go

@@ -0,0 +1,153 @@
+package dns
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+	"sync"
+
+	"github.com/go-gost/core/dialer"
+	"github.com/go-gost/core/logger"
+	md "github.com/go-gost/core/metadata"
+	dns_util "github.com/go-gost/x/internal/util/dns"
+	"github.com/go-gost/x/registry"
+	"github.com/quic-go/quic-go"
+)
+
+func init() {
+	registry.DialerRegistry().Register("dns", NewDialer)
+	registry.DialerRegistry().Register("dns-tunnel", NewDialer)
+	registry.DialerRegistry().Register("dnst", NewDialer)
+}
+
+type dnsDialer struct {
+	sessions     map[string]*quicSession
+	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 &dnsDialer{
+		sessions: make(map[string]*quicSession),
+		logger:   options.Logger,
+		options:  options,
+	}
+}
+
+func (d *dnsDialer) Init(md md.Metadata) (err error) {
+	if err = d.parseMetadata(md); err != nil {
+		return
+	}
+
+	return nil
+}
+
+func (d *dnsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) {
+	if _, _, err := net.SplitHostPort(addr); err != nil {
+		addr = net.JoinHostPort(addr, "0")
+	}
+
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	d.sessionMutex.Lock()
+
+	session, ok := d.sessions[addr]
+	if session != nil && session.IsClosed() {
+		delete(d.sessions, addr)
+		ok = false
+	}
+	if !ok {
+		options := &dialer.DialOptions{}
+		for _, opt := range opts {
+			opt(options)
+		}
+
+		c, err := options.Dialer.Dial(ctx, "udp", "")
+		if err != nil {
+			d.sessionMutex.Unlock()
+			return nil, err
+		}
+		pc, ok := c.(net.PacketConn)
+		if !ok {
+			c.Close()
+			d.sessionMutex.Unlock()
+			return nil, errors.New("dns: wrong connection type")
+		}
+
+		pc = dns_util.ClientConn(
+			pc,
+			dns_util.DomainOption(d.md.domain),
+			dns_util.UDPSizeOption(d.md.udpSize),
+		)
+
+		session, err = d.initSession(ctx, udpAddr, pc)
+		if err != nil {
+			d.logger.Error(err)
+			pc.Close()
+			d.sessionMutex.Unlock()
+			return nil, err
+		}
+
+		d.sessions[addr] = session
+	}
+	d.sessionMutex.Unlock()
+
+	conn, err = session.GetConn()
+	if err != nil {
+		d.sessionMutex.Lock()
+		if d.sessions[addr] == session {
+			delete(d.sessions, addr)
+		}
+		session.Close()
+		d.sessionMutex.Unlock()
+		return nil, err
+	}
+
+	return
+}
+
+func (d *dnsDialer) initSession(ctx context.Context, addr net.Addr, conn net.PacketConn) (*quicSession, error) {
+	quicConfig := &quic.Config{
+		KeepAlivePeriod:      d.md.keepAlivePeriod,
+		HandshakeIdleTimeout: d.md.handshakeTimeout,
+		MaxIdleTimeout:       d.md.maxIdleTimeout,
+		Versions: []quic.Version{
+			quic.Version1,
+			quic.Version2,
+		},
+		MaxIncomingStreams: int64(d.md.maxStreams),
+		EnableDatagrams:    d.md.enableDatagram,
+	}
+
+	tlsCfg := d.options.TLSConfig
+	if tlsCfg == nil {
+		tlsCfg = &tls.Config{}
+	} else {
+		tlsCfg = tlsCfg.Clone()
+	}
+	if len(tlsCfg.NextProtos) == 0 {
+		tlsCfg.NextProtos = []string{"h3", "quic/v1"}
+	}
+
+	session, err := quic.DialEarly(ctx, conn, addr, tlsCfg, quicConfig)
+	if err != nil {
+		return nil, err
+	}
+	return &quicSession{session: session}, nil
+}
+
+// Multiplex implements dialer.Multiplexer interface.
+func (d *dnsDialer) Multiplex() bool {
+	return true
+}

dialer/dns/metadata.go

@@ -0,0 +1,48 @@
+package dns
+
+import (
+	"time"
+
+	mdata "github.com/go-gost/core/metadata"
+	mdutil "github.com/go-gost/x/metadata/util"
+)
+
+type metadata struct {
+	keepAlivePeriod  time.Duration
+	maxIdleTimeout   time.Duration
+	handshakeTimeout time.Duration
+	maxStreams       int
+	enableDatagram   bool
+
+	domain  string
+	udpSize int
+}
+
+func (d *dnsDialer) parseMetadata(md mdata.Metadata) (err error) {
+	const (
+		keepAlive        = "keepAlive"
+		keepAlivePeriod  = "ttl"
+		handshakeTimeout = "handshakeTimeout"
+		maxIdleTimeout   = "maxIdleTimeout"
+		maxStreams       = "maxStreams"
+
+		domain  = "domain"
+		udpSize = "udpSize"
+	)
+
+	if md == nil || !md.IsExists(keepAlive) || mdutil.GetBool(md, keepAlive) {
+		d.md.keepAlivePeriod = mdutil.GetDuration(md, keepAlivePeriod)
+		if d.md.keepAlivePeriod <= 0 {
+			d.md.keepAlivePeriod = 10 * time.Second
+		}
+	}
+	d.md.handshakeTimeout = mdutil.GetDuration(md, handshakeTimeout)
+	d.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
+	d.md.maxStreams = mdutil.GetInt(md, maxStreams)
+	d.md.enableDatagram = mdutil.GetBool(md, "quic.enableDatagram", "enableDatagram")
+
+	d.md.domain = mdutil.GetString(md, domain, "dns.domain")
+	d.md.udpSize = mdutil.GetInt(md, udpSize, "dns.udpSize")
+
+	return
+}