Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

fix(egress): forward DNS queries over TCP when the client used TCP

Maohao901422dd76c4
diff --git a/components/egress/pkg/dnsproxy/proxy.go b/components/egress/pkg/dnsproxy/proxy.go
index 1afccbf75..fea234586 100644
--- a/components/egress/pkg/dnsproxy/proxy.go
+++ b/components/egress/pkg/dnsproxy/proxy.go
@@ -284,7 +284,7 @@ func (p *Proxy) serveDNS(w dns.ResponseWriter, r *dns.Msg) {
// reply is written, so nft programming lands before the client can dial.
func (p *Proxy) forwardAndReply(w dns.ResponseWriter, r *dns.Msg, domain, host string, notify func(string, []nftables.ResolvedIP)) {
start := time.Now()
- resp, failure, err := p.forward(r)
+ resp, failure, err := p.forward(r, upstreamNetwork(w))
elapsed := time.Since(start).Seconds()
if err != nil {
telemetry.RecordDNSForward(elapsed)
@@ -393,8 +393,18 @@ func (p *Proxy) maybeNotifyResolved(domain string, resp *dns.Msg) {
// forward returns the response, or the bounded failure reason (a telemetry.DNSFailure*
// constant) alongside the error. The reason is what the last attempted upstream failed
// with: the loop keeps trying, so only the final outcome is reported.
-func (p *Proxy) forward(r *dns.Msg) (*dns.Msg, string, error) {
- return p.forwardContext(context.Background(), r)
+func (p *Proxy) forward(r *dns.Msg, network string) (*dns.Msg, string, error) {
+ return p.forwardContext(context.Background(), r, network)
+}
+
+// upstreamNetwork returns the transport the client used, to forward its query
+// over the same one. A client retries over TCP after a truncated UDP answer,
+// and only a TCP exchange with the upstream returns that answer in full.
+func upstreamNetwork(w dns.ResponseWriter) string {
+ if _, ok := w.RemoteAddr().(*net.TCPAddr); ok {
+ return "tcp"
+ }
+ return "udp"
}
func (p *Proxy) ResolveDomain(ctx context.Context, domain string) ([]nftables.ResolvedIP, error) {
@@ -403,7 +413,7 @@ func (p *Proxy) ResolveDomain(ctx context.Context, domain string) ([]nftables.Re
for _, queryType := range []uint16{dns.TypeA, dns.TypeAAAA} {
query := new(dns.Msg)
query.SetQuestion(dns.Fqdn(domain), queryType)
- response, _, err := p.forwardContext(ctx, query)
+ response, _, err := p.forwardContext(ctx, query, "udp")
if err != nil {
return nil, err
}
@@ -425,7 +435,7 @@ func (p *Proxy) ResolveDomain(ctx context.Context, domain string) ([]nftables.Re
return ips, nil
}
-func (p *Proxy) forwardContext(ctx context.Context, r *dns.Msg) (*dns.Msg, string, error) {
+func (p *Proxy) forwardContext(ctx context.Context, r *dns.Msg, network string) (*dns.Msg, string, error) {
list := p.forwardUpstreams()
var lastErr error
lastFailure := telemetry.DNSFailureNoUpstreams
@@ -439,6 +449,7 @@ func (p *Proxy) forwardContext(ctx context.Context, r *dns.Msg) (*dns.Msg, strin
query.SetEdns0(upstreamUDPSize, false)
}
c := &dns.Client{
+ Net: network,
Timeout: p.upstreamExchangeTimeout,
Dialer: p.dialerForUpstream(upstream),
UDPSize: upstreamUDPSize,
diff --git a/components/egress/pkg/dnsproxy/proxy_test.go b/components/egress/pkg/dnsproxy/proxy_test.go
index d05158e51..7ff7b0eb3 100644
--- a/components/egress/pkg/dnsproxy/proxy_test.go
+++ b/components/egress/pkg/dnsproxy/proxy_test.go
@@ -17,8 +17,10 @@ package dnsproxy
import (
"context"
"errors"
+ "fmt"
"net"
"net/netip"
+ "strings"
"testing"
"time"
@@ -123,7 +125,7 @@ func TestForwardAddsEDNS0BufferSize(t *testing.T) {
query := new(dns.Msg)
query.SetQuestion("example.com.", dns.TypeA)
- resp, failure, err := proxy.forward(query)
+ resp, failure, err := proxy.forward(query, "udp")
require.NoError(t, err)
require.Empty(t, failure, "a successful forward must not report a failure reason")
require.Len(t, resp.Answer, 1)
@@ -200,7 +202,7 @@ func TestForwardClassifiesFailures(t *testing.T) {
query := new(dns.Msg)
query.SetQuestion("example.com.", dns.TypeA)
- resp, failure, err := proxy.forward(query)
+ resp, failure, err := proxy.forward(query, "udp")
require.Error(t, err)
require.Nil(t, resp)
@@ -222,7 +224,7 @@ func TestForwardClassifiesFailures(t *testing.T) {
query := new(dns.Msg)
query.SetQuestion("example.com.", dns.TypeA)
- resp, failure, err := proxy.forward(query)
+ resp, failure, err := proxy.forward(query, "udp")
require.Error(t, err)
require.Nil(t, resp)
@@ -259,7 +261,7 @@ func TestForwardClassifiesFailures(t *testing.T) {
query := new(dns.Msg)
query.SetQuestion("example.com.", dns.TypeA)
- resp, failure, err := proxy.forward(query)
+ resp, failure, err := proxy.forward(query, "udp")
require.Error(t, err, "SERVFAIL from the only upstream must exhaust the chain")
require.Nil(t, resp)
@@ -445,3 +447,76 @@ func TestProxyShouldSkipOutboundLog_ClearedByEmptyList(t *testing.T) {
require.False(t, p.shouldSkipOutboundLog("metadata.internal"),
"clearing the list must re-enable logging for all hosts")
}
+
+// startLargeAnswerUpstream serves the same answer set over UDP and TCP on one
+// port. Over UDP it truncates to the client's EDNS0 size, as resolvers do.
+func startLargeAnswerUpstream(t *testing.T, records int) string {
+ t.Helper()
+ t.Setenv(constants.EnvNameserverExempt, "127.0.0.1")
+ resetNameserverExemptCache(t)
+
+ handler := dns.HandlerFunc(func(w dns.ResponseWriter, r *dns.Msg) {
+ resp := new(dns.Msg)
+ resp.SetReply(r)
+ for i := range records {
+ resp.Answer = append(resp.Answer, &dns.TXT{
+ Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 60},
+ Txt: []string{fmt.Sprintf("record-%03d-%s", i, strings.Repeat("x", 40))},
+ })
+ }
+ if _, udp := w.RemoteAddr().(*net.UDPAddr); udp {
+ size := uint16(dns.MinMsgSize)
+ if opt := r.IsEdns0(); opt != nil {
+ size = opt.UDPSize()
+ }
+ resp.Truncate(int(size))
+ }
+ _ = w.WriteMsg(resp)
+ })
+
+ packetConn, err := net.ListenPacket("udp", "127.0.0.1:0")
+ require.NoError(t, err)
+ listener, err := net.Listen("tcp", packetConn.LocalAddr().String())
+ require.NoError(t, err)
+ for _, server := range []*dns.Server{
+ {PacketConn: packetConn, Handler: handler},
+ {Listener: listener, Handler: handler},
+ } {
+ started := make(chan struct{})
+ server.NotifyStartedFunc = func() { close(started) }
+ go func() { _ = server.ActivateAndServe() }()
+ t.Cleanup(func() { _ = server.Shutdown() })
+ <-started
+ }
+ return packetConn.LocalAddr().String()
+}
+
+// A client retries over TCP after a truncated UDP answer; that retry must
+// reach the upstream over TCP too, or the answer stays truncated.
+func TestServeDNSForwardsTCPQueriesOverTCP(t *testing.T) {
+ t.Cleanup(func() { resetNameserverExemptCache(t) })
+ const records = 100
+ upstream := startLargeAnswerUpstream(t, records)
+ allow, err := policy.ParsePolicy(`{"defaultAction":"deny","egress":[{"action":"allow","target":"big.example.com"}]}`)
+ require.NoError(t, err)
+ proxy := &Proxy{
+ upstreams: []string{upstream},
+ activeUpstreams: []string{upstream},
+ upstreamExchangeTimeout: time.Second,
+ effectivePolicy: allow,
+ userPolicy: allow,
+ }
+ query := new(dns.Msg)
+ query.SetQuestion("big.example.com.", dns.TypeTXT)
+
+ udpClient := &fakeRespWriter{remote: &net.UDPAddr{IP: net.IPv4(10, 0, 0, 5), Port: 5353}}
+ proxy.serveDNS(udpClient, query)
+ require.Len(t, udpClient.msgs, 1)
+ require.True(t, udpClient.msgs[0].Truncated, "a UDP client gets the truncated answer and retries over TCP")
+
+ tcpClient := &fakeRespWriter{remote: &net.TCPAddr{IP: net.IPv4(10, 0, 0, 5), Port: 5353}}
+ proxy.serveDNS(tcpClient, query)
+ require.Len(t, tcpClient.msgs, 1)
+ require.False(t, tcpClient.msgs[0].Truncated)
+ require.Len(t, tcpClient.msgs[0].Answer, records)
+}