From 82b5b76bc510d0f2d5afd04485d71f9e125de19d Mon Sep 17 00:00:00 2001 From: TurboRigby <100000848+TurboRigby@users.noreply.github.com> Date: Tue, 17 Nov 2026 18:43:50 +0200 Subject: [PATCH] XMC finalmask: Prevent deadlock during bidirectional startup padding (#7430) https://github.com/XTLS/Xray-core/pull/7430#issuecomment-6954499005 --- transport/internet/finalmask/xmc/client.go | 2 + .../internet/finalmask/xmc/handshake_test.go | 110 ++++++++++++++++++ transport/internet/finalmask/xmc/padding.go | 7 +- .../internet/finalmask/xmc/padding_reader.go | 61 ++++++++++ .../finalmask/xmc/padding_reader_test.go | 76 ++++++++++++ transport/internet/finalmask/xmc/server.go | 2 + 6 files changed, 254 insertions(+), 4 deletions(-) create mode 100644 transport/internet/finalmask/xmc/handshake_test.go create mode 100644 transport/internet/finalmask/xmc/padding_reader.go create mode 100644 transport/internet/finalmask/xmc/padding_reader_test.go diff --git a/transport/internet/finalmask/xmc/client.go b/transport/internet/finalmask/xmc/client.go index 5798a5423..744b2fdb0 100644 --- a/transport/internet/finalmask/xmc/client.go +++ b/transport/internet/finalmask/xmc/client.go @@ -236,7 +236,9 @@ func (c *clientConn) handshake() error { if err != nil { 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 { + _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) } diff --git a/transport/internet/finalmask/xmc/handshake_test.go b/transport/internet/finalmask/xmc/handshake_test.go new file mode 100644 index 000000000..ca83e2421 --- /dev/null +++ b/transport/internet/finalmask/xmc/handshake_test.go @@ -0,0 +1,110 @@ +package xmc + +import ( + "bytes" + "crypto/x509" + "io" + "net" + "testing" + "time" +) + +func TestHandshakeWithBidirectionalPadding(t *testing.T) { + t.Run("pipe", func(t *testing.T) { + client, server := net.Pipe() + testHandshakeWithPadding(t, client, server, 64*1024) + }) + t.Run("tcp", func(t *testing.T) { + listener, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)}) + if err != nil { + t.Fatal(err) + } + defer listener.Close() + client, err := net.DialTCP("tcp", nil, listener.Addr().(*net.TCPAddr)) + if err != nil { + t.Fatal(err) + } + defer client.Close() + server, err := listener.AcceptTCP() + if err != nil { + t.Fatal(err) + } + defer server.Close() + for _, conn := range []*net.TCPConn{client, server} { + if err := conn.SetWriteBuffer(16 * 1024); err != nil { + t.Fatal(err) + } + if err := conn.SetReadBuffer(64 * 1024); err != nil { + t.Fatal(err) + } + } + testHandshakeWithPadding(t, client, server, maxPaddingTurnLength) + }) +} + +func testHandshakeWithPadding(t *testing.T, clientRaw, serverRaw net.Conn, length int64) { + t.Helper() + defer clientRaw.Close() + defer serverRaw.Close() + + key, err := DeriveRSAKey("padding-regression") + if err != nil { + t.Fatal(err) + } + publicKey, err := x509.MarshalPKIXPublicKey(&key.PublicKey) + if err != nil { + t.Fatal(err) + } + profiles := []loginProfile{{Username: "TestUser", TexturesValue: "texture", TexturesSignature: "signature"}} + padding := []*Padding{ + {Direction: 1, LengthMin: length, LengthMax: length}, + {Direction: 2, LengthMin: length, LengthMax: length}, + } + client, err := newClientConn(clientRaw, profiles, "password", publicKey, "localhost", padding) + if err != nil { + t.Fatal(err) + } + defer client.Close() + server, err := wrapConnServer(serverRaw, profiles, "password", x509.MarshalPKCS1PrivateKey(key), publicKey, padding) + if err != nil { + t.Fatal(err) + } + defer server.Close() + for _, conn := range []net.Conn{client, server} { + if err := conn.SetDeadline(time.Now().Add(15 * time.Second)); err != nil { + t.Fatal(err) + } + } + + results := make(chan error, 2) + go func() { results <- client.handshake() }() + go func() { results <- server.handshake() }() + for range 2 { + if err := <-results; err != nil { + t.Errorf("handshake: %v", err) + } + } + if t.Failed() { + return + } + + // Both startup readers can already be waiting for the next packet. The + // first proxy payload in either direction must survive the handoff. + for _, pair := range [][2]net.Conn{{client, server}, {server, client}} { + want := bytes.Repeat([]byte("proxy payload"), 4096) + go func() { + _, err := pair[0].Write(want) + results <- err + }() + got := make([]byte, len(want)) + if _, err := io.ReadFull(pair[1], got); err != nil { + t.Fatal(err) + } + if err := <-results; err != nil { + t.Fatal(err) + } + if !bytes.Equal(got, want) { + t.Fatal("proxy payload changed after startup padding") + } + } +} diff --git a/transport/internet/finalmask/xmc/padding.go b/transport/internet/finalmask/xmc/padding.go index 8fb841bc4..ed2494e3c 100644 --- a/transport/internet/finalmask/xmc/padding.go +++ b/transport/internet/finalmask/xmc/padding.go @@ -73,10 +73,9 @@ func runPaddingScheduleWithSleep(writer io.Writer, isClient bool, firstTurnPrefi } if isClient != (turn.direction == paddingClientToServer) { - // Padding is ordinary Minecraft traffic, so the peer's turns are - // never consumed here: they stay in the stream and are dropped as - // unknown packets by whoever reads it next. Both endpoints still - // apply the same minimum pause, including after the last turn. + // 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) } diff --git a/transport/internet/finalmask/xmc/padding_reader.go b/transport/internet/finalmask/xmc/padding_reader.go new file mode 100644 index 000000000..7f70e3c6a --- /dev/null +++ b/transport/internet/finalmask/xmc/padding_reader.go @@ -0,0 +1,61 @@ +package xmc + +import ( + "bytes" + "io" +) + +type paddingReadResult struct { + frame []byte + err error +} + +type paddingReader struct { + reader io.Reader + first <-chan paddingReadResult +} + +// newPaddingReader drains startup padding while the local padding schedule is +// writing. Buffer only the first non-padding packet, then let the caller resume +// reading the underlying stream. This keeps memory bounded without requiring +// matching padding lengths or an extra end-of-padding packet on the wire. +func newPaddingReader(reader io.Reader, isClient bool) io.Reader { + first := make(chan paddingReadResult, 1) + go func() { + frame, err := readPastPadding(reader, paddingFramePacketID(!isClient)) + first <- paddingReadResult{frame: frame, err: err} + }() + return &paddingReader{reader: reader, first: first} +} + +func readPastPadding(reader io.Reader, packetID int) ([]byte, error) { + for { + packet, err := readPacket(reader) + if err != nil { + return nil, err + } + if packet.packetID == packetID { + var channel String + if err := channel.readFrom(bytes.NewReader(packet.data)); err == nil && channel == paddingFrameChannel { + continue + } + } + payload := RestBytes(packet.data) + return encodePacket(packet.packetID, &payload) + } +} + +func (r *paddingReader) Read(p []byte) (int, error) { + if len(p) == 0 { + return 0, nil + } + if r.first != nil { + result := <-r.first + r.first = nil + if result.err != nil { + return 0, result.err + } + r.reader = io.MultiReader(bytes.NewReader(result.frame), r.reader) + } + return r.reader.Read(p) +} diff --git a/transport/internet/finalmask/xmc/padding_reader_test.go b/transport/internet/finalmask/xmc/padding_reader_test.go new file mode 100644 index 000000000..8ccdef16a --- /dev/null +++ b/transport/internet/finalmask/xmc/padding_reader_test.go @@ -0,0 +1,76 @@ +package xmc + +import ( + "bytes" + "errors" + "io" + "net" + "testing" +) + +func TestPaddingReaderPreservesFollowingPackets(t *testing.T) { + for _, isClient := range []bool{true, false} { + packetID := paddingFramePacketID(!isClient) + var wire bytes.Buffer + paddingChannel := String(paddingFrameChannel) + padding := RestBytes(make([]byte, 1024)) + if err := writePacket(&wire, packetID, &paddingChannel, &padding); err != nil { + t.Fatal(err) + } + var want bytes.Buffer + unknownChannel := String("other:channel") + payload := RestBytes("preserve unknown custom payloads") + if err := writePacket(&want, packetID, &unknownChannel, &payload); err != nil { + t.Fatal(err) + } + id := Long(42) + if err := writePacket(&want, configurationKeepAlive, &id); err != nil { + t.Fatal(err) + } + channel := String(packetChannel) + if err := writePacket(&want, packetID, &channel, &payload); err != nil { + t.Fatal(err) + } + wire.Write(want.Bytes()) + got, err := io.ReadAll(newPaddingReader(&wire, isClient)) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(got, want.Bytes()) { + t.Fatalf("client=%v: non-padding packets changed", isClient) + } + } +} + +func TestPaddingReaderReadErrors(t *testing.T) { + for _, test := range []struct { + name string + wire []byte + err error + }{ + {name: "eof", err: io.EOF}, + {name: "truncated", wire: []byte{2, 1}, err: io.ErrUnexpectedEOF}, + } { + t.Run(test.name, func(t *testing.T) { + reader := newPaddingReader(bytes.NewReader(test.wire), true) + if _, err := reader.Read(make([]byte, 1)); !errors.Is(err, test.err) { + t.Fatalf("got %v, want %v", err, test.err) + } + }) + } +} + +func TestPaddingReaderUnblocksOnClose(t *testing.T) { + client, server := net.Pipe() + defer server.Close() + reader := newPaddingReader(client, true) + if n, err := reader.Read(nil); n != 0 || err != nil { + t.Fatalf("empty read = %d, %v", n, err) + } + if err := client.Close(); err != nil { + t.Fatal(err) + } + if _, err := reader.Read(make([]byte, 1)); !errors.Is(err, io.ErrClosedPipe) { + t.Fatalf("closed read = %v", err) + } +} diff --git a/transport/internet/finalmask/xmc/server.go b/transport/internet/finalmask/xmc/server.go index 30748017b..09294a7a4 100644 --- a/transport/internet/finalmask/xmc/server.go +++ b/transport/internet/finalmask/xmc/server.go @@ -245,7 +245,9 @@ func (c *serverConn) handshake() error { if err = validateLoginAcknowledgedPacket(pkt); err != nil { return err } + c.reader = newPaddingReader(c.reader, false) if err = runPaddingSchedule(c.writer, false, loginAcknowledgedLength, c.paddingSchedule); err != nil { + _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) }