1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-26 12:07:47 -05:00
v2fly/testing/scenarios/tls_test.go

379 lines
9.8 KiB
Go
Raw Normal View History

2016-12-16 15:39:00 -05:00
package scenarios
import (
2017-02-08 11:57:21 -05:00
"crypto/rand"
2016-12-30 17:12:00 -05:00
"testing"
"time"
2016-12-16 15:39:00 -05:00
"v2ray.com/core"
"v2ray.com/core/app/proxyman"
"v2ray.com/core/common/net"
2016-12-30 17:12:00 -05:00
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
"v2ray.com/core/common/uuid"
"v2ray.com/core/proxy/dokodemo"
"v2ray.com/core/proxy/freedom"
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/servers/tcp"
2017-01-12 10:10:03 -05:00
tlsgen "v2ray.com/core/testing/tls"
2016-12-30 17:12:00 -05:00
"v2ray.com/core/transport/internet"
"v2ray.com/core/transport/internet/tls"
2017-02-08 11:57:21 -05:00
"v2ray.com/core/transport/internet/websocket"
2017-10-26 15:44:22 -04:00
. "v2ray.com/ext/assert"
2016-12-16 15:39:00 -05:00
)
2016-12-30 17:12:00 -05:00
func TestSimpleTLSConnection(t *testing.T) {
2017-10-24 10:15:35 -04:00
assert := With(t)
2016-12-30 17:12:00 -05:00
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
defer tcpServer.Close()
2016-12-30 17:12:00 -05:00
userID := protocol.NewID(uuid.New())
serverPort := pickPort()
serverConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
2016-12-30 17:12:00 -05:00
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(serverPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
StreamSettings: &internet.StreamConfig{
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
Certificate: []*tls.Certificate{tlsgen.GenerateCertificateForTest()},
}),
},
},
}),
ProxySettings: serial.ToTypedMessage(&inbound.Config{
2016-12-30 17:12:00 -05:00
User: []*protocol.User{
{
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
},
},
}),
2017-01-12 10:10:03 -05:00
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
2017-01-12 10:10:03 -05:00
{
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
2017-01-12 10:10:03 -05:00
},
},
}
clientPort := pickPort()
clientConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
2017-01-12 10:10:03 -05:00
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(clientPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
}),
ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
Address: net.NewIPOrDomain(dest.Address),
2017-01-12 10:10:03 -05:00
Port: uint32(dest.Port),
NetworkList: &net.NetworkList{
Network: []net.Network{net.Network_TCP},
2017-01-12 10:10:03 -05:00
},
}),
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
2017-01-12 10:10:03 -05:00
{
ProxySettings: serial.ToTypedMessage(&outbound.Config{
2017-01-12 10:10:03 -05:00
Receiver: []*protocol.ServerEndpoint{
{
Address: net.NewIPOrDomain(net.LocalHostIP),
2017-01-12 10:10:03 -05:00
Port: uint32(serverPort),
User: []*protocol.User{
2016-12-30 17:12:00 -05:00
{
2017-01-12 10:10:03 -05:00
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
2016-12-30 17:12:00 -05:00
},
},
2017-01-12 10:10:03 -05:00
},
},
}),
SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
StreamSettings: &internet.StreamConfig{
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
AllowInsecure: true,
}),
},
2017-01-12 10:10:03 -05:00
},
}),
2017-01-12 10:10:03 -05:00
},
},
}
2017-05-17 18:39:30 -04:00
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-01-12 10:10:03 -05:00
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-01-12 10:10:03 -05:00
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
2017-01-12 10:10:03 -05:00
response := readFrom(conn, time.Second*2, len(payload))
2017-10-24 10:15:35 -04:00
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
2017-01-12 10:10:03 -05:00
2017-05-17 18:39:30 -04:00
CloseAllServers(servers)
2017-01-12 10:10:03 -05:00
}
func TestTLSOverKCP(t *testing.T) {
2017-10-24 10:15:35 -04:00
assert := With(t)
2017-01-12 10:10:03 -05:00
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-01-12 10:10:03 -05:00
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
2017-05-17 18:39:30 -04:00
serverPort := pickUDPPort()
2017-01-12 10:10:03 -05:00
serverConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
2017-01-12 10:10:03 -05:00
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(serverPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
StreamSettings: &internet.StreamConfig{
Protocol: internet.TransportProtocol_MKCP,
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
Certificate: []*tls.Certificate{tlsgen.GenerateCertificateForTest()},
}),
},
},
}),
ProxySettings: serial.ToTypedMessage(&inbound.Config{
2017-01-12 10:10:03 -05:00
User: []*protocol.User{
{
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
},
},
}),
2016-12-30 17:12:00 -05:00
},
2016-12-16 15:39:00 -05:00
},
Outbound: []*proxyman.OutboundHandlerConfig{
2016-12-30 17:12:00 -05:00
{
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
2016-12-30 17:12:00 -05:00
},
},
}
clientPort := pickPort()
clientConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
2016-12-30 17:12:00 -05:00
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(clientPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
}),
ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
Address: net.NewIPOrDomain(dest.Address),
2016-12-30 17:12:00 -05:00
Port: uint32(dest.Port),
NetworkList: &net.NetworkList{
Network: []net.Network{net.Network_TCP},
2016-12-30 17:12:00 -05:00
},
}),
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
2016-12-30 17:12:00 -05:00
{
ProxySettings: serial.ToTypedMessage(&outbound.Config{
2016-12-30 17:12:00 -05:00
Receiver: []*protocol.ServerEndpoint{
{
Address: net.NewIPOrDomain(net.LocalHostIP),
2016-12-30 17:12:00 -05:00
Port: uint32(serverPort),
User: []*protocol.User{
{
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
},
},
},
},
}),
SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
StreamSettings: &internet.StreamConfig{
Protocol: internet.TransportProtocol_MKCP,
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
AllowInsecure: true,
}),
},
2016-12-30 17:12:00 -05:00
},
}),
2016-12-30 17:12:00 -05:00
},
},
}
2017-05-17 18:39:30 -04:00
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2016-12-30 17:12:00 -05:00
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2016-12-30 17:12:00 -05:00
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
2016-12-30 17:12:00 -05:00
2017-01-04 09:42:06 -05:00
response := readFrom(conn, time.Second*2, len(payload))
2017-10-24 10:15:35 -04:00
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
2017-01-04 09:42:06 -05:00
2017-05-17 18:39:30 -04:00
CloseAllServers(servers)
2017-01-04 09:42:06 -05:00
}
2017-02-08 11:57:21 -05:00
func TestTLSOverWebSocket(t *testing.T) {
2017-10-24 10:15:35 -04:00
assert := With(t)
2017-02-08 11:57:21 -05:00
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-02-08 11:57:21 -05:00
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
serverPort := pickPort()
serverConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(serverPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
2017-02-08 11:57:21 -05:00
StreamSettings: &internet.StreamConfig{
Protocol: internet.TransportProtocol_WebSocket,
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
Certificate: []*tls.Certificate{tlsgen.GenerateCertificateForTest()},
}),
},
},
}),
ProxySettings: serial.ToTypedMessage(&inbound.Config{
User: []*protocol.User{
{
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
},
},
}),
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
{
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
},
},
}
clientPort := pickPort()
clientConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: net.SinglePortRange(clientPort),
Listen: net.NewIPOrDomain(net.LocalHostIP),
2017-02-08 11:57:21 -05:00
}),
ProxySettings: serial.ToTypedMessage(&dokodemo.Config{
Address: net.NewIPOrDomain(dest.Address),
2017-02-08 11:57:21 -05:00
Port: uint32(dest.Port),
NetworkList: &net.NetworkList{
Network: []net.Network{net.Network_TCP},
2017-02-08 11:57:21 -05:00
},
}),
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
{
ProxySettings: serial.ToTypedMessage(&outbound.Config{
Receiver: []*protocol.ServerEndpoint{
{
Address: net.NewIPOrDomain(net.LocalHostIP),
2017-02-08 11:57:21 -05:00
Port: uint32(serverPort),
User: []*protocol.User{
{
Account: serial.ToTypedMessage(&vmess.Account{
Id: userID.String(),
}),
},
},
},
},
}),
SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
StreamSettings: &internet.StreamConfig{
Protocol: internet.TransportProtocol_WebSocket,
TransportSettings: []*internet.TransportConfig{
{
Protocol: internet.TransportProtocol_WebSocket,
Settings: serial.ToTypedMessage(&websocket.Config{}),
2017-02-08 11:57:21 -05:00
},
},
SecurityType: serial.GetMessageType(&tls.Config{}),
SecuritySettings: []*serial.TypedMessage{
serial.ToTypedMessage(&tls.Config{
AllowInsecure: true,
}),
},
},
}),
},
},
}
2017-05-17 18:39:30 -04:00
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-02-08 11:57:21 -05:00
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
2017-02-08 11:57:21 -05:00
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
2017-10-24 10:15:35 -04:00
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
2017-02-08 11:57:21 -05:00
2017-04-16 15:31:33 -04:00
response := readFrom(conn, time.Second*20, len(payload))
2017-10-24 10:15:35 -04:00
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
2017-02-08 11:57:21 -05:00
2017-05-17 18:39:30 -04:00
CloseAllServers(servers)
2017-02-08 11:57:21 -05:00
}