Skip to content

Commit 85d6b17

Browse files
author
null
committed
manager
1 parent e86c365 commit 85d6b17

28 files changed

Lines changed: 350 additions & 551 deletions

File tree

‎common/crypto/crypto.go‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,3 +16,9 @@ func RandBetween(from int64, to int64) int64 {
1616
bigInt, _ := rand.Int(rand.Reader, big.NewInt(to-from))
1717
return from + bigInt.Int64()
1818
}
19+
20+
func RandBytesBetween(b []byte, from, to int64) {
21+
for i := range b {
22+
b[i] = byte(RandBetween(from, to))
23+
}
24+
}

‎infra/conf/transport_internet.go‎

Lines changed: 31 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1256,6 +1256,7 @@ var (
12561256
type TCPItem struct {
12571257
Delay Int32Range `json:"delay"`
12581258
Rand int32 `json:"rand"`
1259+
Range *Int32Range `json:"range"`
12591260
Type string `json:"type"`
12601261
Packet json.RawMessage `json:"packet"`
12611262
}
@@ -1293,6 +1294,9 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
12931294
for i, value := range c.Clients {
12941295
clients[i] = &custom.TCPSequence{}
12951296
for _, item := range value {
1297+
if item.Range == nil {
1298+
item.Range = &Int32Range{From: 0, To: 256}
1299+
}
12961300
var err error
12971301
if item.Packet, err = PraseByteSlice(item.Packet, item.Type); err != nil {
12981302
return nil, err
@@ -1301,6 +1305,8 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
13011305
DelayMin: int64(item.Delay.From),
13021306
DelayMax: int64(item.Delay.To),
13031307
Rand: item.Rand,
1308+
RandMin: item.Range.From,
1309+
RandMax: item.Range.To,
13041310
Packet: item.Packet,
13051311
})
13061312
}
@@ -1310,6 +1316,9 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
13101316
for i, value := range c.Servers {
13111317
servers[i] = &custom.TCPSequence{}
13121318
for _, item := range value {
1319+
if item.Range == nil {
1320+
item.Range = &Int32Range{From: 0, To: 256}
1321+
}
13131322
var err error
13141323
if item.Packet, err = PraseByteSlice(item.Packet, item.Type); err != nil {
13151324
return nil, err
@@ -1318,6 +1327,8 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
13181327
DelayMin: int64(item.Delay.From),
13191328
DelayMax: int64(item.Delay.To),
13201329
Rand: item.Rand,
1330+
RandMin: item.Range.From,
1331+
RandMax: item.Range.To,
13211332
Packet: item.Packet,
13221333
})
13231334
}
@@ -1327,6 +1338,9 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
13271338
for i, value := range c.Errors {
13281339
errors[i] = &custom.TCPSequence{}
13291340
for _, item := range value {
1341+
if item.Range == nil {
1342+
item.Range = &Int32Range{From: 0, To: 256}
1343+
}
13301344
var err error
13311345
if item.Packet, err = PraseByteSlice(item.Packet, item.Type); err != nil {
13321346
return nil, err
@@ -1335,6 +1349,8 @@ func (c *HeaderCustomTCP) Build() (proto.Message, error) {
13351349
DelayMin: int64(item.Delay.From),
13361350
DelayMax: int64(item.Delay.To),
13371351
Rand: item.Rand,
1352+
RandMin: item.Range.From,
1353+
RandMax: item.Range.To,
13381354
Packet: item.Packet,
13391355
})
13401356
}
@@ -1434,6 +1450,7 @@ func (c *NoiseMask) Build() (proto.Message, error) {
14341450

14351451
type UDPItem struct {
14361452
Rand int32 `json:"rand"`
1453+
Range *Int32Range `json:"range"`
14371454
Type string `json:"type"`
14381455
Packet json.RawMessage `json:"packet"`
14391456
}
@@ -1457,25 +1474,35 @@ func (c *HeaderCustomUDP) Build() (proto.Message, error) {
14571474

14581475
client := make([]*custom.UDPItem, 0, len(c.Client))
14591476
for _, item := range c.Client {
1477+
if item.Range == nil {
1478+
item.Range = &Int32Range{From: 0, To: 256}
1479+
}
14601480
var err error
14611481
if item.Packet, err = PraseByteSlice(item.Packet, item.Type); err != nil {
14621482
return nil, err
14631483
}
14641484
client = append(client, &custom.UDPItem{
1465-
Rand: item.Rand,
1466-
Packet: item.Packet,
1485+
Rand: item.Rand,
1486+
RandMin: item.Range.From,
1487+
RandMax: item.Range.To,
1488+
Packet: item.Packet,
14671489
})
14681490
}
14691491

14701492
server := make([]*custom.UDPItem, 0, len(c.Server))
14711493
for _, item := range c.Server {
1494+
if item.Range == nil {
1495+
item.Range = &Int32Range{From: 0, To: 256}
1496+
}
14721497
var err error
14731498
if item.Packet, err = PraseByteSlice(item.Packet, item.Type); err != nil {
14741499
return nil, err
14751500
}
14761501
server = append(server, &custom.UDPItem{
1477-
Rand: item.Rand,
1478-
Packet: item.Packet,
1502+
Rand: item.Rand,
1503+
RandMin: item.Range.From,
1504+
RandMax: item.Range.To,
1505+
Packet: item.Packet,
14791506
})
14801507
}
14811508

‎transport/internet/finalmask/finalmask.go‎

Lines changed: 147 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -3,14 +3,11 @@ package finalmask
33
import (
44
"context"
55
"net"
6+
"sync"
67

78
"github.com/xtls/xray-core/common/errors"
89
)
910

10-
const (
11-
UDPSize = 4096 + 123
12-
)
13-
1411
type Udpmask interface {
1512
UDP()
1613

@@ -29,27 +26,165 @@ func NewUdpmaskManager(udpmasks []Udpmask) *UdpmaskManager {
2926
}
3027

3128
func (m *UdpmaskManager) WrapPacketConnClient(raw net.PacketConn) (net.PacketConn, error) {
32-
var err error
29+
var sizes []int
30+
var conns []net.PacketConn
3331
for i, mask := range m.udpmasks {
34-
raw, err = mask.WrapPacketConnClient(raw, i, len(m.udpmasks)-1)
35-
if err != nil {
36-
return nil, err
32+
if _, ok := mask.(headerConn); ok {
33+
conn, err := mask.WrapPacketConnClient(nil, i, len(m.udpmasks)-1)
34+
if err != nil {
35+
return nil, err
36+
}
37+
sizes = append(sizes, conn.(headerSize).Size())
38+
conns = append(conns, conn)
39+
} else {
40+
if len(conns) > 0 {
41+
raw = &headerManagerConn{sizes: sizes, conns: conns, PacketConn: raw}
42+
sizes = nil
43+
conns = nil
44+
}
45+
var err error
46+
raw, err = mask.WrapPacketConnClient(raw, i, len(m.udpmasks)-1)
47+
if err != nil {
48+
return nil, err
49+
}
3750
}
3851
}
52+
53+
if len(conns) > 0 {
54+
raw = &headerManagerConn{sizes: sizes, conns: conns, PacketConn: raw}
55+
sizes = nil
56+
conns = nil
57+
}
3958
return raw, nil
4059
}
4160

4261
func (m *UdpmaskManager) WrapPacketConnServer(raw net.PacketConn) (net.PacketConn, error) {
43-
var err error
62+
var sizes []int
63+
var conns []net.PacketConn
4464
for i, mask := range m.udpmasks {
45-
raw, err = mask.WrapPacketConnServer(raw, i, len(m.udpmasks)-1)
46-
if err != nil {
47-
return nil, err
65+
if _, ok := mask.(headerConn); ok {
66+
conn, err := mask.WrapPacketConnServer(nil, i, len(m.udpmasks)-1)
67+
if err != nil {
68+
return nil, err
69+
}
70+
sizes = append(sizes, conn.(headerSize).Size())
71+
conns = append(conns, conn)
72+
} else {
73+
if len(conns) > 0 {
74+
raw = &headerManagerConn{sizes: sizes, conns: conns, PacketConn: raw}
75+
sizes = nil
76+
conns = nil
77+
}
78+
var err error
79+
raw, err = mask.WrapPacketConnServer(raw, i, len(m.udpmasks)-1)
80+
if err != nil {
81+
return nil, err
82+
}
4883
}
4984
}
85+
86+
if len(conns) > 0 {
87+
raw = &headerManagerConn{sizes: sizes, conns: conns, PacketConn: raw}
88+
sizes = nil
89+
conns = nil
90+
}
5091
return raw, nil
5192
}
5293

94+
const (
95+
UDPSize = 4096
96+
)
97+
98+
type headerConn interface {
99+
HeaderConn()
100+
}
101+
102+
type headerSize interface {
103+
Size() int
104+
}
105+
106+
type headerManagerConn struct {
107+
sizes []int
108+
conns []net.PacketConn
109+
net.PacketConn
110+
m sync.Mutex
111+
writeBuf [UDPSize]byte
112+
}
113+
114+
func (c *headerManagerConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
115+
buf := p
116+
if len(buf) < UDPSize {
117+
buf = make([]byte, UDPSize)
118+
}
119+
120+
n, addr, err = c.PacketConn.ReadFrom(buf)
121+
if n == 0 || err != nil {
122+
return 0, addr, err
123+
}
124+
newBuf := buf[:n]
125+
126+
sum := 0
127+
for _, size := range c.sizes {
128+
sum += size
129+
}
130+
131+
if n < sum {
132+
errors.LogDebug(context.Background(), addr, " mask read err short length")
133+
return 0, addr, nil
134+
}
135+
136+
for i := range c.conns {
137+
n, _, err = c.conns[i].ReadFrom(newBuf)
138+
if n == 0 || err != nil {
139+
errors.LogDebug(context.Background(), addr, " mask read err ", err)
140+
return 0, addr, nil
141+
}
142+
newBuf = newBuf[c.sizes[i] : n+c.sizes[i]]
143+
}
144+
145+
if len(p) < n {
146+
errors.LogDebug(context.Background(), addr, " mask read err short buffer")
147+
return 0, addr, nil
148+
}
149+
150+
copy(p, buf[sum:sum+n])
151+
152+
return n, addr, nil
153+
}
154+
155+
func (c *headerManagerConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
156+
c.m.Lock()
157+
defer c.m.Unlock()
158+
159+
sum := 0
160+
for _, size := range c.sizes {
161+
sum += size
162+
}
163+
164+
if sum+len(p) > UDPSize {
165+
errors.LogDebug(context.Background(), addr, " mask write err short write")
166+
return 0, nil
167+
}
168+
169+
n = copy(c.writeBuf[sum:], p)
170+
171+
for i := len(c.conns) - 1; i >= 0; i-- {
172+
n, err = c.conns[i].WriteTo(c.writeBuf[sum-c.sizes[i]:n+sum], nil)
173+
if n == 0 || err != nil {
174+
errors.LogDebug(context.Background(), addr, " mask write err ", err)
175+
return 0, nil
176+
}
177+
sum -= c.sizes[i]
178+
}
179+
180+
n, err = c.PacketConn.WriteTo(c.writeBuf[:n], addr)
181+
if n == 0 || err != nil {
182+
return n, err
183+
}
184+
185+
return len(p), nil
186+
}
187+
53188
type Tcpmask interface {
54189
TCP()
55190

‎transport/internet/finalmask/fragment/conn.go‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -33,9 +33,6 @@ func NewConnServer(c *Config, raw net.Conn, server bool) (net.Conn, error) {
3333
func (c *fragmentConn) TcpMaskConn() {}
3434

3535
func (c *fragmentConn) RawConn() net.Conn {
36-
if c.server {
37-
return c
38-
}
3936
return c.Conn
4037
}
4138

‎transport/internet/finalmask/header/custom/config.go‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,3 +25,6 @@ func (c *UDPConfig) WrapPacketConnClient(raw net.PacketConn, level int, levelCou
2525
func (c *UDPConfig) WrapPacketConnServer(raw net.PacketConn, level int, levelCount int) (net.PacketConn, error) {
2626
return NewConnServerUDP(c, raw)
2727
}
28+
29+
func (c *UDPConfig) HeaderConn() {
30+
}

0 commit comments

Comments
 (0)