Finalmask: Add header-custom (TCP & UDP), fragment (TCP), noise (UDP); Support dialer-proxy, XHTTP/3; Fix XDNS, XICMP potential panic (#5657)

https://github.com/XTLS/Xray-core/pull/5657#issuecomment-4016609446

transport/internet/finalmask/salamander/config.go

@@ -7,10 +7,10 @@ import (
 func (c *Config) UDP() {
 }
 
-func (c *Config) WrapPacketConnClient(raw net.PacketConn, first bool, leaveSize int32, end bool) (net.PacketConn, error) {
-	return NewConnClient(c, raw, first, leaveSize)
+func (c *Config) WrapPacketConnClient(raw net.PacketConn, level int, levelCount int) (net.PacketConn, error) {
+	return NewConnClient(c, raw)
 }
 
-func (c *Config) WrapPacketConnServer(raw net.PacketConn, first bool, leaveSize int32, end bool) (net.PacketConn, error) {
-	return NewConnServer(c, raw, first, leaveSize)
+func (c *Config) WrapPacketConnServer(raw net.PacketConn, level int, levelCount int) (net.PacketConn, error) {
+	return NewConnServer(c, raw)
 }

transport/internet/finalmask/salamander/conn.go

@@ -1,147 +1,83 @@
 package salamander
 
 import (
-	"io"
+	"context"
 	"net"
-	"sync"
-	"time"
 
 	"github.com/xtls/xray-core/common/errors"
+	"github.com/xtls/xray-core/transport/internet/finalmask"
 )
 
-type obfsPacketConn struct {
-	first     bool
-	leaveSize int32
-
-	conn net.PacketConn
+type salamanderConn struct {
+	net.PacketConn
 	obfs *SalamanderObfuscator
-
-	readBuf    []byte
-	readMutex  sync.Mutex
-	writeBuf   []byte
-	writeMutex sync.Mutex
 }
 
-func NewConnClient(c *Config, raw net.PacketConn, first bool, leaveSize int32) (net.PacketConn, error) {
+func NewConnClient(c *Config, raw net.PacketConn) (net.PacketConn, error) {
 	ob, err := NewSalamanderObfuscator([]byte(c.Password))
 	if err != nil {
 		return nil, errors.New("salamander err").Base(err)
 	}
 
-	conn := &obfsPacketConn{
-		first:     first,
-		leaveSize: leaveSize,
-
-		conn: raw,
-		obfs: ob,
-	}
-
-	if first {
-		conn.readBuf = make([]byte, 8192)
-		conn.writeBuf = make([]byte, 8192)
+	conn := &salamanderConn{
+		PacketConn: raw,
+		obfs:       ob,
 	}
 
 	return conn, nil
 }
 
-func NewConnServer(c *Config, raw net.PacketConn, first bool, leaveSize int32) (net.PacketConn, error) {
-	return NewConnClient(c, raw, first, leaveSize)
+func NewConnServer(c *Config, raw net.PacketConn) (net.PacketConn, error) {
+	return NewConnClient(c, raw)
 }
 
-func (c *obfsPacketConn) Size() int32 {
-	return smSaltLen
-}
-
-func (c *obfsPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
-	if c.first {
-		c.readMutex.Lock()
-
-		n, addr, err = c.conn.ReadFrom(c.readBuf)
-		if err != nil {
-			c.readMutex.Unlock()
-			return n, addr, err
-		}
-
-		if n < int(c.Size()) {
-			c.readMutex.Unlock()
-			return 0, addr, errors.New("salamander").Base(io.ErrShortBuffer)
-		}
-
-		if len(p) < n-int(c.Size()) {
-			c.readMutex.Unlock()
-			return 0, addr, errors.New("salamander").Base(io.ErrShortBuffer)
-		}
-
-		c.obfs.Deobfuscate(c.readBuf[:n], p)
-
-		c.readMutex.Unlock()
-		return n - int(c.Size()), addr, err
+func (c *salamanderConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
+	buf := p
+	if len(p) < finalmask.UDPSize {
+		buf = make([]byte, finalmask.UDPSize)
 	}
 
-	n, addr, err = c.conn.ReadFrom(p)
-	if err != nil {
+	n, addr, err = c.PacketConn.ReadFrom(buf)
+	if err != nil || n == 0 {
 		return n, addr, err
 	}
 
-	if n < int(c.Size()) {
-		return 0, addr, errors.New("salamander").Base(io.ErrShortBuffer)
+	if n < smSaltLen {
+		errors.LogDebug(context.Background(), addr, " mask read err short lenth ", n)
+		return 0, addr, nil
 	}
 
-	c.obfs.Deobfuscate(p[:n], p)
-
-	return n - int(c.Size()), addr, err
-}
-
-func (c *obfsPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
-	if c.first {
-		if c.leaveSize+c.Size()+int32(len(p)) > 8192 {
-			return 0, errors.New("too many masks")
-		}
-
-		c.writeMutex.Lock()
-
-		n = copy(c.writeBuf[c.leaveSize+c.Size():], p)
-		n += int(c.leaveSize) + int(c.Size())
-
-		c.obfs.Obfuscate(c.writeBuf[c.leaveSize+c.Size():n], c.writeBuf[c.leaveSize:n])
-
-		nn, err := c.conn.WriteTo(c.writeBuf[:n], addr)
-
-		if err != nil {
-			c.writeMutex.Unlock()
-			return 0, err
-		}
-
-		if nn != n {
-			c.writeMutex.Unlock()
-			return 0, errors.New("nn != n")
-		}
-
-		c.writeMutex.Unlock()
-		return len(p), nil
+	if len(p) < n-smSaltLen {
+		errors.LogDebug(context.Background(), addr, " mask read err short buffer ", len(p), " ", n-smSaltLen)
+		return 0, addr, nil
 	}
 
-	c.obfs.Obfuscate(p[c.leaveSize+c.Size():], p[c.leaveSize:])
+	c.obfs.Deobfuscate(buf[:n], p)
 
-	return c.conn.WriteTo(p, addr)
+	return n - smSaltLen, addr, nil
 }
 
-func (c *obfsPacketConn) Close() error {
-	return c.conn.Close()
-}
+func (c *salamanderConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
+	if smSaltLen+len(p) > finalmask.UDPSize {
+		errors.LogDebug(context.Background(), addr, " mask write err short write ", smSaltLen+len(p), " ", finalmask.UDPSize)
+		return 0, nil
+	}
 
-func (c *obfsPacketConn) LocalAddr() net.Addr {
-	return c.conn.LocalAddr()
-}
+	var buf []byte
+	if cap(p) != finalmask.UDPSize {
+		buf = make([]byte, finalmask.UDPSize)
+	} else {
+		buf = p[:smSaltLen+len(p)]
+		copy(buf[smSaltLen:], p)
+		p = buf[smSaltLen:]
+	}
 
-func (c *obfsPacketConn) SetDeadline(t time.Time) error {
-	return c.conn.SetDeadline(t)
-}
+	c.obfs.Obfuscate(p, buf)
 
-func (c *obfsPacketConn) SetReadDeadline(t time.Time) error {
-	return c.conn.SetReadDeadline(t)
-}
+	_, err = c.PacketConn.WriteTo(buf[:smSaltLen+len(p)], addr)
+	if err != nil {
+		return 0, err
+	}
 
-func (c *obfsPacketConn) SetWriteDeadline(t time.Time) error {
-	return c.conn.SetWriteDeadline(t)
+	return len(p), nil
 }