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.NewDestination(v2net.NetTCP, address) }
func (config VNextConfig) ToVNextServer() 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)) } network := v2net.NetTCP if config.Network == "udp" { network = v2net.NetUDP } return VNextServer{ Destination: v2net.NewDestination(network, v2net.IPAddress(ip, config.Port)), Users: users, } }
func (request *VMessRequest) Destination() *v2net.Destination { return v2net.NewDestination(request.Command, request.Address) }
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\", \"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.NewDestination(v2net.NetTCP, v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) ich.Communicate(dest) 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.NewDestination(v2net.NetTCP, 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 }