Add ddr experiment

internal/bytecounter/resolver.go

@@ -41,6 +41,11 @@ func (r *ContextAwareSystemResolver) LookupHTTPS(ctx context.Context, domain str
 	return r.wrap(ctx).LookupHTTPS(ctx, domain)
 }
 
+// LookupSVCB implements model.Resolver.
+func (r *ContextAwareSystemResolver) LookupSVCB(ctx context.Context, domain string) ([]*model.SVCB, error) {
+	return r.wrap(ctx).LookupSVCB(ctx, domain)
+}
+
 // LookupHost implements model.Resolver.
 func (r *ContextAwareSystemResolver) LookupHost(ctx context.Context, hostname string) (addrs []string, err error) {
 	return r.wrap(ctx).LookupHost(ctx, hostname)
@@ -108,6 +113,14 @@ func (r *resolver) LookupHTTPS(ctx context.Context, domain string) (*model.HTTPS
 	return out, err
 }
 
+// LookupSVCB implements model.Resolver
+func (r *resolver) LookupSVCB(ctx context.Context, domain string) ([]*model.SVCB, error) {
+	r.updateCounterBytesSent(domain, 1)
+	out, err := r.Resolver.LookupSVCB(ctx, domain)
+	r.updateCounterBytesRecv(err)
+	return out, err
+}
+
 // LookupHost implements model.Resolver
 func (r *resolver) LookupHost(ctx context.Context, hostname string) (addrs []string, err error) {
 	r.updateCounterBytesSent(hostname, 2)

internal/bytecounter/resolver_test.go

@@ -122,6 +122,84 @@ func TestMaybeWrapSystemResolver(t *testing.T) {
 		})
 	})
 
+	t.Run("LookupSVCB works as intended", func(t *testing.T) {
+		t.Run("on success", func(t *testing.T) {
+			expected := []*model.SVCB{
+				{Priority: 1, TargetName: "target1"},
+				{Priority: 2, TargetName: "target2"},
+				{Priority: 3, TargetName: "target3"},
+			}
+			underlying := &mocks.Resolver{
+				MockLookupSVCB: func(ctx context.Context, domain string) ([]*model.SVCB, error) {
+					return expected, nil
+				},
+			}
+			counter := New()
+			reso := MaybeWrapSystemResolver(underlying, counter)
+			got, err := reso.LookupSVCB(context.Background(), "dns.google")
+			if err != nil {
+				t.Fatal("unexpected error", err)
+			}
+			if len(got) != 3 {
+				t.Fatal("invalid result")
+			}
+			if nsent := counter.BytesSent(); nsent != 10 {
+				t.Fatal("unexpected nsent", nsent)
+			}
+			if nrecv := counter.BytesReceived(); nrecv != 256 {
+				t.Fatal("unexpected nrecv")
+			}
+		})
+
+		t.Run("on non-DNS failure", func(t *testing.T) {
+			expected := errors.New("mocked error")
+			underlying := &mocks.Resolver{
+				MockLookupSVCB: func(ctx context.Context, domain string) ([]*model.SVCB, error) {
+					return nil, expected
+				},
+			}
+			counter := New()
+			reso := MaybeWrapSystemResolver(underlying, counter)
+			got, err := reso.LookupSVCB(context.Background(), "dns.google")
+			if !errors.Is(err, expected) {
+				t.Fatal("unexpected error", err)
+			}
+			if got != nil {
+				t.Fatal("invalid result")
+			}
+			if nsent := counter.BytesSent(); nsent != 10 {
+				t.Fatal("unexpected nsent", nsent)
+			}
+			if nrecv := counter.BytesReceived(); nrecv != 0 {
+				t.Fatal("unexpected nrecv")
+			}
+		})
+
+		t.Run("on DNS failure", func(t *testing.T) {
+			expected := errors.New(netxlite.FailureDNSNXDOMAINError)
+			underlying := &mocks.Resolver{
+				MockLookupSVCB: func(ctx context.Context, domain string) ([]*model.SVCB, error) {
+					return nil, expected
+				},
+			}
+			counter := New()
+			reso := MaybeWrapSystemResolver(underlying, counter)
+			got, err := reso.LookupSVCB(context.Background(), "dns.google")
+			if !errors.Is(err, expected) {
+				t.Fatal("unexpected error", err)
+			}
+			if got != nil {
+				t.Fatal("invalid result")
+			}
+			if nsent := counter.BytesSent(); nsent != 10 {
+				t.Fatal("unexpected nsent", nsent)
+			}
+			if nrecv := counter.BytesReceived(); nrecv != 128 {
+				t.Fatal("unexpected nrecv")
+			}
+		})
+	})
+
 	t.Run("LookupNS works as intended", func(t *testing.T) {
 		t.Run("on success", func(t *testing.T) {
 			underlying := &mocks.Resolver{

internal/cmd/oohelper/internal/fake_test.go

@@ -56,6 +56,10 @@ func (c FakeResolver) LookupHTTPS(ctx context.Context, domain string) (*model.HT
 	return nil, errors.New("not implemented")
 }
 
+func (c FakeResolver) LookupSVCB(ctx context.Context, domain string) ([]*model.SVCB, error) {
+	return nil, errors.New("not implemented")
+}
+
 func (c FakeResolver) LookupNS(ctx context.Context, domain string) ([]*net.NS, error) {
 	return nil, errors.New("not implemented")
 }

internal/engineresolver/resolver.go

@@ -88,6 +88,11 @@ func (r *Resolver) LookupHTTPS(ctx context.Context, domain string) (*model.HTTPS
 	return nil, errLookupNotImplemented
 }
 
+// LookupSVCB implements Resolver.LookupSVCB.
+func (r *Resolver) LookupSVCB(ctx context.Context, domain string) ([]*model.SVCB, error) {
+	return nil, errLookupNotImplemented
+}
+
 // LookupNS implements Resolver.LookupNS.
 func (r *Resolver) LookupNS(ctx context.Context, domain string) ([]*net.NS, error) {
 	return nil, errLookupNotImplemented

internal/experiment/ddr/ddr.go

@@ -0,0 +1,125 @@
+package ddr
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/apex/log"
+	"github.com/miekg/dns"
+	"github.com/ooni/probe-cli/v3/internal/legacy/netx"
+	"github.com/ooni/probe-cli/v3/internal/legacy/tracex"
+	"github.com/ooni/probe-cli/v3/internal/model"
+	"github.com/ooni/probe-cli/v3/internal/netxlite"
+)
+
+const (
+	testName    = "ddr"
+	testVersion = "0.1.0"
+)
+
+type Config struct {
+	// CustomResolver is the custom resolver to use.
+	// If empty, the system resolver is used.
+	CustomResolver *string
+}
+
+// Measurer performs the measurement.
+type Measurer struct {
+	config Config
+}
+
+// ExperimentName implements ExperimentMeasurer.ExperimentName.
+func (m *Measurer) ExperimentName() string {
+	return testName
+}
+
+// ExperimentVersion implements ExperimentMeasurer.ExperimentVersion.
+func (m *Measurer) ExperimentVersion() string {
+	return testVersion
+}
+
+type TestKeys struct {
+	// DNS Queries and results (as specified in https://github.com/ooni/spec/blob/master/data-formats/df-002-dnst.md#dns-data-format)
+	Queries []model.ArchivalDNSLookupResult `json:"queries"`
+
+	// SupportsDDR is true if DDR is supported.
+	SupportsDDR bool `json:"supports_ddr"`
+
+	// Failure is the failure that occurred, or nil.
+	Failure *string `json:"failure"`
+}
+
+func (m *Measurer) Run(ctx context.Context, args *model.ExperimentArgs) error {
+	log.SetLevel(log.DebugLevel)
+	measurement := args.Measurement
+
+	tk := &TestKeys{}
+	measurement.TestKeys = tk
+
+	timeout := 60 * time.Second
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	resolverAddress := ""
+	if m.config.CustomResolver == nil {
+		systemResolver := getSystemResolverAddress()
+		if systemResolver == "" {
+			return errors.New("could not get system resolver")
+		}
+		log.Infof("Using system resolver: %s", systemResolver)
+		resolverAddress = systemResolver
+	} else {
+		resolverAddress = *m.config.CustomResolver
+	}
+
+	netxlite := &netxlite.Netx{}
+	evsaver := new(tracex.Saver)
+	dialer := netxlite.NewDialerWithoutResolver(log.Log)
+	baseResolver := netxlite.NewParallelUDPResolver(log.Log, dialer, resolverAddress)
+	resolver := netx.NewResolver(netx.Config{
+		BaseResolver: baseResolver,
+		Saver:        evsaver,
+	})
+
+	// As specified in RFC 9462 a DDR Query is a SVCB query for the _dns.resolver.arpa. domain
+	resp, err := resolver.LookupSVCB(ctx, "_dns.resolver.arpa.")
+	if err != nil {
+		tk.Failure = new(string)
+		*tk.Failure = err.Error()
+		return nil
+	}
+	queries := tracex.NewDNSQueriesList(measurement.MeasurementStartTimeSaved, evsaver.Read())
+
+	for r := range resp {
+		log.Debug(fmt.Sprintf("Got SVCB record: %v", r))
+	}
+
+	tk.Queries = queries
+	tk.SupportsDDR = len(resp) > 0
+
+	return nil
+}
+
+// Get the system resolver address from /etc/resolv.conf
+// This should also be possible via querying the system resolver and checking the response
+func getSystemResolverAddress() string {
+	resolverConfig, err := dns.ClientConfigFromFile("/etc/resolv.conf")
+	if err != nil {
+		return ""
+	}
+
+	if len(resolverConfig.Servers) > 0 {
+		return net.JoinHostPort(resolverConfig.Servers[0], resolverConfig.Port)
+	}
+
+	return ""
+}
+
+func NewExperimentMeasurer(config Config) model.ExperimentMeasurer {
+	return &Measurer{
+		config: config,
+	}
+}