Bind HTTP and proxy sockets
This commit is contained in:
parent
7d57216d30
commit
4b14040ce1
4 changed files with 353 additions and 10 deletions
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -332,6 +332,7 @@ func (plugin *PluginCloak) Eval(pluginsState *PluginsState, msg *dns.Msg) error
|
|||
pluginsState.xTransport.mainProto,
|
||||
target,
|
||||
pluginsState.xTransport.internalResolvers,
|
||||
false,
|
||||
returnIPv4,
|
||||
returnIPv6,
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
220
dnscrypt-proxy/xtransport_outbound_source_test.go
Normal file
220
dnscrypt-proxy/xtransport_outbound_source_test.go
Normal 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)
|
||||
}
|
||||
Loading…
Reference in a new issue