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>
246 lines
6.3 KiB
Go
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
|
|
}
|