mirror of
https://github.com/XTLS/Xray-core.git
synced 2026-11-20 08:39:14 +00:00
XMC finalmask: Prevent deadlock during bidirectional startup padding (#7430)
https://github.com/XTLS/Xray-core/pull/7430#issuecomment-6954499005
This commit is contained in:
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user