Merge pull request #273 from aojea/dns-tcp-fallback

internal/node: fall back to DNS-over-TCP when a TXT lookup comes back…

Author: aojea

internal/node/dnstcp.go

@@ -0,0 +1,238 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package node
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"strings"
+	"time"
+
+	madns "github.com/multiformats/go-multiaddr-dns"
+	"golang.org/x/net/dns/dnsmessage"
+)
+
+// fqdnName appends a trailing dot, which dnsmessage.NewName requires for a
+// fully-qualified name, unless the caller already supplied one.
+func fqdnName(name string) string {
+	if strings.HasSuffix(name, ".") {
+		return name
+	}
+	return name + "."
+}
+
+// tcpFallbackResolver wraps a madns.BasicResolver and retries LookupTXT with
+// a direct DNS-over-TCP exchange whenever the wrapped (UDP-based) lookup
+// comes back empty. Some networks silently drop or corrupt UDP DNS responses
+// once they're large enough to need fragmentation, instead of returning the
+// truncated reply a resolver would normally retry over TCP on its own - which
+// breaks resolution of libp2p's dnsaddr TXT records (often several entries)
+// even though the record itself is fine and a plain TCP query resolves it.
+//
+// Observed concretely on a ChromeOS Crostini VM: its DNS proxy answered a
+// multi-entry dnsaddr TXT record with an empty result over plain UDP, and a
+// direct UDP query to 8.8.8.8/1.1.1.1 from the same VM came back partial and
+// flagged as a malformed packet - while `dig +tcp` and a second Linux machine
+// on the same network resolved it correctly every time. That points at the
+// VM's handling of a fragmented/oversized UDP response, not the record or
+// the wider network, so retrying over TCP - which needs no fragmentation -
+// is the fix rather than anything specific to that one environment.
+type tcpFallbackResolver struct {
+	def madns.BasicResolver
+	// servers overrides the nameservers used for the TCP retry; only set in
+	// tests. Production leaves this nil and reads /etc/resolv.conf fresh on
+	// every fallback instead, so nameserver changes take effect immediately.
+	servers []string
+}
+
+var _ madns.BasicResolver = (*tcpFallbackResolver)(nil)
+
+// newTCPFallbackResolver builds a tcpFallbackResolver backed by def. The
+// system's configured nameservers are read from /etc/resolv.conf on demand
+// for each TCP retry (see LookupTXT) rather than cached here, so the node
+// keeps working across VPN connects, Wi-Fi switches, and DHCP renewals
+// without needing a restart.
+func newTCPFallbackResolver(def madns.BasicResolver) *tcpFallbackResolver {
+	return &tcpFallbackResolver{def: def}
+}
+
+func (r *tcpFallbackResolver) LookupIPAddr(ctx context.Context, host string) ([]net.IPAddr, error) {
+	return r.def.LookupIPAddr(ctx, host)
+}
+
+func (r *tcpFallbackResolver) LookupTXT(ctx context.Context, name string) ([]string, error) {
+	txt, err := r.def.LookupTXT(ctx, name)
+	if err == nil && len(txt) > 0 {
+		return txt, nil
+	}
+	// r.servers is a test-only override; production always re-reads
+	// /etc/resolv.conf here so nameserver changes take effect immediately.
+	servers := r.servers
+	if len(servers) == 0 {
+		var sysErr error
+		servers, sysErr = systemNameservers()
+		if sysErr != nil {
+			logger.Debugf("dnstcp: no nameservers for TCP fallback: %v", sysErr)
+		}
+	}
+	if len(servers) == 0 {
+		return txt, err
+	}
+	tcpTXT, tcpErr := lookupTXTOverTCP(ctx, name, servers)
+	if tcpErr != nil || len(tcpTXT) == 0 {
+		logger.Debugf("dnstcp: TCP fallback for TXT %q also failed: %v", name, tcpErr)
+		return txt, err
+	}
+	logger.Debugf("dnstcp: recovered %d TXT record(s) for %q via TCP after an empty UDP result", len(tcpTXT), name)
+	return tcpTXT, nil
+}
+
+// lookupTXTOverTCP resolves a TXT record with a direct, length-prefixed
+// DNS-over-TCP exchange (RFC 1035 section 4.2.2) against servers in order,
+// bypassing the standard resolver's UDP-first behavior entirely.
+func lookupTXTOverTCP(ctx context.Context, name string, servers []string) ([]string, error) {
+	qname, err := dnsmessage.NewName(fqdnName(name))
+	if err != nil {
+		return nil, fmt.Errorf("invalid DNS name %q: %w", name, err)
+	}
+	query := dnsmessage.Message{
+		Header: dnsmessage.Header{ID: uint16(time.Now().UnixNano()), RecursionDesired: true},
+		Questions: []dnsmessage.Question{{
+			Name:  qname,
+			Type:  dnsmessage.TypeTXT,
+			Class: dnsmessage.ClassINET,
+		}},
+	}
+	packed, err := query.Pack()
+	if err != nil {
+		return nil, fmt.Errorf("failed to build DNS query: %w", err)
+	}
+
+	var lastErr error
+	for _, server := range servers {
+		txt, err := exchangeTCP(ctx, server, packed)
+		if err == nil {
+			return txt, nil
+		}
+		lastErr = err
+	}
+	return nil, lastErr
+}
+
+func exchangeTCP(ctx context.Context, server string, query []byte) ([]string, error) {
+	d := net.Dialer{Timeout: 5 * time.Second}
+	conn, err := d.DialContext(ctx, "tcp", server)
+	if err != nil {
+		return nil, fmt.Errorf("dial %s: %w", server, err)
+	}
+	defer func() { _ = conn.Close() }()
+	deadline := time.Now().Add(5 * time.Second)
+	if ctxDeadline, ok := ctx.Deadline(); ok && ctxDeadline.Before(deadline) {
+		deadline = ctxDeadline
+	}
+	_ = conn.SetDeadline(deadline)
+
+	// conn.Write/Read below only respect the deadline above, not ctx
+	// cancellation directly; close the connection as soon as the caller's
+	// context is done so a cancelled/timed-out caller isn't stuck waiting
+	// out the full deadline.
+	done := make(chan struct{})
+	defer close(done)
+	go func() {
+		select {
+		case <-ctx.Done():
+			_ = conn.Close()
+		case <-done:
+		}
+	}()
+
+	var lenBuf [2]byte
+	binary.BigEndian.PutUint16(lenBuf[:], uint16(len(query)))
+	if _, err := conn.Write(lenBuf[:]); err != nil {
+		return nil, fmt.Errorf("writing length prefix to %s: %w", server, err)
+	}
+	if _, err := conn.Write(query); err != nil {
+		return nil, fmt.Errorf("writing query to %s: %w", server, err)
+	}
+
+	if _, err := io.ReadFull(conn, lenBuf[:]); err != nil {
+		return nil, fmt.Errorf("reading response length from %s: %w", server, err)
+	}
+	resp := make([]byte, binary.BigEndian.Uint16(lenBuf[:]))
+	if _, err := io.ReadFull(conn, resp); err != nil {
+		return nil, fmt.Errorf("reading response from %s: %w", server, err)
+	}
+
+	var msg dnsmessage.Message
+	if err := msg.Unpack(resp); err != nil {
+		return nil, fmt.Errorf("parsing DNS response from %s: %w", server, err)
+	}
+	if msg.RCode != dnsmessage.RCodeSuccess {
+		return nil, fmt.Errorf("%s returned %s", server, msg.RCode)
+	}
+
+	var out []string
+	for _, ans := range msg.Answers {
+		if txtRes, ok := ans.Body.(*dnsmessage.TXTResource); ok {
+			out = append(out, strings.Join(txtRes.TXT, ""))
+		}
+	}
+	return out, nil
+}
+
+// resolvConfPath is a package-level var (rather than a hardcoded literal)
+// purely so tests can point it at a fixture without touching the real file.
+var resolvConfPath = "/etc/resolv.conf"
+
+// systemNameservers reads the "nameserver" entries from /etc/resolv.conf.
+// It returns a nil slice, not an error, when the file doesn't exist (e.g. on
+// Windows) so callers can silently skip the TCP fallback there.
+func systemNameservers() ([]string, error) {
+	data, err := os.ReadFile(resolvConfPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return parseNameservers(string(data)), nil
+}
+
+// parseNameservers extracts "host:port" nameserver entries (port 53) from
+// the contents of a resolv.conf file.
+func parseNameservers(resolvConf string) []string {
+	var servers []string
+	for _, line := range strings.Split(resolvConf, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || fields[0] != "nameserver" {
+			continue
+		}
+		servers = append(servers, net.JoinHostPort(fields[1], "53"))
+	}
+	return servers
+}
+
+func init() {
+	r, err := madns.NewResolver(madns.WithDefaultResolver(newTCPFallbackResolver(net.DefaultResolver)))
+	if err != nil {
+		logger.Warnf("dnstcp: failed to install TCP-fallback DNS resolver, dnsaddr resolution keeps its default UDP-only behavior: %v", err)
+		return
+	}
+	madns.DefaultResolver = r
+}