Default managed SOCKS hostname DNS to verified HTTPS with literal-IP bootstrap and no plaintext fallback. Supervise the loopback forwarder with private anchored readiness and preserve foreign markers. Include configuration, deployment, documentation and offline checks. Co-authored-by: GPT-6 <gpt-6@openai.com>
665 lines
21 KiB
Go
665 lines
21 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"sync"
|
|
"sync/atomic"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type dnsRoundTripFunc func(*http.Request) (*http.Response, error)
|
|
|
|
func (f dnsRoundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
|
|
|
|
func testDNSQuery() []byte {
|
|
return []byte{0x12, 0x34, 1, 0x20, 0, 1, 0, 0, 0, 0, 0, 0, 3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0, 0, 1, 0, 1}
|
|
}
|
|
|
|
func testDNSResponse(query []byte) []byte {
|
|
response := append([]byte(nil), query...)
|
|
response[2] |= 0x80
|
|
response[3] |= 0x80
|
|
return response
|
|
}
|
|
|
|
func testDNSForwarder(t *testing.T, roundTrip dnsRoundTripFunc) *dnsForwarder {
|
|
t.Helper()
|
|
return &dnsForwarder{cfg: dnsConfigForTest(t, nil), client: &http.Client{Transport: roundTrip}, slots: make(chan struct{}, dnsConcurrency)}
|
|
}
|
|
|
|
func dnsHTTPResponse(body []byte) *http.Response {
|
|
return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": {"application/dns-message"}}, Body: io.NopCloser(bytes.NewReader(body)), ContentLength: int64(len(body))}
|
|
}
|
|
|
|
func TestDNSWireValidation(t *testing.T) {
|
|
query := testDNSQuery()
|
|
if !validDNSQuery(query) || !validDNSResponse(query, testDNSResponse(query)) {
|
|
t.Fatal("valid wire rejected")
|
|
}
|
|
edns := append([]byte(nil), query...)
|
|
edns[11] = 1
|
|
edns = append(edns, 0, 0, 41, 0x10, 0, 0, 0, 0x80, 0, 0, 0)
|
|
if !validDNSQuery(edns) {
|
|
t.Fatal("EDNS/DNSSEC query rejected")
|
|
}
|
|
failure := dnsServfail(edns)
|
|
if len(failure) != len(query) || !bytes.Equal(failure[:2], query[:2]) || failure[2] != 0x81 || failure[3] != 2 || !bytes.Equal(failure[12:], query[12:]) || !bytes.Equal(failure[6:12], make([]byte, 6)) {
|
|
t.Fatal(failure)
|
|
}
|
|
for _, mutate := range []func([]byte) []byte{
|
|
func(q []byte) []byte { return q[:11] },
|
|
func(q []byte) []byte { q[2] |= 0x80; return q },
|
|
func(q []byte) []byte { q[2] |= 0x08; return q },
|
|
func(q []byte) []byte { q[2] |= 0x04; return q },
|
|
func(q []byte) []byte { q[3] |= 0x40; return q },
|
|
func(q []byte) []byte { q[5] = 2; return q },
|
|
func(q []byte) []byte { q[7] = 1; return q },
|
|
func(q []byte) []byte { q[11] = 255; return q },
|
|
func(q []byte) []byte { q[12] = 64; return q },
|
|
func(q []byte) []byte { q[12] = 0xc0; q[13] = 12; return q },
|
|
func(q []byte) []byte { q[12] = 0xc0; q[13] = 255; return q },
|
|
func(q []byte) []byte { return q[:len(q)-1] },
|
|
func(q []byte) []byte { return append(q, 0) },
|
|
func(q []byte) []byte { return append(q, make([]byte, 4096)...) },
|
|
} {
|
|
bad := mutate(append([]byte(nil), query...))
|
|
if validDNSQuery(bad) || dnsServfail(bad) != nil {
|
|
t.Fatal("malformed query accepted")
|
|
}
|
|
}
|
|
// A backwards compression reference is legal; a self-reference is not.
|
|
if end, ok := dnsNameEnd(append(query, 0xc0, 12), len(query)); !ok || end != len(query)+2 {
|
|
t.Fatal(end, ok)
|
|
}
|
|
}
|
|
|
|
func TestDNSExchangePassThroughAndRejects(t *testing.T) {
|
|
query := testDNSQuery()
|
|
response := testDNSResponse(query)
|
|
// Opaque record bytes (including DNSSEC and TTL) must remain untouched.
|
|
response[7] = 1
|
|
response = append(response, 0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 37, 0, 4, 1, 2, 3, 4)
|
|
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
|
|
body, _ := io.ReadAll(r.Body)
|
|
if r.Method != "POST" || r.URL.String() != defaultDoHURL || r.Header.Get("Content-Type") != "application/dns-message" || r.Header.Get("Accept") != "application/dns-message" || !bytes.Equal(body, query) {
|
|
t.Error("incorrect DoH request")
|
|
}
|
|
return dnsHTTPResponse(response), nil
|
|
})
|
|
if actual := f.exchange(context.Background(), query); !bytes.Equal(actual, response) {
|
|
t.Fatal(actual)
|
|
}
|
|
for name, change := range map[string]func(*http.Response){
|
|
"status": func(r *http.Response) { r.StatusCode = 503 },
|
|
"type": func(r *http.Response) { r.Header.Set("Content-Type", "text/plain") },
|
|
"encoding": func(r *http.Response) { r.Header.Set("Content-Encoding", "gzip") },
|
|
"length": func(r *http.Response) { r.ContentLength++ },
|
|
"overflow": func(r *http.Response) {
|
|
r.Body = io.NopCloser(bytes.NewReader(make([]byte, 65536)))
|
|
r.ContentLength = 65536
|
|
},
|
|
"short": func(r *http.Response) { r.Body = io.NopCloser(bytes.NewReader(response[:11])); r.ContentLength = 11 },
|
|
"id": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[0]++
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"qr": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[2] &= 0x7f
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"opcode": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[2] |= 0x08
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"question": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[13] = 'x'
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"qdcount": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[5] = 0
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"record-count": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[7] = 2
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"record-length": func(r *http.Response) {
|
|
b := append([]byte(nil), response...)
|
|
b[len(query)+11] = 255
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
},
|
|
"truncated": func(r *http.Response) { r.Body = io.NopCloser(dnsBrokenReader{}) },
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) { r := dnsHTTPResponse(response); change(r); return r, nil })
|
|
if actual := f.exchange(context.Background(), query); !bytes.Equal(actual, dnsServfail(query)) {
|
|
t.Fatal(actual)
|
|
}
|
|
})
|
|
}
|
|
f = testDNSForwarder(t, func(*http.Request) (*http.Response, error) { return nil, errors.New("secret upstream") })
|
|
if !bytes.Equal(f.exchange(context.Background(), query), dnsServfail(query)) {
|
|
t.Fatal("outage not SERVFAIL")
|
|
}
|
|
}
|
|
|
|
type dnsBrokenReader struct{}
|
|
|
|
func (dnsBrokenReader) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
|
|
|
|
func TestDNSBootstrapAndHTTPPolicy(t *testing.T) {
|
|
cfg := dnsConfigForTest(t, nil)
|
|
var addresses []string
|
|
dial := dnsBootstrapDial(cfg, func(ctx context.Context, network, address string) (net.Conn, error) {
|
|
if network != "tcp" {
|
|
t.Fatal(network)
|
|
}
|
|
if _, ok := ctx.Deadline(); !ok {
|
|
t.Fatal("no bounded deadline")
|
|
}
|
|
addresses = append(addresses, address)
|
|
return nil, errDNSForwarder
|
|
})
|
|
for i := 0; i < 2; i++ {
|
|
dial(context.Background(), "tcp", "dns.google:443")
|
|
}
|
|
if len(addresses) != 4 || addresses[0] != "8.8.8.8:443" || addresses[2] != "8.8.4.4:443" {
|
|
t.Fatal(addresses)
|
|
}
|
|
for _, addr := range []string{"other:443", "dns.google:80", "8.8.8.8:443"} {
|
|
dial(context.Background(), "tcp", addr)
|
|
}
|
|
if len(addresses) != 4 {
|
|
t.Fatal("unexpected endpoint dialed")
|
|
}
|
|
cfg.BootstrapIPs = []net.IP{net.ParseIP("2001:db8::1")}
|
|
dnsBootstrapDial(cfg, func(_ context.Context, _, addr string) (net.Conn, error) {
|
|
if addr != "[2001:db8::1]:443" {
|
|
t.Fatal(addr)
|
|
}
|
|
return nil, errDNSForwarder
|
|
})(context.Background(), "tcp", "dns.google:443")
|
|
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
|
|
defer transport.CloseIdleConnections()
|
|
if transport.Proxy != nil || transport.TLSClientConfig.InsecureSkipVerify || transport.TLSClientConfig.ServerName != "dns.google" || transport.TLSClientConfig.MinVersion != tls.VersionTLS12 || !transport.DisableCompression || transport.MaxConnsPerHost != 16 {
|
|
t.Fatal("unsafe transport policy")
|
|
}
|
|
if client.CheckRedirect(&http.Request{}, nil) == nil {
|
|
t.Fatal("redirect allowed")
|
|
}
|
|
}
|
|
|
|
type dnsFakeRaw struct{ err error }
|
|
|
|
func (r dnsFakeRaw) Control(f func(uintptr)) error {
|
|
if r.err == nil {
|
|
f(42)
|
|
}
|
|
return r.err
|
|
}
|
|
func (dnsFakeRaw) Read(func(uintptr) bool) error { return nil }
|
|
func (dnsFakeRaw) Write(func(uintptr) bool) error { return nil }
|
|
|
|
func TestDNSSocketMarkStrict(t *testing.T) {
|
|
called := false
|
|
if err := setDNSSocketMark(dnsFakeRaw{}, func(fd, level, opt, mark int) error {
|
|
called = true
|
|
if fd != 42 || level != syscall.SOL_SOCKET || opt != syscall.SO_MARK || mark != 0x50000000 || mark&0x40000000 == 0 || mark&0x10000000 == 0 {
|
|
t.Fatal(fd, level, opt, mark)
|
|
}
|
|
return nil
|
|
}); err != nil || !called {
|
|
t.Fatal(err, called)
|
|
}
|
|
failure := errors.New("mark denied")
|
|
if err := setDNSSocketMark(dnsFakeRaw{}, func(int, int, int, int) error { return failure }); err != failure {
|
|
t.Fatal(err)
|
|
}
|
|
if err := setDNSSocketMark(dnsFakeRaw{err: failure}, func(int, int, int, int) error { t.Fatal("called on raw failure"); return nil }); err != failure {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestDNSTCPFramesAndCancellation(t *testing.T) {
|
|
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
|
|
q, _ := io.ReadAll(r.Body)
|
|
return dnsHTTPResponse(testDNSResponse(q)), nil
|
|
})
|
|
server, client := net.Pipe()
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan struct{})
|
|
go func() { defer close(done); f.tcpWorker(ctx, server) }()
|
|
defer client.Close()
|
|
client.SetDeadline(time.Now().Add(3 * time.Second))
|
|
q := testDNSQuery()
|
|
for i := 0; i < 2; i++ {
|
|
q[1] = byte(i)
|
|
var size [2]byte
|
|
binary.BigEndian.PutUint16(size[:], uint16(len(q)))
|
|
if err := writeDNSFrame(client, size[:], q); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := io.ReadFull(client, size[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b := make([]byte, int(binary.BigEndian.Uint16(size[:])))
|
|
if _, err := io.ReadFull(client, b); err != nil || !bytes.Equal(b, testDNSResponse(q)) {
|
|
t.Fatal(err, b)
|
|
}
|
|
}
|
|
cancel()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("idle TCP worker did not join")
|
|
}
|
|
}
|
|
|
|
func TestDNSTCPLimits(t *testing.T) {
|
|
for _, n := range []int{11, 4097, 65535} {
|
|
t.Run(fmt.Sprint(n), func(t *testing.T) {
|
|
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) {
|
|
t.Error("invalid frame forwarded")
|
|
return nil, errDNSForwarder
|
|
})
|
|
server, client := net.Pipe()
|
|
done := make(chan struct{})
|
|
go func() { defer close(done); f.tcpWorker(context.Background(), server) }()
|
|
client.SetDeadline(time.Now().Add(time.Second))
|
|
var size [2]byte
|
|
binary.BigEndian.PutUint16(size[:], uint16(n))
|
|
client.Write(size[:])
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("invalid frame not closed")
|
|
}
|
|
client.Close()
|
|
})
|
|
}
|
|
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
|
|
q, _ := io.ReadAll(r.Body)
|
|
return dnsHTTPResponse(testDNSResponse(q)), nil
|
|
})
|
|
server, client := net.Pipe()
|
|
defer client.Close()
|
|
client.SetDeadline(time.Now().Add(3 * time.Second))
|
|
done := make(chan struct{})
|
|
go func() { defer close(done); f.tcpWorker(context.Background(), server) }()
|
|
q := testDNSQuery()
|
|
var size [2]byte
|
|
for i := 0; i < 16; i++ {
|
|
binary.BigEndian.PutUint16(size[:], uint16(len(q)))
|
|
if err := writeDNSFrame(client, size[:], q); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := io.ReadFull(client, size[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := io.CopyN(io.Discard, client, int64(binary.BigEndian.Uint16(size[:]))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("frame lifetime cap not enforced")
|
|
}
|
|
}
|
|
|
|
func TestDNSRedirectNeverFollowed(t *testing.T) {
|
|
cfg := dnsConfigForTest(t, nil)
|
|
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
|
|
defer transport.CloseIdleConnections()
|
|
var calls int
|
|
client.Transport = dnsRoundTripFunc(func(*http.Request) (*http.Response, error) {
|
|
calls++
|
|
return &http.Response{StatusCode: 302, Header: http.Header{"Location": {"https://secret.example/dns-query"}}, Body: io.NopCloser(bytes.NewReader(nil))}, nil
|
|
})
|
|
f := &dnsForwarder{cfg: cfg, client: client}
|
|
if !bytes.Equal(f.exchange(context.Background(), testDNSQuery()), dnsServfail(testDNSQuery())) || calls != 1 {
|
|
t.Fatal("redirect followed", calls)
|
|
}
|
|
}
|
|
|
|
func TestDNSReadinessFailureClosesListeners(t *testing.T) {
|
|
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) {
|
|
t.Error("request before ready")
|
|
return nil, errDNSForwarder
|
|
})
|
|
p := &dnsFakePacketConn{closed: make(chan struct{})}
|
|
l := &dnsIdleListener{closed: make(chan struct{})}
|
|
if err := f.run(context.Background(), p, l, func() (func(), error) { return nil, errDNSForwarder }); err == nil {
|
|
t.Fatal("readiness error ignored")
|
|
}
|
|
select {
|
|
case <-p.closed:
|
|
default:
|
|
t.Fatal("UDP not closed")
|
|
}
|
|
select {
|
|
case <-l.closed:
|
|
default:
|
|
t.Fatal("TCP not closed")
|
|
}
|
|
}
|
|
|
|
func TestDNSReadyOwnership(t *testing.T) {
|
|
dir := t.TempDir()
|
|
os.Chmod(dir, 0700)
|
|
path := filepath.Join(dir, "dns-ready")
|
|
cleanup, err := createDNSReady(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
info, _ := os.Stat(path)
|
|
body, _ := os.ReadFile(path)
|
|
if info.Mode().Perm() != 0600 || string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
|
|
t.Fatal(info, string(body))
|
|
}
|
|
if _, err := createDNSReady(path); err == nil {
|
|
t.Fatal("existing readiness overwritten")
|
|
}
|
|
if entries, err := os.ReadDir(dir); err != nil || len(entries) != 1 || entries[0].Name() != "dns-ready" {
|
|
t.Fatal("readiness publication/failure left a temporary link", entries, err)
|
|
}
|
|
// The forwarder itself must hold both descriptors, not the test, so an
|
|
// unlinked readiness inode cannot be recycled for a foreign replacement.
|
|
fileFD := dnsHeldFD(t, info)
|
|
parentInfo, _ := os.Stat(dir)
|
|
parentFD := dnsHeldFD(t, parentInfo)
|
|
os.Remove(path)
|
|
var held syscall.Stat_t
|
|
if err := syscall.Fstat(fileFD, &held); err != nil || held.Nlink != 0 {
|
|
t.Fatal("readiness inode not held after unlink", err, held.Nlink)
|
|
}
|
|
os.WriteFile(path, []byte("replacement"), 0600)
|
|
cleanup()
|
|
cleanup() // Idempotent even after its descriptors have been closed.
|
|
for _, fd := range []int{fileFD, parentFD} {
|
|
if err := syscall.Fstat(fd, &held); err != syscall.EBADF {
|
|
t.Fatal("cleanup leaked descriptor", fd, err)
|
|
}
|
|
}
|
|
if b, err := os.ReadFile(path); err != nil || string(b) != "replacement" {
|
|
t.Fatal("foreign readiness removed", err)
|
|
}
|
|
os.Remove(path)
|
|
cleanup, err = createDNSReady(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cleanup()
|
|
if _, err := os.Lstat(path); !os.IsNotExist(err) {
|
|
t.Fatal(err)
|
|
}
|
|
os.Symlink("missing", path)
|
|
if _, err := createDNSReady(path); err == nil {
|
|
t.Fatal("symlink accepted")
|
|
}
|
|
os.Remove(path)
|
|
os.Chmod(dir, 0755)
|
|
if _, err := createDNSReady(path); err == nil {
|
|
t.Fatal("public parent accepted")
|
|
}
|
|
}
|
|
|
|
func dnsHeldFD(t *testing.T, info os.FileInfo) int {
|
|
t.Helper()
|
|
entries, err := os.ReadDir("/proc/self/fd")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := info.Sys().(*syscall.Stat_t)
|
|
for _, entry := range entries {
|
|
fd, err := strconv.Atoi(entry.Name())
|
|
if err != nil {
|
|
continue
|
|
}
|
|
var stat syscall.Stat_t
|
|
if syscall.Fstat(fd, &stat) == nil && stat.Ino == want.Ino && stat.Dev == want.Dev {
|
|
return fd
|
|
}
|
|
}
|
|
t.Fatal("owned inode has no held descriptor")
|
|
return -1
|
|
}
|
|
|
|
func TestDNSReadyAtomicPublication(t *testing.T) {
|
|
dir := t.TempDir()
|
|
file, err := os.CreateTemp(dir, ".dns-ready-")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer file.Close()
|
|
path := filepath.Join(dir, "dns-ready")
|
|
if _, err := os.Lstat(path); !os.IsNotExist(err) {
|
|
t.Fatal("readiness published before PID", err)
|
|
}
|
|
if err := publishDNSReady(file, path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if body, err := os.ReadFile(path); err != nil || string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
|
|
t.Fatal("partial PID published", string(body), err)
|
|
}
|
|
other, err := os.CreateTemp(dir, "foreign-")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer other.Close()
|
|
if err := publishDNSReady(other, path); !os.IsExist(err) {
|
|
t.Fatal("publication overwrote existing inode", err)
|
|
}
|
|
if body, _ := os.ReadFile(path); string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
|
|
t.Fatal("original PID changed")
|
|
}
|
|
}
|
|
|
|
// Verify actual certificate validation over net.Pipe, never a TCP network listener.
|
|
func TestDNSVerifiedTLSOverPipe(t *testing.T) {
|
|
key, err := rsa.GenerateKey(rand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
template := &x509.Certificate{SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "dns.google"}, DNSNames: []string{"dns.google"}, NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour), KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, IsCA: true, BasicConstraintsValid: true}
|
|
der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cert, err := x509.ParseCertificate(der)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, name := range []string{"trusted", "untrusted", "wrong-name"} {
|
|
t.Run(name, func(t *testing.T) {
|
|
cfg := dnsConfigForTest(t, nil)
|
|
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
|
|
defer transport.CloseIdleConnections()
|
|
if name != "untrusted" {
|
|
roots := x509.NewCertPool()
|
|
roots.AddCert(cert)
|
|
transport.TLSClientConfig.RootCAs = roots
|
|
}
|
|
if name == "wrong-name" {
|
|
transport.TLSClientConfig.ServerName = "wrong.example"
|
|
}
|
|
var servers sync.WaitGroup
|
|
transport.DialContext = dnsBootstrapDial(cfg, func(ctx context.Context, _, addr string) (net.Conn, error) {
|
|
if addr != "8.8.8.8:443" && addr != "8.8.4.4:443" {
|
|
t.Error(addr)
|
|
}
|
|
a, b := net.Pipe()
|
|
servers.Add(1)
|
|
go func() {
|
|
defer servers.Done()
|
|
defer b.Close()
|
|
b.SetDeadline(time.Now().Add(3 * time.Second))
|
|
tlsConn := tls.Server(b, &tls.Config{Certificates: []tls.Certificate{{Certificate: [][]byte{der}, PrivateKey: key}}, MinVersion: tls.VersionTLS12})
|
|
if err := tlsConn.Handshake(); err != nil {
|
|
return
|
|
}
|
|
if tlsConn.ConnectionState().ServerName != "dns.google" {
|
|
t.Error("SNI changed")
|
|
}
|
|
request, err := http.ReadRequest(bufio.NewReader(tlsConn))
|
|
if err != nil {
|
|
return
|
|
}
|
|
q, _ := io.ReadAll(request.Body)
|
|
request.Body.Close()
|
|
response := dnsHTTPResponse(testDNSResponse(q))
|
|
response.Close = true
|
|
response.Write(tlsConn)
|
|
}()
|
|
return a, nil
|
|
})
|
|
f := &dnsForwarder{cfg: cfg, client: client}
|
|
actual := f.exchange(context.Background(), testDNSQuery())
|
|
want := dnsServfail(testDNSQuery())
|
|
if name == "trusted" {
|
|
want = testDNSResponse(testDNSQuery())
|
|
}
|
|
if !bytes.Equal(actual, want) {
|
|
t.Fatal(actual)
|
|
}
|
|
transport.CloseIdleConnections()
|
|
servers.Wait()
|
|
})
|
|
}
|
|
}
|
|
|
|
type dnsTestPacket struct {
|
|
data []byte
|
|
addr net.Addr
|
|
}
|
|
type dnsFakePacketConn struct {
|
|
incoming chan dnsTestPacket
|
|
outgoing chan dnsTestPacket
|
|
closed chan struct{}
|
|
once sync.Once
|
|
}
|
|
|
|
func (p *dnsFakePacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
|
|
select {
|
|
case q := <-p.incoming:
|
|
return copy(b, q.data), q.addr, nil
|
|
case <-p.closed:
|
|
return 0, nil, net.ErrClosed
|
|
}
|
|
}
|
|
func (p *dnsFakePacketConn) WriteTo(b []byte, a net.Addr) (int, error) {
|
|
select {
|
|
case p.outgoing <- dnsTestPacket{append([]byte(nil), b...), a}:
|
|
return len(b), nil
|
|
case <-p.closed:
|
|
return 0, net.ErrClosed
|
|
}
|
|
}
|
|
func (p *dnsFakePacketConn) Close() error { p.once.Do(func() { close(p.closed) }); return nil }
|
|
func (p *dnsFakePacketConn) LocalAddr() net.Addr { return &net.UDPAddr{} }
|
|
func (p *dnsFakePacketConn) SetDeadline(time.Time) error { return nil }
|
|
func (p *dnsFakePacketConn) SetReadDeadline(time.Time) error { return nil }
|
|
func (p *dnsFakePacketConn) SetWriteDeadline(time.Time) error { return nil }
|
|
|
|
type dnsIdleListener struct {
|
|
closed chan struct{}
|
|
once sync.Once
|
|
}
|
|
|
|
func (l *dnsIdleListener) Accept() (net.Conn, error) { <-l.closed; return nil, net.ErrClosed }
|
|
func (l *dnsIdleListener) Close() error { l.once.Do(func() { close(l.closed) }); return nil }
|
|
func (l *dnsIdleListener) Addr() net.Addr { return &net.TCPAddr{} }
|
|
|
|
func TestDNSUDPBoundedCopiesAndJoins(t *testing.T) {
|
|
var active, maximum atomic.Int32
|
|
started := make(chan struct{}, dnsConcurrency)
|
|
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
|
|
n := active.Add(1)
|
|
defer active.Add(-1)
|
|
for old := maximum.Load(); n > old; old = maximum.Load() {
|
|
if maximum.CompareAndSwap(old, n) {
|
|
break
|
|
}
|
|
}
|
|
q, _ := io.ReadAll(r.Body)
|
|
started <- struct{}{}
|
|
<-r.Context().Done()
|
|
if q[1] >= dnsConcurrency {
|
|
t.Error("UDP buffer was reused")
|
|
}
|
|
return nil, r.Context().Err()
|
|
})
|
|
p := &dnsFakePacketConn{incoming: make(chan dnsTestPacket, 32), outgoing: make(chan dnsTestPacket, 32), closed: make(chan struct{})}
|
|
l := &dnsIdleListener{closed: make(chan struct{})}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
ready := make(chan struct{})
|
|
cleaned := make(chan struct{})
|
|
done := make(chan error, 1)
|
|
go func() {
|
|
done <- f.run(ctx, p, l, func() (func(), error) { close(ready); return func() { close(cleaned) }, nil })
|
|
}()
|
|
<-ready
|
|
for i := 0; i < dnsConcurrency; i++ {
|
|
q := testDNSQuery()
|
|
q[1] = byte(i)
|
|
p.incoming <- dnsTestPacket{q, &net.UDPAddr{}}
|
|
}
|
|
for i := 0; i < dnsConcurrency; i++ {
|
|
select {
|
|
case <-started:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("worker not started")
|
|
}
|
|
}
|
|
q := testDNSQuery()
|
|
q[1] = 99
|
|
p.incoming <- dnsTestPacket{q, &net.UDPAddr{}}
|
|
select {
|
|
case response := <-p.outgoing:
|
|
if !bytes.Equal(response.data, dnsServfail(q)) {
|
|
t.Fatal(response)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("saturation not SERVFAIL")
|
|
}
|
|
cancel()
|
|
select {
|
|
case err := <-done:
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatal("workers not joined")
|
|
}
|
|
<-cleaned
|
|
if maximum.Load() != dnsConcurrency || active.Load() != 0 || len(f.slots) != 0 {
|
|
t.Fatal(maximum.Load(), active.Load(), len(f.slots))
|
|
}
|
|
}
|