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>
677 lines
19 KiB
Go
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
|
|
}
|