Skip to content

Commit 71973da

Browse files
yuhan6665yuhan6665
committed
Add VLESS seed tests
1 parent bbdac34 commit 71973da

3 files changed

Lines changed: 234 additions & 6 deletions

File tree

‎proxy/proxy.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ func (w *VisionReader) ReadMultiBuffer() (buf.MultiBuffer, error) {
180180
w.trafficState.StartTime = time.Now()
181181
}
182182
w.trafficState.ByteReceived += int64(buffer.Len())
183-
if w.trafficState.WithinPaddingBuffers || !ShouldStopSeed(w.addons, w.trafficState) {
183+
if w.trafficState.WithinPaddingBuffers || w.trafficState.NumberOfPacketReceived <= 8 || !ShouldStopSeed(w.addons, w.trafficState) {
184184
mb2 := make(buf.MultiBuffer, 0, len(buffer))
185185
for _, b := range buffer {
186186
newbuffer := XtlsUnpadding(b, w.trafficState, w.ctx)

‎proxy/scheduler.go‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ import (
88
"time"
99

1010
"github.com/xtls/xray-core/common/buf"
11-
"github.com/xtls/xray-core/common/session"
11+
"github.com/xtls/xray-core/common/errors"
1212
)
1313

1414
type Scheduler struct {
@@ -47,16 +47,16 @@ func(s *Scheduler) mainLoop() {
4747
if s.addons.Delay != nil {
4848
l, err := rand.Int(rand.Reader, big.NewInt(int64(s.addons.Delay.MaxMillis - s.addons.Delay.MinMillis)))
4949
if err != nil {
50-
newError("failed to generate delay", trigger).Base(err).WriteToLog(session.ExportIDToError(s.ctx))
50+
errors.LogInfoInner(s.ctx, err, "failed to generate delay", trigger)
5151
}
52-
d = time.Duration(uint32(l.Int64()) + s.addons.Delay.MinMillis)
53-
time.Sleep(d * time.Millisecond)
52+
d = time.Duration(uint32(l.Int64()) + s.addons.Delay.MinMillis) * time.Millisecond
53+
time.Sleep(d)
5454
}
5555

5656
s.bufferReadLock.Lock() // guard against multiple trigger threads
5757
var sending = len(s.Buffer)
5858
if sending > 0 {
59-
newError("Scheduler Trigger for ", sending, " buffer(s) with ", d, " ", trigger).AtDebug().WriteToLog(session.ExportIDToError(s.ctx))
59+
errors.LogDebug(s.ctx, "Scheduler Trigger for ", sending, " buffer(s) with ", d, " ", trigger)
6060
}
6161
for i := 0; i<sending; i++ {
6262
s.Error <- s.writer.WriteMultiBuffer(<-s.Buffer)

‎testing/scenarios/vless_test.go‎

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,106 @@ func TestVless(t *testing.T) {
125125
}
126126
}
127127

128+
func TestVlessSeedWithIndependentScheduler(t *testing.T) {
129+
tcpServer := tcp.Server{
130+
MsgProcessor: xor,
131+
}
132+
dest, err := tcpServer.Start()
133+
common.Must(err)
134+
defer tcpServer.Close()
135+
136+
userID := protocol.NewID(uuid.New())
137+
serverPort := tcp.PickPort()
138+
serverConfig := &core.Config{
139+
App: []*serial.TypedMessage{
140+
serial.ToTypedMessage(&log.Config{
141+
ErrorLogLevel: clog.Severity_Debug,
142+
ErrorLogType: log.LogType_Console,
143+
}),
144+
},
145+
Inbound: []*core.InboundHandlerConfig{
146+
{
147+
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
148+
PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
149+
Listen: net.NewIPOrDomain(net.LocalHostIP),
150+
}),
151+
ProxySettings: serial.ToTypedMessage(&inbound.Config{
152+
Clients: []*protocol.User{
153+
{
154+
Account: serial.ToTypedMessage(&vless.Account{
155+
Id: userID.String(),
156+
Seed: "1",
157+
}),
158+
},
159+
},
160+
}),
161+
},
162+
},
163+
Outbound: []*core.OutboundHandlerConfig{
164+
{
165+
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
166+
},
167+
},
168+
}
169+
170+
clientPort := tcp.PickPort()
171+
clientConfig := &core.Config{
172+
App: []*serial.TypedMessage{
173+
serial.ToTypedMessage(&log.Config{
174+
ErrorLogLevel: clog.Severity_Debug,
175+
ErrorLogType: log.LogType_Console,
176+
}),
177+
},
178+
Inbound: []*core.InboundHandlerConfig{
179+
{
180+
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
181+
PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
182+
Listen: net.NewIPOrDomain(net.LocalHostIP),
183+
}),
184+
ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
185+
Address: net.NewIPOrDomain(dest.Address),
186+
Port: uint32(dest.Port),
187+
NetworkList: &net.NetworkList{
188+
Network: []net.Network{net.Network_TCP},
189+
},
190+
}),
191+
},
192+
},
193+
Outbound: []*core.OutboundHandlerConfig{
194+
{
195+
ProxySettings: serial.ToTypedMessage(&outbound.Config{
196+
Vnext: []*protocol.ServerEndpoint{
197+
{
198+
Address: net.NewIPOrDomain(net.LocalHostIP),
199+
Port: uint32(serverPort),
200+
User: []*protocol.User{
201+
{
202+
Account: serial.ToTypedMessage(&vless.Account{
203+
Id: userID.String(),
204+
Seed: "1",
205+
}),
206+
},
207+
},
208+
},
209+
},
210+
}),
211+
},
212+
},
213+
}
214+
215+
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
216+
common.Must(err)
217+
defer CloseAllServers(servers)
218+
219+
var errg errgroup.Group
220+
for i := 0; i < 10; i++ {
221+
errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
222+
}
223+
if err := errg.Wait(); err != nil {
224+
t.Error(err)
225+
}
226+
}
227+
128228
func TestVlessTls(t *testing.T) {
129229
tcpServer := tcp.Server{
130230
MsgProcessor: xor,
@@ -371,6 +471,134 @@ func TestVlessXtlsVision(t *testing.T) {
371471
}
372472
}
373473

474+
func TestVlessXtlsVisionWithSeed(t *testing.T) {
475+
tcpServer := tcp.Server{
476+
MsgProcessor: xor,
477+
}
478+
dest, err := tcpServer.Start()
479+
common.Must(err)
480+
defer tcpServer.Close()
481+
482+
userID := protocol.NewID(uuid.New())
483+
serverPort := tcp.PickPort()
484+
serverConfig := &core.Config{
485+
App: []*serial.TypedMessage{
486+
serial.ToTypedMessage(&log.Config{
487+
ErrorLogLevel: clog.Severity_Debug,
488+
ErrorLogType: log.LogType_Console,
489+
}),
490+
},
491+
Inbound: []*core.InboundHandlerConfig{
492+
{
493+
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
494+
PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
495+
Listen: net.NewIPOrDomain(net.LocalHostIP),
496+
StreamSettings: &internet.StreamConfig{
497+
Protocol: internet.TransportProtocol_TCP,
498+
SecurityType: serial.GetMessageType(&tls.Config{}),
499+
SecuritySettings: []*serial.TypedMessage{
500+
serial.ToTypedMessage(&tls.Config{
501+
Certificate: []*tls.Certificate{tls.ParseCertificate(cert.MustGenerate(nil))},
502+
}),
503+
},
504+
},
505+
}),
506+
ProxySettings: serial.ToTypedMessage(&inbound.Config{
507+
Clients: []*protocol.User{
508+
{
509+
Account: serial.ToTypedMessage(&vless.Account{
510+
Id: userID.String(),
511+
Flow: vless.XRV,
512+
Seed: "1",
513+
}),
514+
},
515+
},
516+
}),
517+
},
518+
},
519+
Outbound: []*core.OutboundHandlerConfig{
520+
{
521+
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
522+
},
523+
},
524+
}
525+
526+
clientPort := tcp.PickPort()
527+
clientConfig := &core.Config{
528+
App: []*serial.TypedMessage{
529+
serial.ToTypedMessage(&log.Config{
530+
ErrorLogLevel: clog.Severity_Debug,
531+
ErrorLogType: log.LogType_Console,
532+
}),
533+
},
534+
Inbound: []*core.InboundHandlerConfig{
535+
{
536+
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
537+
PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
538+
Listen: net.NewIPOrDomain(net.LocalHostIP),
539+
}),
540+
ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
541+
Address: net.NewIPOrDomain(dest.Address),
542+
Port: uint32(dest.Port),
543+
NetworkList: &net.NetworkList{
544+
Network: []net.Network{net.Network_TCP},
545+
},
546+
}),
547+
},
548+
},
549+
Outbound: []*core.OutboundHandlerConfig{
550+
{
551+
ProxySettings: serial.ToTypedMessage(&outbound.Config{
552+
Vnext: []*protocol.ServerEndpoint{
553+
{
554+
Address: net.NewIPOrDomain(net.LocalHostIP),
555+
Port: uint32(serverPort),
556+
User: []*protocol.User{
557+
{
558+
Account: serial.ToTypedMessage(&vless.Account{
559+
Id: userID.String(),
560+
Flow: vless.XRV,
561+
Seed: "1",
562+
}),
563+
},
564+
},
565+
},
566+
},
567+
}),
568+
SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
569+
StreamSettings: &internet.StreamConfig{
570+
Protocol: internet.TransportProtocol_TCP,
571+
TransportSettings: []*internet.TransportConfig{
572+
{
573+
Protocol: internet.TransportProtocol_TCP,
574+
Settings: serial.ToTypedMessage(&transtcp.Config{}),
575+
},
576+
},
577+
SecurityType: serial.GetMessageType(&tls.Config{}),
578+
SecuritySettings: []*serial.TypedMessage{
579+
serial.ToTypedMessage(&tls.Config{
580+
AllowInsecure: true,
581+
}),
582+
},
583+
},
584+
}),
585+
},
586+
},
587+
}
588+
589+
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
590+
common.Must(err)
591+
defer CloseAllServers(servers)
592+
593+
var errg errgroup.Group
594+
for i := 0; i < 10; i++ {
595+
errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
596+
}
597+
if err := errg.Wait(); err != nil {
598+
t.Error(err)
599+
}
600+
}
601+
374602
func TestVlessXtlsVisionReality(t *testing.T) {
375603
tcpServer := tcp.Server{
376604
MsgProcessor: xor,

0 commit comments

Comments
 (0)