From ae2fa30e01fceb2d4565ca1320d00e2515399f05 Mon Sep 17 00:00:00 2001
From: yuhan6665 <1588741+yuhan6665@users.noreply.github.com>
Date: Sun, 18 Jun 2023 09:12:11 -0400
Subject: [PATCH] Add Vless tests

---
 testing/scenarios/vless_test.go | 518 ++++++++++++++++++++++++++++++++
 1 file changed, 518 insertions(+)
 create mode 100644 testing/scenarios/vless_test.go

diff --git a/testing/scenarios/vless_test.go b/testing/scenarios/vless_test.go
new file mode 100644
index 00000000..84d82643
--- /dev/null
+++ b/testing/scenarios/vless_test.go
@@ -0,0 +1,518 @@
+package scenarios
+
+import (
+	// "encoding/base64"
+	// "encoding/hex"
+	"testing"
+	"time"
+
+	"github.com/xtls/xray-core/app/log"
+	"github.com/xtls/xray-core/app/proxyman"
+	"github.com/xtls/xray-core/common"
+	clog "github.com/xtls/xray-core/common/log"
+	"github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/common/protocol"
+	"github.com/xtls/xray-core/common/protocol/tls/cert"
+	"github.com/xtls/xray-core/common/serial"
+	"github.com/xtls/xray-core/common/uuid"
+	core "github.com/xtls/xray-core/core"
+	"github.com/xtls/xray-core/proxy/dokodemo"
+	"github.com/xtls/xray-core/proxy/freedom"
+	"github.com/xtls/xray-core/proxy/vless"
+	"github.com/xtls/xray-core/proxy/vless/inbound"
+	"github.com/xtls/xray-core/proxy/vless/outbound"
+	"github.com/xtls/xray-core/testing/servers/tcp"
+	"github.com/xtls/xray-core/transport/internet"
+	// "github.com/xtls/xray-core/transport/internet/reality"
+	transtcp "github.com/xtls/xray-core/transport/internet/tcp"
+	"github.com/xtls/xray-core/transport/internet/tls"
+	"golang.org/x/sync/errgroup"
+)
+
+func TestVless(t *testing.T) {
+	tcpServer := tcp.Server{
+		MsgProcessor: xor,
+	}
+	dest, err := tcpServer.Start()
+	common.Must(err)
+	defer tcpServer.Close()
+
+	userID := protocol.NewID(uuid.New())
+	serverPort := tcp.PickPort()
+	serverConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+				}),
+				ProxySettings: serial.ToTypedMessage(&inbound.Config{
+					Clients: []*protocol.User{
+						{
+							Account: serial.ToTypedMessage(&vless.Account{
+								Id: userID.String(),
+							}),
+						},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
+			},
+		},
+	}
+
+	clientPort := tcp.PickPort()
+	clientConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+				}),
+				ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
+					Address: net.NewIPOrDomain(dest.Address),
+					Port:    uint32(dest.Port),
+					NetworkList: &net.NetworkList{
+						Network: []net.Network{net.Network_TCP},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&outbound.Config{
+					Vnext: []*protocol.ServerEndpoint{
+						{
+							Address: net.NewIPOrDomain(net.LocalHostIP),
+							Port:    uint32(serverPort),
+							User: []*protocol.User{
+								{
+									Account: serial.ToTypedMessage(&vless.Account{
+										Id: userID.String(),
+									}),
+								},
+							},
+						},
+					},
+				}),
+			},
+		},
+	}
+
+	servers, err := InitializeServerConfigs(serverConfig, clientConfig)
+	common.Must(err)
+	defer CloseAllServers(servers)
+
+	var errg errgroup.Group
+	for i := 0; i < 10; i++ {
+		errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
+	}
+	if err := errg.Wait(); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestVlessTls(t *testing.T) {
+	tcpServer := tcp.Server{
+		MsgProcessor: xor,
+	}
+	dest, err := tcpServer.Start()
+	common.Must(err)
+	defer tcpServer.Close()
+
+	userID := protocol.NewID(uuid.New())
+	serverPort := tcp.PickPort()
+	serverConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+					StreamSettings: &internet.StreamConfig{
+						Protocol:     internet.TransportProtocol_TCP,
+						SecurityType: serial.GetMessageType(&tls.Config{}),
+						SecuritySettings: []*serial.TypedMessage{
+							serial.ToTypedMessage(&tls.Config{
+								Certificate: []*tls.Certificate{tls.ParseCertificate(cert.MustGenerate(nil))},
+							}),
+						},
+					},
+				}),
+				ProxySettings: serial.ToTypedMessage(&inbound.Config{
+					Clients: []*protocol.User{
+						{
+							Account: serial.ToTypedMessage(&vless.Account{
+								Id: userID.String(),
+							}),
+						},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
+			},
+		},
+	}
+
+	clientPort := tcp.PickPort()
+	clientConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+				}),
+				ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
+					Address: net.NewIPOrDomain(dest.Address),
+					Port:    uint32(dest.Port),
+					NetworkList: &net.NetworkList{
+						Network: []net.Network{net.Network_TCP},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&outbound.Config{
+					Vnext: []*protocol.ServerEndpoint{
+						{
+							Address: net.NewIPOrDomain(net.LocalHostIP),
+							Port:    uint32(serverPort),
+							User: []*protocol.User{
+								{
+									Account: serial.ToTypedMessage(&vless.Account{
+										Id: userID.String(),
+									}),
+								},
+							},
+						},
+					},
+				}),
+				SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
+					StreamSettings: &internet.StreamConfig{
+						Protocol: internet.TransportProtocol_TCP,
+						TransportSettings: []*internet.TransportConfig{
+							{
+								Protocol: internet.TransportProtocol_TCP,
+								Settings: serial.ToTypedMessage(&transtcp.Config{}),
+							},
+						},
+						SecurityType: serial.GetMessageType(&tls.Config{}),
+						SecuritySettings: []*serial.TypedMessage{
+							serial.ToTypedMessage(&tls.Config{
+								AllowInsecure: true,
+							}),
+						},
+					},
+				}),
+			},
+		},
+	}
+
+	servers, err := InitializeServerConfigs(serverConfig, clientConfig)
+	common.Must(err)
+	defer CloseAllServers(servers)
+
+	var errg errgroup.Group
+	for i := 0; i < 10; i++ {
+		errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
+	}
+	if err := errg.Wait(); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestVlessXtlsVision(t *testing.T) {
+	tcpServer := tcp.Server{
+		MsgProcessor: xor,
+	}
+	dest, err := tcpServer.Start()
+	common.Must(err)
+	defer tcpServer.Close()
+
+	userID := protocol.NewID(uuid.New())
+	serverPort := tcp.PickPort()
+	serverConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+					StreamSettings: &internet.StreamConfig{
+						Protocol:     internet.TransportProtocol_TCP,
+						SecurityType: serial.GetMessageType(&tls.Config{}),
+						SecuritySettings: []*serial.TypedMessage{
+							serial.ToTypedMessage(&tls.Config{
+								Certificate: []*tls.Certificate{tls.ParseCertificate(cert.MustGenerate(nil))},
+							}),
+						},
+					},
+				}),
+				ProxySettings: serial.ToTypedMessage(&inbound.Config{
+					Clients: []*protocol.User{
+						{
+							Account: serial.ToTypedMessage(&vless.Account{
+								Id:   userID.String(),
+								Flow: vless.XRV,
+							}),
+						},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
+			},
+		},
+	}
+
+	clientPort := tcp.PickPort()
+	clientConfig := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&log.Config{
+				ErrorLogLevel: clog.Severity_Debug,
+				ErrorLogType:  log.LogType_Console,
+			}),
+		},
+		Inbound: []*core.InboundHandlerConfig{
+			{
+				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
+					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+				}),
+				ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
+					Address: net.NewIPOrDomain(dest.Address),
+					Port:    uint32(dest.Port),
+					NetworkList: &net.NetworkList{
+						Network: []net.Network{net.Network_TCP},
+					},
+				}),
+			},
+		},
+		Outbound: []*core.OutboundHandlerConfig{
+			{
+				ProxySettings: serial.ToTypedMessage(&outbound.Config{
+					Vnext: []*protocol.ServerEndpoint{
+						{
+							Address: net.NewIPOrDomain(net.LocalHostIP),
+							Port:    uint32(serverPort),
+							User: []*protocol.User{
+								{
+									Account: serial.ToTypedMessage(&vless.Account{
+										Id:   userID.String(),
+										Flow: vless.XRV,
+									}),
+								},
+							},
+						},
+					},
+				}),
+				SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
+					StreamSettings: &internet.StreamConfig{
+						Protocol: internet.TransportProtocol_TCP,
+						TransportSettings: []*internet.TransportConfig{
+							{
+								Protocol: internet.TransportProtocol_TCP,
+								Settings: serial.ToTypedMessage(&transtcp.Config{}),
+							},
+						},
+						SecurityType: serial.GetMessageType(&tls.Config{}),
+						SecuritySettings: []*serial.TypedMessage{
+							serial.ToTypedMessage(&tls.Config{
+								AllowInsecure: true,
+							}),
+						},
+					},
+				}),
+			},
+		},
+	}
+
+	servers, err := InitializeServerConfigs(serverConfig, clientConfig)
+	common.Must(err)
+	defer CloseAllServers(servers)
+
+	var errg errgroup.Group
+	for i := 0; i < 10; i++ {
+		errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
+	}
+	if err := errg.Wait(); err != nil {
+		t.Error(err)
+	}
+}
+
+// func TestVlessXtlsVisionReality(t *testing.T) {
+// 	tcpServer := tcp.Server{
+// 		MsgProcessor: xor,
+// 	}
+// 	dest, err := tcpServer.Start()
+// 	common.Must(err)
+// 	defer tcpServer.Close()
+
+// 	userID := protocol.NewID(uuid.New())
+// 	serverPort := tcp.PickPort()
+// 	privateKey, _ := base64.RawURLEncoding.DecodeString("aGSYystUbf59_9_6LKRxD27rmSW_-2_nyd9YG_Gwbks")
+// 	publicKey, _ := base64.RawURLEncoding.DecodeString("E59WjnvZcQMu7tR7_BgyhycuEdBS-CtKxfImRCdAvFM")
+// 	shortIds := make([][]byte, 1)
+// 	shortIds[0] = make([]byte, 8)
+// 	hex.Decode(shortIds[0], []byte("0123456789abcdef"))
+// 	serverConfig := &core.Config{
+// 		App: []*serial.TypedMessage{
+// 			serial.ToTypedMessage(&log.Config{
+// 				ErrorLogLevel: clog.Severity_Debug,
+// 				ErrorLogType:  log.LogType_Console,
+// 			}),
+// 		},
+// 		Inbound: []*core.InboundHandlerConfig{
+// 			{
+// 				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+// 					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(serverPort)}},
+// 					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+// 					StreamSettings: &internet.StreamConfig{
+// 						Protocol:     internet.TransportProtocol_TCP,
+// 						SecurityType: serial.GetMessageType(&reality.Config{}),
+// 						SecuritySettings: []*serial.TypedMessage{
+// 							serial.ToTypedMessage(&reality.Config{
+// 								Show: true,
+// 								Dest: "www.google.com:443", // use google for now, may fail in some region
+// 								ServerNames: []string{"www.google.com"},
+// 								PrivateKey: privateKey,
+// 								ShortIds: shortIds,
+// 							}),
+// 						},
+// 					},
+// 				}),
+// 				ProxySettings: serial.ToTypedMessage(&inbound.Config{
+// 					Clients: []*protocol.User{
+// 						{
+// 							Account: serial.ToTypedMessage(&vless.Account{
+// 								Id:   userID.String(),
+// 								Flow: vless.XRV,
+// 							}),
+// 						},
+// 					},
+// 				}),
+// 			},
+// 		},
+// 		Outbound: []*core.OutboundHandlerConfig{
+// 			{
+// 				ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
+// 			},
+// 		},
+// 	}
+
+// 	clientPort := tcp.PickPort()
+// 	clientConfig := &core.Config{
+// 		App: []*serial.TypedMessage{
+// 			serial.ToTypedMessage(&log.Config{
+// 				ErrorLogLevel: clog.Severity_Debug,
+// 				ErrorLogType:  log.LogType_Console,
+// 			}),
+// 		},
+// 		Inbound: []*core.InboundHandlerConfig{
+// 			{
+// 				ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
+// 					PortList: &net.PortList{Range: []*net.PortRange{net.SinglePortRange(clientPort)}},
+// 					Listen:   net.NewIPOrDomain(net.LocalHostIP),
+// 				}),
+// 				ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
+// 					Address: net.NewIPOrDomain(dest.Address),
+// 					Port:    uint32(dest.Port),
+// 					NetworkList: &net.NetworkList{
+// 						Network: []net.Network{net.Network_TCP},
+// 					},
+// 				}),
+// 			},
+// 		},
+// 		Outbound: []*core.OutboundHandlerConfig{
+// 			{
+// 				ProxySettings: serial.ToTypedMessage(&outbound.Config{
+// 					Vnext: []*protocol.ServerEndpoint{
+// 						{
+// 							Address: net.NewIPOrDomain(net.LocalHostIP),
+// 							Port:    uint32(serverPort),
+// 							User: []*protocol.User{
+// 								{
+// 									Account: serial.ToTypedMessage(&vless.Account{
+// 										Id:   userID.String(),
+// 										Flow: vless.XRV,
+// 									}),
+// 								},
+// 							},
+// 						},
+// 					},
+// 				}),
+// 				SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
+// 					StreamSettings: &internet.StreamConfig{
+// 						Protocol: internet.TransportProtocol_TCP,
+// 						TransportSettings: []*internet.TransportConfig{
+// 							{
+// 								Protocol: internet.TransportProtocol_TCP,
+// 								Settings: serial.ToTypedMessage(&transtcp.Config{}),
+// 							},
+// 						},
+// 						SecurityType: serial.GetMessageType(&reality.Config{}),
+// 						SecuritySettings: []*serial.TypedMessage{
+// 							serial.ToTypedMessage(&reality.Config{
+// 								Show: true,
+// 								Fingerprint: "chrome",
+// 								ServerName: "www.google.com",
+// 								PublicKey: publicKey,
+// 								ShortId: shortIds[0],
+// 								SpiderX: "/",
+// 							}),
+// 						},
+// 					},
+// 				}),
+// 			},
+// 		},
+// 	}
+
+// 	servers, err := InitializeServerConfigs(serverConfig, clientConfig)
+// 	common.Must(err)
+// 	defer CloseAllServers(servers)
+
+// 	var errg errgroup.Group
+// 	for i := 0; i < 1; i++ {
+// 		errg.Go(testTCPConn(clientPort, 1024*1024, time.Second*30))
+// 	}
+// 	if err := errg.Wait(); err != nil {
+// 		t.Error(err)
+// 	}
+// }