func (server *SocksServer) handleSocks4(reader io.Reader, writer io.Writer, auth protocol.Socks4AuthenticationRequest) error { result := protocol.Socks4RequestGranted if auth.Command == protocol.CmdBind { result = protocol.Socks4RequestRejected } socks4Response := protocol.NewSocks4AuthenticationResponse(result, auth.Port, auth.IP[:]) responseBuffer := alloc.NewSmallBuffer().Clear() socks4Response.Write(responseBuffer) writer.Write(responseBuffer.Value) responseBuffer.Release() if result == protocol.Socks4RequestRejected { log.Warning("Unsupported socks 4 command %d", auth.Command) return UnsupportedSocksCommand } dest := v2net.NewTCPDestination(v2net.IPAddress(auth.IP[:], auth.Port)) data, err := v2net.ReadFrom(reader, nil) if err != nil { return err } packet := v2net.NewPacket(dest, data, true) server.transport(reader, writer, packet) return nil }
func (config VNextConfig) ToVNextServer(network string) VNextServer { users := make([]user.User, 0, len(config.Users)) for _, user := range config.Users { vuser, err := user.ToUser() if err != nil { panic(log.Error("Failed to convert %v to User.", user)) } users = append(users, vuser) } ip := net.ParseIP(config.Address) if ip == nil { panic(log.Error("Unable to parse VNext IP: %s", config.Address)) } address := v2net.IPAddress(ip, config.Port) var dest v2net.Destination if network == "tcp" { dest = v2net.NewTCPDestination(address) } else { dest = v2net.NewUDPDestination(address) } return VNextServer{ Destination: dest, Users: users, } }
// Destination is the final destination of this request. func (request *VMessRequest) Destination() v2net.Destination { if request.Command == CmdTCP { return v2net.NewTCPDestination(request.Address) } else { return v2net.NewUDPDestination(request.Address) } }
// Destination is the final destination of this request. func (this *VMessRequest) Destination() v2net.Destination { if this.Command == CmdTCP { return v2net.NewTCPDestination(this.Address) } else { return v2net.NewUDPDestination(this.Address) } }
func TestDomainMatching(t *testing.T) { assert := unit.Assert(t) rule := &FieldRule{ Domain: NewStringList("v2ray.com"), } dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80)) assert.Bool(rule.Apply(dest)).IsTrue() }
func TestPortMatching(t *testing.T) { assert := unit.Assert(t) rule := &FieldRule{ Port: &v2nettesting.PortRange{ FromValue: 0, ToValue: 100, }, } dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80)) assert.Bool(rule.Apply(dest)).IsTrue() }
func TestIPMatching(t *testing.T) { assert := unit.Assert(t) rawJson := `{ "type": "field", "ip": "10.0.0.0/8", "tag": "test" }` rule := parseRule([]byte(rawJson)) dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80)) assert.Bool(rule.Apply(dest)).IsTrue() }
func TestDomainNotMatchingDomain(t *testing.T) { assert := unit.Assert(t) rawJson := `{ "type": "field", "domain": ["google.com", "v2ray.com"], "tag": "test" }` rule := parseRule([]byte(rawJson)) dest := v2net.NewTCPDestination(v2net.DomainAddress("baidu.com", 80)) assert.Bool(rule.Apply(dest)).IsFalse() }
func TestPortNotMatching(t *testing.T) { assert := unit.Assert(t) rawJson := `{ "type": "field", "port": "80-100", "tag": "test" }` rule := parseRule([]byte(rawJson)) dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 79)) assert.Bool(rule.Apply(dest)).IsFalse() }
func (request *Socks5Request) Destination() v2net.Destination { var address v2net.Address switch request.AddrType { case AddrTypeIPv4: address = v2net.IPAddress(request.IPv4[:], request.Port) case AddrTypeIPv6: address = v2net.IPAddress(request.IPv6[:], request.Port) case AddrTypeDomain: address = v2net.DomainAddress(request.Domain, request.Port) default: panic("Unknown address type") } return v2net.NewTCPDestination(address) }
func (o *Outbound) Targets() []*vmessconfig.OutboundTarget { targets := make([]*vmessconfig.OutboundTarget, 0, 2*len(o.TargetList)) for _, rawTarget := range o.TargetList { users := make([]vmessconfig.User, 0, len(rawTarget.Users)) for _, rawUser := range rawTarget.Users { users = append(users, rawUser) } targets = append(targets, &vmessconfig.OutboundTarget{ Destination: v2net.NewTCPDestination(rawTarget.Address), Accounts: users, }) } return targets }
func (this *DokodemoDoor) HandleTCPConnection(conn *net.TCPConn) { defer conn.Close() packet := v2net.NewPacket(v2net.NewTCPDestination(this.address), nil, true) ray := this.dispatcher.DispatchToOutbound(packet) var inputFinish, outputFinish sync.Mutex inputFinish.Lock() outputFinish.Lock() reader := v2net.NewTimeOutReader(this.config.Timeout, conn) go dumpInput(reader, ray.InboundInput(), &inputFinish) go dumpOutput(conn, ray.InboundOutput(), &outputFinish) outputFinish.Lock() }
func (server *SocksServer) handleSocks4(reader io.Reader, writer io.Writer, auth protocol.Socks4AuthenticationRequest) error { result := protocol.Socks4RequestGranted if auth.Command == protocol.CmdBind { result = protocol.Socks4RequestRejected } socks4Response := protocol.NewSocks4AuthenticationResponse(result, auth.Port, auth.IP[:]) writer.Write(socks4Response.ToBytes(nil)) if result == protocol.Socks4RequestRejected { return errors.NewInvalidOperationError("Socks4 command " + strconv.Itoa(int(auth.Command))) } dest := v2net.NewTCPDestination(v2net.IPAddress(auth.IP[:], auth.Port)) data, err := v2net.ReadFrom(reader) if err != nil { return err } packet := v2net.NewPacket(dest, data, true) server.transport(reader, writer, packet) return nil }
func TestVMessInAndOut(t *testing.T) { assert := unit.Assert(t) data2Send := "The data to be send to outbound server." testAccount, err := config.NewID("ad937d9d-6e23-4a5a-ba23-bce5092a7c51") assert.Error(err).IsNil() portA := uint16(17392) ich := &mocks.InboundConnectionHandler{ Data2Send: []byte(data2Send), DataReturned: bytes.NewBuffer(make([]byte, 0, 1024)), } proxy.RegisterInboundConnectionHandlerFactory("mock_ich", ich) configA := mocks.Config{ PortValue: portA, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_ich", SettingsValue: nil, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &json.Outbound{ []*json.ConfigTarget{ &json.ConfigTarget{ Address: v2net.IPAddress([]byte{127, 0, 0, 1}, 13829), TCPEnabled: true, Users: []*json.ConfigUser{ &json.ConfigUser{Id: testAccount}, }, }, }, }, }, } pointA, err := point.NewPoint(&configA) assert.Error(err).IsNil() err = pointA.Start() assert.Error(err).IsNil() portB := uint16(13829) och := &mocks.OutboundConnectionHandler{ Data2Send: bytes.NewBuffer(make([]byte, 0, 1024)), Data2Return: []byte("The data to be returned to inbound server."), } proxy.RegisterOutboundConnectionHandlerFactory("mock_och", och) configB := mocks.Config{ PortValue: portB, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &json.Inbound{ AllowedClients: []*json.ConfigUser{ &json.ConfigUser{Id: testAccount}, }, }, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_och", SettingsValue: nil, }, } pointB, err := point.NewPoint(&configB) assert.Error(err).IsNil() err = pointB.Start() assert.Error(err).IsNil() dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) ich.Communicate(v2net.NewPacket(dest, nil, true)) assert.Bytes([]byte(data2Send)).Equals(och.Data2Send.Bytes()) assert.Bytes(ich.DataReturned.Bytes()).Equals(och.Data2Return) }
func (server *SocksServer) HandleConnection(connection net.Conn) error { defer connection.Close() reader := connection.(io.Reader) auth, auth4, err := protocol.ReadAuthentication(reader) if err != nil && err != protocol.ErrorSocksVersion4 { log.Error("Error on reading authentication: %v", err) return err } var dest v2net.Destination // TODO refactor this part if err == protocol.ErrorSocksVersion4 { result := protocol.Socks4RequestGranted if auth4.Command == protocol.CmdBind { result = protocol.Socks4RequestRejected } socks4Response := protocol.NewSocks4AuthenticationResponse(result, auth4.Port, auth4.IP[:]) protocol.WriteSocks4AuthenticationResponse(connection, socks4Response) if result == protocol.Socks4RequestRejected { return ErrorCommandNotSupported } dest = v2net.NewTCPDestination(v2net.IPAddress(auth4.IP[:], auth4.Port)) } else { expectedAuthMethod := protocol.AuthNotRequired if server.config.AuthMethod == JsonAuthMethodUserPass { expectedAuthMethod = protocol.AuthUserPass } if !auth.HasAuthMethod(expectedAuthMethod) { authResponse := protocol.NewAuthenticationResponse(protocol.AuthNoMatchingMethod) err = protocol.WriteAuthentication(connection, authResponse) if err != nil { log.Error("Error on socksio write authentication: %v", err) return err } log.Warning("Client doesn't support allowed any auth methods.") return ErrorAuthenticationFailed } authResponse := protocol.NewAuthenticationResponse(expectedAuthMethod) err = protocol.WriteAuthentication(connection, authResponse) if err != nil { log.Error("Error on socksio write authentication: %v", err) return err } if server.config.AuthMethod == JsonAuthMethodUserPass { upRequest, err := protocol.ReadUserPassRequest(reader) if err != nil { log.Error("Failed to read username and password: %v", err) return err } status := byte(0) if !upRequest.IsValid(server.config.Username, server.config.Password) { status = byte(0xFF) } upResponse := protocol.NewSocks5UserPassResponse(status) err = protocol.WriteUserPassResponse(connection, upResponse) if err != nil { log.Error("Error on socksio write user pass response: %v", err) return err } if status != byte(0) { return ErrorInvalidUser } } request, err := protocol.ReadRequest(reader) if err != nil { log.Error("Error on reading socks request: %v", err) return err } response := protocol.NewSocks5Response() if request.Command == protocol.CmdBind || request.Command == protocol.CmdUdpAssociate { response := protocol.NewSocks5Response() response.Error = protocol.ErrorCommandNotSupported err = protocol.WriteResponse(connection, response) if err != nil { log.Error("Error on socksio write response: %v", err) return err } log.Warning("Unsupported socks command %d", request.Command) return ErrorCommandNotSupported } response.Error = protocol.ErrorSuccess response.Port = request.Port response.AddrType = request.AddrType switch response.AddrType { case protocol.AddrTypeIPv4: copy(response.IPv4[:], request.IPv4[:]) case protocol.AddrTypeIPv6: copy(response.IPv6[:], request.IPv6[:]) case protocol.AddrTypeDomain: response.Domain = request.Domain } err = protocol.WriteResponse(connection, response) if err != nil { log.Error("Error on socksio write response: %v", err) return err } dest = request.Destination() } ray := server.vPoint.NewInboundConnectionAccepted(dest) input := ray.InboundInput() output := ray.InboundOutput() readFinish := make(chan bool) writeFinish := make(chan bool) go server.dumpInput(reader, input, readFinish) go server.dumpOutput(connection, output, writeFinish) <-writeFinish return nil }
func TestVMessInAndOut(t *testing.T) { assert := unit.Assert(t) data2Send := "The data to be send to outbound server." portA := uint16(17392) ich := &mocks.InboundConnectionHandler{ Data2Send: []byte(data2Send), DataReturned: bytes.NewBuffer(make([]byte, 0, 1024)), } core.RegisterInboundConnectionHandlerFactory("mock_ich", ich) configA := mocks.Config{ PortValue: portA, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_ich", SettingsValue: nil, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &VMessOutboundConfig{ []VNextConfig{ VNextConfig{ Address: "127.0.0.1", Port: 13829, Network: "tcp", Users: []VMessUser{ VMessUser{Id: "ad937d9d-6e23-4a5a-ba23-bce5092a7c51"}, }, }, }, }, }, } pointA, err := core.NewPoint(&configA) assert.Error(err).IsNil() err = pointA.Start() assert.Error(err).IsNil() portB := uint16(13829) och := &mocks.OutboundConnectionHandler{ Data2Send: bytes.NewBuffer(make([]byte, 0, 1024)), Data2Return: []byte("The data to be returned to inbound server."), } core.RegisterOutboundConnectionHandlerFactory("mock_och", och) configB := mocks.Config{ PortValue: portB, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &VMessInboundConfig{ AllowedClients: []VMessUser{ VMessUser{Id: "ad937d9d-6e23-4a5a-ba23-bce5092a7c51"}, }, }, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_och", SettingsValue: nil, }, } pointB, err := core.NewPoint(&configB) assert.Error(err).IsNil() err = pointB.Start() assert.Error(err).IsNil() dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) ich.Communicate(v2net.NewPacket(dest, nil, true)) assert.Bytes([]byte(data2Send)).Equals(och.Data2Send.Bytes()) assert.Bytes(ich.DataReturned.Bytes()).Equals(och.Data2Return) }
func TestVMessInAndOut(t *testing.T) { assert := unit.Assert(t) data2Send := "The data to be send to outbound server." portA := uint16(17392) ich := &mocks.InboundConnectionHandler{ Data2Send: []byte(data2Send), DataReturned: bytes.NewBuffer(make([]byte, 0, 1024)), } core.RegisterInboundConnectionHandlerFactory("mock_ich", ich) configA := mocks.Config{ PortValue: portA, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_ich", ContentValue: nil, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", ContentValue: []byte("{\"vnext\":[{\"address\": \"127.0.0.1\", \"network\": \"tcp\", \"port\": 13829, \"users\":[{\"id\": \"ad937d9d-6e23-4a5a-ba23-bce5092a7c51\"}]}]}"), }, } pointA, err := core.NewPoint(&configA) assert.Error(err).IsNil() err = pointA.Start() assert.Error(err).IsNil() portB := uint16(13829) och := &mocks.OutboundConnectionHandler{ Data2Send: bytes.NewBuffer(make([]byte, 0, 1024)), Data2Return: []byte("The data to be returned to inbound server."), } core.RegisterOutboundConnectionHandlerFactory("mock_och", och) configB := mocks.Config{ PortValue: portB, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", ContentValue: []byte("{\"clients\": [{\"id\": \"ad937d9d-6e23-4a5a-ba23-bce5092a7c51\"}]}"), }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_och", ContentValue: nil, }, } pointB, err := core.NewPoint(&configB) assert.Error(err).IsNil() err = pointB.Start() assert.Error(err).IsNil() dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) ich.Communicate(v2net.NewTCPPacket(dest)) assert.Bytes([]byte(data2Send)).Equals(och.Data2Send.Bytes()) assert.Bytes(ich.DataReturned.Bytes()).Equals(och.Data2Return) }
func TestVMessInAndOut(t *testing.T) { assert := unit.Assert(t) testAccount, err := config.NewID("ad937d9d-6e23-4a5a-ba23-bce5092a7c51") assert.Error(err).IsNil() portA := v2nettesting.PickPort() portB := v2nettesting.PickPort() ichConnInput := []byte("The data to be send to outbound server.") ichConnOutput := bytes.NewBuffer(make([]byte, 0, 1024)) ich := &proxymocks.InboundConnectionHandler{ ConnInput: bytes.NewReader(ichConnInput), ConnOutput: ichConnOutput, } connhandler.RegisterInboundConnectionHandlerFactory("mock_ich", ich) configA := mocks.Config{ PortValue: portA, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_ich", SettingsValue: nil, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &json.Outbound{ []*json.ConfigTarget{ &json.ConfigTarget{ Address: v2net.IPAddress([]byte{127, 0, 0, 1}, portB), Users: []*json.ConfigUser{ &json.ConfigUser{Id: testAccount}, }, }, }, }, }, } pointA, err := point.NewPoint(&configA) assert.Error(err).IsNil() err = pointA.Start() assert.Error(err).IsNil() ochConnInput := []byte("The data to be returned to inbound server.") ochConnOutput := bytes.NewBuffer(make([]byte, 0, 1024)) och := &proxymocks.OutboundConnectionHandler{ ConnInput: bytes.NewReader(ochConnInput), ConnOutput: ochConnOutput, } connhandler.RegisterOutboundConnectionHandlerFactory("mock_och", och) configB := mocks.Config{ PortValue: portB, InboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "vmess", SettingsValue: &json.Inbound{ AllowedClients: []*json.ConfigUser{ &json.ConfigUser{Id: testAccount}, }, }, }, OutboundConfigValue: &mocks.ConnectionConfig{ ProtocolValue: "mock_och", SettingsValue: nil, }, } pointB, err := point.NewPoint(&configB) assert.Error(err).IsNil() err = pointB.Start() assert.Error(err).IsNil() dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) ich.Communicate(v2net.NewPacket(dest, nil, true)) assert.Bytes(ichConnInput).Equals(ochConnOutput.Bytes()) assert.Bytes(ichConnOutput.Bytes()).Equals(ochConnInput) }
func (server *SocksServer) HandleConnection(connection net.Conn) error { defer connection.Close() reader := v2net.NewTimeOutReader(4, connection) auth, auth4, err := protocol.ReadAuthentication(reader) if err != nil && !errors.HasCode(err, 1000) { log.Error("Socks failed to read authentication: %v", err) return err } var dest v2net.Destination // TODO refactor this part if errors.HasCode(err, 1000) { result := protocol.Socks4RequestGranted if auth4.Command == protocol.CmdBind { result = protocol.Socks4RequestRejected } socks4Response := protocol.NewSocks4AuthenticationResponse(result, auth4.Port, auth4.IP[:]) connection.Write(socks4Response.ToBytes(nil)) if result == protocol.Socks4RequestRejected { return errors.NewInvalidOperationError("Socks4 command " + strconv.Itoa(int(auth4.Command))) } dest = v2net.NewTCPDestination(v2net.IPAddress(auth4.IP[:], auth4.Port)) } else { expectedAuthMethod := protocol.AuthNotRequired if server.config.IsPassword() { expectedAuthMethod = protocol.AuthUserPass } if !auth.HasAuthMethod(expectedAuthMethod) { authResponse := protocol.NewAuthenticationResponse(protocol.AuthNoMatchingMethod) err = protocol.WriteAuthentication(connection, authResponse) if err != nil { log.Error("Socks failed to write authentication: %v", err) return err } log.Warning("Socks client doesn't support allowed any auth methods.") return errors.NewInvalidOperationError("Unsupported auth methods.") } authResponse := protocol.NewAuthenticationResponse(expectedAuthMethod) err = protocol.WriteAuthentication(connection, authResponse) if err != nil { log.Error("Socks failed to write authentication: %v", err) return err } if server.config.IsPassword() { upRequest, err := protocol.ReadUserPassRequest(reader) if err != nil { log.Error("Socks failed to read username and password: %v", err) return err } status := byte(0) if !upRequest.IsValid(server.config.Username, server.config.Password) { status = byte(0xFF) } upResponse := protocol.NewSocks5UserPassResponse(status) err = protocol.WriteUserPassResponse(connection, upResponse) if err != nil { log.Error("Socks failed to write user pass response: %v", err) return err } if status != byte(0) { err = errors.NewAuthenticationError(upRequest.AuthDetail()) log.Warning(err.Error()) return err } } request, err := protocol.ReadRequest(reader) if err != nil { log.Error("Socks failed to read request: %v", err) return err } response := protocol.NewSocks5Response() if request.Command == protocol.CmdBind || request.Command == protocol.CmdUdpAssociate { response := protocol.NewSocks5Response() response.Error = protocol.ErrorCommandNotSupported err = protocol.WriteResponse(connection, response) if err != nil { log.Error("Socks failed to write response: %v", err) return err } log.Warning("Unsupported socks command %d", request.Command) return errors.NewInvalidOperationError("Socks command " + strconv.Itoa(int(request.Command))) } response.Error = protocol.ErrorSuccess response.Port = request.Port response.AddrType = request.AddrType switch response.AddrType { case protocol.AddrTypeIPv4: copy(response.IPv4[:], request.IPv4[:]) case protocol.AddrTypeIPv6: copy(response.IPv6[:], request.IPv6[:]) case protocol.AddrTypeDomain: response.Domain = request.Domain } err = protocol.WriteResponse(connection, response) if err != nil { log.Error("Socks failed to write response: %v", err) return err } dest = request.Destination() } ray := server.vPoint.DispatchToOutbound(v2net.NewTCPPacket(dest)) input := ray.InboundInput() output := ray.InboundOutput() var readFinish, writeFinish sync.Mutex readFinish.Lock() writeFinish.Lock() go dumpInput(reader, input, &readFinish) go dumpOutput(connection, output, &writeFinish) writeFinish.Lock() return nil }