refactor(tlstool): support more ways of splitting SNI

experiment/tlstool/internal/dialer.go

@@ -0,0 +1,29 @@
+package internal
+
+import (
+	"context"
+	"net"
+	"time"
+
+	"github.com/ooni/probe-engine/netx"
+)
+
+// Dialer creates net.Conn instances where (1) we delay writes if
+// a delay is configured and (2) we split outgoing buffers if there
+// is a configured splitter function.
+type Dialer struct {
+	netx.Dialer
+	Delay    time.Duration
+	Splitter func([]byte) [][]byte
+}
+
+// DialContext implements netx.Dialer.DialContext.
+func (d Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	conn, err := d.Dialer.DialContext(ctx, network, address)
+	if err != nil {
+		return nil, err
+	}
+	conn = SleeperWriter{Conn: conn, Delay: d.Delay}
+	conn = SplitterWriter{Conn: conn, Splitter: d.Splitter}
+	return conn, nil
+}

experiment/tlstool/internal/dialer_test.go

@@ -0,0 +1,56 @@
+package internal_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/ooni/probe-engine/experiment/tlstool/internal"
+)
+
+func TestDialerFailure(t *testing.T) {
+	expected := errors.New("mocked error")
+	dialer := internal.Dialer{Dialer: internal.FakeDialer{
+		Err: expected,
+	}}
+	conn, err := dialer.DialContext(context.Background(), "tcp", "8.8.8.8:853")
+	if !errors.Is(err, expected) {
+		t.Fatalf("not the error we expected: %+v", err)
+	}
+	if conn != nil {
+		t.Fatal("expected nil conn here")
+	}
+}
+
+func TestDialerSuccess(t *testing.T) {
+	splitter := func([]byte) [][]byte {
+		return nil // any value is fine we just a need a splitter != nil here
+	}
+	innerconn := &internal.FakeConn{}
+	dialer := internal.Dialer{
+		Delay:    12345,
+		Dialer:   internal.FakeDialer{Conn: innerconn},
+		Splitter: splitter,
+	}
+	conn, err := dialer.DialContext(context.Background(), "tcp", "8.8.8.8:853")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sconn, ok := conn.(internal.SplitterWriter)
+	if !ok {
+		t.Fatal("the outer connection is not a splitter")
+	}
+	if sconn.Splitter == nil {
+		t.Fatal("not the splitter we expected")
+	}
+	dconn, ok := sconn.Conn.(internal.SleeperWriter)
+	if !ok {
+		t.Fatal("the inner connection is not a sleeper")
+	}
+	if dconn.Delay != 12345 {
+		t.Fatal("invalid delay")
+	}
+	if dconn.Conn != innerconn {
+		t.Fatal("invalid inner connection")
+	}
+}

experiment/tlstool/internal/segmenter/fake_test.go → experiment/tlstool/internal/fake_test.go

@@ -1,4 +1,4 @@
-package segmenter
+package internal
 
 import (
 	"context"

experiment/tlstool/internal/internal.go

@@ -0,0 +1,57 @@
+// Package internal contains the implementation of tlstool.
+package internal
+
+import (
+	"time"
+
+	"github.com/ooni/probe-engine/netx"
+)
+
+// DialerConfig contains the config for creating a dialer
+type DialerConfig struct {
+	Dialer netx.Dialer
+	Delay  time.Duration
+	SNI    string
+}
+
+// NewSNISplitterDialer creates a new dialer that splits
+// outgoing messages such that the SNI should end up being
+// splitted into different TCP segments.
+func NewSNISplitterDialer(config DialerConfig) Dialer {
+	return Dialer{
+		Dialer: config.Dialer,
+		Delay:  config.Delay,
+		Splitter: func(b []byte) [][]byte {
+			return SNISplitter(b, []byte(config.SNI))
+		},
+	}
+}
+
+// NewThriceSplitterDialer creates a new dialer that splits
+// outgoing messages in three parts according to the circumvention
+// technique described by Kevin Boch in the Internet Measurement
+// Village 2020 <https://youtu.be/ksojSRFLbBM?t=1140>.
+func NewThriceSplitterDialer(config DialerConfig) Dialer {
+	return Dialer{
+		Dialer:   config.Dialer,
+		Delay:    config.Delay,
+		Splitter: Splitter84rest,
+	}
+}
+
+// NewRandomSplitterDialer creates a new dialer that splits
+// the SNI like the fixed splitting schema used by outline. See
+// github.com/Jigsaw-Code/outline-go-tun2socks.
+func NewRandomSplitterDialer(config DialerConfig) Dialer {
+	return Dialer{
+		Dialer:   config.Dialer,
+		Delay:    config.Delay,
+		Splitter: Splitter3264rand,
+	}
+}
+
+// NewVanillaDialer creates a new vanilla dialer that does
+// nothing and is used to establish a baseline.
+func NewVanillaDialer(config DialerConfig) Dialer {
+	return Dialer{Dialer: config.Dialer}
+}

experiment/tlstool/internal/internal_test.go

@@ -0,0 +1,40 @@
+package internal_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ooni/probe-engine/experiment/tlstool/internal"
+	"github.com/ooni/probe-engine/netx"
+)
+
+var config = internal.DialerConfig{
+	Dialer: netx.NewDialer(netx.Config{}),
+	Delay:  10,
+	SNI:    "dns.google",
+}
+
+func dial(t *testing.T, d netx.Dialer) {
+	td := netx.NewTLSDialer(netx.Config{Dialer: d})
+	conn, err := td.DialTLSContext(context.Background(), "tcp", "dns.google:853")
+	if err != nil {
+		t.Fatal(err)
+	}
+	conn.Close()
+}
+
+func TestNewSNISplitterDialer(t *testing.T) {
+	dial(t, internal.NewSNISplitterDialer(config))
+}
+
+func TestNewThriceSplitterDialer(t *testing.T) {
+	dial(t, internal.NewThriceSplitterDialer(config))
+}
+
+func TestNewRandomSplitterDialer(t *testing.T) {
+	dial(t, internal.NewRandomSplitterDialer(config))
+}
+
+func TestNewVanillaDialer(t *testing.T) {
+	dial(t, internal.NewVanillaDialer(config))
+}