From a32023be5f1e2bef57833fa6de7681bb9bfce711 Mon Sep 17 00:00:00 2001 From: yangdujun <137720155+yandujun363@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:27:34 +0800 Subject: [PATCH] XMC finalmask: Bound padding schedules; Fix delay placement; Stop compressing frames (#7423) https://github.com/XTLS/Xray-core/pull/7402#issuecomment-6912788851 https://github.com/XTLS/Xray-core/pull/7430#issuecomment-6917170115 https://github.com/XTLS/Xray-core/pull/7423#issuecomment-6973045579 --- infra/conf/transport_finalmask.go | 19 ++- infra/conf/transport_finalmask_xmc_test.go | 39 +++++ transport/internet/finalmask/xmc/client.go | 24 ++- .../internet/finalmask/xmc/compression.go | 54 +++--- .../finalmask/xmc/compression_test.go | 131 +++++++++------ transport/internet/finalmask/xmc/config.go | 70 ++++++-- transport/internet/finalmask/xmc/config.pb.go | 33 +++- transport/internet/finalmask/xmc/config.proto | 18 +- .../internet/finalmask/xmc/config_test.go | 125 ++++++++++++++ .../internet/finalmask/xmc/handshake_test.go | 8 +- transport/internet/finalmask/xmc/padding.go | 82 ++++++--- .../finalmask/xmc/padding_frames_test.go | 157 +++++++++++++++++- transport/internet/finalmask/xmc/server.go | 18 +- 13 files changed, 628 insertions(+), 150 deletions(-) diff --git a/infra/conf/transport_finalmask.go b/infra/conf/transport_finalmask.go index 50a4b01b3..29d3fe838 100644 --- a/infra/conf/transport_finalmask.go +++ b/infra/conf/transport_finalmask.go @@ -936,12 +936,20 @@ type XMC struct { Profiles []XMCProfile `json:"profiles"` Password string `json:"password"` Paddings []XMCPaddingTurn `json:"paddings,omitempty"` + // A configured list is the complete padding schedule and replaces the + // built-in preset entirely, including the preset's Play-state join tail. + // NoPadding disables padding. An explicit empty "paddings" array means the + // same; an absent one keeps the built-in preset. + NoPadding bool `json:"noPadding,omitempty"` } type XMCPaddingTurn struct { Length string `json:"length"` Direction string `json:"direction"` - // Delay is an optional millisecond value or inclusive min-max range. + // Delay is an optional millisecond value or inclusive min-max range: the + // pause that leads into this turn, written on the turn that follows the gap + // it reproduces. The sending side samples the range, the peer spends its + // minimum, and nothing pauses after the last turn. Delay string `json:"delay,omitempty"` } @@ -988,7 +996,14 @@ func (c *XMC) Build() (proto.Message, error) { if len(c.Password) > xmc.MaxLegacyPasswordLength { return nil, fmt.Errorf("minecraft password is longer than %d bytes", xmc.MaxLegacyPasswordLength) } - config := &xmc.Config{Password: c.Password, Hostname: c.Hostname} + // An explicit empty array is different from an absent field: json leaves + // Paddings nil when it is absent, so the user can turn padding off without + // a second switch. + noPadding := c.NoPadding || (c.Paddings != nil && len(c.Paddings) == 0) + if noPadding && len(c.Paddings) > 0 { + return nil, fmt.Errorf("minecraft padding: noPadding and paddings are exclusive") + } + config := &xmc.Config{Password: c.Password, Hostname: c.Hostname, NoPadding: noPadding} for i, turn := range c.Paddings { minimum, maximum, err := ParseRangeString(turn.Length) if err != nil { diff --git a/infra/conf/transport_finalmask_xmc_test.go b/infra/conf/transport_finalmask_xmc_test.go index aae1d0f65..1ce0b1474 100644 --- a/infra/conf/transport_finalmask_xmc_test.go +++ b/infra/conf/transport_finalmask_xmc_test.go @@ -112,3 +112,42 @@ func TestXMCBuildRejectsLongPassword(t *testing.T) { t.Fatalf("expected a password length error, got %v", err) } } + +func TestXMCBuildDisablesPadding(t *testing.T) { + profile := XMCProfile{ + Username: "TestUser", UUID: "00112233-4455-6677-8899-aabbccddeeff", + TexturesValue: "textures-value", TexturesSignature: "textures-signature", + } + + for name, settings := range map[string]string{ + "explicit_empty_array": `{"paddings": []}`, + "no_padding_switch": `{"noPadding": true}`, + } { + t.Run(name, func(t *testing.T) { + var config XMC + if err := json.Unmarshal([]byte(settings), &config); err != nil { + t.Fatal(err) + } + config.Password = "test-password" + config.Profiles = []XMCProfile{profile} + built, err := config.Build() + if err != nil { + t.Fatalf("build XMC config: %v", err) + } + builtConfig := built.(*xmc.Config) + if !builtConfig.NoPadding || len(builtConfig.Paddings) != 0 { + t.Fatalf("padding was not disabled: %+v", builtConfig) + } + }) + } + + var config XMC + if err := json.Unmarshal([]byte(`{"noPadding": true, "paddings": [{"length": "3", "direction": "c2s"}]}`), &config); err != nil { + t.Fatal(err) + } + config.Password = "test-password" + config.Profiles = []XMCProfile{profile} + if _, err := config.Build(); err == nil || !strings.Contains(err.Error(), "exclusive") { + t.Fatalf("expected an exclusive padding error, got %v", err) + } +} diff --git a/transport/internet/finalmask/xmc/client.go b/transport/internet/finalmask/xmc/client.go index 744b2fdb0..0ed47a57d 100644 --- a/transport/internet/finalmask/xmc/client.go +++ b/transport/internet/finalmask/xmc/client.go @@ -32,6 +32,9 @@ type clientConn struct { paddingSchedule []paddingTurn packet *packetStream deadlines *connectionDeadlines + + done chan struct{} + closeOnce sync.Once } type clientState int @@ -41,7 +44,7 @@ var ( clientStateProxy clientState = 2 ) -func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPublicKey []byte, hostname string, padding []*Padding) (*clientConn, error) { +func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPublicKey []byte, hostname string, paddingSchedule []paddingTurn) (*clientConn, error) { if len(rsaPublicKey) == 0 { return nil, fmt.Errorf("empty rsa public key") } @@ -51,10 +54,6 @@ func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPubl if len(password) > MaxLegacyPasswordLength { return nil, fmt.Errorf("password is longer than %d bytes", MaxLegacyPasswordLength) } - paddingSchedule, err := newPaddingSchedule(padding, true) - if err != nil { - return nil, fmt.Errorf("select padding profile: %w", err) - } return &clientConn{ reader: bufio.NewReader(c), writer: c, @@ -67,9 +66,15 @@ func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPubl hostname: hostname, paddingSchedule: paddingSchedule, deadlines: newConnectionDeadlines(c), + done: make(chan struct{}), }, nil } +// paddingPause applies one padding pause, stopping early on Close. +func (c *clientConn) paddingPause(d time.Duration) error { + return pausePadding(c.done, d) +} + func (c *clientConn) handshake() error { c.handshakeLock.Lock() defer c.handshakeLock.Unlock() @@ -199,7 +204,9 @@ func (c *clientConn) handshake() error { return fmt.Errorf("read login finished: %w", err) } // Set Compression is not compressed itself and must be handled before the - // packet that follows it, which already uses the compressed framing. + // packet that follows it, which already uses the compressed framing. The + // threshold only decides whether the framing applies: this writer never + // compresses, so a server-side threshold does not shrink padding turns. if pkt.packetID == 0x03 { var threshold Varint if thresholdErr := pkt.readFields(&threshold); thresholdErr != nil { @@ -207,7 +214,7 @@ func (c *clientConn) handshake() error { } if threshold >= 0 { c.reader = newCompressionReader(c.reader) - c.writer = newCompressionWriter(c.writer, int32(threshold)) + c.writer = newCompressionWriter(c.writer) } pkt, err = readPacket(c.reader) if err != nil { @@ -237,7 +244,7 @@ func (c *clientConn) handshake() error { return fmt.Errorf("write login acknowledged: %w", err) } c.reader = newPaddingReader(c.reader, true) - if err = runPaddingSchedule(c.writer, true, loginAcknowledgedLength, c.paddingSchedule); err != nil { + if err = runPaddingSchedule(c.writer, true, loginAcknowledgedLength, c.paddingSchedule, c.paddingPause); err != nil { _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) } @@ -281,6 +288,7 @@ func (c *clientConn) Close() error { c.closed = true packet := c.packet c.lifecycleMu.Unlock() + c.closeOnce.Do(func() { close(c.done) }) if packet != nil { packet.Stop() } diff --git a/transport/internet/finalmask/xmc/compression.go b/transport/internet/finalmask/xmc/compression.go index cf24675f2..d22e6d7d7 100644 --- a/transport/internet/finalmask/xmc/compression.go +++ b/transport/internet/finalmask/xmc/compression.go @@ -1,4 +1,6 @@ // Minecraft compression framing, negotiated by the login Set Compression packet. +// The reader decodes whatever the peer sends, including deflated bodies; the +// writer always sends the uncompressed variant. package xmc import ( @@ -99,14 +101,21 @@ func (c *compressionReader) readFrame() error { // compressionWriter converts a plain frame (VarInt body length, body) into the // post-Set Compression framing. Frames are buffered until complete, because a // caller may split one frame across several Write calls. +// +// It never compresses, whatever the negotiated threshold is. What XMC writes is +// padding and proxied bytes: the padding exists for its size on the wire, so +// deflating it would shrink a padded turn from tens of kilobytes to a hundred +// bytes and erase the shape it is there for, and proxied bytes are already +// encrypted or compressed by whoever produced them. Vanilla accepts an +// uncompressed body of any size when Data Length is zero, so the framing alone +// is enough to stay inside the protocol. type compressionWriter struct { - w io.Writer - threshold int32 - pending []byte + w io.Writer + pending []byte } -func newCompressionWriter(w io.Writer, threshold int32) io.Writer { - return &compressionWriter{w: w, threshold: threshold} +func newCompressionWriter(w io.Writer) io.Writer { + return &compressionWriter{w: w} } func (c *compressionWriter) Write(p []byte) (int, error) { @@ -156,36 +165,13 @@ func (c *compressionWriter) nextFrame() ([]byte, bool, error) { } func (c *compressionWriter) writeFrame(body []byte) error { - if len(body) >= int(c.threshold) { - var compressed bytes.Buffer - zw := zlib.NewWriter(&compressed) - if _, err := zw.Write(body); err != nil { - _ = zw.Close() - return fmt.Errorf("compress packet: %w", err) - } - if err := zw.Close(); err != nil { - return fmt.Errorf("close compressor: %w", err) - } - - var frame bytes.Buffer - packetLength := varintSize(Varint(len(body))) + compressed.Len() - frame.Grow(varintSize(Varint(packetLength)) + packetLength) - packetLengthVarint := Varint(packetLength) - if err := packetLengthVarint.writeTo(&frame); err != nil { - return err - } - bodyLength := Varint(len(body)) - if err := bodyLength.writeTo(&frame); err != nil { - return err - } - frame.Write(compressed.Bytes()) - return writeFull(c.w, frame.Bytes()) - } - + // Packet Length covers the Data Length varint and the body; a zero Data + // Length is the uncompressed variant. + packetLength := 1 + len(body) var frame bytes.Buffer - frame.Grow(varintSize(Varint(1+len(body))) + 1 + len(body)) - frameLength := Varint(1 + len(body)) - if err := frameLength.writeTo(&frame); err != nil { + frame.Grow(varintSize(Varint(packetLength)) + packetLength) + packetLengthVarint := Varint(packetLength) + if err := packetLengthVarint.writeTo(&frame); err != nil { return err } frame.WriteByte(0) diff --git a/transport/internet/finalmask/xmc/compression_test.go b/transport/internet/finalmask/xmc/compression_test.go index e3a52b7c0..5a26f13c2 100644 --- a/transport/internet/finalmask/xmc/compression_test.go +++ b/transport/internet/finalmask/xmc/compression_test.go @@ -2,6 +2,7 @@ package xmc import ( "bytes" + "compress/zlib" "crypto/rand" "errors" "io" @@ -49,39 +50,39 @@ func randomBody(t *testing.T, size int) []byte { return body } -func TestCompressionWriterThreshold(t *testing.T) { - for _, threshold := range []int32{0, 1, 256, 65536} { - for _, size := range []int{1, 10, 255, 256, 257, 65535, 65536} { - body := bytes.Repeat([]byte{0}, size) +// TestCompressionWriterNeverCompresses pins the write policy: whatever the +// negotiated threshold is, XMC sends the uncompressed framing so that a padding +// turn keeps its wire size. A padded turn of zeros would otherwise deflate from +// tens of kilobytes to a hundred bytes and the shape would be gone. +func TestCompressionWriterNeverCompresses(t *testing.T) { + for _, size := range []int{1, 10, 255, 256, 257, 32768, 65535, 65536} { + for _, body := range [][]byte{bytes.Repeat([]byte{0}, size), randomBody(t, size)} { var wire bytes.Buffer - w := newCompressionWriter(&wire, threshold) + w := newCompressionWriter(&wire) if _, err := w.Write(plainFrame(body)); err != nil { - t.Fatalf("threshold %d size %d: write: %v", threshold, size, err) + t.Fatalf("size %d: write: %v", size, err) } frame := readWireFrame(t, bytes.NewReader(wire.Bytes())) - wantCompressed := int32(size) >= threshold - if wantCompressed && frame.dataLength != size { - t.Fatalf("threshold %d size %d: want compressed data length %d, got %d", threshold, size, size, frame.dataLength) + if frame.dataLength != 0 { + t.Fatalf("size %d: writer compressed the body (data length %d)", size, frame.dataLength) } - if !wantCompressed { - if frame.dataLength != 0 { - t.Fatalf("threshold %d size %d: want uncompressed frame, got data length %d", threshold, size, frame.dataLength) - } - if !bytes.Equal(frame.payload, body) { - t.Fatalf("threshold %d size %d: uncompressed payload mismatch", threshold, size) - } - if frame.packetLength != 1+size { - t.Fatalf("threshold %d size %d: packet length %d", threshold, size, frame.packetLength) - } + if !bytes.Equal(frame.payload, body) { + t.Fatalf("size %d: payload mismatch", size) + } + if frame.packetLength != 1+size { + t.Fatalf("size %d: packet length %d, want %d", size, frame.packetLength, 1+size) + } + if wire.Len() != varintSize(Varint(1+size))+1+size { + t.Fatalf("size %d: frame is %d bytes on the wire, want %d", size, wire.Len(), varintSize(Varint(1+size))+1+size) } decoded, _, err := readFrame(newCompressionReader(bytes.NewReader(wire.Bytes())), maxUncompressedFrameBody) if err != nil { - t.Fatalf("threshold %d size %d: decode: %v", threshold, size, err) + t.Fatalf("size %d: decode: %v", size, err) } if !bytes.Equal(decoded, body) { - t.Fatalf("threshold %d size %d: round trip mismatch", threshold, size) + t.Fatalf("size %d: round trip mismatch", size) } } } @@ -96,38 +97,36 @@ func TestCompressionRoundTripChunked(t *testing.T) { bytes.Repeat([]byte("xmc"), 8*1024), } - for _, threshold := range []int32{0, 256, 65536} { - var wire bytes.Buffer - w := newCompressionWriter(&wire, threshold) - // One Write per frame, split into awkward chunk sizes. - for _, body := range cases { - frame := plainFrame(body) - for len(frame) > 0 { - n := 7 - if n > len(frame) { - n = len(frame) - } - if _, err := w.Write(frame[:n]); err != nil { - t.Fatalf("threshold %d: chunked write: %v", threshold, err) - } - frame = frame[n:] + var wire bytes.Buffer + w := newCompressionWriter(&wire) + // One Write per frame, split into awkward chunk sizes. + for _, body := range cases { + frame := plainFrame(body) + for len(frame) > 0 { + n := 7 + if n > len(frame) { + n = len(frame) } + if _, err := w.Write(frame[:n]); err != nil { + t.Fatalf("chunked write: %v", err) + } + frame = frame[n:] } + } - r := newCompressionReader(bytes.NewReader(wire.Bytes())) - for i, want := range cases { - got, _, err := readFrame(r, maxUncompressedFrameBody) - if err != nil { - t.Fatalf("threshold %d frame %d: decode: %v", threshold, i, err) - } - if !bytes.Equal(got, want) { - t.Fatalf("threshold %d frame %d: mismatch (%d vs %d bytes)", threshold, i, len(got), len(want)) - } + r := newCompressionReader(bytes.NewReader(wire.Bytes())) + for i, want := range cases { + got, _, err := readFrame(r, maxUncompressedFrameBody) + if err != nil { + t.Fatalf("frame %d: decode: %v", i, err) } - if _, _, err := readFrame(r, maxUncompressedFrameBody); !errors.Is(err, io.EOF) { - t.Fatalf("threshold %d: expected EOF after the last frame, got %v", threshold, err) + if !bytes.Equal(got, want) { + t.Fatalf("frame %d: mismatch (%d vs %d bytes)", i, len(got), len(want)) } } + if _, _, err := readFrame(r, maxUncompressedFrameBody); !errors.Is(err, io.EOF) { + t.Fatalf("expected EOF after the last frame, got %v", err) + } } func TestCompressionMultipleFramesOneWrite(t *testing.T) { @@ -138,7 +137,7 @@ func TestCompressionMultipleFramesOneWrite(t *testing.T) { } var wire bytes.Buffer - w := newCompressionWriter(&wire, 256) + w := newCompressionWriter(&wire) if _, err := w.Write(plain); err != nil { t.Fatalf("write: %v", err) } @@ -176,6 +175,40 @@ func TestCompressionReaderUncompressedOverThreshold(t *testing.T) { } } +// The writer stopped compressing, but a real server still does, so the reader +// must keep decoding deflated bodies. +func TestCompressionReaderDecodesCompressedBody(t *testing.T) { + body := append(bytes.Repeat([]byte("xmc"), 4096), 0, 1, 2, 3) + + var compressed bytes.Buffer + zw := zlib.NewWriter(&compressed) + if _, err := zw.Write(body); err != nil { + t.Fatal(err) + } + if err := zw.Close(); err != nil { + t.Fatal(err) + } + + var wire bytes.Buffer + packetLength := Varint(varintSize(Varint(len(body))) + compressed.Len()) + if err := packetLength.writeTo(&wire); err != nil { + t.Fatal(err) + } + dataLength := Varint(len(body)) + if err := dataLength.writeTo(&wire); err != nil { + t.Fatal(err) + } + wire.Write(compressed.Bytes()) + + got, _, err := readFrame(newCompressionReader(bytes.NewReader(wire.Bytes())), maxUncompressedFrameBody) + if err != nil { + t.Fatalf("decode: %v", err) + } + if !bytes.Equal(got, body) { + t.Fatal("payload mismatch") + } +} + func TestCompressionReaderErrors(t *testing.T) { // Compressed packet with a bogus body. var badZlib bytes.Buffer @@ -213,7 +246,7 @@ func TestCompressionReaderErrors(t *testing.T) { func TestCompressionWriterInvalidFrameLength(t *testing.T) { var wire bytes.Buffer - w := newCompressionWriter(&wire, 256) + w := newCompressionWriter(&wire) if _, err := w.Write([]byte{0xff, 0xff, 0xff, 0xff, 0xff}); err == nil { t.Fatal("expected an error for an invalid frame length prefix") } diff --git a/transport/internet/finalmask/xmc/config.go b/transport/internet/finalmask/xmc/config.go index ab7cea839..0fc1d4121 100644 --- a/transport/internet/finalmask/xmc/config.go +++ b/transport/internet/finalmask/xmc/config.go @@ -23,7 +23,11 @@ func (c *Config) WrapConnClient(conn net.Conn, dest *net.Destination, dialer *fi if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } - cc, err := newClientConn(conn, profiles, c.Password, c.RsaPublicKey, c.Hostname, c.Paddings) + paddingSchedule, err := c.paddingSchedule(true) + if err != nil { + return nil, fmt.Errorf("minecraft finalmask: %w", err) + } + cc, err := newClientConn(conn, profiles, c.Password, c.RsaPublicKey, c.Hostname, paddingSchedule) if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } @@ -36,7 +40,11 @@ func (c *Config) WrapConnServer(conn net.Conn) (net.Conn, error) { if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } - cc, err := wrapConnServer(conn, profiles, c.Password, c.RsaPrivateKey, c.RsaPublicKey, c.Paddings) + paddingSchedule, err := c.paddingSchedule(false) + if err != nil { + return nil, fmt.Errorf("minecraft finalmask: %w", err) + } + cc, err := wrapConnServer(conn, profiles, c.Password, c.RsaPrivateKey, c.RsaPublicKey, paddingSchedule) if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } @@ -44,16 +52,53 @@ func (c *Config) WrapConnServer(conn net.Conn) (net.Conn, error) { return cc, nil } -// ValidatePadding checks custom startup turns without selecting a built-in preset. +// ValidatePadding checks the configured startup turns (including their bounds) +// without selecting a built-in preset. func (c *Config) ValidatePadding() error { + if c.NoPadding { + if len(c.Paddings) != 0 { + return fmt.Errorf("padding is disabled and configured at the same time") + } + return nil + } _, err := paddingScheduleFromConfig(c.Paddings) return err } +// paddingSchedule selects the padding turns for one connection. An explicit +// empty configuration disables padding; an absent one keeps the built-in +// preset. +// +// A configured list is the complete schedule, not a replacement for its startup +// part: the built-in preset also carries a Play-state join tail, and that tail +// runs only with the preset. A user who captured their own login decides the +// whole shape, including whether it has a tail. +func (c *Config) paddingSchedule(isClient bool) ([]paddingTurn, error) { + if c.NoPadding { + if len(c.Paddings) != 0 { + return nil, fmt.Errorf("padding is disabled and configured at the same time") + } + return nil, nil + } + if len(c.Paddings) > 0 { + return paddingScheduleFromConfig(c.Paddings) + } + if isClient { + return newClientPaddingSchedule2612() + } + return newServerPaddingSchedule2612() +} + +// paddingScheduleFromConfig builds the complete schedule from a configured list. +// The list replaces the preset entirely, including its Play-state join tail. func paddingScheduleFromConfig(paddings []*Padding) ([]paddingTurn, error) { if len(paddings) == 0 { return nil, nil } + if len(paddings) > maxPaddingTurns { + return nil, fmt.Errorf("too many padding turns: %d (at most %d)", len(paddings), maxPaddingTurns) + } + var totalLength, totalDelayMilliseconds int64 schedule := make([]paddingTurn, len(paddings)) for i, turn := range paddings { if turn == nil || turn.LengthMin < 1 || turn.LengthMax < turn.LengthMin || turn.LengthMax > maxPaddingTurnLength { @@ -65,6 +110,14 @@ func paddingScheduleFromConfig(paddings []*Padding) ([]paddingTurn, error) { if turn.DelayMax > maxPaddingDelayMilliseconds { return nil, fmt.Errorf("padding delay range %d-%d at turn %d is too large", turn.DelayMin, turn.DelayMax, i) } + totalLength += turn.LengthMax + if totalLength > maxPaddingTotalLength { + return nil, fmt.Errorf("padding turns are longer than %d bytes in total", maxPaddingTotalLength) + } + totalDelayMilliseconds += turn.DelayMax + if totalDelayMilliseconds > int64(maxPaddingScheduleDelay/time.Millisecond) { + return nil, fmt.Errorf("padding pauses are longer than %s in total", maxPaddingScheduleDelay) + } var direction paddingDirection switch turn.Direction { case 1: @@ -90,14 +143,3 @@ func paddingScheduleFromConfig(paddings []*Padding) ([]paddingTurn, error) { } return schedule, nil } - -func newPaddingSchedule(paddings []*Padding, isClient bool) ([]paddingTurn, error) { - schedule, err := paddingScheduleFromConfig(paddings) - if err != nil || schedule != nil { - return schedule, err - } - if isClient { - return newClientPaddingSchedule2612() - } - return newServerPaddingSchedule2612() -} diff --git a/transport/internet/finalmask/xmc/config.pb.go b/transport/internet/finalmask/xmc/config.pb.go index 8db565a15..f1afd8fb4 100644 --- a/transport/internet/finalmask/xmc/config.pb.go +++ b/transport/internet/finalmask/xmc/config.pb.go @@ -99,8 +99,13 @@ type Config struct { RsaPublicKey []byte `protobuf:"bytes,9,opt,name=rsa_public_key,json=rsaPublicKey,proto3" json:"rsa_public_key,omitempty"` Hostname string `protobuf:"bytes,10,opt,name=hostname,proto3" json:"hostname,omitempty"` Profiles []*Profile `protobuf:"bytes,11,rep,name=profiles,proto3" json:"profiles,omitempty"` - // Startup padding turns. Empty uses the built-in preset. - Paddings []*Padding `protobuf:"bytes,12,rep,name=paddings,proto3" json:"paddings,omitempty"` + // Padding turns. Empty uses the built-in preset, unless no_padding is set. + // A configured list is the complete schedule and replaces the preset + // entirely: the preset's Play-state join tail runs only with the preset. + Paddings []*Padding `protobuf:"bytes,12,rep,name=paddings,proto3" json:"paddings,omitempty"` + // Disables startup padding. The configuration sets this for an explicit + // empty "paddings" array, which an unset repeated field cannot express. + NoPadding bool `protobuf:"varint,14,opt,name=no_padding,json=noPadding,proto3" json:"no_padding,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -177,15 +182,27 @@ func (x *Config) GetPaddings() []*Padding { return nil } +func (x *Config) GetNoPadding() bool { + if x != nil { + return x.NoPadding + } + return false +} + type Padding struct { state protoimpl.MessageState `protogen:"open.v1"` LengthMin int64 `protobuf:"varint,1,opt,name=length_min,json=lengthMin,proto3" json:"length_min,omitempty"` LengthMax int64 `protobuf:"varint,2,opt,name=length_max,json=lengthMax,proto3" json:"length_max,omitempty"` // 1 = client to server, 2 = server to client Direction int32 `protobuf:"varint,3,opt,name=direction,proto3" json:"direction,omitempty"` - // Millisecond pause after this turn, including the last one. The sender - // waits for a uniformly selected value in [delay_min, delay_max]; the - // receiver waits at least delay_min. Zero means no delay. + // Millisecond pause that leads into this turn: it sits between the previous + // padding turn (or Login Acknowledged, for the first turn) and this turn's + // bytes, so a captured gap is written on the turn that follows it. The side + // that sends the turn waits for a uniformly selected value in + // [delay_min, delay_max]; the peer spends exactly delay_min at the same + // place, so only the sending side jitters: use delay_min == delay_max to + // reproduce a captured gap. Nothing pauses after the last turn. Zero means + // no pause. DelayMin int64 `protobuf:"varint,4,opt,name=delay_min,json=delayMin,proto3" json:"delay_min,omitempty"` DelayMax int64 `protobuf:"varint,5,opt,name=delay_max,json=delayMax,proto3" json:"delay_max,omitempty"` unknownFields protoimpl.UnknownFields @@ -266,7 +283,7 @@ const file_transport_internet_finalmask_xmc_config_proto_rawDesc = "" + "\busername\x18\x01 \x01(\tR\busername\x12\x12\n" + "\x04uuid\x18\x02 \x01(\fR\x04uuid\x12%\n" + "\x0etextures_value\x18\x03 \x01(\tR\rtexturesValue\x12-\n" + - "\x12textures_signature\x18\x04 \x01(\tR\x11texturesSignature\"\xac\x02\n" + + "\x12textures_signature\x18\x04 \x01(\tR\x11texturesSignature\"\xcb\x02\n" + "\x06Config\x12\x1a\n" + "\bpassword\x18\x01 \x01(\tR\bpassword\x12&\n" + "\x0frsa_private_key\x18\b \x01(\fR\rrsaPrivateKey\x12$\n" + @@ -274,7 +291,9 @@ const file_transport_internet_finalmask_xmc_config_proto_rawDesc = "" + "\bhostname\x18\n" + " \x01(\tR\bhostname\x12J\n" + "\bprofiles\x18\v \x03(\v2..xray.transport.internet.finalmask.xmc.ProfileR\bprofiles\x12J\n" + - "\bpaddings\x18\f \x03(\v2..xray.transport.internet.finalmask.xmc.PaddingR\bpaddingsJ\x04\b\x02\x10\x03\"\x9f\x01\n" + + "\bpaddings\x18\f \x03(\v2..xray.transport.internet.finalmask.xmc.PaddingR\bpaddings\x12\x1d\n" + + "\n" + + "no_padding\x18\x0e \x01(\bR\tnoPaddingJ\x04\b\x02\x10\x03\"\x9f\x01\n" + "\aPadding\x12\x1d\n" + "\n" + "length_min\x18\x01 \x01(\x03R\tlengthMin\x12\x1d\n" + diff --git a/transport/internet/finalmask/xmc/config.proto b/transport/internet/finalmask/xmc/config.proto index 153921eb3..6c36d688b 100644 --- a/transport/internet/finalmask/xmc/config.proto +++ b/transport/internet/finalmask/xmc/config.proto @@ -23,8 +23,13 @@ message Config { bytes rsa_public_key = 9; string hostname = 10; repeated Profile profiles = 11; - // Startup padding turns. Empty uses the built-in preset. + // Padding turns. Empty uses the built-in preset, unless no_padding is set. + // A configured list is the complete schedule and replaces the preset + // entirely: the preset's Play-state join tail runs only with the preset. repeated Padding paddings = 12; + // Disables startup padding. The configuration sets this for an explicit + // empty "paddings" array, which an unset repeated field cannot express. + bool no_padding = 14; } message Padding { @@ -32,9 +37,14 @@ message Padding { int64 length_max = 2; // 1 = client to server, 2 = server to client int32 direction = 3; - // Millisecond pause after this turn, including the last one. The sender - // waits for a uniformly selected value in [delay_min, delay_max]; the - // receiver waits at least delay_min. Zero means no delay. + // Millisecond pause that leads into this turn: it sits between the previous + // padding turn (or Login Acknowledged, for the first turn) and this turn's + // bytes, so a captured gap is written on the turn that follows it. The side + // that sends the turn waits for a uniformly selected value in + // [delay_min, delay_max]; the peer spends exactly delay_min at the same + // place, so only the sending side jitters: use delay_min == delay_max to + // reproduce a captured gap. Nothing pauses after the last turn. Zero means + // no pause. int64 delay_min = 4; int64 delay_max = 5; } diff --git a/transport/internet/finalmask/xmc/config_test.go b/transport/internet/finalmask/xmc/config_test.go index 461f0a58b..dcfd739c4 100644 --- a/transport/internet/finalmask/xmc/config_test.go +++ b/transport/internet/finalmask/xmc/config_test.go @@ -1,9 +1,11 @@ package xmc import ( + "errors" "net" "strings" "testing" + "time" ) func TestClientRejectsLongLegacyPassword(t *testing.T) { @@ -21,3 +23,126 @@ func TestClientRejectsLongLegacyPassword(t *testing.T) { t.Fatal("expected the long password to be rejected") } } + +func TestPaddingScheduleCaps(t *testing.T) { + turn := func(length, delay int64) *Padding { + return &Padding{LengthMin: length, LengthMax: length, Direction: 1, DelayMin: delay, DelayMax: delay} + } + + t.Run("too many turns", func(t *testing.T) { + paddings := make([]*Padding, maxPaddingTurns+1) + for i := range paddings { + paddings[i] = turn(3, 0) + } + if _, err := paddingScheduleFromConfig(paddings); err == nil { + t.Fatal("expected a turn count error") + } + }) + + t.Run("too many bytes", func(t *testing.T) { + paddings := make([]*Padding, maxPaddingTotalLength/maxPaddingTurnLength+1) + for i := range paddings { + paddings[i] = turn(maxPaddingTurnLength, 0) + } + if _, err := paddingScheduleFromConfig(paddings); err == nil { + t.Fatal("expected a total length error") + } + }) + + t.Run("too much delay", func(t *testing.T) { + tooLong := int64(maxPaddingScheduleDelay/time.Millisecond) + 1 + if _, err := paddingScheduleFromConfig([]*Padding{turn(3, tooLong)}); err == nil { + t.Fatal("expected a total delay error") + } + if _, err := paddingScheduleFromConfig([]*Padding{turn(3, int64(maxPaddingScheduleDelay/time.Millisecond))}); err != nil { + t.Fatalf("delay at the limit was rejected: %v", err) + } + }) +} + +func TestPaddingDisabled(t *testing.T) { + config := &Config{NoPadding: true} + if err := config.ValidatePadding(); err != nil { + t.Fatalf("disabled padding failed validation: %v", err) + } + schedule, err := config.paddingSchedule(true) + if err != nil { + t.Fatal(err) + } + if schedule != nil { + t.Fatalf("disabled padding returned %d turns", len(schedule)) + } + config.Paddings = []*Padding{{LengthMin: 3, LengthMax: 3, Direction: 1}} + if err := config.ValidatePadding(); err == nil { + t.Fatal("expected a conflict between disabled and configured padding") + } + if _, err := config.paddingSchedule(false); err == nil { + t.Fatal("expected a conflict between disabled and configured padding") + } + + preset := &Config{} + if schedule, err := preset.paddingSchedule(true); err != nil || len(schedule) == 0 { + t.Fatalf("client preset = %d turns, err %v", len(schedule), err) + } + if schedule, err := preset.paddingSchedule(false); err != nil || len(schedule) == 0 { + t.Fatalf("server preset = %d turns, err %v", len(schedule), err) + } +} + +// TestConfiguredPaddingsReplaceTheWholePreset pins the documented policy: a +// configured list is the complete schedule, so the preset's Play-state join tail +// does not run behind it on either end. +func TestConfiguredPaddingsReplaceTheWholePreset(t *testing.T) { + config := &Config{Paddings: []*Padding{ + {LengthMin: 44, LengthMax: 44, Direction: 1}, + {LengthMin: 64, LengthMax: 64, Direction: 2}, + }} + for _, isClient := range []bool{true, false} { + schedule, err := config.paddingSchedule(isClient) + if err != nil { + t.Fatal(err) + } + if len(schedule) != len(config.Paddings) { + t.Fatalf("isClient=%v: schedule has %d turns, want the %d configured turns", isClient, len(schedule), len(config.Paddings)) + } + for i, turn := range schedule { + want := paddingClientToServer + if config.Paddings[i].Direction == 2 { + want = paddingServerToClient + } + if turn.direction != want || turn.minLength != int(config.Paddings[i].LengthMin) { + t.Fatalf("isClient=%v: turn %d = %+v, want the configured %+v", isClient, i, turn, config.Paddings[i]) + } + } + } + + // The preset, in contrast, carries the join tail behind the startup turns. + preset, err := (&Config{}).paddingSchedule(true) + if err != nil { + t.Fatal(err) + } + if len(preset) <= len(startupPaddingSchedule2612) { + t.Fatalf("preset has %d turns, want the startup turns plus the join tail", len(preset)) + } +} + +func TestCloseCancelsPaddingPause(t *testing.T) { + client, server := net.Pipe() + defer server.Close() + + conn, err := newClientConn(client, []loginProfile{{Username: "TestUser"}}, "password", []byte{0x01}, "localhost", nil) + if err != nil { + t.Fatal(err) + } + if err := conn.Close(); err != nil { + t.Fatal(err) + } + + started := time.Now() + if err := conn.paddingPause(time.Hour); !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if time.Since(started) > time.Second { + t.Fatal("closing the connection did not cancel the pause") + } +} diff --git a/transport/internet/finalmask/xmc/handshake_test.go b/transport/internet/finalmask/xmc/handshake_test.go index ca83e2421..c6acd2d58 100644 --- a/transport/internet/finalmask/xmc/handshake_test.go +++ b/transport/internet/finalmask/xmc/handshake_test.go @@ -60,12 +60,16 @@ func testHandshakeWithPadding(t *testing.T, clientRaw, serverRaw net.Conn, lengt {Direction: 1, LengthMin: length, LengthMax: length}, {Direction: 2, LengthMin: length, LengthMax: length}, } - client, err := newClientConn(clientRaw, profiles, "password", publicKey, "localhost", padding) + paddingSchedule, err := paddingScheduleFromConfig(padding) + if err != nil { + t.Fatal(err) + } + client, err := newClientConn(clientRaw, profiles, "password", publicKey, "localhost", paddingSchedule) if err != nil { t.Fatal(err) } defer client.Close() - server, err := wrapConnServer(serverRaw, profiles, "password", x509.MarshalPKCS1PrivateKey(key), publicKey, padding) + server, err := wrapConnServer(serverRaw, profiles, "password", x509.MarshalPKCS1PrivateKey(key), publicKey, paddingSchedule) if err != nil { t.Fatal(err) } diff --git a/transport/internet/finalmask/xmc/padding.go b/transport/internet/finalmask/xmc/padding.go index ed2494e3c..cd9846903 100644 --- a/transport/internet/finalmask/xmc/padding.go +++ b/transport/internet/finalmask/xmc/padding.go @@ -5,6 +5,7 @@ import ( "fmt" "io" "math/big" + "net" "time" ) @@ -18,6 +19,16 @@ const ( maxPaddingChunkLength = 48 * 1024 maxPaddingTurnLength = 8 * 1024 * 1024 + // A configured schedule is bounded so that one handshake cannot be told to + // send an arbitrary amount of padding: maxPaddingTurns limits the number of + // turns and maxPaddingTotalLength the worst-case sum of their lengths. + maxPaddingTurns = 256 + maxPaddingTotalLength = 64 << 20 + // maxPaddingScheduleDelay keeps the configured pauses inside the handshake + // deadline. A schedule that cannot finish before the deadline would fail + // every connection, so it is rejected when the configuration is built. + maxPaddingScheduleDelay = handshakeTimeout - 10*time.Second + // Frame padding carries the startup padding in ordinary Minecraft custom // payload packets so that a vanilla server can parse the whole connection // without taking the pipeline over. The channel is deliberately different @@ -43,10 +54,12 @@ type paddingDelayRange struct { } type paddingTurn struct { - direction paddingDirection - minLength int - maxLength int - delay paddingDelayRange // pause after this turn, including the last one + direction paddingDirection + minLength int + maxLength int + // delay leads into this turn: the side that sends it samples the range, the + // peer spends its minimum, and no pause follows the last turn. + delay paddingDelayRange variants []paddingVariant startDelay paddingDelayRange chunkDelay paddingDelayRange @@ -57,11 +70,37 @@ type paddingTurn struct { sendVariants []int } -func runPaddingSchedule(writer io.Writer, isClient bool, firstTurnPrefixLength int, schedule []paddingTurn) error { - return runPaddingScheduleWithSleep(writer, isClient, firstTurnPrefixLength, schedule, time.Sleep) +// pausePadding waits for one padding pause. It returns as soon as the +// connection is closed so that a handshake cannot keep sleeping after its +// connection is gone. +func pausePadding(done <-chan struct{}, d time.Duration) error { + if d <= 0 { + return nil + } + timer := time.NewTimer(d) + defer timer.Stop() + select { + case <-timer.C: + return nil + case <-done: + return net.ErrClosed + } } -func runPaddingScheduleWithSleep(writer io.Writer, isClient bool, firstTurnPrefixLength int, schedule []paddingTurn, sleep func(time.Duration)) error { +// runPaddingSchedule sends the local turns of the schedule and applies the +// configured pauses. A turn's pause leads into the turn, so the bytes of a turn +// always follow the pause that was configured next to it, and nothing pauses +// after the last turn: the proxy stream follows it directly. An empty schedule +// means padding is disabled and nothing is written or waited for. +// +// Nothing here checks when a peer's turn arrives: the turns are ordinary +// Minecraft packets that carry nothing to compare an early arrival against, and +// the startup reader drains them on its own while this schedule writes. A peer +// that stalls is bounded by maxPaddingScheduleDelay instead. +func runPaddingSchedule(writer io.Writer, isClient bool, firstTurnPrefixLength int, schedule []paddingTurn, sleep func(time.Duration) error) error { + if len(schedule) == 0 { + return nil + } if err := validatePaddingSchedule(schedule, firstTurnPrefixLength); err != nil { return err } @@ -74,22 +113,23 @@ func runPaddingScheduleWithSleep(writer io.Writer, isClient bool, firstTurnPrefi if isClient != (turn.direction == paddingClientToServer) { // The startup reader drains peer padding independently so writes - // cannot fill both connection buffers. Both endpoints still apply - // the same minimum pause, including after the last turn. - if turn.delay.min > 0 { - sleep(turn.delay.min) + // cannot fill both connection buffers. The peer still spends the + // same pause at the same place in the schedule, which keeps both + // timelines in phase; it only knows the minimum. + if err := sleep(turn.delay.min); err != nil { + return err } continue } - if _, err := writePaddingTurnFrames(writer, turn, prefixLength, sleep, paddingFramePacketID(isClient)); err != nil { - return fmt.Errorf("write padding turn %d: %w", i, err) - } delay, err := randomPaddingDelay(turn.delay) if err != nil { return fmt.Errorf("select padding turn %d delay: %w", i, err) } - if delay > 0 { - sleep(delay) + if err := sleep(delay); err != nil { + return err + } + if _, err := writePaddingTurnFrames(writer, turn, prefixLength, sleep, paddingFramePacketID(isClient)); err != nil { + return fmt.Errorf("write padding turn %d: %w", i, err) } } return nil @@ -166,13 +206,13 @@ func paddingFramePacketID(isClient bool) int { // writePaddingTurnFrames writes one padding turn as a sequence of valid // Minecraft custom payload frames. Only the framing is native: payload bodies // stay zero-filled, so the captured traffic shape is kept. -func writePaddingTurnFrames(w io.Writer, turn paddingTurn, prefixLength int, sleep func(time.Duration), packetID int) (int, error) { +func writePaddingTurnFrames(w io.Writer, turn paddingTurn, prefixLength int, sleep func(time.Duration) error, packetID int) (int, error) { startDelay, err := randomPaddingDelay(turn.startDelay) if err != nil { return 0, fmt.Errorf("select padding start delay: %w", err) } - if startDelay > 0 { - sleep(startDelay) + if err := sleep(startDelay); err != nil { + return 0, err } targetLength, chunks, delays, err := selectPaddingVariant(turn, prefixLength) @@ -209,8 +249,8 @@ func writePaddingTurnFrames(w io.Writer, turn paddingTurn, prefixLength int, sle if delayErr != nil { return written, fmt.Errorf("select padding chunk %d delay: %w", i, delayErr) } - if delay > 0 { - sleep(delay) + if delayErr = sleep(delay); delayErr != nil { + return written, delayErr } } frameLengths, planErr := paddingFramePlan(chunkLength) diff --git a/transport/internet/finalmask/xmc/padding_frames_test.go b/transport/internet/finalmask/xmc/padding_frames_test.go index 390e39c92..a419a6494 100644 --- a/transport/internet/finalmask/xmc/padding_frames_test.go +++ b/transport/internet/finalmask/xmc/padding_frames_test.go @@ -2,6 +2,10 @@ package xmc import ( "bytes" + "errors" + "io" + "net" + "strings" "testing" "time" ) @@ -58,7 +62,7 @@ func TestWritePaddingTurnFramesIsMinecraftTraffic(t *testing.T) { } for i, turn := range turns { var buffer bytes.Buffer - written, err := writePaddingTurnFrames(&buffer, turn, 0, func(time.Duration) {}, configurationServerboundCustomPayload) + written, err := writePaddingTurnFrames(&buffer, turn, 0, noPaddingPause, configurationServerboundCustomPayload) if err != nil { t.Fatalf("turn %d: %v", i, err) } @@ -103,7 +107,7 @@ func TestRunPaddingScheduleLeavesPeerTurnsAlone(t *testing.T) { } var out bytes.Buffer - if err := runPaddingSchedule(&out, true, 2, schedule); err != nil { + if err := runPaddingSchedule(&out, true, 2, schedule, noPaddingPause); err != nil { t.Fatal(err) } @@ -131,7 +135,154 @@ func TestRunPaddingScheduleRejectsInvalidSchedule(t *testing.T) { schedule := []paddingTurn{ {direction: paddingServerToClient, minLength: 10, maxLength: 10}, } - if err := runPaddingSchedule(&bytes.Buffer{}, true, 2, schedule); err == nil { + if err := runPaddingSchedule(&bytes.Buffer{}, true, 2, schedule, noPaddingPause); err == nil { t.Fatal("expected an error for a prefixed server-to-client first turn") } } + +func noPaddingPause(time.Duration) error { return nil } + +func TestRunPaddingScheduleWithoutTurns(t *testing.T) { + var out bytes.Buffer + if err := runPaddingSchedule(&out, true, 2, nil, noPaddingPause); err != nil { + t.Fatal(err) + } + if out.Len() != 0 { + t.Fatalf("disabled padding wrote %d bytes", out.Len()) + } +} + +func TestRunPaddingScheduleStopsWhenClosed(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(1000, 1000)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + } + + var out bytes.Buffer + pauses := 0 + sleep := func(d time.Duration) error { + if d <= 0 { + return nil + } + pauses++ + return net.ErrClosed + } + err := runPaddingSchedule(&out, true, 2, schedule, sleep) + if !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if pauses != 1 { + t.Fatalf("pauses = %d, want 1", pauses) + } + // The pause leads into turn 0, so the cancelled pause came before its bytes. + if out.Len() != 0 { + t.Fatalf("schedule kept writing after a cancelled pause: %d bytes", out.Len()) + } +} + +// recordingWriter records one event per write, so a test can see where the +// pauses fall relative to the padding bytes. +type recordingWriter struct { + events *[]string +} + +func (w recordingWriter) Write(p []byte) (int, error) { + *w.events = append(*w.events, "write") + return len(p), nil +} + +// TestPaddingDelayLeadsIntoTheTurn pins the placement of a configured pause: +// it belongs to the turn it precedes, the peer spends its minimum at the same +// place, and the last turn is not followed by one. +func TestPaddingDelayLeadsIntoTheTurn(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(10, 10)}, + {direction: paddingServerToClient, minLength: 20, maxLength: 20, delay: millisecondRange(20, 20)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(30, 30)}, + } + run := func(isClient bool) []string { + var events []string + sleep := func(d time.Duration) error { + if d > 0 { + events = append(events, "pause "+d.String()) + } + return nil + } + if err := runPaddingSchedule(recordingWriter{events: &events}, isClient, 2, schedule, sleep); err != nil { + t.Fatal(err) + } + return events + } + + // The client sends turns 0 and 2, so it pauses before each of them and + // spends the minimum of turn 1 while the server sends it. + client := strings.Join(run(true), ",") + wantClient := "pause 10ms,write,pause 20ms,pause 30ms,write" + if client != wantClient { + t.Fatalf("client events = %q, want %q", client, wantClient) + } + + // The server sends turn 1, so the same pauses lead into its bytes. The last + // turn's pause still happens, but nothing follows the final write. + server := strings.Join(run(false), ",") + wantServer := "pause 10ms,pause 20ms,write,pause 30ms" + if server != wantServer { + t.Fatalf("server events = %q, want %q", server, wantServer) + } +} + +// TestPaddingDelayRangeJittersOnlyTheSender pins which value each end waits: +// the side that sends the turn samples the range, the peer spends the minimum. +func TestPaddingDelayRangeJittersOnlyTheSender(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(20, 200)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + } + run := func(isClient bool) []time.Duration { + var pauses []time.Duration + sleep := func(d time.Duration) error { + if d > 0 { + pauses = append(pauses, d) + } + return nil + } + if err := runPaddingSchedule(io.Discard, isClient, 2, schedule, sleep); err != nil { + t.Fatal(err) + } + return pauses + } + + // The peer, which sends nothing here, spends exactly the minimum. + if got := run(false); len(got) != 1 || got[0] != 20*time.Millisecond { + t.Fatalf("peer pauses = %v, want exactly [20ms]", got) + } + + seenLarge := false + for i := 0; i < 64; i++ { + pauses := run(true) + if len(pauses) != 1 { + t.Fatalf("sender pauses = %v, want exactly one pause", pauses) + } + if pauses[0] < 20*time.Millisecond || pauses[0] > 200*time.Millisecond { + t.Fatalf("sender pause %s is outside the configured range", pauses[0]) + } + if pauses[0] >= 20*time.Millisecond && pauses[0] <= 200*time.Millisecond && pauses[0] != 20*time.Millisecond { + seenLarge = true + } + } + if !seenLarge { + t.Fatal("the sender never sampled a value above the minimum") + } +} + +func TestPaddingPauseReturnsOnClose(t *testing.T) { + done := make(chan struct{}) + close(done) + started := time.Now() + if err := pausePadding(done, time.Hour); !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if time.Since(started) > time.Second { + t.Fatal("pausePadding did not return on close") + } +} diff --git a/transport/internet/finalmask/xmc/server.go b/transport/internet/finalmask/xmc/server.go index 09294a7a4..40c050a85 100644 --- a/transport/internet/finalmask/xmc/server.go +++ b/transport/internet/finalmask/xmc/server.go @@ -41,6 +41,9 @@ type serverConn struct { paddingSchedule []paddingTurn packet *packetStream deadlines *connectionDeadlines + + done chan struct{} + closeOnce sync.Once } func (c *serverConn) handshake() error { @@ -246,7 +249,7 @@ func (c *serverConn) handshake() error { return err } c.reader = newPaddingReader(c.reader, false) - if err = runPaddingSchedule(c.writer, false, loginAcknowledgedLength, c.paddingSchedule); err != nil { + if err = runPaddingSchedule(c.writer, false, loginAcknowledgedLength, c.paddingSchedule, c.paddingPause); err != nil { _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) } @@ -304,12 +307,18 @@ func (c *serverConn) Close() error { c.closed = true packet := c.packet c.lifecycleMu.Unlock() + c.closeOnce.Do(func() { close(c.done) }) if packet != nil { packet.Stop() } return c.c.Close() } +// paddingPause applies one padding pause, stopping early on Close. +func (c *serverConn) paddingPause(d time.Duration) error { + return pausePadding(c.done, d) +} + func (c *serverConn) LocalAddr() net.Addr { return c.c.LocalAddr() } @@ -330,7 +339,7 @@ func (c *serverConn) SetWriteDeadline(t time.Time) error { return c.deadlines.setWriteDeadline(t) } -func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPrivateKeyDER []byte, rsaPublicKey []byte, padding []*Padding) (*serverConn, error) { +func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPrivateKeyDER []byte, rsaPublicKey []byte, paddingSchedule []paddingTurn) (*serverConn, error) { if len(profiles) == 0 { return nil, fmt.Errorf("empty profiles") } @@ -344,10 +353,6 @@ func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPri if err != nil { return nil, fmt.Errorf("parse rsa private key: %w", err) } - paddingSchedule, err := newPaddingSchedule(padding, false) - if err != nil { - return nil, fmt.Errorf("select padding profile: %w", err) - } s := &serverConn{ reader: bufio.NewReader(c), @@ -360,6 +365,7 @@ func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPri rsaPublicKey: rsaPublicKey, paddingSchedule: paddingSchedule, deadlines: newConnectionDeadlines(c), + done: make(chan struct{}), } return s, nil