Files
zapret-autotune/cmd/zapret-autotune/resource_dns.go
T
ZeusinaandGPT-6 Bot 4d7c4b33c3 feat: add declarative HTTPS resource checks
Add strict check-only resource configuration, owned DNS resolution and pinned HTTPS probes with bounded private output. Document the schema limits and pending remote acceptance; leave generic controller and strategy migration out of scope.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-13 18:38:46 +03:00

246 lines
6.3 KiB
Go

package main
import (
"context"
"crypto/rand"
"encoding/binary"
"io"
"net"
"strings"
"time"
)
func resourceDNSQuery(host string, kind uint16) ([]byte, error) {
if !discoveryHostname(host) {
return nil, errDNSForwarder
}
query := make([]byte, 12)
if _, err := rand.Read(query[:2]); err != nil {
return nil, errDNSForwarder
}
query[2], query[5] = 1, 1
for _, label := range strings.Split(strings.ToLower(host), ".") {
query = append(query, byte(len(label)))
query = append(query, label...)
}
query = append(query, 0, byte(kind>>8), byte(kind), 0, 1)
if !validDNSQuery(query) {
return nil, errDNSForwarder
}
return query, nil
}
func resourceDNSExchange(ctx context.Context, server string, query []byte, dial dnsDialFunc) ([]byte, error) {
conn, err := dial(ctx, "tcp", server)
if err != nil {
return nil, errDNSForwarder
}
defer conn.Close()
deadline := time.Now().Add(5 * time.Second)
if d, ok := ctx.Deadline(); ok && d.Before(deadline) {
deadline = d
}
if conn.SetDeadline(deadline) != nil {
return nil, errDNSForwarder
}
// Closing the connection interrupts framed I/O, including contexts cancelled
// without a deadline. The callback is joined before returning.
done := make(chan struct{})
stop := context.AfterFunc(ctx, func() { conn.Close(); close(done) })
defer func() {
if !stop() {
<-done
}
}()
var size [2]byte
binary.BigEndian.PutUint16(size[:], uint16(len(query)))
if writeDNSFrame(conn, size[:], query) != nil {
return nil, errDNSForwarder
}
if _, err := io.ReadFull(conn, size[:]); err != nil {
return nil, errDNSForwarder
}
n := int(binary.BigEndian.Uint16(size[:]))
if n < 12 {
return nil, errDNSForwarder
}
response := make([]byte, n)
if _, err := io.ReadFull(conn, response); err != nil {
return nil, errDNSForwarder
}
if ctx.Err() != nil || !validDNSResponse(query, response) || response[2]&2 != 0 || response[3]&15 != 0 {
return nil, errDNSForwarder
}
return response, nil
}
func resourceDNSHost(name []byte) (string, bool) {
var labels []string
for i := 0; i < len(name); {
n := int(name[i])
i++
if n == 0 {
host := strings.ToLower(strings.Join(labels, "."))
return host, i == len(name) && discoveryHostname(host)
}
if n > 63 || i+n > len(name) {
return "", false
}
labels = append(labels, string(name[i:i+n]))
i += n
}
return "", false
}
// Only Answer records on a complete, unambiguous chain from the original
// question contribute addresses. Authority/Additional glue is never a target.
func resourceDNSAnswers(query, wire []byte, priorAliases map[string]bool) ([]net.IP, string, error) {
if !validDNSResponse(query, wire) {
return nil, "", errDNSForwarder
}
_, question, ok := dnsQuestion(query)
if !ok {
return nil, "", errDNSForwarder
}
host, ok := resourceDNSHost(question[:len(question)-4])
if !ok {
return nil, "", errDNSForwarder
}
end, ok := dnsQuestionEnd(wire)
if !ok {
return nil, "", errDNSForwarder
}
count := int(binary.BigEndian.Uint16(wire[6:8]))
if count > 128 {
return nil, "", errDNSForwarder
}
aliases := map[string]string{}
addresses := map[string][]net.IP{}
for i := 0; i < count; i++ {
header, name, ok := dnsName(wire, end)
if !ok || header+10 > len(wire) {
return nil, "", errDNSForwarder
}
owner, valid := resourceDNSHost(name)
if !valid {
return nil, "", errDNSForwarder
}
kind, class := binary.BigEndian.Uint16(wire[header:]), binary.BigEndian.Uint16(wire[header+2:])
start := header + 10
end = start + int(binary.BigEndian.Uint16(wire[header+8:]))
if end > len(wire) || class != 1 {
return nil, "", errDNSForwarder
}
switch kind {
case 1, 28:
size := 4
if kind == 28 {
size = 16
}
if end-start != size {
return nil, "", errDNSForwarder
}
addresses[owner] = append(addresses[owner], append(net.IP(nil), wire[start:end]...))
case 5:
last, target, ok := dnsName(wire, start)
if !ok || last != end {
return nil, "", errDNSForwarder
}
alias, ok := resourceDNSHost(target)
if !ok || aliases[owner] != "" {
return nil, "", errDNSForwarder
}
aliases[owner] = alias
}
}
seen := map[string]bool{}
for steps := 0; steps < 16; steps++ {
if seen[host] || priorAliases[host] {
return nil, "", errDNSForwarder
}
seen[host] = true
if alias := aliases[host]; alias != "" {
if len(addresses[host]) != 0 {
return nil, "", errDNSForwarder
}
priorAliases[host] = true
if len(priorAliases) > 16 {
return nil, "", errDNSForwarder
}
host = alias
continue
}
// Unrelated answer addresses/aliases are ambiguous, not a safe partial set.
for owner := range addresses {
if !seen[owner] {
return nil, "", errDNSForwarder
}
}
for owner := range aliases {
if !seen[owner] {
return nil, "", errDNSForwarder
}
}
if len(addresses[host]) > 0 {
return addresses[host], "", nil
}
if len(aliases) > 0 {
return nil, host, nil
}
return nil, "", nil // authenticated framing with NOERROR/NODATA
}
return nil, "", errDNSForwarder
}
func resolveResourceIPsWithDial(ctx context.Context, server, host string, dial dnsDialFunc) ([]net.IP, error) {
serverHost, port, err := net.SplitHostPort(server)
if err != nil || net.ParseIP(serverHost) == nil || (port != "53" && server != dnsListenAddress) || dial == nil {
return nil, errDNSForwarder
}
if ip := net.ParseIP(host); ip != nil {
return []net.IP{ip}, nil
}
var ips []net.IP
unique := map[string]bool{}
for _, kind := range []uint16{1, 28} {
name := host
seen := map[string]bool{}
priorAliases := map[string]bool{}
for steps := 0; ; steps++ {
if steps >= 16 || seen[strings.ToLower(name)] || ctx.Err() != nil {
return nil, errDNSForwarder
}
seen[strings.ToLower(name)] = true
query, err := resourceDNSQuery(name, kind)
if err != nil {
return nil, err
}
wire, err := resourceDNSExchange(ctx, server, query, dial)
if err != nil {
return nil, err
}
answers, alias, err := resourceDNSAnswers(query, wire, priorAliases)
if err != nil {
return nil, err
}
for _, ip := range answers {
if !unique[ip.String()] {
unique[ip.String()] = true
ips = append(ips, ip)
}
if len(ips) > 64 {
return nil, errDNSForwarder
}
}
if alias == "" {
if steps > 0 && len(answers) == 0 {
return nil, errDNSForwarder
}
break
}
name = alias
}
}
return ips, nil
}