XMC finalmask: Prevent deadlock during bidirectional startup padding (#7430)

https://github.com/XTLS/Xray-core/pull/7430#issuecomment-6954499005
This commit is contained in:
TurboRigby
2026-11-17 16:43:50 +00:00
committed by GitHub
parent f781c68715
commit 82b5b76bc5
6 changed files with 254 additions and 4 deletions
@@ -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)
}
@@ -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")
}
}
}
+3 -4
View File
@@ -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)
}
@@ -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)
}
@@ -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)
}
}
@@ -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)
}