Bind HTTP and proxy sockets

This commit is contained in:
Frank Denis 2026-08-22 13:10:32 +02:00
parent 7d57216d30
commit 4b14040ce1
4 changed files with 353 additions and 10 deletions

View file

@ -123,7 +123,11 @@ func configureXTransport(proxy *Proxy, config *Config) error {
if err != nil {
return fmt.Errorf("Unable to parse the proxy URL [%v]", config.Proxy)
}
proxyDialer, err := netproxy.FromURL(proxyDialerURL, netproxy.Direct)
forwardDialer := netproxy.Dialer(netproxy.Direct)
if proxy.outboundSource.enabled() {
forwardDialer = &sourceAwareProxyForwardDialer{xTransport: proxy.xTransport}
}
proxyDialer, err := netproxy.FromURL(proxyDialerURL, forwardDialer)
if err != nil {
return fmt.Errorf("Unable to use the proxy: [%v]", err)
}

View file

@ -332,6 +332,7 @@ func (plugin *PluginCloak) Eval(pluginsState *PluginsState, msg *dns.Msg) error
pluginsState.xTransport.mainProto,
target,
pluginsState.xTransport.internalResolvers,
false,
returnIPv4,
returnIPv6,
)

View file

@ -10,10 +10,12 @@
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"io"
"math/rand"
"net"
"net/http"
"net/netip"
"net/url"
"os"
"strconv"
@ -104,6 +106,58 @@ type XTransport struct {
outboundSource *outboundSourcePolicy
}
type sourceAwareProxyForwardDialer struct {
xTransport *XTransport
}
var _ netproxy.Dialer = (*sourceAwareProxyForwardDialer)(nil)
var _ netproxy.ContextDialer = (*sourceAwareProxyForwardDialer)(nil)
func (dialer *sourceAwareProxyForwardDialer) Dial(network, address string) (net.Conn, error) {
return dialer.DialContext(context.Background(), network, address)
}
func (dialer *sourceAwareProxyForwardDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
if network != "tcp" && network != "tcp4" && network != "tcp6" {
return nil, fmt.Errorf("unsupported proxy forward network %q", network)
}
host, portStr, err := net.SplitHostPort(address)
if err != nil {
return nil, err
}
port, err := strconv.Atoi(portStr)
if err != nil || port < 0 || port > 65535 {
return nil, fmt.Errorf("invalid proxy endpoint port %q", portStr)
}
var ips []net.IP
if literal := ParseIP(host); literal != nil {
ips = []net.IP{literal}
} else {
ips, _, err = dialer.xTransport.resolve(host, dialer.xTransport.useIPv4, dialer.xTransport.useIPv6)
if err != nil {
return nil, fmt.Errorf("unable to resolve proxy endpoint %q: %w", host, err)
}
}
var lastErr error
for _, ip := range ips {
target := &net.TCPAddr{IP: ip, Port: port}
conn, err := dialer.xTransport.outboundSource.dialTCPContext(
ctx,
target,
dialer.xTransport.timeout,
dialer.xTransport.keepAlive,
)
if err == nil {
return conn, nil
}
lastErr = err
}
if lastErr == nil {
lastErr = fmt.Errorf("proxy endpoint %q has no usable IP addresses", host)
}
return nil, lastErr
}
func NewXTransport(policy ...*outboundSourcePolicy) *XTransport {
if err := isIPAndPort(DefaultBootstrapResolver); err != nil {
panic("DefaultBootstrapResolver does not parse")
@ -318,6 +372,23 @@ func (xTransport *XTransport) rebuildTransport() {
}
cachedIPs, _, _ := xTransport.loadCachedIPs(host)
if xTransport.outboundSource.enabled() && xTransport.proxyDialer == nil && len(cachedIPs) == 0 {
if literal := ParseIP(host); literal != nil {
cachedIPs = []net.IP{literal}
} else {
resolved, ttl, err := xTransport.resolve(host, xTransport.useIPv4, xTransport.useIPv6)
if err != nil {
return nil, fmt.Errorf("unable to resolve covered HTTP destination %q: %w", host, err)
}
cachedIPs = resolved
if len(resolved) > 0 {
xTransport.saveCachedIPs(host, resolved, ttl)
}
}
if len(cachedIPs) == 0 {
return nil, fmt.Errorf("covered HTTP destination %q has no usable IP addresses", host)
}
}
targets := make([]string, 0, len(cachedIPs))
for _, ip := range cachedIPs {
targets = append(targets, formatEndpoint(ip))
@ -328,11 +399,21 @@ func (xTransport *XTransport) rebuildTransport() {
}
dial := func(address string) (net.Conn, error) {
if xTransport.proxyDialer == nil {
if xTransport.proxyDialer != nil {
if contextDialer, ok := (*xTransport.proxyDialer).(netproxy.ContextDialer); ok {
return contextDialer.DialContext(ctx, network, address)
}
return (*xTransport.proxyDialer).Dial(network, address)
}
if !xTransport.outboundSource.enabled() {
dialer := &net.Dialer{Timeout: timeout, KeepAlive: xTransport.keepAlive}
return dialer.DialContext(ctx, network, address)
}
return (*xTransport.proxyDialer).Dial(network, address)
target, err := net.ResolveTCPAddr("tcp", address)
if err != nil {
return nil, err
}
return xTransport.outboundSource.dialTCPContext(ctx, target, timeout, xTransport.keepAlive)
}
var lastErr error
@ -466,6 +547,23 @@ type udpTarget struct {
}
cachedIPs, _, _ := xTransport.loadCachedIPs(host)
if xTransport.outboundSource.enabled() && len(cachedIPs) == 0 {
if literal := ParseIP(host); literal != nil {
cachedIPs = []net.IP{literal}
} else {
resolved, ttl, err := xTransport.resolve(host, xTransport.useIPv4, xTransport.useIPv6)
if err != nil {
return nil, fmt.Errorf("unable to resolve covered HTTP/3 destination %q: %w", host, err)
}
cachedIPs = resolved
if len(resolved) > 0 {
xTransport.saveCachedIPs(host, resolved, ttl)
}
}
if len(cachedIPs) == 0 {
return nil, fmt.Errorf("covered HTTP/3 destination %q has no usable IP addresses", host)
}
}
targets := make([]udpTarget, 0, len(cachedIPs))
for _, ip := range cachedIPs {
targets = append(targets, buildAddr(ip))
@ -485,7 +583,21 @@ type udpTarget struct {
}
continue
}
udpConn, err := net.ListenUDP(target.network, nil)
var udpConn *net.UDPConn
if xTransport.outboundSource.enabled() {
addrPort, addrErr := udpAddrPort(udpAddr)
if addrErr != nil {
lastErr = addrErr
continue
}
var normalized netip.Addr
udpConn, target.network, normalized, err = xTransport.outboundSource.listenUDP(addrPort.Addr())
if err == nil {
udpAddr = net.UDPAddrFromAddrPort(netip.AddrPortFrom(normalized, addrPort.Port()))
}
} else {
udpConn, err = net.ListenUDP(target.network, nil)
}
if err != nil {
lastErr = err
if idx < len(targets)-1 {
@ -532,10 +644,15 @@ func (xTransport *XTransport) resolveUsingSystem(host string, returnIPv4, return
func (xTransport *XTransport) resolveUsingResolver(
proto, host string,
resolver string,
covered bool,
returnIPv4, returnIPv6 bool,
) (ips []net.IP, ttl time.Duration, err error) {
transport := dns.NewTransport()
transport := newDNSTransport()
transport.ReadTimeout = ResolverReadTimeout
proto, resolver, err = xTransport.outboundSource.configureDNSTransport(transport, proto, resolver, covered)
if err != nil {
return nil, 0, err
}
dnsClient := dns.Client{Transport: transport}
queryType := make([]uint16, 0, 2)
if returnIPv4 {
@ -574,7 +691,7 @@ func (xTransport *XTransport) resolveUsingResolver(
}
}
} else {
lastErr = err
lastErr = xTransport.outboundSource.wrapDNSError(err, strings.TrimRight(proto, "46"), resolver, covered)
}
}
if len(ips) > 0 {
@ -587,6 +704,7 @@ func (xTransport *XTransport) resolveUsingResolver(
func (xTransport *XTransport) resolveUsingServers(
proto, host string,
resolvers []string,
covered bool,
returnIPv4, returnIPv6 bool,
) (ips []net.IP, ttl time.Duration, err error) {
if len(resolvers) == 0 {
@ -596,7 +714,7 @@ func (xTransport *XTransport) resolveUsingServers(
for i, resolver := range resolvers {
delay := resolverRetryInitialBackoff
for attempt := 1; attempt <= resolverRetryCount; attempt++ {
ips, ttl, err = xTransport.resolveUsingResolver(proto, host, resolver, returnIPv4, returnIPv6)
ips, ttl, err = xTransport.resolveUsingResolver(proto, host, resolver, covered, returnIPv4, returnIPv6)
if err == nil && len(ips) > 0 {
if i > 0 {
dlog.Infof("Resolution succeeded with resolver %s[%s]", proto, resolver)
@ -635,7 +753,7 @@ func (xTransport *XTransport) resolve(host string, returnIPv4, returnIPv6 bool)
if xTransport.ignoreSystemDNS {
if xTransport.internalResolverReady.Load() {
for _, proto := range protos {
ips, ttl, err = xTransport.resolveUsingServers(proto, host, xTransport.internalResolvers, returnIPv4, returnIPv6)
ips, ttl, err = xTransport.resolveUsingServers(proto, host, xTransport.internalResolvers, false, returnIPv4, returnIPv6)
if err == nil {
break
}
@ -660,13 +778,13 @@ func (xTransport *XTransport) resolve(host string, returnIPv4, returnIPv6 bool)
proto,
)
}
ips, ttl, err = xTransport.resolveUsingServers(proto, host, xTransport.bootstrapResolvers, returnIPv4, returnIPv6)
ips, ttl, err = xTransport.resolveUsingServers(proto, host, xTransport.bootstrapResolvers, true, returnIPv4, returnIPv6)
if err == nil {
break
}
}
}
if err != nil && xTransport.ignoreSystemDNS {
if err != nil && xTransport.ignoreSystemDNS && !xTransport.outboundSource.enabled() {
dlog.Noticef("Bootstrap resolvers didn't respond - Trying with the system resolver as a last resort")
ips, ttl, err = xTransport.resolveUsingSystem(host, returnIPv4, returnIPv6)
}

View file

@ -0,0 +1,220 @@
package main
import (
"context"
"errors"
"net"
"net/netip"
"strconv"
"strings"
"testing"
"time"
"codeberg.org/miekg/dns"
"codeberg.org/miekg/dns/rdata"
)
func TestXTransportOutboundSourceDial(t *testing.T) {
sourceIP := usableNonLoopbackIPv4(t)
policy, err := parseOutboundSourcePolicy(sourceIP.String(), "")
if err != nil {
t.Fatal(err)
}
listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4zero})
if err != nil {
t.Fatal(err)
}
defer listener.Close()
peerCh := make(chan net.IP, 1)
go func() {
conn, err := listener.AcceptTCP()
if err == nil {
peerCh <- conn.RemoteAddr().(*net.TCPAddr).IP
_ = conn.Close()
}
}()
xTransport := NewXTransport(&policy)
xTransport.timeout = time.Second
xTransport.saveCachedIPs("ordered.test", []net.IP{
net.ParseIP("127.0.0.2"),
net.ParseIP(sourceIP.String()),
}, time.Hour)
xTransport.rebuildTransport()
port := listener.Addr().(*net.TCPAddr).Port
conn, err := xTransport.transport.DialContext(context.Background(), "tcp", net.JoinHostPort("ordered.test", formatPort(port)))
if err != nil {
t.Fatal(err)
}
_ = conn.Close()
if peer := <-peerCh; !peer.Equal(sourceIP) {
t.Fatalf("peer source = %s, want %s", peer, sourceIP)
}
}
func TestXTransportOutboundSourceMissingFamily(t *testing.T) {
policy, err := parseOutboundSourcePolicy("192.0.2.10", "")
if err != nil {
t.Fatal(err)
}
xTransport := NewXTransport(&policy)
xTransport.rebuildTransport()
_, err = xTransport.transport.DialContext(context.Background(), "tcp", "[2001:db8::1]:443")
if err == nil || !strings.Contains(err.Error(), "outbound_source_ipv6") {
t.Fatalf("error = %v", err)
}
}
func TestSourceAwareProxyForwardDialer(t *testing.T) {
sourceIP := usableNonLoopbackIPv4(t)
policy, err := parseOutboundSourcePolicy(sourceIP.String(), "")
if err != nil {
t.Fatal(err)
}
xTransport := NewXTransport(&policy)
xTransport.timeout = time.Second
forward := &sourceAwareProxyForwardDialer{xTransport: xTransport}
t.Run("remote", func(t *testing.T) {
listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4zero})
if err != nil {
t.Fatal(err)
}
defer listener.Close()
peerCh := make(chan net.IP, 1)
go func() {
conn, err := listener.AcceptTCP()
if err == nil {
peerCh <- conn.RemoteAddr().(*net.TCPAddr).IP
_ = conn.Close()
}
}()
port := listener.Addr().(*net.TCPAddr).Port
conn, err := forward.DialContext(context.Background(), "tcp", net.JoinHostPort(sourceIP.String(), formatPort(port)))
if err != nil {
t.Fatal(err)
}
_ = conn.Close()
if peer := <-peerCh; !peer.Equal(sourceIP) {
t.Fatalf("peer source = %s, want %s", peer, sourceIP)
}
})
t.Run("local bypass", func(t *testing.T) {
listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)})
if err != nil {
t.Fatal(err)
}
defer listener.Close()
go func() {
conn, err := listener.AcceptTCP()
if err == nil {
_ = conn.Close()
}
}()
conn, err := forward.DialContext(context.Background(), "tcp", listener.Addr().String())
if err != nil {
t.Fatal(err)
}
if !conn.LocalAddr().(*net.TCPAddr).IP.IsLoopback() {
t.Fatalf("local proxy used configured source: %s", conn.LocalAddr())
}
_ = conn.Close()
})
t.Run("canceled context", func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := forward.DialContext(ctx, "tcp", net.JoinHostPort(sourceIP.String(), "9"))
if !errors.Is(err, context.Canceled) {
t.Fatalf("error = %v, want context canceled", err)
}
})
}
func TestXTransportResolverOutboundSource(t *testing.T) {
sourceIP := usableNonLoopbackIPv4(t)
policy, err := parseOutboundSourcePolicy(sourceIP.String(), "")
if err != nil {
t.Fatal(err)
}
xTransport := NewXTransport(&policy)
for _, proto := range []string{"udp", "tcp"} {
t.Run(proto, func(t *testing.T) {
resolver, peerCh, closeServer := startResolvingDNSServer(t, proto, sourceIP)
defer closeServer()
ips, _, err := xTransport.resolveUsingResolver(proto, "example.org", resolver, true, true, false)
if err != nil {
t.Fatal(err)
}
if len(ips) != 1 || !ips[0].Equal(net.ParseIP("203.0.113.5")) {
t.Fatalf("resolved IPs = %v", ips)
}
if peer := <-peerCh; !peer.Equal(sourceIP) {
t.Fatalf("resolver peer source = %s, want %s", peer, sourceIP)
}
})
}
}
func startResolvingDNSServer(t *testing.T, proto string, destinationIP net.IP) (string, <-chan net.IP, func()) {
t.Helper()
peerCh := make(chan net.IP, 1)
respond := func(packet []byte) []byte {
msg := dns.Msg{Data: packet}
if msg.Unpack() != nil {
return nil
}
msg.Response = true
msg.Answer = []dns.RR{&dns.A{
Hdr: dns.Header{Name: "example.org.", Class: dns.ClassINET, TTL: 60},
A: rdata.A{Addr: netip.MustParseAddr("203.0.113.5")},
}}
if msg.Pack() != nil {
return nil
}
return msg.Data
}
if proto == "udp" {
listener, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero})
if err != nil {
t.Fatal(err)
}
go func() {
packet := make([]byte, MaxDNSPacketSize)
length, peer, err := listener.ReadFromUDP(packet)
if err == nil {
peerCh <- peer.IP
_, _ = listener.WriteToUDP(respond(packet[:length]), peer)
}
}()
port := listener.LocalAddr().(*net.UDPAddr).Port
return net.JoinHostPort(destinationIP.String(), formatPort(port)), peerCh, func() { _ = listener.Close() }
}
listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4zero})
if err != nil {
t.Fatal(err)
}
go func() {
conn, err := listener.AcceptTCP()
if err != nil {
return
}
defer conn.Close()
peerCh <- conn.RemoteAddr().(*net.TCPAddr).IP
packet, err := ReadPrefixed(conn)
if err != nil {
return
}
packet, err = PrefixWithSize(respond(packet))
if err == nil {
_, _ = conn.Write(packet)
}
}()
port := listener.Addr().(*net.TCPAddr).Port
return net.JoinHostPort(destinationIP.String(), formatPort(port)), peerCh, func() { _ = listener.Close() }
}
func formatPort(port int) string {
return strconv.Itoa(port)
}