Files
zapret-autotune/cmd/zapret-autotune/dns_forwarder.go
T
ZeusinaandGPT-6 Bot 721cad42ce fix: preserve DNS TCP replies after upstream timeout
Separate bounded TCP read, upstream and write phases while retaining the total connection lifetime. Add net.Pipe regressions for upstream timeout, partial reads, cancellation and lifetime limits.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-13 15:02:41 +03:00

677 lines
19 KiB
Go

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.SetReadDeadline(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
}
if !time.Now().Before(lifetime) {
return
}
requestCtx, cancel := context.WithDeadline(ctx, lifetime)
reply := f.exchange(requestCtx, query)
cancel()
if reply == nil || !time.Now().Before(lifetime) {
return
}
// An upstream timeout must still leave a bounded window to send SERVFAIL.
deadline = time.Now().Add(f.cfg.Timeout)
if lifetime.Before(deadline) {
deadline = lifetime
}
if err := conn.SetWriteDeadline(deadline); err != 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
}