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

新增dnst隧道

Browse Source
This commit is contained in:
wenyifan
2026-07-04 13:01:21 +08:00
parent bf85966600
commit 74fef8838e
9 changed files with 906 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
listener/dns/listener.go
+36
View File
@@ -27,11 +27,14 @@ import (
func init() {
registry.ListenerRegistry().Register("dns", NewListener)
registry.ListenerRegistry().Register("dns-tunnel", NewTunnelListener)
registry.ListenerRegistry().Register("dnst", NewTunnelListener)
}
type dnsListener struct {
addr net.Addr
server Server
tunnel listener.Listener
cqueue chan net.Conn
errChan chan error
logger logger.Logger
@@ -55,6 +58,29 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
return
}
if isTunnelMode(l.md.mode) {
tunnel := NewTunnelListener(
listener.AddrOption(l.options.Addr),
listener.RouterOption(l.options.Router),
listener.AutherOption(l.options.Auther),
listener.AuthOption(l.options.Auth),
listener.TLSConfigOption(l.options.TLSConfig),
listener.AdmissionOption(l.options.Admission),
listener.TrafficLimiterOption(l.options.TrafficLimiter),
listener.ConnLimiterOption(l.options.ConnLimiter),
listener.ServiceOption(l.options.Service),
listener.ProxyProtocolOption(l.options.ProxyProtocol),
listener.StatsOption(l.options.Stats),
listener.NetnsOption(l.options.Netns),
listener.LoggerOption(l.options.Logger),
)
if err = tunnel.Init(md); err != nil {
return
}
l.tunnel = tunnel
return nil
}
switch strings.ToLower(l.md.mode) {
case "tcp":
l.addr, err = net.ResolveTCPAddr("tcp", l.options.Addr)
@@ -230,6 +256,10 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
}
func (l *dnsListener) Accept() (conn net.Conn, err error) {
if l.tunnel != nil {
return l.tunnel.Accept()
}
var ok bool
select {
case conn = <-l.cqueue:
@@ -254,10 +284,16 @@ func (l *dnsListener) Accept() (conn net.Conn, err error) {
}
func (l *dnsListener) Close() error {
if l.tunnel != nil {
return l.tunnel.Close()
}
return l.server.Shutdown()
}
func (l *dnsListener) Addr() net.Addr {
if l.tunnel != nil {
return l.tunnel.Addr()
}
return l.addr
}
listener/dns/metadata.go
+10
View File
@@ -1,6 +1,7 @@
package dns
import (
"strings"
"time"
mdata "github.com/go-gost/core/metadata"
@@ -20,6 +21,15 @@ type metadata struct {
mptcp bool
}
func isTunnelMode(mode string) bool {
switch strings.ToLower(mode) {
case "tunnel", "quic", "packet":
return true
default:
return false
}
}
func (l *dnsListener) parseMetadata(md mdata.Metadata) (err error) {
const (
backlog = "backlog"
listener/dns/tunnel.go
+205
View File
@@ -0,0 +1,205 @@
package dns
import (
"context"
"crypto/tls"
"net"
"strings"
"github.com/go-gost/core/limiter"
"github.com/go-gost/core/listener"
"github.com/go-gost/core/logger"
md "github.com/go-gost/core/metadata"
admission "github.com/go-gost/x/admission/wrapper"
xnet "github.com/go-gost/x/internal/net"
dns_util "github.com/go-gost/x/internal/util/dns"
traffic_limiter "github.com/go-gost/x/limiter/traffic"
limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
metrics "github.com/go-gost/x/metrics/wrapper"
stats "github.com/go-gost/x/observer/stats/wrapper"
"github.com/quic-go/quic-go"
)
type dnsTunnelListener struct {
ln quic.EarlyListener
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md tunnelMetadata
options listener.Options
}
func NewTunnelListener(opts ...listener.Option) listener.Listener {
options := listener.Options{}
for _, opt := range opts {
opt(&options)
}
return &dnsTunnelListener{
logger: options.Logger,
options: options,
}
}
func (l *dnsTunnelListener) Init(md md.Metadata) (err error) {
if err = l.parseMetadata(md); err != nil {
return
}
addr := l.options.Addr
if _, _, err := net.SplitHostPort(addr); err != nil {
addr = net.JoinHostPort(strings.Trim(addr, "[]"), "0")
}
network := "udp"
if xnet.IsIPv4(addr) {
network = "udp4"
}
laddr, err := net.ResolveUDPAddr(network, addr)
if err != nil {
return
}
lc := net.ListenConfig{}
var conn net.PacketConn
conn, err = lc.ListenPacket(context.Background(), network, laddr.String())
if err != nil {
return
}
conn = dns_util.ServerConn(
conn,
dns_util.DomainOption(l.md.domain),
dns_util.UDPSizeOption(l.md.udpSize),
)
conn = metrics.WrapPacketConn(l.options.Service, conn)
conn = stats.WrapPacketConn(conn, l.options.Stats)
conn = admission.WrapPacketConn(l.options.Admission, conn)
conn = limiter_wrapper.WrapPacketConn(
conn,
l.options.TrafficLimiter,
traffic_limiter.ServiceLimitKey,
limiter.ScopeOption(limiter.ScopeService),
limiter.ServiceOption(l.options.Service),
limiter.NetworkOption(conn.LocalAddr().Network()),
)
config := &quic.Config{
KeepAlivePeriod: l.md.keepAlivePeriod,
HandshakeIdleTimeout: l.md.handshakeTimeout,
MaxIdleTimeout: l.md.maxIdleTimeout,
Versions: []quic.Version{
quic.Version1,
quic.Version2,
},
MaxIncomingStreams: int64(l.md.maxStreams),
EnableDatagrams: l.md.enableDatagram,
}
tlsCfg := l.options.TLSConfig
if tlsCfg == nil {
tlsCfg = &tls.Config{}
} else {
tlsCfg = tlsCfg.Clone()
}
if len(tlsCfg.NextProtos) == 0 {
tlsCfg.NextProtos = []string{"h3", "quic/v1"}
}
ln, err := quic.ListenEarly(conn, tlsCfg, config)
if err != nil {
_ = conn.Close()
return
}
l.ln = *ln
l.cqueue = make(chan net.Conn, l.md.backlog)
l.errChan = make(chan error, 1)
go l.listenLoop()
return
}
func (l *dnsTunnelListener) Accept() (conn net.Conn, err error) {
var ok bool
select {
case conn = <-l.cqueue:
conn = limiter_wrapper.WrapConn(
conn,
l.options.TrafficLimiter,
conn.RemoteAddr().String(),
limiter.ScopeOption(limiter.ScopeConn),
limiter.ServiceOption(l.options.Service),
limiter.NetworkOption(conn.LocalAddr().Network()),
limiter.SrcOption(conn.RemoteAddr().String()),
)
case err, ok = <-l.errChan:
if !ok {
err = listener.ErrClosed
}
}
return
}
func (l *dnsTunnelListener) Close() error {
return l.ln.Close()
}
func (l *dnsTunnelListener) Addr() net.Addr {
return l.ln.Addr()
}
func (l *dnsTunnelListener) listenLoop() {
for {
ctx := context.Background()
session, err := l.ln.Accept(ctx)
if err != nil {
l.logger.Error("accept: ", err)
l.errChan <- err
close(l.errChan)
return
}
l.logger.Infof("new client session: %v", session.RemoteAddr())
go l.mux(ctx, session)
}
}
func (l *dnsTunnelListener) mux(ctx context.Context, session *quic.Conn) {
defer session.CloseWithError(0, "closed")
for {
stream, err := session.AcceptStream(ctx)
if err != nil {
l.logger.Error("accept stream: ", err)
return
}
conn := &dnsTunnelConn{
Stream: stream,
laddr: session.LocalAddr(),
raddr: session.RemoteAddr(),
}
select {
case l.cqueue <- conn:
case <-stream.Context().Done():
stream.Close()
default:
stream.Close()
l.logger.Warnf("connection queue is full, client %s discarded", session.RemoteAddr())
}
}
}
type dnsTunnelConn struct {
*quic.Stream
laddr net.Addr
raddr net.Addr
}
func (c *dnsTunnelConn) LocalAddr() net.Addr {
return c.laddr
}
func (c *dnsTunnelConn) RemoteAddr() net.Addr {
return c.raddr
}
listener/dns/tunnel_metadata.go
+55
View File
@@ -0,0 +1,55 @@
package dns
import (
"time"
mdata "github.com/go-gost/core/metadata"
mdutil "github.com/go-gost/x/metadata/util"
)
type tunnelMetadata struct {
keepAlivePeriod time.Duration
handshakeTimeout time.Duration
maxIdleTimeout time.Duration
maxStreams int
enableDatagram bool
backlog int
domain string
udpSize int
}
func (l *dnsTunnelListener) parseMetadata(md mdata.Metadata) (err error) {
const (
keepAlive = "keepAlive"
keepAlivePeriod = "ttl"
handshakeTimeout = "handshakeTimeout"
maxIdleTimeout = "maxIdleTimeout"
maxStreams = "maxStreams"
backlog = "backlog"
domain = "domain"
udpSize = "udpSize"
)
l.md.backlog = mdutil.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog
}
if mdutil.GetBool(md, keepAlive) {
l.md.keepAlivePeriod = mdutil.GetDuration(md, keepAlivePeriod)
if l.md.keepAlivePeriod <= 0 {
l.md.keepAlivePeriod = 10 * time.Second
}
}
l.md.handshakeTimeout = mdutil.GetDuration(md, handshakeTimeout)
l.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
l.md.maxStreams = mdutil.GetInt(md, maxStreams)
l.md.enableDatagram = mdutil.GetBool(md, "quic.enableDatagram", "enableDatagram")
l.md.domain = mdutil.GetString(md, domain, "dns.domain")
l.md.udpSize = mdutil.GetInt(md, udpSize, "dns.udpSize")
return
}