feat: add configurable PID1-owned DoH forwarding

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>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-13 14:32:58 +03:00
1 parent ea886e5bc8
commit 367d956ae3
20 files changed
+2383 -37

No files matched your search

+663
View File
@@ -0,0 +1,663 @@
package main
import (
"bytes"
"context"
"crypto/tls"
"encoding/binary"
"errors"
"fmt"
"io"
"mime"
"net"
"net/http"
"os"
"os/signal"
"path/filepath"
"strconv"
"sync"
"sync/atomic"
"syscall"
"time"
)
const dnsSocketMark = 0x50000000 // Exclude both deployed (0x40000000) and probe (0x10000000) queues.
const dnsMaxQuery = 4096
const dnsConcurrency = 16
const dnsMaxUDPPayload = 65507 // Fixed IPv4 listener: maximum UDP payload, excluding IP/UDP headers.
var errDNSForwarder = errors.New("DNS forwarder unavailable")
func markDNSSocket(_, _ string, raw syscall.RawConn) error {
return setDNSSocketMark(raw, syscall.SetsockoptInt)
}
func setDNSSocketMark(raw syscall.RawConn, set func(int, int, int, int) error) error {
var markErr error
err := raw.Control(func(fd uintptr) { markErr = set(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, dnsSocketMark) })
if err != nil {
return err
}
return markErr
}
type dnsDialFunc func(context.Context, string, string) (net.Conn, error)
func dnsBootstrapDial(cfg managedDNSConfig, dial dnsDialFunc) dnsDialFunc {
var next atomic.Uint64
return func(ctx context.Context, network, address string) (net.Conn, error) {
if network != "tcp" || address != net.JoinHostPort(cfg.Host, "443") || len(cfg.BootstrapIPs) == 0 {
return nil, errDNSForwarder
}
ctx, cancelAll := context.WithTimeout(ctx, cfg.Timeout)
defer cancelAll()
start := int((next.Add(1) - 1) % uint64(len(cfg.BootstrapIPs)))
for i := range cfg.BootstrapIPs {
if ctx.Err() != nil {
break
}
// Give every bootstrap a bounded share of the remaining deadline.
remaining := cfg.Timeout
if deadline, ok := ctx.Deadline(); ok {
remaining = time.Until(deadline)
}
attempt, cancel := context.WithTimeout(ctx, remaining/time.Duration(len(cfg.BootstrapIPs)-i))
conn, err := dial(attempt, "tcp", net.JoinHostPort(cfg.BootstrapIPs[(start+i)%len(cfg.BootstrapIPs)].String(), "443"))
cancel()
if err == nil {
return conn, nil
}
}
return nil, errDNSForwarder
}
}
func newDNSHTTPClient(cfg managedDNSConfig, control func(string, string, syscall.RawConn) error) (*http.Client, *http.Transport) {
dialer := &net.Dialer{Timeout: cfg.Timeout, Control: control}
transport := &http.Transport{
Proxy: nil, DialContext: dnsBootstrapDial(cfg, dialer.DialContext),
TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12, ServerName: cfg.Host},
TLSHandshakeTimeout: cfg.Timeout, ResponseHeaderTimeout: cfg.Timeout,
DisableCompression: true, MaxConnsPerHost: dnsConcurrency,
MaxIdleConns: dnsConcurrency, MaxIdleConnsPerHost: dnsConcurrency,
IdleConnTimeout: 30 * time.Second, MaxResponseHeaderBytes: 8192,
}
return &http.Client{Transport: transport, Timeout: cfg.Timeout, CheckRedirect: func(*http.Request, []*http.Request) error { return errDNSForwarder }}, transport
}
// DNS names may use compression. Bound both pointer traversal and expanded name size.
func dnsNameEnd(wire []byte, start int) (int, bool) {
end, _, ok := dnsName(wire, start)
return end, ok
}
func dnsName(wire []byte, start int) (int, []byte, bool) {
pos, end, expanded := start, -1, 0
var name []byte
for steps := 0; steps < 256; steps++ {
if pos < 12 || pos >= len(wire) {
return 0, nil, false
}
n := int(wire[pos])
pos++
if n == 0 {
if end < 0 {
end = pos
}
return end, append(name, 0), true
}
if n&0xc0 == 0xc0 {
if pos >= len(wire) {
return 0, nil, false
}
target := (n&0x3f)<<8 | int(wire[pos])
if target < 12 || target >= len(wire) {
return 0, nil, false
}
if end < 0 {
end = pos + 1
}
pos = target
continue
}
if n > 63 || pos+n >= len(wire) {
return 0, nil, false
}
expanded += n + 1
if expanded > 254 {
return 0, nil, false
}
name = append(name, byte(n))
name = append(name, wire[pos:pos+n]...)
pos += n
}
return 0, nil, false
}
func dnsQuestionEnd(wire []byte) (int, bool) {
end, _, ok := dnsQuestion(wire)
return end, ok
}
func dnsQuestion(wire []byte) (int, []byte, bool) {
if len(wire) < 12 || binary.BigEndian.Uint16(wire[4:6]) != 1 {
return 0, nil, false
}
end, name, ok := dnsName(wire, 12)
if !ok || end+4 > len(wire) {
return 0, nil, false
}
if binary.BigEndian.Uint16(wire[end:end+2]) == 0 || binary.BigEndian.Uint16(wire[end+2:end+4]) == 0 {
return 0, nil, false
}
return end + 4, append(name, wire[end:end+4]...), true
}
func validDNSQuery(wire []byte) bool {
if len(wire) < 12 || len(wire) > dnsMaxQuery || wire[2]&0xfe != 0 || wire[3]&0xcf != 0 || binary.BigEndian.Uint16(wire[6:8]) != 0 || binary.BigEndian.Uint16(wire[8:10]) != 0 {
return false
}
end, ok := dnsQuestionEnd(wire)
if !ok {
return false
}
_, ok = dnsQueryUDPLimit(wire, end)
return ok
}
// Query additional records have the same framing as answers. Only OPT affects
// downstream UDP sizing; its root owner and option framing must be valid.
func dnsQueryUDPLimit(wire []byte, end int) (int, bool) {
limit, seenOPT := 512, false
for count := int(binary.BigEndian.Uint16(wire[10:12])); count > 0; count-- {
header, name, ok := dnsName(wire, end)
if !ok || header+10 > len(wire) {
return 0, false
}
end = header + 10 + int(binary.BigEndian.Uint16(wire[header+8:header+10]))
if end > len(wire) {
return 0, false
}
if binary.BigEndian.Uint16(wire[header:header+2]) != 41 {
continue
}
if seenOPT || len(name) != 1 || wire[header+4] != 0 || wire[header+5] != 0 || binary.BigEndian.Uint16(wire[header+6:header+8])&0x7fff != 0 {
return 0, false
}
seenOPT = true
limit = int(binary.BigEndian.Uint16(wire[header+2 : header+4]))
if limit < 512 {
limit = 512
}
if limit > dnsMaxUDPPayload {
limit = dnsMaxUDPPayload
}
for option := header + 10; option < end; {
if option+4 > end {
return 0, false
}
option += 4 + int(binary.BigEndian.Uint16(wire[option+2:option+4]))
if option > end {
return 0, false
}
}
}
return limit, end == len(wire)
}
// Validate only record boundaries (including EDNS/DNSSEC), never decode or rewrite RDATA.
func validDNSRecordFraming(wire []byte, end, count int) bool {
for ; count > 0; count-- {
var ok bool
end, ok = dnsNameEnd(wire, end)
if !ok || end+10 > len(wire) {
return false
}
end += 10 + int(binary.BigEndian.Uint16(wire[end+8:end+10]))
if end > len(wire) {
return false
}
}
return end == len(wire)
}
func validDNSResponse(query, response []byte) bool {
if len(query) < 12 || len(response) < 12 || len(response) > 65535 || response[2]&0x80 == 0 || response[2]&0x78 != query[2]&0x78 || !bytes.Equal(query[:2], response[:2]) || response[3]&0x40 != 0 {
return false
}
_, question, qok := dnsQuestion(query)
re, responseQuestion, rok := dnsQuestion(response)
if !qok || !rok || !bytes.Equal(question, responseQuestion) {
return false
}
count := int(binary.BigEndian.Uint16(response[6:8])) + int(binary.BigEndian.Uint16(response[8:10])) + int(binary.BigEndian.Uint16(response[10:12]))
return validDNSRecordFraming(response, re, count)
}
func dnsServfail(query []byte) []byte {
if !validDNSQuery(query) {
return nil
}
reply := dnsQuestionReply(query, query)
reply[2] = 0x80 | query[2]&0x79 // QR, opcode and RD, not AA/TC.
reply[3] = 0x02 // SERVFAIL, no fabricated recursion/DNSSEC assertions.
return reply
}
// Re-encode the question without pointers into records omitted from this reply.
func dnsQuestionReply(query, header []byte) []byte {
_, question, ok := dnsQuestion(query)
if !ok || len(header) < 12 {
return nil
}
reply := append([]byte(nil), header[:12]...)
clear(reply[6:12])
return append(reply, question...)
}
func dnsUDPReply(query, response []byte) []byte {
if response == nil {
return nil
}
end, ok := dnsQuestionEnd(query)
if !ok {
return nil
}
limit, ok := dnsQueryUDPLimit(query, end)
if !ok {
return nil
}
if len(response) <= limit {
return response
}
reply := dnsQuestionReply(query, response)
if reply != nil {
reply[2] |= 0x82 // QR and TC; preserve upstream opcode, RD, AA and other flags.
reply[3] &^= 0x40 // Reserved Z bit; no records/assertions are invented.
}
return reply
}
func writeDNSDatagram(udp net.PacketConn, addr net.Addr, query, response []byte) {
if reply := dnsUDPReply(query, response); reply != nil {
if _, err := udp.WriteTo(reply, addr); err != nil {
return
} // Drop only this datagram; never retry plaintext or stop the server.
}
}
type dnsForwarder struct {
cfg managedDNSConfig
client *http.Client
slots chan struct{}
}
func (f *dnsForwarder) exchange(ctx context.Context, query []byte) []byte {
if !validDNSQuery(query) {
return nil
}
ctx, cancel := context.WithTimeout(ctx, f.cfg.Timeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodPost, f.cfg.URL, bytes.NewReader(query))
if err != nil {
return dnsServfail(query)
}
req.Header.Set("Content-Type", "application/dns-message")
req.Header.Set("Accept", "application/dns-message")
resp, err := f.client.Do(req)
if err != nil {
return dnsServfail(query)
}
defer resp.Body.Close()
typ, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil || typ != "application/dns-message" || resp.StatusCode != http.StatusOK || resp.Header.Get("Content-Encoding") != "" {
return dnsServfail(query)
}
body, err := io.ReadAll(io.LimitReader(resp.Body, 65536))
if err != nil || resp.ContentLength >= 0 && resp.ContentLength != int64(len(body)) || !validDNSResponse(query, body) {
return dnsServfail(query)
}
return body
}
// One connection owns one request slot; frames are sequential, capped in number
// and total lifetime, so slow/idle clients cannot create unbounded workers.
func (f *dnsForwarder) tcpWorker(ctx context.Context, conn net.Conn) {
defer conn.Close()
stop := context.AfterFunc(ctx, func() { conn.Close() })
defer stop()
lifetime := time.Now().Add(16 * f.cfg.Timeout)
for frame := 0; frame < 16; frame++ {
deadline := time.Now().Add(f.cfg.Timeout)
if lifetime.Before(deadline) {
deadline = lifetime
}
if err := conn.SetDeadline(deadline); err != nil {
return
}
var size [2]byte
if _, err := io.ReadFull(conn, size[:]); err != nil {
return
}
n := int(binary.BigEndian.Uint16(size[:]))
if n < 12 || n > dnsMaxQuery {
return
}
query := make([]byte, n)
if _, err := io.ReadFull(conn, query); err != nil {
return
}
reply := f.exchange(ctx, query)
if reply == nil {
return
}
binary.BigEndian.PutUint16(size[:], uint16(len(reply)))
if err := writeDNSFrame(conn, size[:], reply); err != nil {
return
}
}
}
func writeDNSFrame(w io.Writer, size, reply []byte) error {
for _, part := range [][]byte{size, reply} {
for len(part) > 0 {
n, err := w.Write(part)
if err != nil {
return err
}
if n == 0 {
return io.ErrShortWrite
}
part = part[n:]
}
}
return nil
}
func (f *dnsForwarder) run(ctx context.Context, udp net.PacketConn, tcp net.Listener, ready func() (func(), error)) error {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
stop := context.AfterFunc(ctx, func() { udp.Close(); tcp.Close() })
defer stop()
defer udp.Close()
defer tcp.Close()
cleanup, err := ready()
if err != nil {
return errDNSForwarder
}
defer cleanup()
var workers sync.WaitGroup
var loops sync.WaitGroup
var failed atomic.Bool
loops.Add(2)
go func() {
defer loops.Done()
buffer := make([]byte, dnsMaxQuery+1)
for {
n, addr, err := udp.ReadFrom(buffer)
if err != nil {
if ctx.Err() == nil {
failed.Store(true)
cancel()
}
return
}
if !validDNSQuery(buffer[:n]) {
continue
}
select {
case f.slots <- struct{}{}:
query := append([]byte(nil), buffer[:n]...)
workers.Add(1)
go func() {
defer workers.Done()
defer func() { <-f.slots }()
if reply := f.exchange(ctx, query); reply != nil {
writeDNSDatagram(udp, addr, query, reply)
}
}()
default:
writeDNSDatagram(udp, addr, buffer[:n], dnsServfail(buffer[:n]))
}
}
}()
go func() {
defer loops.Done()
for {
conn, err := tcp.Accept()
if err != nil {
if ctx.Err() == nil {
failed.Store(true)
cancel()
}
return
}
select {
case f.slots <- struct{}{}:
workers.Add(1)
go func() { defer workers.Done(); defer func() { <-f.slots }(); f.tcpWorker(ctx, conn) }()
default:
conn.Close()
}
}
}()
loops.Wait()
workers.Wait()
if failed.Load() {
return errDNSForwarder
}
return nil
}
func createDNSReady(path string) (func(), error) {
dir := filepath.Dir(path)
if err := managedDirectory(dir); err != nil {
return nil, errDNSForwarder
}
info, err := os.Lstat(dir)
if err != nil || info.Mode().Perm() != 0700 || info.Mode()&(os.ModeSetuid|os.ModeSetgid|os.ModeSticky) != 0 {
return nil, errDNSForwarder
}
fd, err := syscall.Open(dir, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW|syscall.O_CLOEXEC, 0)
if err != nil {
return nil, errDNSForwarder
}
parent := os.NewFile(uintptr(fd), dir)
opened, err := parent.Stat()
if err != nil || !os.SameFile(info, opened) {
parent.Close()
return nil, errDNSForwarder
}
heldDir := fmt.Sprintf("/proc/self/fd/%d", fd)
file, err := os.CreateTemp(heldDir, ".dns-ready-")
if err != nil {
parent.Close()
return nil, errDNSForwarder
}
owned, statErr := file.Stat()
if statErr == nil && owned.Mode().Perm() != 0600 {
statErr = errDNSForwarder
}
var once sync.Once
cleanup := func() {
once.Do(func() {
// Inspect and unlink relative to the held private parent, not a replacement directory.
for _, name := range []string{filepath.Base(path), filepath.Base(file.Name())} {
current, e := os.Lstat(filepath.Join(heldDir, name))
if e == nil && owned != nil && os.SameFile(owned, current) {
syscall.Unlinkat(fd, name)
}
}
parent.Close()
// Hold the inode until all identity checks/unlinks finish, preventing reuse.
file.Close()
})
}
if statErr == nil {
err = publishDNSReady(file, filepath.Join(heldDir, filepath.Base(path)))
}
if statErr != nil || err != nil {
cleanup()
return nil, errDNSForwarder
}
if err := syscall.Unlinkat(fd, filepath.Base(file.Name())); err != nil {
cleanup()
return nil, errDNSForwarder
}
return cleanup, nil
}
func publishDNSReady(file *os.File, destination string) error {
if _, err := fmt.Fprintf(file, "%d\n", os.Getpid()); err != nil {
return err
}
if err := file.Sync(); err != nil {
return err
}
return os.Link(file.Name(), destination) // Atomic complete-PID publication, EXCL even for a symlink destination.
}
func serveDNSForwarder(ctx context.Context, cfg managedDNSConfig) error {
udp, err := net.ListenPacket("udp4", dnsListenAddress)
if err != nil {
return errDNSForwarder
}
tcp, err := net.Listen("tcp4", dnsListenAddress)
if err != nil {
udp.Close()
return errDNSForwarder
}
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
defer transport.CloseIdleConnections()
f := &dnsForwarder{cfg: cfg, client: client, slots: make(chan struct{}, dnsConcurrency)}
return f.run(ctx, udp, tcp, func() (func(), error) { return createDNSReady(dnsReadyPath) })
}
func dnsForwarderCLI(args []string, stdout, stderr io.Writer) int {
if len(args) > 0 && (args[0] == "readiness-check" || args[0] == "readiness-cleanup") {
return dnsReadinessCLI(args, stderr)
}
if len(args) != 1 || (args[0] != "mode" && args[0] != "address" && args[0] != "serve") {
fmt.Fprintln(stderr, "configerror: invalid DNS forwarder command")
return 64
}
cfg, err := parseManagedDNSConfig(os.LookupEnv)
if err != nil || args[0] == "serve" && cfg.Mode != "doh" {
fmt.Fprintln(stderr, "configerror: invalid managed DNS configuration")
return 64
}
switch args[0] {
case "mode":
_, err = fmt.Fprintln(stdout, cfg.Mode)
case "address":
_, err = fmt.Fprintln(stdout, cfg.serverAddress())
case "serve":
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
err = serveDNSForwarder(ctx, cfg)
}
if err != nil {
fmt.Fprintln(stderr, "error: DNS forwarder unavailable")
return 75
}
return 0
}
// PID 1 holds FD 8 (private directory) and FD 9 (readiness inode) across the
// child's lifetime, including SIGKILL. Helpers borrow duplicates, never offsets.
func duplicateDNSAnchor(fd int) (*os.File, error) {
// Keep duplicates above both reserved descriptors; a missing anchor must
// never be filled by duplicating the other one.
duplicate, _, err := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), syscall.F_DUPFD_CLOEXEC, 10)
if err != 0 {
return nil, errDNSForwarder
}
return os.NewFile(duplicate, "DNS readiness anchor"), nil
}
func dnsReadinessCLI(args []string, stderr io.Writer) int {
if len(args) != 2 {
fmt.Fprintln(stderr, "configerror: invalid DNS readiness command")
return 64
}
pid, err := strconv.ParseInt(args[1], 10, 32)
if err != nil || pid <= 1 || strconv.FormatInt(pid, 10) != args[1] {
fmt.Fprintln(stderr, "configerror: invalid DNS readiness command")
return 64
}
cfg, err := parseManagedDNSConfig(os.LookupEnv)
if err != nil || cfg.Mode != "doh" {
fmt.Fprintln(stderr, "configerror: invalid managed DNS configuration")
return 64
}
anchor, _ := duplicateDNSAnchor(9)
if anchor != nil {
defer anchor.Close()
}
parent, err := duplicateDNSAnchor(8)
if err == nil {
defer parent.Close()
err = dnsReadinessAction(parent, anchor, int(pid), args[0] == "readiness-cleanup")
}
if err != nil {
fmt.Fprintln(stderr, "error: DNS readiness ownership unavailable")
return 78
}
return 0
}
func dnsOwnedAnchor(info os.FileInfo, directory bool) bool {
stat, ok := info.Sys().(*syscall.Stat_t)
if !ok || stat.Uid != uint32(os.Geteuid()) || info.Mode()&(os.ModeSetuid|os.ModeSetgid|os.ModeSticky) != 0 {
return false
}
if directory {
return info.IsDir() && info.Mode().Perm() == 0700
}
return info.Mode().IsRegular() && info.Mode().Perm() == 0600
}
func dnsReadinessAction(parent, anchor *os.File, expectedPID int, cleanup bool) error {
if parent == nil || expectedPID <= 1 || int64(expectedPID) > 2147483647 {
return errDNSForwarder
}
info, err := parent.Stat()
if err != nil || !dnsOwnedAnchor(info, true) {
return errDNSForwarder
}
name := filepath.Base(dnsReadyPath)
fd, err := syscall.Openat(int(parent.Fd()), name, syscall.O_RDONLY|syscall.O_NONBLOCK|syscall.O_NOFOLLOW|syscall.O_CLOEXEC, 0)
if err != nil {
if cleanup && errors.Is(err, syscall.ENOENT) {
return nil
}
return errDNSForwarder
}
current := os.NewFile(uintptr(fd), "DNS readiness entry")
defer current.Close()
if anchor == nil {
return errDNSForwarder
}
owned, err := anchor.Stat()
if err != nil || !dnsOwnedAnchor(owned, false) {
return errDNSForwarder
}
entry, err := current.Stat()
if err != nil || !dnsOwnedAnchor(entry, false) || !os.SameFile(owned, entry) {
return errDNSForwarder
}
expected := strconv.Itoa(expectedPID) + "\n"
if owned.Size() != int64(len(expected)) {
return errDNSForwarder
}
buffer := make([]byte, len(expected))
if _, err := anchor.ReadAt(buffer, 0); err != nil || string(buffer) != expected {
return errDNSForwarder
}
if cleanup {
if err := syscall.Unlinkat(int(parent.Fd()), name); err != nil && !errors.Is(err, syscall.ENOENT) {
return errDNSForwarder
}
}
return nil
}
+105
View File
@@ -0,0 +1,105 @@
package main
import (
"errors"
"net"
"net/url"
"strconv"
"strings"
"time"
)
const defaultDoHURL = "https://dns.google/dns-query"
const dnsListenAddress = "127.0.0.1:5353"
const dnsReadyPath = "/run/zapret-autotune-ss/dns-ready"
var errDNSConfig = errors.New("invalid managed DNS configuration")
type managedDNSConfig struct {
Mode string
URL string
Host string
BootstrapIPs []net.IP
Timeout time.Duration
NativeServer string
}
func parseManagedDNSConfig(lookup func(string) (string, bool)) (managedDNSConfig, error) {
cfg := managedDNSConfig{Mode: "doh", URL: defaultDoHURL, Timeout: 5 * time.Second}
if v, ok := lookup("ZAPRET_AUTOTUNE_DNS_MODE"); ok {
cfg.Mode = v
}
if cfg.Mode == "native" {
cfg.NativeServer, _ = lookup("SS_DNS_SERVER")
if cfg.NativeServer != "" && net.ParseIP(cfg.NativeServer) == nil {
return cfg, errDNSConfig
}
return cfg, nil
}
if cfg.Mode != "doh" {
return cfg, errDNSConfig
}
if v, ok := lookup("ZAPRET_AUTOTUNE_DOH_URL"); ok {
cfg.URL = v
}
u, err := url.Parse(cfg.URL)
if err != nil || u.Scheme != "https" || u.Opaque != "" || u.User != nil || u.RawQuery != "" || u.ForceQuery || u.Fragment != "" || strings.Contains(cfg.URL, "#") || u.Host == "" || u.Path == "" || !strings.HasPrefix(u.Path, "/") || (u.Port() != "" && u.Port() != "443") {
return cfg, errDNSConfig
}
cfg.Host = u.Hostname()
// Do not accept opaque/control-bearing authorities, zone IDs or ambiguous ports.
if cfg.Host == "" || strings.ContainsAny(cfg.URL, "\x00\r\n\t ") || strings.Contains(cfg.Host, "%") {
return cfg, errDNSConfig
}
if net.ParseIP(cfg.Host) == nil {
for _, label := range strings.Split(cfg.Host, ".") {
if len(label) == 0 || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' {
return cfg, errDNSConfig
}
for _, c := range label {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '-') {
return cfg, errDNSConfig
}
}
}
if len(cfg.Host) > 253 {
return cfg, errDNSConfig
}
}
if u.Host != net.JoinHostPort(cfg.Host, "443") && u.Host != cfg.Host && u.Host != "["+cfg.Host+"]" {
return cfg, errDNSConfig
}
bootstrap, explicit := lookup("ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS")
if !explicit || bootstrap == "" {
if cfg.URL != defaultDoHURL {
return cfg, errDNSConfig
}
bootstrap = "8.8.8.8,8.8.4.4"
}
parts := strings.Split(bootstrap, ",")
if len(parts) > 4 {
return cfg, errDNSConfig
}
for _, part := range parts {
ip := net.ParseIP(part)
if ip == nil {
return cfg, errDNSConfig
}
cfg.BootstrapIPs = append(cfg.BootstrapIPs, ip)
}
if v, ok := lookup("ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC"); ok {
seconds, err := strconv.Atoi(v)
if err != nil || seconds < 1 || seconds > 30 || strconv.Itoa(seconds) != v {
return cfg, errDNSConfig
}
cfg.Timeout = time.Duration(seconds) * time.Second
}
return cfg, nil
}
func (c managedDNSConfig) serverAddress() string {
if c.Mode == "doh" {
return dnsListenAddress
}
return c.NativeServer
}
@@ -0,0 +1,91 @@
package main
import (
"bytes"
"strings"
"testing"
"time"
)
func dnsConfigForTest(t *testing.T, env map[string]string) managedDNSConfig {
t.Helper()
cfg, err := parseManagedDNSConfig(func(k string) (string, bool) { v, ok := env[k]; return v, ok })
if err != nil {
t.Fatal(err)
}
return cfg
}
func TestDNSConfigDefaultsAndNative(t *testing.T) {
cfg := dnsConfigForTest(t, map[string]string{"SS_DNS_SERVER": "ignored\nsecret"})
if cfg.Mode != "doh" || cfg.URL != defaultDoHURL || cfg.Host != "dns.google" || cfg.Timeout != 5*time.Second || cfg.serverAddress() != dnsListenAddress || len(cfg.BootstrapIPs) != 2 {
t.Fatal(cfg)
}
emptyBootstrap := dnsConfigForTest(t, map[string]string{"ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": ""})
if len(emptyBootstrap.BootstrapIPs) != 2 || emptyBootstrap.BootstrapIPs[0].String() != "8.8.8.8" || emptyBootstrap.BootstrapIPs[1].String() != "8.8.4.4" {
t.Fatal("empty default bootstrap did not use default IPs")
}
for _, ip := range []string{"", "8.8.8.8", "::1"} {
cfg = dnsConfigForTest(t, map[string]string{"ZAPRET_AUTOTUNE_DNS_MODE": "native", "SS_DNS_SERVER": ip, "ZAPRET_AUTOTUNE_DOH_URL": "ignored"})
if cfg.serverAddress() != ip {
t.Fatal(cfg)
}
}
cfg = dnsConfigForTest(t, map[string]string{"ZAPRET_AUTOTUNE_DOH_URL": "https://resolver.example:443/dns-query", "ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": "1.1.1.1,2001:db8::1", "ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC": "30"})
if cfg.Host != "resolver.example" || cfg.Timeout != 30*time.Second {
t.Fatal(cfg)
}
}
func TestDNSConfigRejectsOpaqueInputs(t *testing.T) {
cases := []map[string]string{
{"ZAPRET_AUTOTUNE_DNS_MODE": ""}, {"ZAPRET_AUTOTUNE_DNS_MODE": "auto"},
{"ZAPRET_AUTOTUNE_DNS_MODE": "native", "SS_DNS_SERVER": "dns.google"},
{"ZAPRET_AUTOTUNE_DNS_MODE": "native", "SS_DNS_SERVER": "8.8.8.8:53"},
{"ZAPRET_AUTOTUNE_DOH_URL": "https://other.example/dns-query"},
{"ZAPRET_AUTOTUNE_DOH_URL": "https://other.example/dns-query", "ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": ""},
{"ZAPRET_AUTOTUNE_DOH_URL": "https://dns.google/custom-path", "ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": ""},
}
for _, raw := range []string{"", "http://dns.google/dns-query", "https://token@dns.google/dns-query", "https://dns.google/dns-query?token=secret", "https://dns.google/dns-query#", "https://dns.google:5353/dns-query", "https://dns.google:/dns-query", "https://dns.google", "https://dns.google/\nsecret", "https://dns_google/dns-query"} {
cases = append(cases, map[string]string{"ZAPRET_AUTOTUNE_DOH_URL": raw, "ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": "8.8.8.8"})
}
for _, raw := range []string{"dns.google", "1.1.1.1,", " 1.1.1.1", "1.1.1.1:443", "[::1]", "fe80::1%eth0", "1.1.1.1,1.1.1.1,1.1.1.1,1.1.1.1,1.1.1.1"} {
cases = append(cases, map[string]string{"ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS": raw})
}
for _, raw := range []string{"", "0", "31", "-1", "05", "1\n"} {
cases = append(cases, map[string]string{"ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC": raw})
}
for i, env := range cases {
_, err := parseManagedDNSConfig(func(k string) (string, bool) { v, ok := env[k]; return v, ok })
if err != errDNSConfig {
t.Errorf("case %d: %v", i, err)
}
}
}
func TestDNSForwarderCLI(t *testing.T) {
t.Setenv("ZAPRET_AUTOTUNE_DNS_MODE", "doh")
t.Setenv("ZAPRET_AUTOTUNE_DOH_URL", defaultDoHURL)
t.Setenv("ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS", "8.8.8.8")
t.Setenv("ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC", "5")
t.Setenv("SS_DNS_SERVER", "secret-invalid-legacy")
for cmd, want := range map[string]string{"mode": "doh\n", "address": dnsListenAddress + "\n"} {
var out, diagnostic bytes.Buffer
if code := run([]string{"dns-forwarder", cmd}, &out, &diagnostic); code != 0 || out.String() != want || diagnostic.Len() != 0 {
t.Fatal(code, out.String(), diagnostic.String())
}
}
t.Setenv("ZAPRET_AUTOTUNE_DNS_MODE", "native")
t.Setenv("SS_DNS_SERVER", "")
var out, diagnostic bytes.Buffer
if code := run([]string{"dns-forwarder", "address"}, &out, &diagnostic); code != 0 || out.String() != "\n" {
t.Fatal(code, out.String())
}
for _, args := range [][]string{{"serve"}, {"wrong"}, {"mode", "extra"}} {
out.Reset()
diagnostic.Reset()
if code := dnsForwarderCLI(args, &out, &diagnostic); code != 64 || out.Len() != 0 || !strings.HasPrefix(diagnostic.String(), "configerror:") {
t.Fatal(code, out.String(), diagnostic.String())
}
}
}
@@ -0,0 +1,295 @@
package main
import (
"bufio"
"bytes"
"context"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"syscall"
"testing"
"time"
)
func dnsReadyAnchorsForTest(t *testing.T) (string, *os.File, *os.File, func()) {
t.Helper()
dir := t.TempDir()
if err := os.Chmod(dir, 0700); err != nil {
t.Fatal(err)
}
path := filepath.Join(dir, "dns-ready")
cleanup, err := createDNSReady(path)
if err != nil {
t.Fatal(err)
}
t.Cleanup(cleanup)
parent, err := os.Open(dir)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { parent.Close() })
anchor, err := os.Open(path)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { anchor.Close() })
return path, parent, anchor, cleanup
}
func TestDNSReadinessAnchorActions(t *testing.T) {
path, parent, anchor, childCleanup := dnsReadyAnchorsForTest(t)
pid := os.Getpid()
if _, err := anchor.Seek(1, io.SeekStart); err != nil {
t.Fatal(err)
}
if err := dnsReadinessAction(parent, anchor, pid, false); err != nil {
t.Fatal(err)
}
if offset, _ := anchor.Seek(0, io.SeekCurrent); offset != 1 {
t.Fatal("shared anchor offset changed", offset)
}
if err := dnsReadinessAction(parent, anchor, pid+1, false); err == nil {
t.Fatal("wrong PID accepted")
}
if err := dnsReadinessAction(parent, nil, pid, false); err == nil {
t.Fatal("missing file anchor accepted")
}
if err := dnsReadinessAction(parent, nil, pid, true); err == nil {
t.Fatal("unanchored entry removed")
}
if _, err := os.Stat(path); err != nil {
t.Fatal("unanchored entry not preserved", err)
}
if err := dnsReadinessAction(parent, anchor, pid, true); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatal("owned entry not removed", err)
}
if err := dnsReadinessAction(parent, nil, pid, true); err != nil {
t.Fatal("missing entry cleanup not idempotent", err)
}
if err := dnsReadinessAction(parent, anchor, pid, false); err == nil {
t.Fatal("unlinked entry reported ready")
}
childCleanup() // Graceful child cleanup after parent cleanup also remains safe.
}
func TestDNSReadinessForeignReplacement(t *testing.T) {
for _, kind := range []string{"same-PID-copy", "symlink", "directory", "FIFO"} {
t.Run(kind, func(t *testing.T) {
path, parent, anchor, childCleanup := dnsReadyAnchorsForTest(t)
os.Remove(path)
switch kind {
case "same-PID-copy":
if err := os.WriteFile(path, []byte(fmt.Sprintf("%d\n", os.Getpid())), 0600); err != nil {
t.Fatal(err)
}
case "symlink":
if err := os.Symlink("missing", path); err != nil {
t.Fatal(err)
}
case "directory":
if err := os.Mkdir(path, 0700); err != nil {
t.Fatal(err)
}
case "FIFO":
if err := syscall.Mkfifo(path, 0600); err != nil {
t.Fatal(err)
}
}
foreign, err := os.Lstat(path)
if err != nil {
t.Fatal(err)
}
for _, cleanup := range []bool{false, true} {
if err := dnsReadinessAction(parent, anchor, os.Getpid(), cleanup); err == nil {
t.Fatal("foreign entry accepted", cleanup)
}
}
childCleanup()
current, err := os.Lstat(path)
if err != nil || !os.SameFile(foreign, current) {
t.Fatal("foreign entry deleted/replaced", err)
}
})
}
}
func TestDNSReadinessRejectsUnsafeAnchors(t *testing.T) {
path, parent, anchor, _ := dnsReadyAnchorsForTest(t)
pid := os.Getpid()
if err := dnsReadinessAction(nil, anchor, pid, true); err == nil {
t.Fatal("missing directory anchor accepted")
}
if err := dnsReadinessAction(anchor, anchor, pid, true); err == nil {
t.Fatal("regular file used as directory anchor")
}
for _, body := range []string{"", strconv.Itoa(pid), strconv.Itoa(pid) + "\nextra", "secret-content\n", strings.Repeat("x", 1024)} {
if err := os.WriteFile(path, []byte(body), 0600); err != nil {
t.Fatal(err)
}
if err := dnsReadinessAction(parent, anchor, pid, true); err == nil {
t.Fatal("malformed PID body accepted")
}
}
os.WriteFile(path, []byte(fmt.Sprintf("%d\n", pid)), 0600)
os.Chmod(path, 0644)
if err := dnsReadinessAction(parent, anchor, pid, true); err == nil {
t.Fatal("public file accepted")
}
os.Chmod(path, 0600)
os.Chmod(filepath.Dir(path), 0755)
if err := dnsReadinessAction(parent, anchor, pid, true); err == nil {
t.Fatal("public directory accepted")
}
os.Chmod(filepath.Dir(path), 0700)
}
// Subprocess helper exercises the actual inherited FD 8/9 CLI contract.
func TestDNSReadinessCLIHelper(t *testing.T) {
if os.Getenv("DNS_TEST_READINESS_CLI") != "1" {
return
}
for i, arg := range os.Args {
if arg == "--" {
os.Exit(run(os.Args[i+1:], os.Stdout, os.Stderr))
}
}
os.Exit(99)
}
func dnsReadinessSubprocess(t *testing.T, parent, anchor *os.File, command, pid string) (int, string) {
t.Helper()
binary, err := os.Executable()
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, binary, "-test.run=^TestDNSReadinessCLIHelper$", "--", "dns-forwarder", command, pid)
cmd.Env = append(os.Environ(), "DNS_TEST_READINESS_CLI=1", "ZAPRET_AUTOTUNE_DNS_MODE=doh", "ZAPRET_AUTOTUNE_DOH_URL="+defaultDoHURL, "ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS=", "ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC=5")
padding, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer padding.Close()
cmd.ExtraFiles = []*os.File{padding, padding, padding, padding, padding, parent}
if anchor != nil {
cmd.ExtraFiles = append(cmd.ExtraFiles, anchor)
}
output, err := cmd.CombinedOutput()
if ctx.Err() != nil {
t.Fatal("readiness helper timed out")
}
if err == nil {
return 0, string(output)
}
if exit, ok := err.(*exec.ExitError); ok {
return exit.ExitCode(), string(output)
}
t.Fatal(err)
return -1, ""
}
func TestDNSReadinessInheritedCLI(t *testing.T) {
path, parent, anchor, _ := dnsReadyAnchorsForTest(t)
pid := strconv.Itoa(os.Getpid())
for _, bad := range []string{"0", "1", "-2", "+2", "02", "2\n", "2147483648", "secret-token"} {
code, out := dnsReadinessSubprocess(t, parent, anchor, "readiness-check", bad)
if code != 64 || out != "configerror: invalid DNS readiness command\n" {
t.Fatal(code, out)
}
}
if code, out := dnsReadinessSubprocess(t, parent, anchor, "readiness-check", pid); code != 0 || out != "" {
t.Fatal(code, out)
}
if code, out := dnsReadinessSubprocess(t, nil, anchor, "readiness-cleanup", pid); code != 78 || out != "error: DNS readiness ownership unavailable\n" {
t.Fatal("missing directory anchor accepted", code, out)
}
if offset, _ := anchor.Seek(0, io.SeekCurrent); offset != 0 {
t.Fatal("CLI changed parent's offset", offset)
}
if code, out := dnsReadinessSubprocess(t, parent, nil, "readiness-cleanup", pid); code != 78 || out != "error: DNS readiness ownership unavailable\n" {
t.Fatal(code, out)
}
if code, out := dnsReadinessSubprocess(t, parent, anchor, "readiness-cleanup", pid); code != 0 || out != "" {
t.Fatal(code, out)
}
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatal(err)
}
if code, out := dnsReadinessSubprocess(t, parent, nil, "readiness-cleanup", pid); code != 0 || out != "" {
t.Fatal(code, out)
}
}
func TestDNSReadinessPublisherHelper(t *testing.T) {
dir := os.Getenv("DNS_TEST_READINESS_PUBLISH_DIR")
if dir == "" {
return
}
cleanup, err := createDNSReady(filepath.Join(dir, "dns-ready"))
if err != nil {
os.Exit(99)
}
defer cleanup()
fmt.Fprintln(os.Stdout, "published")
time.Sleep(time.Hour)
}
func TestDNSReadinessAnchorsSurviveSIGKILL(t *testing.T) {
dir := t.TempDir()
os.Chmod(dir, 0700)
binary, err := os.Executable()
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, binary, "-test.run=^TestDNSReadinessPublisherHelper$")
cmd.Env = append(os.Environ(), "DNS_TEST_READINESS_PUBLISH_DIR="+dir)
stdout, err := cmd.StdoutPipe()
if err != nil {
t.Fatal(err)
}
var diagnostic bytes.Buffer
cmd.Stderr = &diagnostic
if err := cmd.Start(); err != nil {
t.Fatal(err)
}
defer cmd.Process.Kill()
if line, err := bufio.NewReader(stdout).ReadString('\n'); err != nil || line != "published\n" {
t.Fatal("publisher failed", line, err)
}
parent, err := os.Open(dir)
if err != nil {
t.Fatal(err)
}
defer parent.Close()
path := filepath.Join(dir, "dns-ready")
anchor, err := os.Open(path)
if err != nil {
t.Fatal(err)
}
defer anchor.Close()
pid := cmd.Process.Pid
if err := dnsReadinessAction(parent, anchor, pid, false); err != nil {
t.Fatal(err)
}
if err := cmd.Process.Kill(); err != nil {
t.Fatal(err)
}
cmd.Wait()
if err := dnsReadinessAction(parent, anchor, pid, true); err != nil {
t.Fatal("anchored SIGKILL cleanup failed", err)
}
if _, err := os.Lstat(path); !os.IsNotExist(err) {
t.Fatal("SIGKILL left owned readiness entry", err)
}
}
+664
View File
@@ -0,0 +1,664 @@
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))
}
}
@@ -0,0 +1,169 @@
package main
import (
"bytes"
"context"
"encoding/binary"
"errors"
"io"
"net"
"net/http"
"testing"
"time"
)
func dnsTestEDNSQuery(payload uint16) []byte {
q := testDNSQuery()
q[11] = 1
return append(q, 0, 0, 41, byte(payload>>8), byte(payload), 0, 0, 0x80, 0, 0, 0)
}
func dnsTestSizedResponse(query []byte, size int) []byte {
response := dnsQuestionReply(query, query)
response[2] = 0x81
response[3] = 0xa0 // RA and AD survive truncation.
response[7] = 1
dataSize := size - len(response) - 12
response = append(response, 0xc0, 12, 0, 16, 0, 1, 0, 0, 0, 37, byte(dataSize>>8), byte(dataSize))
return append(response, make([]byte, dataSize)...)
}
func TestDNSUDPPayloadLimits(t *testing.T) {
for _, tc := range []struct {
name string
query []byte
size, limit int
truncated bool
}{
{"no-EDNS-full-TCP", testDNSQuery(), 65535, 512, true},
{"no-EDNS-at-limit", testDNSQuery(), 512, 512, false},
{"EDNS-at-limit", dnsTestEDNSQuery(1232), 1232, 1232, false},
{"EDNS-over-limit", dnsTestEDNSQuery(1232), 1233, 1232, true},
{"EDNS-small-clamp", dnsTestEDNSQuery(1), 513, 512, true},
{"EDNS-max-at-IPv4-limit", dnsTestEDNSQuery(65535), 65507, 65507, false},
{"EDNS-max-over-IPv4-limit", dnsTestEDNSQuery(65535), 65535, 65507, true},
} {
t.Run(tc.name, func(t *testing.T) {
response := dnsTestSizedResponse(tc.query, tc.size)
if !validDNSQuery(tc.query) || !validDNSResponse(tc.query, response) {
t.Fatal("invalid fixture")
}
actual := dnsUDPReply(tc.query, response)
if len(actual) > tc.limit || (actual[2]&2 != 0) != tc.truncated {
t.Fatal("incorrect UDP ceiling/TC", len(actual), actual[:12])
}
if !tc.truncated {
if !bytes.Equal(actual, response) {
t.Fatal("in-range answer changed")
}
return
}
if !validDNSResponse(tc.query, actual) || !bytes.Equal(actual[:2], response[:2]) || actual[2] != response[2]|2 || actual[3] != response[3] || !bytes.Equal(actual[6:12], make([]byte, 6)) {
t.Fatal("invalid truncated reply", actual)
}
})
}
}
func TestDNSOversizedUDPThenFullTCP(t *testing.T) {
q := testDNSQuery()
response := dnsTestSizedResponse(q, 65535)
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) { return dnsHTTPResponse(response), nil })
p := &dnsFakePacketConn{outgoing: make(chan dnsTestPacket, 1), closed: make(chan struct{})}
writeDNSDatagram(p, &net.UDPAddr{}, q, f.exchange(context.Background(), q))
if packet := <-p.outgoing; len(packet.data) > 512 || packet.data[2]&2 == 0 {
t.Fatal("oversized UDP did not force TCP")
}
server, client := net.Pipe()
defer client.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(ctx, server) }()
client.SetDeadline(time.Now().Add(3 * time.Second))
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 || binary.BigEndian.Uint16(size[:]) != 65535 {
t.Fatal("incorrect full TCP frame", size, err)
}
actual := make([]byte, 65535)
if _, err := io.ReadFull(client, actual); err != nil || !bytes.Equal(actual, response) {
t.Fatal("full TCP reply changed", err)
}
cancel()
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("TCP worker did not join")
}
}
func TestDNSCompressedQuestionReplies(t *testing.T) {
plain := testDNSQuery()
// Question points forward into an additional RR's owner; copying just the
// original question would leave a dangling pointer after dropping that RR.
q := append([]byte(nil), plain[:12]...)
q[11] = 1
q = append(q, 0xc0, 18, 0, 1, 0, 1)
q = append(q, plain[12:len(plain)-4]...)
q = append(q, 0, 1, 0, 1, 0, 0, 0, 37, 0, 4, 1, 2, 3, 4)
if !validDNSQuery(q) {
t.Fatal("compressed query rejected")
}
for _, reply := range [][]byte{dnsServfail(q), dnsUDPReply(q, dnsTestSizedResponse(q, 65535))} {
if !validDNSResponse(q, reply) || !bytes.Equal(reply[12:], plain[12:]) || reply[12]&0xc0 != 0 || !bytes.Equal(reply[6:12], make([]byte, 6)) {
t.Fatal("dangling/compressed synthesized question", reply)
}
}
response := dnsTestSizedResponse(q, 65535)
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) { return dnsHTTPResponse(response), nil })
if !bytes.Equal(f.exchange(context.Background(), q), response) {
t.Fatal("equivalent uncompressed upstream question rejected")
}
q[18] = 0xc0
q[19] = 12 // Question -> owner -> question compression loop.
if validDNSQuery(q) || dnsServfail(q) != nil {
t.Fatal("compression loop accepted")
}
}
func TestDNSMalformedEDNSQueries(t *testing.T) {
q := dnsTestEDNSQuery(1232)
duplicate := append(append([]byte(nil), q...), q[len(testDNSQuery()):]...)
duplicate[11] = 2
badOwner := append([]byte(nil), q...)
start := len(testDNSQuery())
badOwner = append(badOwner[:start], append([]byte{1, 'x'}, badOwner[start:]...)...)
badOptions := append([]byte(nil), q...)
badOptions[len(badOptions)-1] = 3
badOptions = append(badOptions, 0, 1, 0)
for i, bad := range [][]byte{duplicate, badOwner, badOptions, q[:len(q)-1]} {
if validDNSQuery(bad) {
t.Fatal("malformed EDNS accepted", i)
}
}
}
type dnsFailingPacketConn struct {
*dnsFakePacketConn
writes int
}
func (p *dnsFailingPacketConn) WriteTo([]byte, net.Addr) (int, error) {
p.writes++
return 0, errors.New("datagram dropped")
}
func TestDNSUDPWriteErrorDropsOnlyDatagram(t *testing.T) {
p := &dnsFailingPacketConn{}
q := testDNSQuery()
for i := 0; i < 2; i++ {
writeDNSDatagram(p, &net.UDPAddr{}, q, dnsTestSizedResponse(q, 65535))
}
if p.writes != 2 {
t.Fatal("write error stopped subsequent datagrams", p.writes)
}
}
+9 -3
View File
@@ -3,13 +3,16 @@ package main
import (
"fmt"
"io"
"net"
"os"
)
const usage = `Usage: zapret-autotune <command>
Commands:
dns-forwarder mode|address|serve
Managed DNS configuration or loopback DoH forwarder
dns-forwarder readiness-check|readiness-cleanup <expected-dns-pid>
Validate or clean readiness using inherited PID 1 anchors
status Show latest recorded tune run/proposal (not live service health)
history [--limit N] List recorded tune attempts (default 20; proposals not active)
strategies youtube List recorded proposals by group (not active)
@@ -36,13 +39,16 @@ func run(args []string, stdout, stderr io.Writer) int {
}
func runWithPlayer(args []string, stdout, stderr io.Writer, player playerRunner) int {
if len(args) > 0 && args[0] == "dns-forwarder" {
return dnsForwarderCLI(args[1:], stdout, stderr)
}
if len(args) == 1 && args[0] == "target-config-check" {
if _, err := parseManagedHealthConfig(os.LookupEnv); err != nil {
fmt.Fprintln(stderr, "configerror: invalid target health/service configuration")
return 64
}
if dns := os.Getenv("SS_DNS_SERVER"); dns != "" && net.ParseIP(dns) == nil {
fmt.Fprintln(stderr, "configerror: SS_DNS_SERVER requires a literal IPv4 or IPv6 address")
if _, err := parseManagedDNSConfig(os.LookupEnv); err != nil {
fmt.Fprintln(stderr, "configerror: invalid managed DNS configuration")
return 64
}
return 0
@@ -34,6 +34,9 @@ func TestManagedPrestartHelper(t *testing.T) {
// Use the production validator, not a fixture-only success response.
os.Exit(run(args, os.Stdout, os.Stderr))
}
if len(args) == 2 && args[0] == "dns-forwarder" && (args[1] == "mode" || args[1] == "address") {
os.Exit(run(args, os.Stdout, os.Stderr))
}
if len(args) < 2 || args[0] != "managed" {
os.Exit(1)
}
@@ -165,7 +168,8 @@ func TestManagedEntrypointPrestartReconciliation(t *testing.T) {
// use the fixture config, via its own script rather than CLI path flags.
cmd.Env = append(cmd.Env, "FIXTURE_CONFIG="+filepath.Join(d.directory, "config"))
childStarted := filepath.Join(root, "child-started")
cmd.Env = append(cmd.Env, "FIXTURE_CHILD_STARTED="+childStarted, "SS_DNS_SERVER=8.8.8.8")
// This legacy daemon fixture deliberately exercises explicit native DNS.
cmd.Env = append(cmd.Env, "FIXTURE_CHILD_STARTED="+childStarted, "ZAPRET_AUTOTUNE_DNS_MODE=native", "SS_DNS_SERVER=8.8.8.8")
wantExit := 78
if mode == "invalid-dns" {
cmd.Env = append(cmd.Env, "SS_DNS_SERVER=8.8.8.8\n--invalid")
@@ -672,6 +676,14 @@ func TestManagedEntrypointSupervision(t *testing.T) {
write("ss-local", child)
zapret := write("zapret", "#!/bin/sh\necho zapret-$1 >> \"$LOG\"\nstage=$1\n"+startupFailure+"if [ \"$MODE:$1\" = ss-early:start ] && [ \"$(grep -c zapret-start \"$LOG\")\" -gt 1 ]; then\nuntil [ \"$(grep -c 'stopped-.*/ss-local' \"$LOG\")\" -ge \"$(grep -c zapret-start \"$LOG\")\" ]; do sleep 0.02; done\nsleep 0.02\nfi\nif [ \"$MODE:$1\" = stop-failure:stop ]; then exit 1; fi\nif [ \"$MODE:$1\" = stop-hang:stop ]; then trap '' TERM INT; exec sleep 300; fi\n")
monitor := write("autotune", "#!/bin/sh\nif [ \"$2\" != monitor ]; then\necho managed-$2 >> \"$LOG\"\nstage=$2\n"+startupFailure+"exit 0\nfi\nsleeper=\ntrap '"+joinSleeper+"echo monitor-stopped >> \"$LOG\"; case \"$MODE\" in *unsafe) exit 78;; *unknown) exit 7;; ss-technical) exit 75;; esac; exit 0' TERM INT\necho managed-monitor >> \"$LOG\"\nif [ \"$MODE\" = term-hang ]; then trap '' TERM INT; exec sleep 300; fi\ncase \"$MODE\" in fatal) exit 78;; technical|stop-failure|stop-hang) exit 75;; panic) exit 2;; killed) kill -KILL $$;; segv) exit 139;; zero) exit 0;; unknown) exit 7;; esac\nwhile :; do sleep 0.1 & sleeper=$!; wait \"$sleeper\"; done\n")
// This legacy lifecycle fixture has no DNS service. Implement only
// the explicit native getters; dedicated Python fixtures own DoH ACKs.
monitorData, err := os.ReadFile(monitor)
if err != nil {
t.Fatal(err)
}
getters := "if [ \"$1\" = dns-forwarder ]; then\ncase \"$2\" in mode) echo native;; address) echo;; *) exit 64;; esac\nexit 0\nfi\n"
write("autotune", strings.Replace(string(monitorData), "#!/bin/sh\n", "#!/bin/sh\n"+getters, 1))
data, err := os.ReadFile("../../managed-target-entrypoint.sh")
if err != nil {
t.Fatal(err)
@@ -696,7 +708,7 @@ func TestManagedEntrypointSupervision(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "/bin/sh", entry)
cmd.Env = append(os.Environ(), "PATH="+root+":"+os.Getenv("PATH"), "LOG="+log, "MODE="+mode, "ZAPRET_CONFIG="+filepath.Join(root, "config"), "SS_PASSWORD="+strings.Repeat("a", 32))
cmd.Env = append(os.Environ(), "PATH="+root+":"+os.Getenv("PATH"), "LOG="+log, "MODE="+mode, "ZAPRET_CONFIG="+filepath.Join(root, "config"), "SS_PASSWORD="+strings.Repeat("a", 32), "ZAPRET_AUTOTUNE_DNS_MODE=native")
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
var shutdownSnapshot string
stopMonitorSession := func() {
+16
View File
@@ -7,6 +7,7 @@ import (
)
func TestTargetConfigCheck(t *testing.T) {
t.Setenv("ZAPRET_AUTOTUNE_DNS_MODE", "native")
t.Setenv("ZAPRET_AUTOTUNE_YOUTUBE_SERVICE", "0")
t.Setenv("ZAPRET_AUTOTUNE_GOOGLEVIDEO_MODE", "cold")
t.Setenv("ZAPRET_AUTOTUNE_VIDEO_ID", "dQw4w9WgXcQ")
@@ -23,6 +24,21 @@ func TestTargetConfigCheck(t *testing.T) {
}
})
}
t.Run("DoH ignores deprecated native DNS", func(t *testing.T) {
t.Setenv("ZAPRET_AUTOTUNE_DNS_MODE", "doh")
t.Setenv("ZAPRET_AUTOTUNE_DOH_URL", defaultDoHURL)
t.Setenv("ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS", "8.8.8.8")
t.Setenv("ZAPRET_AUTOTUNE_DOH_TIMEOUT_SEC", "5")
t.Setenv("SS_DNS_SERVER", "ignored invalid legacy setting")
var out, errOut bytes.Buffer
if code := run([]string{"target-config-check"}, &out, &errOut); code != 0 || out.Len() != 0 || errOut.Len() != 0 {
t.Fatal(code, out.String(), errOut.String())
}
t.Setenv("ZAPRET_AUTOTUNE_DOH_BOOTSTRAP_IPS", "secret-bootstrap-host")
if code := run([]string{"target-config-check"}, &out, &errOut); code != 64 || strings.Contains(errOut.String(), "secret-bootstrap-host") {
t.Fatal(code, errOut.String())
}
})
t.Setenv("SS_DNS_SERVER", "")
for key, value := range map[string]string{
"ZAPRET_AUTOTUNE_YOUTUBE_SERVICE": "true",