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.goindex 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.Refor _, 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.Rereturn 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 errorlastFailure := telemetry.DNSFailureNoUpstreams@@ -439,6 +449,7 @@ func (p *Proxy) forwardContext(ctx context.Context, r *dns.Msg) (*dns.Msg, strinquery.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.goindex d05158e51..7ff7b0eb3 100644--- a/components/egress/pkg/dnsproxy/proxy_test.go+++ b/components/egress/pkg/dnsproxy/proxy_test.go@@ -17,8 +17,10 @@ package dnsproxyimport ("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)+}