public RemotePeer Connect(EndPoint remoteEndpoint) { RemotePeer remotePeer = new RemotePeer() { ConnectionState = ConnectState.WaitingForChallenge, ChallengeSeed = RandomUtils.GetULong(Constants.USE_CRYPTO_RANDOM), RemoteEndpoint = remoteEndpoint }; PendingPeers.Add(new ConnectKey(remoteEndpoint, remotePeer.ChallengeSeed), remotePeer); ConnectionRequestPacket packet = new ConnectionRequestPacket(remotePeer.ChallengeSeed); SendPacket(packet, remotePeer); for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++) { _network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket() { Packet = packet, LocalPeer = this, RemotePeer = remotePeer }); } return(remotePeer); }
public void OnReceivePacket(IPEndPoint ipEndpoint, PacketType packetType, Stream stream) { switch (packetType) { case PacketType.ConnectionRequest: ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); connectionRequestPacket.Deserialize(stream); CheckAndSendChallengeRequest(ipEndpoint, connectionRequestPacket.payload); break; case PacketType.ChallengeRequest: ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket(); challengeRequestPacket.Deserialize(stream); CheckAndSendChallengeResponse(ipEndpoint, challengeRequestPacket.payload); break; case PacketType.ChallengeResponse: ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket(); challengeResponsePacket.Deserialize(stream); CheckResult(ipEndpoint, challengeResponsePacket.payload); break; case PacketType.Connected: if (!isServer && currentState == State.RespondingChallenge) { currentState = State.Connected; } break; } }
private void SendConnectionRequest() { ConnectionRequestPacket request = new ConnectionRequestPacket(); request.payload.clientSalt = UlongRandom.GetRandom(); SendToServer(request); }
public void OnReceivePacket(IPEndPoint ipEndpoint, PacketType packetType, Stream stream) { switch (packetType) { case PacketType.ConnectionRequest: { ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); connectionRequestPacket.Deserialize(stream); CheckAndSendChallengeRequest(ipEndpoint, connectionRequestPacket.payload); } break; case PacketType.ChallengeRequest: { ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket(); challengeRequestPacket.Deserialize(stream); CheckAndSendChallengeResponse(ipEndpoint, challengeRequestPacket.payload); } break; case PacketType.ChallengeResponse: { ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket(); challengeResponsePacket.Deserialize(stream); CheckResult(ipEndpoint, challengeResponsePacket.payload); } break; case PacketType.Connected: { FinishHandShake(); } break; } }
void OnConnectionRequest(Stream stream, IPEndPoint ipEndPoint) { if (NetworkManager.Instance.isServer) { ConnectionRequestPacket packet = new ConnectionRequestPacket(); packet.Deserialize(stream); long clientSalt = packet.payload.clientSalt; long serverSalt = -1; uint id = 0; if (ipToId.ContainsKey(ipEndPoint)) { id = ipToId[ipEndPoint]; serverSalt = clients[id].serverSalt; } else { serverSalt = (long)Random.Range(0, float.MaxValue); id = AddClient(clientSalt, serverSalt, ipEndPoint); } if (id == DECLINED) { SendDeclinedRequest(ipEndPoint); } else { SendChallengeRequest(id, clientSalt, serverSalt, ipEndPoint); } } }
void SendConnectionRequest() { ConnectionRequestPacket packet = new ConnectionRequestPacket(); packet.payload.clientSalt = clientSalt; PacketManager.Instance.SendPacketToServer(packet); }
private void SendConnectionRequest() { ConnectionRequestPacket requestPacket = new ConnectionRequestPacket(); requestPacket.payload.clientSalt = clientSalt; Debug.Log("SendConnectionRequest"); SendToServer(requestPacket); }
private void OnConnectionRequest(IPEndPoint iPEndPoint, Stream stream) { Debug.Log("OnConnectionRequest"); ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); connectionRequestPacket.Deserialize(stream); SendChallengeRequest(iPEndPoint, connectionRequestPacket.payload); }
void SendConnectionRequest() { Debug.Log("Enviando Connection Request"); ConnectionRequestPacket packet = new ConnectionRequestPacket(); packet.payload = clientDirt; PacketsManager.Instance.SendPacket(packet, objectId); }
void SendConnectionRequest() { ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); ConnectionRequestData connectionRequestData; connectionRequestData.clientSalt = saltGeneratedByClient; connectionRequestPacket.Payload = connectionRequestData; PacketsManager.Instance.SendPacket(connectionRequestPacket); }
private void SendConnectionRequest() { Debug.Log("Sending connection request"); ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); connectionRequestPacket.payload.clientSalt = (ulong)UnityEngine.Random.Range(0, ulong.MaxValue); SendToServer(connectionRequestPacket); }
public void TestConnectionRequestPacket() { Random rnd = new Random(0); ulong val = (ulong)rnd.Next(int.MaxValue); ConnectionRequestPacket packet1 = new ConnectionRequestPacket(val); byte[] output = new byte[1024]; int written = packet1.Write(output, null); ConnectionRequestPacket packet2 = new ConnectionRequestPacket(); packet2.Read(output, written); Assert.AreEqual(packet1.ClientRandom, packet2.ClientRandom); }
public void ConnectToServer(string ipAddress, int port, string username, string password) { if (_serverConnection != null && _serverConnection.Status == NetConnectionStatus.Connected) { throw new Exception("Client is already connected to a server."); } ConnectionRequestPacket packet = new ConnectionRequestPacket { Username = username, Password = password }; NetOutgoingMessage message = _client.CreateMessage(); MemoryStream stream = new MemoryStream(); Serializer.Serialize(stream, packet); message.Write(stream.ToArray()); _serverConnection = _client.Connect(ipAddress, port, message); _logger.Info($"Connecting to server: {ipAddress + ":" + port}"); }
public void ReceivingConnectionRequest(Stream stream, IPEndPoint iPEnd) { if (NetworkManager.Instance.isServer) { ConnectionRequestPacket requestPacket = new ConnectionRequestPacket(); requestPacket.Deserialize(stream); long cSalt = requestPacket.payload.clientSalt; long sSalt = -1; int cId = -1; if (NetworkManager.Instance.ipToId.ContainsKey(iPEnd)) { cId = NetworkManager.Instance.ipToId[iPEnd]; Client client = NetworkManager.Instance.clients[cId]; sSalt = NetworkManager.Instance.clients[cId]._serverSalt; } else { sSalt = NetworkManager.Instance.rnd.Next(999999999); cId = NetworkManager.Instance.AddClient(cSalt, sSalt, iPEnd); } SendChallengeRequest(requestPacket.payload, cId, cSalt, sSalt, iPEnd); } }
void OnRecieve(ushort type, Stream stream, IPEndPoint ip) { switch (type) { case (ushort)PacketType.ConnectionRequest: { ConnectionRequestPacket packet = new ConnectionRequestPacket(); packet.Deserialize(stream); AddNewClient(ip, packet.payload); break; } case (ushort)PacketType.ChallengeRequest: { onConectionRequest = false; ChallengeRequestPacket packet = new ChallengeRequestPacket(); packet.Deserialize(stream); serverDirt = packet.payload; DoChallenge(); break; } case (ushort)PacketType.ChallengeResponse: { ChallengeResponsePacket packet = new ChallengeResponsePacket(); packet.Deserialize(stream); CheckChallengeRecieved(ip, packet.payload); break; } case (ushort)PacketType.Conected: OnConected(); break; } }
private void HandlePacket(byte[] data, int length, EndPoint fromEndpoint) { if (length < 1) { // TODO: Shit hit the fan } PacketType type = (PacketType)data[0]; switch (type) { case PacketType.ConnectionRequest: { ConnectionRequestPacket connectionRequest = new ConnectionRequestPacket(); if (connectionRequest.Read(data, length) && !PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, connectionRequest.ClientRandom))) { ulong localSessionPart = RandomUtils.GetULong(Constants.USE_CRYPTO_RANDOM); RemotePeer peer = new RemotePeer() { ChallengeData = connectionRequest.ClientRandom, RemoteEndpoint = fromEndpoint, ConnectionState = ConnectState.WaitingForChallengeResponse, ChallengeSeed = localSessionPart, ChallengeResult = localSessionPart ^ connectionRequest.ClientRandom, LastIncomingMessageDate = DateTime.Now }; PendingPeers.Add(new ConnectKey(fromEndpoint, connectionRequest.ClientRandom), peer); ChallengePacket packet = new ChallengePacket(peer.ChallengeData, peer.ChallengeSeed); SendPacket(packet, peer); for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++) { _network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket() { Packet = packet, LocalPeer = this, RemotePeer = peer }); } } } break; case PacketType.Challenge: { ChallengePacket challenge = new ChallengePacket(); if (challenge.Read(data, length) && PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, challenge.ClientRandom))) { RemotePeer peer = PendingPeers[new ConnectKey(fromEndpoint, challenge.ClientRandom)]; if (peer.ConnectionState == ConnectState.WaitingForChallenge) { peer.CreateChannels(_network.ChannelTypes); peer.LastIncomingMessageDate = DateTime.Now; peer.ChallengeData = challenge.ServerRandom; peer.ChallengeResult = peer.ChallengeData ^ peer.ChallengeSeed; peer.ConnectionState = ConnectState.Connected; PendingPeers.Remove(new ConnectKey(fromEndpoint, challenge.ClientRandom)); Connected.Add(fromEndpoint, peer); incomingEvents.Enqueue(new NetworkEvent() { EventType = EventType.Connect, Packet = null, RemotePeer = peer, LocalPeer = this }); ChallengeResponsePacket packet = new ChallengeResponsePacket(peer.ChallengeSeed, peer.ChallengeData, peer.ChallengeResult); SendPacket(packet, peer); for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++) { _network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket() { Packet = packet, LocalPeer = this, RemotePeer = peer }); } } } } break; case PacketType.ChallengeResponse: { ChallengeResponsePacket challengeResponse = new ChallengeResponsePacket(); if (challengeResponse.Read(data, length) && PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, challengeResponse.ClientRandom))) { RemotePeer peer = PendingPeers[new ConnectKey(fromEndpoint, challengeResponse.ClientRandom)]; if (peer.ConnectionState == ConnectState.WaitingForChallengeResponse && peer.ChallengeResult == challengeResponse.ChallengeResponse) { peer.CreateChannels(_network.ChannelTypes); peer.LastIncomingMessageDate = DateTime.Now; peer.ConnectionState = ConnectState.Connected; PendingPeers.Remove(new ConnectKey(fromEndpoint, challengeResponse.ClientRandom)); Connected.Add(fromEndpoint, peer); incomingEvents.Enqueue(new NetworkEvent() { EventType = EventType.Connect, Packet = null, RemotePeer = peer, LocalPeer = this }); } } } break; case PacketType.Data: { ChanneledPacket channeledPacket = new ChanneledPacket(); if (channeledPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint)) { RemotePeer peer = Connected[fromEndpoint]; if (peer.ConnectionState == ConnectState.Connected) { ChanneledPacket incomingPacket = peer.Channels[channeledPacket.Channel].HandleIncomingMessagePoll(data, length, out bool hasMore); while (incomingPacket != null) { peer.LastIncomingMessageDate = DateTime.Now; incomingEvents.Enqueue(new NetworkEvent() { EventType = EventType.Data, Packet = incomingPacket, RemotePeer = peer, LocalPeer = this }); if (!hasMore) { break; } incomingPacket = peer.Channels[channeledPacket.Channel].HandlePoll(); } } } } break; case PacketType.Disconnect: { DisconnectPacket disconnectPacket = new DisconnectPacket(); if (disconnectPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint)) { RemotePeer peer = Connected[fromEndpoint]; peer.ConnectionState = ConnectState.Disconnected; Connected.Remove(fromEndpoint); incomingEvents.Enqueue(new NetworkEvent() { EventType = EventType.Disconnect, Packet = null, RemotePeer = peer, LocalPeer = this }); } } break; case PacketType.Ack: { AckPacket ackPacket = new AckPacket(); if (ackPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint)) { RemotePeer peer = Connected[fromEndpoint]; if (peer.Channels[ackPacket.Channel].SupportsAck) { peer.Channels[ackPacket.Channel].HandleAck(ackPacket); } } } break; } }
void ReceiveConnectionData(ushort packetTypeIndex, IPEndPoint ipEndPoint, Stream stream) { switch ((PacketType)packetTypeIndex) { case PacketType.ChallengeRequest: if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.RequestingConnection) { ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket(); challengeRequestPacket.Deserialize(stream); challengeResultGeneratedByClient = saltGeneratedByClient ^ challengeRequestPacket.Payload.serverSalt; clientConnectionState = ClientConnectionState.SendingChallengeResponse; } break; case PacketType.ConnectionAccepted: if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.SendingChallengeResponse) { ConnectionAcceptedPacket connectionAcceptedPacket = new ConnectionAcceptedPacket(); connectionAcceptedPacket.Deserialize(stream); UdpNetworkManager.Instance.SetClientID(connectionAcceptedPacket.Payload.clientID); onClientConnectedCallback?.Invoke(connectionAcceptedPacket.Payload.clientsInSession); onClientConnectedCallback = null; clientConnectionState = ClientConnectionState.Connected; } break; case PacketType.ClientJoined: if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.Connected) { ClientJoinedPacket clientJoinedPacket = new ClientJoinedPacket(); clientJoinedPacket.Deserialize(stream); OnOtherClientJoined.Invoke(clientJoinedPacket.Payload.clientID); } break; case PacketType.ConnectionRequest: if (UdpNetworkManager.Instance.IsServer && !udpClientsIDs.ContainsKey(ipEndPoint)) { if (!udpPendingClientsData.ContainsKey(ipEndPoint)) { ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket(); connectionRequestPacket.Deserialize(stream); AddPendingClient(ipEndPoint, connectionRequestPacket.Payload.clientSalt); } UdpPendingClientData udpPendingClientData = udpPendingClientsData[ipEndPoint]; SendChallengeRequest(udpPendingClientData); } break; case PacketType.ChallengeResponse: if (UdpNetworkManager.Instance.IsServer) { if (udpPendingClientsData.ContainsKey(ipEndPoint)) { ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket(); UdpPendingClientData udpPendingClientData = udpPendingClientsData[ipEndPoint]; challengeResponsePacket.Deserialize(stream); long serverResult = udpPendingClientData.clientSalt ^ udpPendingClientData.serverSalt; if (challengeResponsePacket.Payload.result == serverResult) { ClientJoinedPacket clientJoinedPacket = new ClientJoinedPacket(); ClientJoinedData clientJoinedData; clientJoinedData.clientID = ClientID; clientJoinedPacket.Payload = clientJoinedData; PacketsManager.Instance.SendPacket(clientJoinedPacket, null, 0, 0, reliable: true); AddClient(ipEndPoint); RemovePendingClient(ipEndPoint); OnClientAddedByServer?.Invoke(udpClientsIDs[ipEndPoint]); } } if (udpClientsIDs.ContainsKey(ipEndPoint)) { SendConnectionAccepted(udpClientsData[udpClientsIDs[ipEndPoint]]); } } break; } }