public void CollectStatWhenGiven2ip2icmp1tcp5udpPacketsThenCountOfPacketsIsRight() {
     NetworkPacket[] packets = new NetworkPacket[10];
     packets[0] = new IPPacket();
     packets[1] = new IPPacket();
     packets[2] = new ICMPPacket();
     packets[3] = new ICMPPacket();
     packets[4] = new TCPPacket();
     packets[5] = new UDPPacket();
     packets[6] = new UDPPacket();
     packets[7] = new UDPPacket();
     packets[8] = new UDPPacket();
     packets[9] = new UDPPacket();
     Firewall fw = new Firewall(new FilterMock(),
         new DistributorMock());
     CollectStatCommand clltStat = new CollectStatCommand();
     Assert.AreEqual(fw.Statistics["ip"], 0);
     Assert.AreEqual(fw.Statistics["icmp"], 0);
     Assert.AreEqual(fw.Statistics["tcp"], 0);
     Assert.AreEqual(fw.Statistics["udp"], 0);
     Assert.AreEqual(fw.Statistics["total"], 0);
     foreach (var packet in packets) {
         clltStat.DoWithPacket(fw, packet);
     }
     Assert.AreEqual(fw.Statistics["ip"], 2);
     Assert.AreEqual(fw.Statistics["icmp"], 2);
     Assert.AreEqual(fw.Statistics["tcp"], 1);
     Assert.AreEqual(fw.Statistics["udp"], 5);
     Assert.AreEqual(fw.Statistics["total"], 10);
 }
Ejemplo n.º 2
0
 /// <summary>
 /// Sends the message.
 /// </summary>
 /// <param name="message">The message.</param>
 public void SendMessage(string message)
 {
     NetworkPacket packet = new NetworkPacket();
     packet.AllButTargets = true;
     packet.DataWriter.Write(message);
     this.Send(packet);
 }
Ejemplo n.º 3
0
        public override void HandlePacket(ref NetworkPacket Packet, ref SteamClient Client)
        {
            redBuffer Buffer = new redBuffer();

            // We send the length first.
            Client.UpdateFriendslist();
            Buffer.WriteUInt32((UInt32)Client.FriendsList.Count);

            foreach(SteamFriend Friend in Client.FriendsList)
            {
                Buffer.WriteUInt32((UInt32)Friend.Status);
                Buffer.WriteBlob(Friend.Username);
                Buffer.WriteUInt64(Friend.XUID);
            }

            Packet.CreatePacket(Packet._TransactionID, 200, Buffer, Client);

            // Clear the buffer.
            Buffer = new redBuffer();

            // Serialize the packet.
            Packet.Serialize(ref Buffer, Client);

            // Send the response.
            SteamServer.Send(Client.ClientID, Buffer.GetBuffer());
        }
    public void WriteMessage(byte msg)
    {
        NetworkPacket packet = new NetworkPacket();

        packet.Write(msg);
        peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed);
    }
Ejemplo n.º 5
0
 /// <summary>
 /// Sends the message.
 /// </summary>
 /// <param name="message">The message.</param>
 public void SendMessage(string message)
 {
     NetworkPacket packet = new NetworkPacket();
     packet.AllButTargets = true;
     packet.Targets = this.ResendToSender ? null : new int[] { this.Client.ID };
     packet.DataWriter.Write(message);
     this.Send(packet);
 }
 /// <summary>
 /// Delivers the packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 protected void DeliverPacket(NetworkPacket packet)
 {
     INetworkServerService service;
     if (this.Services.TryGetValue(packet.Service, out service))
     {
         service.Receive(packet);
     }
 }
 public void SendGameParamUpdate(GameParamUpdate update)
 {
     if (inSession) {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.GameParamUpdateID);
         packet.Write(update);
         peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
Ejemplo n.º 8
0
 public override void Life()
 {
     while (this.stayAlive)
     {
         String msg = this.ReceiveData();
         if(msg != null && msg != "")
         {
             if(this.notifier != null && this.stayAlive)
             {
                 NetworkPacket np = new NetworkPacket(msg, this.id);
                 this.notifier.PutEvent(np);
             }
         }
     }
 }
Ejemplo n.º 9
0
    private void DiscoveryListener()
    {
      IPEndPoint l_receiveAddress = new IPEndPoint(IPAddress.Any, 0);
      while (this.m_serviceListening) {
        byte[] dataPacket = this.m_discoveryService.Receive(ref l_receiveAddress);
        if (l_receiveAddress.Address == IPAddress.Any) {
          Debug.Warn("Invalid response address '{0}'.", l_receiveAddress);
          continue;
        }

        NetworkPacket l_receivedPacket = NetworkPacket.Parser.ParseFrom(dataPacket);
        if (l_receivedPacket == null || l_receivedPacket.Type != MessageType.ServiceConfigurationRequest) {
          Debug.Error("Invalid network packet.");
          continue;
        }

        try {
          ConfigRequest l_clientRequest = ConfigRequest.Parser.ParseFrom(l_receivedPacket.Message);
          Debug.Log("Client request ServiceId={0} Port={1}.", l_clientRequest.ServiceId, l_clientRequest.Port);

          ConfigResponse l_responseMessage = new ConfigResponse();
          l_responseMessage.ServiceId = l_clientRequest.ServiceId;
          l_responseMessage.IPAddress = this.m_serverAddress.Address.ToString();
          l_responseMessage.Port = this.m_serverAddress.Port;

          NetworkPacket l_responsePacket = new NetworkPacket();
          l_responsePacket.Type = MessageType.ServiceConfigurationResponse;
          // l_responsePacket.Message = Any.Pack(l_responseMessage, String.Empty);
          l_responsePacket.Message = l_responseMessage.ToByteString();

          l_receiveAddress.Port = l_clientRequest.Port;
          byte[] responseData = l_responsePacket.ToByteArray();
          int sendBytes = this.m_discoveryService.Send(responseData, responseData.Length, l_receiveAddress);

          Debug.Log("Response send to {0}, Bytes={1}.", l_receiveAddress, sendBytes);
        }
        catch (Exception ex) {
          Debug.Exception(ex);
          continue;
        }
      }
    }
Ejemplo n.º 10
0
        public override void HandlePacket(ref NetworkPacket Packet, ref SteamClient Client)
        {
            SteamMessage NewMessage = new SteamMessage();
            NewMessage.Deserialize(new redBuffer(Packet._Data));

            // Debug log.
            Log.Debug(String.Format("Got a message from {0}, forwarding to {1}", NewMessage.IM.FromXUID, NewMessage.IM.ToXUID));

            if (SteamServer.isClientConnected(SteamServer.FindClient(NewMessage.IM.ToXUID)))
            {
                if (!SteamServer.Clients[SteamServer.FindClient(NewMessage.IM.ToXUID)].EnqueueMessage(NewMessage))
                {
                    SteamServer.Send(Client.ClientID, NetworkPacket.QuickMessage(Packet._TransactionID, 403,
                                    "Too many messages are being sent to that client right now.", Client));
                }
            }
            else
            {
                SteamServer.Send(Client.ClientID, NetworkPacket.QuickMessage(Packet._TransactionID, 404,
                                    "The client is offline.", Client));
            }
        }
Ejemplo n.º 11
0
 void process_PacketReceived(NetworkPacket packet)
 {
     if (PacketReceived != null) // Relay the packet to the outer event.
     {
         Interlocked.Increment(ref nodeState.NodeInfo.NodeDetails.NetworkPacketsIn);
         PacketReceived(packet);
     }
 }
 /// <summary>
 /// Creates a new top players packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 private ArenaTopPlayersPacket(NetworkPacket packet)
     : base(packet, 4)
 {
 }
Ejemplo n.º 13
0
        public ListViewItem PackettoItem(PacketLogEntry logEntry)
        {
            // hash, protocol, direction, address, type, size
            string hash     = Utilities.BytestoHex(sha.ComputeHash(logEntry.Data), 0, 2, false);
            string protocol = logEntry.Protocol.ToString();

            // Network - Search / Search Req / Store ... - Component

            // Comm - Data / Ack / Syn

            // Rudp - Type - Component

            string name = "?";

            G2Header root = new G2Header(logEntry.Data);

            if (G2Protocol.ReadPacket(root))
            {
                if (logEntry.Protocol == TransportProtocol.Rudp)
                {
                    name = TransportProtocol.Rudp.ToString() + " - ";

                    name += GetVariableName(typeof(CommPacket), root.Name);

                    if (root.Name == CommPacket.Data)
                    {
                        CommData data = CommData.Decode(root);

                        name += " - " + Network.Core.GetServiceName(data.Service);
                    }
                }
                else
                {
                    name = GetVariableName(typeof(RootPacket), root.Name) + " - ";

                    if (root.Name == RootPacket.Comm)
                    {
                        RudpPacket commPacket = RudpPacket.Decode(root);

                        name += GetVariableName(typeof(RudpPacketType), commPacket.PacketType);
                    }

                    if (root.Name == RootPacket.Network)
                    {
                        NetworkPacket netPacket = NetworkPacket.Decode(root);

                        G2Header internalRoot = new G2Header(netPacket.InternalData);
                        if (G2Protocol.ReadPacket(internalRoot))
                        {
                            name += GetVariableName(typeof(NetworkPacket), internalRoot.Name);

                            uint             id   = 0;
                            G2ReceivedPacket wrap = new G2ReceivedPacket();
                            wrap.Root = internalRoot;

                            // search request / search acks / stores have component types
                            if (internalRoot.Name == NetworkPacket.SearchRequest)
                            {
                                SearchReq req = SearchReq.Decode(wrap);
                                id = req.Service;
                            }

                            if (internalRoot.Name == NetworkPacket.SearchAck)
                            {
                                SearchAck ack = SearchAck.Decode(wrap);
                                id = ack.Service;
                            }

                            if (internalRoot.Name == NetworkPacket.StoreRequest)
                            {
                                StoreReq store = StoreReq.Decode(wrap);
                                id = store.Service;
                            }

                            if (id != 0)
                            {
                                name += " - " + Network.Core.GetServiceName(id); // GetVariableName(typeof(ServiceID), id);
                            }
                        }
                    }
                }
            }

            string time = logEntry.Time.ToString("HH:mm:ss:ff");

            string address = (logEntry.Address == null) ? "Broadcast" : logEntry.Address.ToString();

            return(new PacketListViewItem(logEntry, new string[] { time, protocol, address, name, logEntry.Data.Length.ToString(), hash }, logEntry.Direction == DirectionType.In));
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Send the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 /// <param name="serviceID">The service ID.</param>
 protected void Send(NetworkPacket packet, int serviceID)
 {
     if (this.Client != null && this.Client.IsConnected)
     {
         packet.Service = serviceID == Int32.MinValue ? this.ID : serviceID;
         this.Client.Send(packet);
     }
     else
     {
         this.OutgoingPackets.Enqueue(new Tuple<NetworkPacket, int>(packet, serviceID));
     }
 }
Ejemplo n.º 15
0
        public unsafe void StartClient()
        {
            // Initialize ENet
            Library.Initialize();
            _running = true;
            _client  = new Host();
            _client.Create();
            _peer = _client.Connect(_address);
            // Start thread for listening to incoming packets
            Task.Run(() =>
            {
                while (_running)
                {
                    var polled = false;
                    while (!polled)
                    {
                        if (_client.CheckEvents(out var netEvent) <= 0)
                        {
                            if (_client.Service(15, out netEvent) <= 0)
                            {
                                break;
                            }
                            polled = true;
                        }

                        switch (netEvent.Type)
                        {
                        case EventType.None:
                            break;

                        case EventType.Connect:
                            Debug.WriteLine("Client connected to ID: " + _peer.ID);
                            //SendLogin();
                            break;

                        case EventType.Disconnect:
                            Debug.WriteLine("Client disconnected server");
                            break;

                        case EventType.Timeout:
                            Debug.WriteLine("Client connection timeout");
                            break;

                        case EventType.Receive:
                            Debug.WriteLine("Packet received - Channel ID: " + netEvent.ChannelID + ", Data length: " + netEvent.Packet.Length);
                            // Convert packet data back to a INetworkPacket, notify subscribers
                            Parse(netEvent);
                            netEvent.Packet.Dispose();
                            break;
                        }
                    }
                }
                _client?.Flush();
            });
            // Start thread for sending outbound packets
            Task.Run(() =>
            {
                while (_running && !_outboundPackets.IsCompleted)
                {
                    NetworkPacket outboundPacket = null;
                    try
                    {
                        outboundPacket = _outboundPackets.Take();
                    }
                    catch (InvalidOperationException) { }

                    if (outboundPacket != null)
                    {
                        Debug.WriteLine("Sending packet");
                        var outboundNetworkPacket = default(Packet);
                        outboundNetworkPacket.Create(outboundPacket.ToByteArray(), PacketFlags.Reliable);
                        _peer.Send(0, ref outboundNetworkPacket);
                    }
                }
            }, _cancellationTokenSource.Token);
        }
 public void SendGameState(GameStates gameState)
 {
     if (inSession) {
         byte messageType;
         switch (gameState) {
             case GameStates.Paused: {
                 messageType = (byte)MessageType.GamePaused;
                 break;
             }
             case GameStates.Running: {
                 messageType = (byte)MessageType.GameRunning;
                 break;
             }
             default: {
                 return;
             }
         }
         NetworkPacket packet = new NetworkPacket();
         packet.Write(messageType);
         peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
Ejemplo n.º 17
0
        private void RecvThread()
        {
            while (Active)
            {
                try
                {
                    var from       = new IPEndPoint(0, 0);
                    var recvBuffer = udpClient.Receive(ref from);
                    if (recvBuffer == null || recvBuffer.Length == 0)
                    {
                        continue;
                    }

                    NetworkPacket packet = NetworkPacket.FromByteArray(recvBuffer);
                    if ((packet.from != remoteId && packet.from != 0) || (packet.to != localId && packet.to != 0))
                    {
                        continue;
                    }
                    switch (packet.packetType)
                    {
                    case PacketType.SYN:
                    case PacketType.SYN_ACK:
                        throw new InvalidOperationException();

                    case PacketType.FIN:
                        SendRawPacket(new NetworkPacket()
                        {
                            packetType = PacketType.FIN,
                            from       = localId,
                            to         = remoteId
                        });

                        Reset();
                        break;

                    case PacketType.Raw:
                        if (packet.channel != (byte)EStreamChannel.KEstreamChannelDiscovery)
                        {
                            throw new InvalidOperationException();
                        }

                        TypedMessage            msg     = TypedMessage.FromByteArray(packet.payload);
                        EStreamDiscoveryMessage msgType = (EStreamDiscoveryMessage)msg.messageType;
                        switch (msgType)
                        {
                        case EStreamDiscoveryMessage.KEstreamDiscoveryPingRequest:
                            msg.messageType = (byte)EStreamDiscoveryMessage.KEstreamDiscoveryPingResponse;
                            SendRawPacket(new NetworkPacket()
                            {
                                packetType = PacketType.Raw,
                                from       = packet.to,
                                to         = packet.from,
                                channel    = (byte)EStreamChannel.KEstreamChannelDiscovery,
                                payload    = msg.ToByteArray()
                            });
                            break;

                        default:
                            throw new InvalidOperationException();
                        }
                        break;

                    case PacketType.Reliable:
                    case PacketType.ReliableFragment:
                    case PacketType.Unreliable:
                    case PacketType.UnreliableFragment:
                        ChannelData channelData = channels.GetOrNew(packet.channel);
                        if (!channelData.receiveQueue.ContainsKey(packet.seq))
                        {
                            channelData.receiveQueue.Add(packet.seq, packet);
                            if (packet.seq < channelData.remoteSeq)
                            {
                                Console.WriteLine("WARNING! Late packet " + packet.seq + " we are already at " + channelData.remoteSeq);
                            }
                        }
                        else
                        {
                            Console.WriteLine("WARNING! Got a resend of " + packet.seq);
                        }

                        // TODO: Clear the recv queue
                        ushort?lastValidPacketSeq      = channelData.remoteSeq > 0 ? (ushort)(channelData.remoteSeq - 1) : (ushort?)null;
                        bool   droppedIncompletePacket = false;
                        foreach (NetworkPacket firstPacket in channelData.receiveQueue.Values)
                        {
                            if (firstPacket.seq < channelData.remoteSeq)
                            {
                                continue;
                            }
                            if (firstPacket.packetType == PacketType.ReliableFragment || firstPacket.packetType == PacketType.UnreliableFragment)
                            {
                                continue;
                            }

                            // Check if the packet has all the fragments
                            bool isComplete = true;
                            for (ushort neededSeq = firstPacket.seq; neededSeq <= firstPacket.seq + firstPacket.fragment; ++neededSeq)
                            {
                                if (!channelData.receiveQueue.ContainsKey(neededSeq))
                                {
                                    isComplete = false;
                                    break;
                                }
                                else
                                {
                                    lastValidPacketSeq = neededSeq;
                                }
                            }
                            if (!isComplete)
                            {
                                // The packet is not yet fully complete
                                if (firstPacket.packetType == PacketType.Unreliable)
                                {
                                    droppedIncompletePacket = true;
                                    continue;     // this is unreliable so check if maybe next packet is complete
                                }
                                else
                                {
                                    break;     // we cannot skip any packet on reliable transports
                                }
                            }

                            if (channelData.remoteSeq != firstPacket.seq)
                            {
                                Console.WriteLine("WARNING! Dropping unreliable packets! Jump from " + channelData.remoteSeq + " to " + firstPacket.seq + (droppedIncompletePacket ? " (previous incomplete)" : ""));
                            }

                            // We have a complete packet, receive it
                            List <NetworkPacket> reassembleList = new List <NetworkPacket>();
                            for (ushort seq = firstPacket.seq; seq <= firstPacket.seq + firstPacket.fragment; ++seq)
                            {
                                if (seq != firstPacket.seq)
                                {
                                    if (firstPacket.packetType == PacketType.Reliable)
                                    {
                                        Debug.Assert(channelData.receiveQueue[seq].packetType == PacketType.ReliableFragment);
                                    }
                                    else if (firstPacket.packetType == PacketType.Unreliable)
                                    {
                                        Debug.Assert(channelData.receiveQueue[seq].packetType == PacketType.UnreliableFragment);
                                    }
                                    else
                                    {
                                        Debug.Assert(false);
                                    }
                                }
                                reassembleList.Add(channelData.receiveQueue[seq]);
                            }
                            DataPacket dataPacket = ReassembleDataPacket(reassembleList);
                            try
                            {
                                OnPacketReceived?.Invoke(dataPacket);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e);
                            }
                            channelData.remoteSeq = (ushort)(firstPacket.seq + firstPacket.fragment + 1);
                        }

                        if ((packet.packetType == PacketType.Reliable || packet.packetType == PacketType.ReliableFragment) && lastValidPacketSeq.HasValue)
                        {
                            using (MemoryStream ms = new MemoryStream())
                                using (BinaryWriter writer = new BinaryWriter(ms))
                                {
                                    writer.Write(channelData.receiveQueue[lastValidPacketSeq.Value].timestamp);
                                    writer.Flush();

                                    SendRawPacket(new NetworkPacket()
                                    {
                                        packetType = PacketType.ReliableACK,
                                        from       = localId,
                                        to         = remoteId,
                                        channel    = packet.channel,
                                        seq        = lastValidPacketSeq.Value,
                                        payload    = ms.ToArray()
                                    });
                                }
                        }
                        break;

                    case PacketType.ReliableACK:
                        //Console.WriteLine("ACKed channel=" + packet.channel + ", seq=" + packet.seq);
                        // TODO
                        break;
                    }
                }
                catch (SocketException)
                {
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
        }
Ejemplo n.º 18
0
 public virtual void HandlePacket(ref NetworkPacket Packet, ref SteamClient Client)
 {
 }
Ejemplo n.º 19
0
 public void Send_reliable_Message(NetworkPacket np)
 {
     np.Packet_Id = Packet_Counter;
     client.GetStream().Write(np.ToByteArray(), 0, (int)np.Packet_Length + 8);
     Packet_Counter++;
 }
Ejemplo n.º 20
0
    private void ClientMessageReceived(NetworkClient senderClient, NetworkPacket receivedPacket)
    {
      NetworkClient requestedUser = this.GetClientFromId(receivedPacket.ClientId);
      if (requestedUser == null) {
        Debug.Warn("Invalid ClientId={0} requested from ClientId={1}.", receivedPacket.ClientId, senderClient.ClientId);
        return;
      }

      Debug.Log("Forwarding message from ClientId={0} to ClientId={1}.", senderClient.ClientId, receivedPacket.ClientId);
      requestedUser.ForwardNetworkPacket(senderClient.ClientId, receivedPacket);
    }
Ejemplo n.º 21
0
    private void DiscoverDispatcher_Tick(object sender, EventArgs args)
    {
      if (this.m_sendRequests > MAX_RETRIES) {
        Debug.Error("Could not discover network server. Sended {0} discovery requests.", this.m_sendRequests);

        this.Stop(true);
        this.onDiscoveryFailed?.Invoke(this.m_sendRequests);
        return;
      }

      ConfigRequest l_requestMessage = new ConfigRequest();
      l_requestMessage.Port = this.m_responsePort;
      l_requestMessage.ServiceId = this.m_serviceId;

      NetworkPacket l_requestPacket = new NetworkPacket();
      l_requestPacket.Type = MessageType.ServiceConfigurationRequest;
      l_requestPacket.Message = l_requestMessage.ToByteString();

      byte[] requestData = l_requestPacket.ToByteArray();
      int sendBytesCount = this.m_discoverClient.Send(requestData, requestData.Length, this.m_requestAddress);

      Debug.Log("Send {0}. Discovery request Address={1} Bytes={2}.", this.m_sendRequests, this.m_requestAddress, sendBytesCount);
      this.m_sendRequests++;
    }
Ejemplo n.º 22
0
        private void ReceivePacketData(NetworkPacket packet)
        {
            if (packet.Command == 0x7E)
            {
                if (RequiresVersion)
                {
                    var format = new ClientVersion();
                    Send(format);

                    RequiresVersion = false;
                }

                Send(new CreateAccount(User, Pass));
                State = ServerState.Creating;

                Thread.Sleep(5000);
            }
            else if (packet.Command == 0x02)
            {
                if (State == ServerState.Created)
                {
                    State = ServerState.World;
                    Thread.Sleep(5000);
                    Send(new Login(User, Pass));
                    return;
                }

                if (State == ServerState.Creating)
                {
                    Send(new CreateAisling());
                    State = ServerState.Created;
                }
            }
            else if (packet.Command == 0x00)
            {
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
                {
                    _reader.Position--;
                }

                var type = _reader.ReadByte();

                if (type == 0)
                {
                    var serverTableCrc = _reader.ReadUInt32();
                    var seed           = _reader.ReadByte();
                    var salt           = _reader.ReadBytes(_reader.ReadByte());

                    _encryption = new SecurityProvider(
                        new SecurityParameters(seed, salt));

                    Send(new EncryptionReceived(0));
                }
            }
            else if (packet.Command == 0x03)
            {
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
                {
                    _reader.Position--;
                }

                var address = _reader.ReadBytes(4);
                var port    = _reader.ReadUInt16();

                _reader.Position++;

                var seed = _reader.ReadByte();
                var key  = _reader.ReadStringA();

                var name     = _reader.ReadStringA();
                var socketid = _reader.ReadUInt32();

                _encryption = new SecurityProvider(new SecurityParameters(seed, Encoding.ASCII.GetBytes(key)));
                {
                    Array.Reverse(address);
                }

                _socket.Close();
                Connect(address, port);

                State = ServerState.Login;

                Send(new RedirectRequest(seed, key, name, socketid));
            }
            else if (packet.Command == 0x05)
            {
                State = ServerState.World;
                Connections++;
            }
        }
        void C2S_CS_CREATE_CHARACTER(NetworkPacket packet)
        {
            var db       = ServiceContainer.GetService <IDatabase>();
            var ccItems  = GameResources.Instance.CCItemSets;
            var universe = GameResources.Instance.Universe;
            var map      = ServiceContainer.GetService <IMapLoader>().GetPersistentMap(universe.EntryWorld.worldID);
            var start    = map.Find <PlayerStart>(playerStart => playerStart.NavigationTag.Equals(universe.EntryPortal.Tag));

            if (start == null)
            {
                throw new NullReferenceException("Entry portal is null");
            }

            var lod0      = packet.ReadByteArray();
            var lod1      = packet.ReadByteArray();
            var lod2      = packet.ReadByteArray();
            var lod3      = packet.ReadByteArray();
            var name      = packet.ReadString();
            var archeType = packet.ReadInt32();

            var skillDeck = new DB_SkillDeck();

            skillDeck.Id    = db.Characters.AllocateSkillDeckID();
            skillDeck.mName = name; //TODO investigate - probably wrong
            for (var i = 0; i < 5; i++)
            {
                skillDeck.mSkills.Add(packet.ReadInt32());
            }

            var shieldIndicator = packet.ReadInt32();

            Debug.Log("Shield: " + shieldIndicator);
            //Lods parsing
            Array.Reverse(lod0);
            Array.Reverse(lod1);
            Array.Reverse(lod2);
            Array.Reverse(lod3);
            //lod0
            var rightGauntletColour1 = lod0[5];
            var rightGauntletColour2 = lod0[6];
            var leftGauntletColour1  = lod0[7];
            var leftGauntletColour2  = lod0[8];
            var rightGloveColour1    = lod0[9];
            var rightGloveColour2    = lod0[10];
            var leftGloveColour1     = lod0[11];
            var leftGloveColour2     = lod0[12];
            //Lod0 rest
            var voiceId          = lod0[0]; //
            var rightArmTattooId = (byte)(lod0[3] & 0x0F);
            var chestTattooId    = (byte)(lod0[4] & 0x0F);
            var leftArmTattooId  = (byte)((lod0[4] & 0xF0) >> 4);
            //Lod1
            var shinRightColour1     = lod1[0];
            var shinRightColour2     = lod1[1];
            var shinLeftColour1      = lod1[2];
            var shinLeftColour2      = lod1[3];
            var thighRightColour1    = lod1[4];
            var thighRightColour2    = lod1[5];
            var thighLeftColour1     = lod1[6];
            var thighLeftColour2     = lod1[7];
            var beltColour1          = lod1[8];
            var beltColour2          = lod1[9];
            var rightShoulderColour1 = lod1[10];
            var rightShoudlerColour2 = lod1[11];
            var leftShoulderColour1  = lod1[12];
            var leftShoulderColour2  = lod1[13];
            var helmetColour1        = lod1[14];
            var helmetColour2        = lod1[15];
            var shoesColour1         = lod1[16];
            var shoesColour2         = lod1[17];
            var pantsColour1         = lod1[18];
            var pantsColour2         = lod1[19];
            //Lod2
            var rangedWeaponId  = (byte)(((lod2[1] & 0x0F) << 2) | ((lod2[2] & 0xC0) >> 6));
            var shieldId        = (byte)(((lod2[2] & 0x3F) << 2) | ((lod2[3] & 0xC0) >> 6));
            var meleeWeaponId   = (byte)(((lod2[3] & 0x3F) << 2) | ((lod2[4] & 0xC0) >> 6));
            var shinRightId     = (byte)(lod2[4] & 0x3F);
            var shinLeftId      = (byte)((lod2[5] & 0xFC) >> 2);
            var thighRightId    = (byte)(((lod2[5] & 0x03) << 4) | ((lod2[6] & 0xF0) >> 4));
            var thighLeftId     = (byte)(((lod2[6] & 0x0F) << 2) | ((lod2[7] & 0xC0) >> 6));
            var beltId          = (byte)(lod2[7] & 0x3F);
            var gauntletRightId = (byte)((lod2[8] & 0xFC) >> 2);
            var gauntletLeftId  = (byte)(((lod2[8] & 0x03) << 4) | ((lod2[9] & 0xF0) >> 4));
            var shoulderRightId = (byte)(((lod2[9] & 0x0F) << 2) | ((lod2[10] & 0xC0) >> 6));
            var shoulderLeftId  = (byte)(lod2[10] & 0x3F);
            var helmetId        = (byte)((lod2[11] & 0xFC) >> 2);
            var shoesId         = (byte)(((lod2[11] & 0x03) << 5) | ((lod2[12] & 0xF8) >> 3));
            var pantsId         = (byte)(((lod2[12] & 0x07) << 4) | ((lod2[13] & 0xF0) >> 4));
            var gloveRightId    = (byte)(((lod2[13] & 0x0F) << 2) | ((lod2[14] & 0xC0) >> 6));
            var gloveLeftId     = (byte)(lod2[14] & 0x3F);
            //Lod3
            var chestArmourColour1 = (byte)(((lod3[0] & 0xFE) << 1) | (lod3[1] >> 7));
            var chestArmourColour2 = (byte)(((lod3[1] & 0x7F) << 1) | (lod3[2] >> 7));
            var chestArmourId      = (byte)((lod3[2] & 0x7E) >> 1);
            var chestClothColour1  = (byte)((lod3[2] << 7) | (lod3[3] >> 1));
            var chestClothColour2  = (byte)((lod3[3] << 7) | (lod3[4] >> 1));
            var chestClothID       = (byte)((lod3[4] << 7) | (lod3[5] >> 1));
            var hairColour         = (byte)((lod3[5] << 7) | (lod3[6] >> 1));
            var hairStyleId        = (byte)(((lod3[6] & 0x01) << 5) | (lod3[7] >> 3));
            var bodyColour         = (byte)((lod3[7] << 5) | (lod3[8] >> 3));
            var headTypeId         = (byte)(((lod3[8] & 0x07) << 4) | ((lod3[9] & 0xF0) >> 4));
            var bodyTypeId         = (byte)((lod3[9] & 0x0C) >> 2);
            var genderId           = (byte)((lod3[9] & 0x02) >> 1);
            var raceId             = (byte)(lod3[9] & 0x01);

            var dbChar = new DB_Character
            {
                Id                = db.Characters.AllocateCharacterID(),
                Name              = name,
                AccountID         = Account.UID,
                Dead              = (byte)Game_Pawn.EPawnStates.PS_ALIVE,
                FactionId         = 77467, //Enclave (correct?)
                LastUsedTimestamp = DatabaseUtility.GetUnixTimestamp(DateTime.Now),
                Location          = UnitConversion.ToUnreal(start.transform.position),
                Rotation          = start.Rotation,
                Money             = 0,
                worldID           = (int)map.ID
            };

            AppearancePackUtility.Pack(
                raceId, genderId, bodyTypeId, headTypeId, bodyColour, chestTattooId, leftArmTattooId, rightArmTattooId,
                hairStyleId, hairColour, voiceId, out dbChar.AppearancePart1, out dbChar.AppearancePart2);

            var items = new List <DB_Item>();

            if (shoesId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.ShoesSet, shoesId, dbChar.Id, shoesColour1, shoesColour2));
            }
            if (pantsId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.PantsSet, pantsId, dbChar.Id, pantsColour1, pantsColour2));
            }
            if (chestClothID > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.ChestClothesSet, chestClothID, dbChar.Id, chestClothColour1, chestClothColour2));
            }
            if (chestArmourId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.ChestSet, chestArmourId, dbChar.Id, chestArmourColour1, chestArmourColour2));
            }
            if (beltId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.BeltSet, beltId, dbChar.Id, beltColour1, beltColour2));
            }
            if (helmetId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.HeadGearSet, helmetId, dbChar.Id, helmetColour1, helmetColour2));
            }
            if (shinLeftId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.LeftShinSet, shinLeftId, dbChar.Id, shinLeftColour1, shinLeftColour2));
            }
            if (shinRightId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.RightShinSet, shinRightId, dbChar.Id, shinRightColour1, shinRightColour2));
            }
            if (shoulderLeftId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.LeftShoulderSet, shoulderLeftId, dbChar.Id, leftShoulderColour1, leftShoulderColour2));
            }
            if (shoulderRightId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.RightShoulderSet, shoulderRightId, dbChar.Id, rightShoulderColour1, rightShoudlerColour2));
            }
            if (thighLeftId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.LeftThighSet, thighLeftId, dbChar.Id, thighLeftColour1, thighLeftColour2));
            }
            if (thighRightId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.RightThighSet, thighRightId, dbChar.Id, thighRightColour1, thighRightColour2));
            }
            if (gloveLeftId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.LeftGloveSet, gloveLeftId, dbChar.Id, leftGloveColour1, leftGloveColour2));
            }
            if (gloveRightId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.RightGloveSet, gloveRightId, dbChar.Id, rightGloveColour1, rightGloveColour2));
            }
            if (gauntletLeftId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.LeftGauntletSet, gauntletLeftId, dbChar.Id, leftGauntletColour1, leftGauntletColour2));
            }
            if (gauntletRightId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.RightGauntletSet, gauntletRightId, dbChar.Id, rightGauntletColour1, rightGauntletColour2));
            }
            if (meleeWeaponId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.MainWeaponSet, meleeWeaponId, dbChar.Id, 0, 0));
            }
            if (rangedWeaponId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.MainWeaponSet, rangedWeaponId, dbChar.Id, 0, 0));
            }
            if (shieldId > 0)
            {
                items.Add(CreateDBItemFromItemSet(ccItems.OffhandWeaponSet, shieldId, dbChar.Id, 0, 0));
            }

            var charSheet = new DB_CharacterSheet
            {
                ClassId             = archeType,
                ExtraBodyPoints     = 0,
                ExtraMindPoints     = 0,
                ExtraFocusPoints    = 0,
                FamePoints          = 0,
                Health              = 100,
                PepPoints           = 0,
                SelectedSkilldeckID = skillDeck.Id
            };

            if (!db.Characters.Save(new Database.DBPlayerCharacter(dbChar, charSheet)) ||
                !db.Characters.Save(skillDeck) ||
                !db.Characters.Save(items))
            {
                Debug.LogError("Error saving newly created character for " + Account.Name);
                var outMsg = GameHeader.S2C_CS_CREATE_CHARACTER_ACK.CreatePacket();
                outMsg.WriteInt32((int)PacketStatusCode.UNKNOWN_ERROR);
                Connection.SendMessage(outMsg);
            }
            else
            {
                Debug.Log(string.Format("Character '{0}' created for {1}", dbChar.Name, Account.Name));
                var outMsg = GameHeader.S2C_CS_CREATE_CHARACTER_ACK.CreatePacket();
                outMsg.WriteInt32((int)PacketStatusCode.NO_ERROR);
                outMsg.Write(dbChar);
                outMsg.Write(charSheet);
                outMsg.Write(items);
                Connection.SendMessage(outMsg);
            }
        }
Ejemplo n.º 24
0
 public NetworkPacketScriptObject(NetworkPacket packet)
 {
     _nativeObject = packet;
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Creates a new nobility packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 private NobilityPacket(NetworkPacket packet)
     : base(packet, 4)
 {
 }
Ejemplo n.º 26
0
        private void ProcessPacket(NetworkPacket packet)
        {
            switch (packet.Type)
            {
            case NetworkPacketTypes.Leprechaun:
            {
                Leprechaun.Set(new NetworkPacketDrawable(packet));

                int index = NetworkPacketDrawable.GetOffset();

                var flags      = new BitArray(new[] { packet.Data[index++], packet.Data[index++], packet.Data[index++], packet.Data[index++] });
                var beginFlags = new BitArray(new[] { packet.Data[index++], packet.Data[index++], packet.Data[index++], packet.Data[index++] });

                Leprechaun.RainbowProgress = packet.Data[index];

                Leprechaun.IsStunned      = flags.Get((int)Flags.LeprechaunFlags.CaneHit);
                Leprechaun.IsFlying       = flags.Get((int)Flags.LeprechaunFlags.Flying);
                Leprechaun.IsInvulnerable = flags.Get((int)Flags.LeprechaunFlags.Invulnerability);
                Leprechaun.IsStoneHit     = flags.Get((int)Flags.LeprechaunFlags.StoneHit);
                Leprechaun.IsInvisible    = flags.Get((int)Flags.LeprechaunFlags.Invisibility);

                Leprechaun.Hat.Enabled  = flags.Get((int)Flags.LeprechaunFlags.Hat);
                Leprechaun.Cane.Enabled = flags.Get((int)Flags.LeprechaunFlags.Cane);

                if (Leprechaun.RainbowProgress >= 100)
                {
                    if (Leprechaun.GetBoundingCylinder().Intersects(Rainbow))
                    {
                        Vector3 direction = Vector3.Normalize(Config.GoldpotPosition - Rainbow.Point);
                        Vector3 force     = Vector3.Normalize(direction + Vector3.Up) * Config.RainbowKick;

                        Send(new NetworkPacket(NetworkPacketTypes.Kick, force.ToByteArray()));
                    }
                    else if (Leprechaun.GetBoundingCylinder().Intersects(Goldpot))
                    {
                        Server.OnGameOver(PlayerId);
                    }
                }


                lock (Server.PigAI)
                {
                    if ((Leprechaun.IsStunned || Leprechaun.IsFlying) && Server.PigAI.Pig.Captor == Leprechaun)
                    {
                        Server.PigAI.DropPig();
                    }

                    if (beginFlags.Get((int)Flags.LeprechaunFlags.ThrowPig))
                    {
                        Server.PigAI.ThrowPig(this);
                    }

                    if (beginFlags.Get((int)Flags.LeprechaunFlags.PigRobbery))
                    {
                        if (Server.PigAI.Pig.Captor != null)
                        {
                            Server.PigAI.Pig.Captor.Client.Send(new NetworkPacket(NetworkPacketTypes.DropPig));
                        }

                        Server.PigAI.CapturePig(this);
                    }
                }

                Server.ItemsManager.CheckItemCollected(this);

                if (beginFlags.Get((int)Flags.LeprechaunFlags.ExplosionTrap))
                {
                    Trap newTrap = Server.TrapManager.AddTrap(PlayerId);
                    newTrap.Position = Leprechaun.Position;
                    newTrap.Scale    = new Vector3(Config.TrapScale);
                    newTrap.Rotation = Quaternion.Identity;
                    newTrap.Velocity = Vector3.Zero;
                    Server.Send(new NetworkPacketAddTrap(newTrap), this);
                }

                Trap trap = Server.TrapManager.IntersectsEnemyTrap(Leprechaun, PlayerId);
                if (trap != null)
                {
                    lock (Server.TrapManager)
                    {
                        foreach (Client client in Server.GetClientList())
                        {
                            float squaredDistance = (trap.Position - client.Leprechaun.Position).LengthSquared();

                            if (client.PlayerId != trap.PlayerId && !client.Leprechaun.IsInvulnerable && squaredDistance <= Config.TrapSquaredImpactRadius)
                            {
                                client.Send(new NetworkPacket(NetworkPacketTypes.Kick, ((-client.Leprechaun.GetDirection(trap) + Vector3.Up) * (Config.TrapExplosionPower - squaredDistance)).ToByteArray()));
                            }
                        }

                        Server.Send(new NetworkPacketRemoveTrap(trap.PlayerId, trap.TrapId));
                        Server.TrapManager.RemoveTrap(trap);
                    }
                }

                if (beginFlags.Get((int)Flags.LeprechaunFlags.Kick))
                {
                    foreach (Client client in Server.GetClientList(this).Where(c => !c.Leprechaun.IsInvulnerable && c.Leprechaun.IsKicked(Leprechaun)))
                    {
                        Vector3 force = Vector3.Normalize(Leprechaun.GetForward() + Vector3.Up) * Config.KickPower;

                        if (flags.Get((int)Flags.LeprechaunFlags.AttackDouble))
                        {
                            force *= Config.LeprechaunAttackDoubleFactor;
                        }

                        client.Send(new NetworkPacket(NetworkPacketTypes.Kick, force.ToByteArray()));
                    }
                }
            }
            break;

            case NetworkPacketTypes.Hat:
            {
                Leprechaun.Hat.Set(new NetworkPacketDrawable(packet));

                if (Leprechaun.Hat.Scale.Y <= Leprechaun.Scale.Y)
                {
                    break;
                }

                foreach (Client client in Server.GetClientList(this).Where(c => !c.Leprechaun.IsInvulnerable && Leprechaun.Hat.Intersects(c.Leprechaun)))
                {
                    client.Send(new NetworkPacket(NetworkPacketTypes.Kick, ((-client.Leprechaun.GetDirection(Leprechaun.Hat) + Vector3.Up * Config.HatUpPower) * Config.HatPower).ToByteArray()));
                }
            }
            break;

            case NetworkPacketTypes.Cane:
            {
                Leprechaun.Cane.Set(new NetworkPacketDrawable(packet));

                foreach (Client client in Server.GetClientList(this).Where(c => !c.Leprechaun.IsInvulnerable && Leprechaun.Cane.Intersects(c.Leprechaun)))
                {
                    client.Send(new NetworkPacket(NetworkPacketTypes.CaneHit, BitConverter.GetBytes(Config.CaneStunTime)));
                }
            }
            break;
            }
        }
 public override void Distribut(NetworkPacket packet) { }
Ejemplo n.º 28
0
        /// <summary>
        /// Sends the specified packet.
        /// </summary>
        /// <param name="packet">The packet.</param>
        public void Send(NetworkPacket packet)
        {
            lock (this.ConnectionLock)
            {
                if (this._IsOpen)
                {
                    if (packet.AllButTargets)
                    {
                        var connections = this.Connections.ToArray();

                        for (int i = 0; i < connections.Length; i++)
                        {
                            if (packet.Targets == null || !packet.Targets.Contains(connections[i].Key))
                            {
                                connections[i].Value.Send(this.Settings.Serializer.Serialize(packet));
                            }
                        }
                    }
                    else
                    {
                        if (packet.Targets != null)
                        {
                            foreach (var id in packet.Targets)
                            {
                                TcpNetworkConnection conn;
                                if (this.Connections.TryGetValue(id, out conn))
                                {
                                    conn.Send(this.Settings.Serializer.Serialize(packet));
                                }
                            }
                        }
                    }
                }
                else throw new InvalidOperationException("Server must be open");
            }
        }
Ejemplo n.º 29
0
 /// <summary>
 /// Sends the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 public void Send(NetworkPacket packet)
 {
     lock (this.ConnectionLock)
     {
         if (this._IsConnected)
         {
             packet.Sender = this.Connection.ID;
             this.Connection.Send(this.Settings.Serializer.Serialize(packet));
         }
         else throw new InvalidOperationException("Client must be connected");
     }
 }
Ejemplo n.º 30
0
 public ServerTickedEventArgs(NetworkPacket networkPacket)
 {
     NetworkPacket = networkPacket;
 }
Ejemplo n.º 31
0
 /// <summary>
 /// Receive the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 public abstract void Receive(NetworkPacket packet);
Ejemplo n.º 32
0
        private void ReceivePacketData(NetworkPacket packet)
        {
            switch (packet.Command)
            {
                #region Connected, Send Client Version.
            case 0x7E:
            {
                if (RequiresVersion)
                {
                    var format = new ClientVersion();
                    Send(format);

                    RequiresVersion = false;
                }
            }
            break;

                #endregion
                #region Receive Encryption Information.
            case 0x00:
            {
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
                {
                    _reader.Position--;
                }

                byte type = _reader.ReadByte();

                if (type == 0)
                {
                    var serverTableCrc = _reader.ReadUInt32();
                    var seed           = _reader.ReadByte();
                    var salt           = _reader.ReadBytes(_reader.ReadByte());

                    _encryption = new SecurityProvider(
                        new SecurityParameters(seed, salt));

                    Send(new EncryptionReceived(0));
                }
            } break;

                #endregion
                #region Received Server Table Data.
            case 0x56:
            {
                _encryption.Transform(packet);
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
            }
            break;

                #endregion
                #region Received Redirect Information.
            case 0x03:
            {
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
                {
                    _reader.Position--;
                }

                var address = _reader.ReadBytes(4);
                var port    = _reader.ReadUInt16();

                _reader.Position++;

                var seed = _reader.ReadByte();
                var key  = _reader.ReadStringA();

                var name     = _reader.ReadStringA();
                var socketid = _reader.ReadUInt32();

                _encryption = new SecurityProvider(new SecurityParameters(seed, Encoding.ASCII.GetBytes(key)));
                {
                    Array.Reverse(address);
                }

                _socket.Close();
                Connect(address, port);

                State = ServerState.Login;

                Send(new RedirectRequest(seed, key, name, socketid));
            } break;

                #endregion
                #region Request Login
            case 0x60:
            {
                if (State == ServerState.Login)
                {
                    Send(new Login(User, Pass));
                    State = ServerState.World;
                }
            } break;

                #endregion
                #region Login Response
            case 0x02:
            {
                _encryption.Transform(packet);
                _reader        = new NetworkPacketReader();
                _reader.Packet = packet;
            } break;

                #endregion
            case 0x05:
                Connections++;
                break;

            default: break;
            }
        }
 public void SendChatMessage(string chatMessage)
 {
     NetworkPacket packet = new NetworkPacket();
     packet.Write((int)NetworkMessageType.ChatMessage);
     packet.Write(chatMessage);
     peer.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed);
 }
Ejemplo n.º 34
0
        void NetworkServer_OnDataRetrieved(eSock.Server sender, eSock.Server.eSockClient client, object[] data)
        {
            lock (client)
            {
                try
                {
                    MLClientData _ClientData = (MLClientData) client.Tag;
                    Guid PluginID = (Guid) data[0];
                    if (PluginID == Guid.Empty)
                    {
                        NetworkPacket command = (NetworkPacket)data[1];
                        Debug.WriteLine(command, "Command");
                        if (!_ClientData.Handshaken)
                        {
                            
                            if (command == NetworkPacket.Handshake)
                            {
                                _ClientData.Handshaken = true;
                                _ClientData.Encryption.GenerateRandomKey();
                                client.Send(Guid.Empty, (byte)NetworkPacket.Connect, _ClientData.Encryption.Key);
                                _ClientData.Encryption.Enabled = true;
                                return;
                            }
                            return;
                        }

                        if(command == NetworkPacket.BasicSettingsUpdated)
                        {
                            Debug.WriteLine("Basic settings updated", "Settings");
                            ListViewItem i = new ListViewItem(_ClientData.Settings.GetSetting<string>("Username", "Default"));
                            i.Tag = _ClientData;

                            i.SubItems.Add(client.NetworkSocket.RemoteEndPoint.ToString());
                            i.SubItems.Add(_ClientData.Settings.GetSetting<string>("OS", "WinX Lollypop (Unknowen)"));
                            i.SubItems.Add(_ClientData.Settings.GetSetting<string>("Cores", "0"));
                            _ClientData.DisplayObject = i;
                            
                            AddListview(i);
                            foreach (var plugin in LoadedPlugins)
                            {
                                try
                                {
                                    plugin.Value.ServerPlugin.OnClientConnect(new MLClient(_ClientData.ID, plugin.Value.ClientPluginID, _ClientData));
                                }
                                catch (Exception ex)
                                {
                                    DisplayException(plugin.Value, ex);
                                }
                            }
                        }

                        if(command == NetworkPacket.UpdateSetting)
                        {
                            string settingName = (string)data[2];
                            object value = data[3];
                            _ClientData.Settings.UpdateSetting(settingName, value);
                            Debug.WriteLine(string.Format("Updated {0}", settingName), "Settings");
                        }

                        if(command == NetworkPacket.UpdateSettingsDictionary)
                        {
                            var settings = (Dictionary< string, object>)data[2];
                            foreach(var dcItem in settings)
                            {
                                _ClientData.Settings.UpdateSetting(dcItem.Key, dcItem.Value);
                            }
                        }


                        #region " Plugin Checksum "
                        
                        if (command == NetworkPacket.Checksums)
                        {
                            bool Updated = false;
                            Dictionary<Guid, string> Checksums = (Dictionary<Guid, string>)data[2];
                            if (Checksums == null)
                            {
                                foreach (var plugin in LoadedPlugins)
                                {
                                    Guid ID = plugin.Key;
                                    UpdatePlugin(client, ID);
                                    Thread.Sleep(100);
                                    Updated = true;
                                }
                                return;
                            }
                            foreach (var plugin in Checksums)
                            {
                                Guid ID = plugin.Key;
                                string checksum = plugin.Value;
                                if (!LoadedPlugins.ContainsKey(ID))
                                {
                                    client.Send(Guid.Empty, (byte)NetworkPacket.DeletePlugin, ID);
                                    Updated = true;
                                    continue;
                                }
                                if (LoadedPlugins[ID].ClientPluginChecksum!= checksum)
                                {
                                    UpdatePlugin(client, ID);
                                    Thread.Sleep(100);
                                    Updated = true;
                                }
                                 
                            }

                            foreach (var plugin in LoadedPlugins)
                            {
                                Guid ID = plugin.Key;
                                MLPlugin PluginData = plugin.Value;
                                if (!Checksums.ContainsKey(ID))
                                {
                                    UpdatePlugin(client, ID);
                                    Thread.Sleep(100);
                                    Updated = true;
                                }
                            }
                            if (Updated)
                                client.Send(Guid.Empty, (byte)NetworkPacket.Restart);
                            else
                                client.Send(Guid.Empty, (byte)NetworkPacket.PluginsVerified);
                            _ClientData.PluginsVerified = true;
                            
                        }

                        #endregion

                        return;
                    }
                    if (LoadedPlugins.ContainsKey(PluginID))
                    {
                        LoadedPlugins[PluginID].ServerPlugin.OnDataRetrieved(new MLClient(_ClientData.ID, PluginID,
                            _ClientData), (object[]) data[1]);
                    }
                }
                catch(Exception ex)
                {
                    DisplayException(null, ex);
                }
            }
        }
 public void SendScorePoint()
 {
     if (inSession)
     {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.Add1ToScore);
         peerObject.SendTo(remotePlayer.dpnID, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
Ejemplo n.º 36
0
 /// <summary>
 /// Serializes the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 /// <returns>The serialized packet.</returns>
 public byte[] Serialize(NetworkPacket packet)
 {
     byte[] buffer = packet.Serialize();
     return this.Encrypter.Encrypt(buffer, true);
 }
Ejemplo n.º 37
0
 public override void HandlePacket(NetworkPacket packet)
 {
     Debug.Log("received: " + packet.mHead.mAddition);
 }
Ejemplo n.º 38
0
 /// <summary>
 /// Receive the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 public override void Receive(NetworkPacket packet)
 {
     if (this.OnMessageReceived != null) this.OnMessageReceived(packet.DataReader.ReadString(), packet.Sender);
     this.Send(packet);
 }
Ejemplo n.º 39
0
 public void RaiseNetworkPacketReceived(NetworkPacket networkPacket)
 {
     PluginHost.Instance.RaiseNetworkPacketReceived(networkPacket);
 }
        //  These routines handle the communication between the game peers.
        public void SendPlayerUpdate(PlayerUpdate update, ShotUpdate shotUpdate)
        {
            if (inSession) {
                NetworkPacket packet = new NetworkPacket();
                packet.Write((byte)MessageType.PlayerUpdateID);
                packet.Write(update);

                for (int i = 0; i < Constants.NumShots; i++) {
                    packet.Write(shotUpdate.ShotPosition[i]);
                    packet.Write(shotUpdate.ShotAge[i]);
                }

                peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.NoComplete | SendFlags.NoLoopback);
            }
        }
Ejemplo n.º 41
0
 public NetworkResult AddToQueue(Hash publicKeyDestination, NetworkPacket packet)
 {
     return AddToQueue(new NetworkPacketQueueEntry(publicKeyDestination, packet));
 }
 public void SendTwoPointsToPlayer(int player)
 {
     if (inSession) {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.Add2ToScore);
         peerObject.SendTo(player, packet, 0, SendFlags.Guaranteed);
     }
 }
Ejemplo n.º 43
0
        public async void Send(NetworkPacket packet)
        {
            await Task.Delay(millisecondsDelay : 100);

            OnRecieved(packet);
        }
Ejemplo n.º 44
0
 public NetworkPacketEvent(object sender, NetworkPacket networkPacket)
 {
     Sender = sender;
     Packet = networkPacket;
 }
 public void SendScorePointToAll()
 {
     if (inSession) {
         NetworkPacket packet = new NetworkPacket();
         packet.Write((byte)MessageType.Add1ToScore);
         peerObject.SendTo((int)PlayerID.AllPlayers, packet, 0, SendFlags.Guaranteed | SendFlags.NoLoopback);
     }
 }
Ejemplo n.º 46
0
 //Handles the local player being killed
 public static void HandleLocalPlayerDead(ref NetworkPacket Packet)
 {
     Log.In("Handle Local Player Dead");
     PlayerManager.Instance.KillLocalPlayer();
 }
Ejemplo n.º 47
0
 private void SendToClient <T>(NetworkPacket <T> packet, IPEndPoint ipEndPoint)
 {
     Debug.Log("IPENDPOINTCONNECTIONMANAGER: " + ipEndPoint);
     PacketManager.Instance.SendPacketToClient(packet, ipEndPoint);
 }
Ejemplo n.º 48
0
        private void Loop()
        {
            Log("Starting DNS Server. Thead ID: " + Thread.CurrentThread.ManagedThreadId);
            NetworkPortListener listener = OpenPort(DNS_SERVER_PORT);

            if (m_DefaultName != null)
            {
                nameMap[m_DefaultName] = new DNSEntry
                {
                    Name           = m_DefaultName,
                    CurrentAddress = NetworkAddress,
                    GUID           = GUID
                };
            }

            while (true)
            {
                if (m_Exit)
                {
                    break;
                }

                while (listener.PacketCount != 0)
                {
                    NetworkPacket packet = listener.ReadPacket();

                    if (packet.Data.Length == 0)
                    {
                        continue; //Drop Packet
                    }

                    uint cmd = packet.Data[0];

                    if (cmd == DNS_CMD_REGISTER && packet.Data.Length > 1)
                    {
                        string data = new string( packet.Data.Skip(1).Select(x => ( char )x).ToArray());
                        string name = data.Remove(0, 36);   //Remove GUID
                        string guid = data.Remove(36);      //Remove Name

                        if (nameMap.TryGetValue(name, out DNSEntry e))
                        {
                            if (guid == e.GUID)   //Update the Address.
                            {
                                e.CurrentAddress = packet.Sender.NetworkAddress;
                                packet.Respond(this, new[] { 1u });
                            }
                            else
                            {
                                packet.Respond(this, new[] { 0u });
                            }
                        }
                        else
                        {
                            packet.Respond(this, new[] { 1u });

                            nameMap[name] = new DNSEntry
                            {
                                Name           = name,
                                CurrentAddress = packet.Sender.NetworkAddress,
                                GUID           = guid
                            };
                        }
                    }
                    else if (cmd == DNS_CMD_RESOLVE)
                    {
                        string name = new string( packet.Data.Skip(1).Select(x => ( char )x).ToArray());

                        if (nameMap.ContainsKey(name))
                        {
                            packet.Respond(this, new[] { ( uint )nameMap[name].CurrentAddress });
                        }
                        else
                        {
                            packet.Respond(this, new[] { 0u });
                        }
                    }
                }

                Thread.Sleep(NetworkSettings.DNSServerThreadSleep);
            }

            m_Exit = false;
        }
Ejemplo n.º 49
0
 public ClientSentDataEventArgs(NetworkPacket data, IClientData client)
 {
     Data   = data;
     Client = client;
 }
 /// <summary>
 /// Serializes the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 /// <returns>The serialized packet.</returns>
 public byte[] Serialize(NetworkPacket packet)
 {
     return packet.Serialize();
 }
Ejemplo n.º 51
0
 public static bool SendMessage(NetworkPacket coms)
 {
     return(client.SendMessage(coms));
 }
Ejemplo n.º 52
0
 private void SendToServer <T>(NetworkPacket <T> packet)
 {
     PacketManager.Instance.SendPacketToServer(packet);
 }
Ejemplo n.º 53
0
 /// <summary>
 /// Tries to enqueue the packet. This doesn't necessarily immediately send the packet
 /// however it should be non-blocking.
 /// </summary>
 /// <param name="packet">The packet to send.</param>
 /// <returns>True if the packet was enqueued.</returns>
 public bool EnqueuePacket(NetworkPacket packet)
 {
     Logger.Info("Enqueuing packet");
     return(_outboundPackets.TryAdd(packet));
 }
Ejemplo n.º 54
0
    public static void ReadPacket(NetworkPacket Packet, int SenderConnectionID, bool isServerReading)
    {
        switch (Packet.PacketHeader)
        {
        case NetworkPacketHeader.ConnectionID:
        {
            int LocalConnectionID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            NetworkDetails.SetLocalConnectionID(LocalConnectionID);
            NetworkPacketSender.SendPlayerReady(LocalConnectionID);
        }
        break;

        case NetworkPacketHeader.RequestConnectionID:
        {
            NetworkPacket ConnectionIDPacket = ScriptableObject.CreateInstance <NetworkPacket>();
            ConnectionIDPacket.SetPacketTarget(SenderConnectionID);
            ConnectionIDPacket.PacketHeader = NetworkPacketHeader.ConnectionID;
            ConnectionIDPacket.SetPacketData(BitConverter.GetBytes(SenderConnectionID), 0, sizeof(int));
            NetworkManager.Instance.SendPacketToClient(ConnectionIDPacket, QosType.Reliable);
        }
        break;

        case NetworkPacketHeader.PlayerReady:
        {
            int ReadyPlayerConnectionID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            BattleRoyale_GameManager.Instance.PlayerReady(ReadyPlayerConnectionID);
        }
        break;

        case NetworkPacketHeader.StartGame:


            break;

        case NetworkPacketHeader.SpawnPlayer:
        {
            int PlayerConnectionID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            PlayerManager.Instance.SpawnPlayer(PlayerConnectionID);
        }
        break;

        case NetworkPacketHeader.PlayerPosition:
        {
            int     PlayerID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            int     InputID  = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            Vector3 position = Serializer.DeserializeToVector3(Packet.GetPacketData(), 8);
            PlayerManager.Instance.GetPlayer(PlayerID).SetPosition(position);
        }
        break;

        case NetworkPacketHeader.ArmDirection:
        {
            int     PlayerID     = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            int     InputID      = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            Vector3 ArmDirection = Serializer.DeserializeToVector3(Packet.GetPacketData(), 8);
            PlayerManager.Instance.GetPlayer(PlayerID).SetArmDirection(ArmDirection);
        }
        break;

        case NetworkPacketHeader.PlayerTransform:
        {
            int     PlayerID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            Vector3 position = Serializer.DeserializeToVector3(Packet.GetPacketData(), 4);
            Vector3 rotation = Serializer.DeserializeToVector3(Packet.GetPacketData(), 16);
            PlayerManager.Instance.GetPlayer(PlayerID).SetTransform(position, rotation);
        }
        break;

        case NetworkPacketHeader.PlayerUpdate:
        {
            int     PlayerID      = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            int     InputID       = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            Vector3 position      = Serializer.DeserializeToVector3(Packet.GetPacketData(), 8);
            Vector3 ForwardVector = Serializer.DeserializeToVector3(Packet.GetPacketData(), 20);
            Vector3 CurrentArmDir = Serializer.DeserializeToVector3(Packet.GetPacketData(), 32);
        }
        break;

        case NetworkPacketHeader.RagdollPlayer:
        {
            int PlayerToRagdollID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            PlayerManager.Instance.GetPlayer(PlayerToRagdollID).Ragdoll();
        }
        break;

        case NetworkPacketHeader.PlayerInputUpdate:
        {
            int   PlayerID       = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            float DeltaTime      = BitConverter.ToSingle(Packet.GetPacketData(), 4);
            int   InputID        = BitConverter.ToInt32(Packet.GetPacketData(), 8);
            int   AmountOfInputs = BitConverter.ToInt32(Packet.GetPacketData(), 12);

            PlayerManager.Instance.GetPlayer(PlayerID).ReceiveInputs(Packet.GetPacketData(), AmountOfInputs, InputID, DeltaTime);
        }
        break;

        case NetworkPacketHeader.AddPlayerToRoom:
        {
            int     PlayerID       = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            int     RoomIndex      = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            Vector3 PlayerPosition = Serializer.DeserializeToVector3(Packet.GetPacketData(), 8);
            LevelManager.Instance.GetRoom(RoomIndex).PlayerJoinRoom(PlayerID, PlayerPosition);
        }
        break;

        case NetworkPacketHeader.RemovePlayerFromRoom:
        {
            int PlayerID  = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            int RoomIndex = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            LevelManager.Instance.GetRoom(RoomIndex).PlayerLeaveRoom(PlayerID);
        }
        break;

        case NetworkPacketHeader.SpawnPlayerInRoom:
        {
            //int PlayerID = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            //int RoomIndex = BitConverter.ToInt32(Packet.GetPacketData(), 4);
            //LevelManager.Instance.GetRoom(RoomIndex).PlayerJoinRoom(PlayerID);
        }
        break;

        case NetworkPacketHeader.RequestLevel:
        {
            NetworkPacketSender.SendLevelData(SenderConnectionID);
        }
        break;

        case NetworkPacketHeader.LevelData:
        {
            LevelManager.Instance.ReadInLevelBytes(Packet.GetPacketData());
        }
        break;

        case NetworkPacketHeader.RequestRoomData:
        {
            int RoomIndex = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            NetworkPacketSender.SendRoomData(SenderConnectionID, RoomIndex);
        }
        break;

        case NetworkPacketHeader.RoomData:
        {
            int RoomIndex = BitConverter.ToInt32(Packet.GetPacketData(), 0);
            LevelManager.Instance.GetRoom(RoomIndex).ReadInRoomAsBytes(Packet.GetPacketData());
        }
        break;

        case NetworkPacketHeader.RequestCurrentPlayers:
        {
            NetworkPacketSender.SendPlayerData(SenderConnectionID);
        }
        break;

        case NetworkPacketHeader.PlayerData:
        {
            PlayerManager.Instance.ReadInPlayersAsBytes(Packet.GetPacketData());
        }
        break;
        }
    }
Ejemplo n.º 55
0
 /// <summary>
 /// Send the specified packet.
 /// </summary>
 /// <param name="packet">The packet.</param>
 protected void Send(NetworkPacket packet)
 {
     this.Send(packet, Int32.MinValue);
 }
Ejemplo n.º 56
0
 /// <summary>
 /// Tries to enqueue the packet. This doesn't necessarily immediately send the packet
 /// however it should be non-blocking.
 /// </summary>
 /// <param name="packet">The packet to send.</param>
 /// <returns>True if the packet was enqueued.</returns>
 public bool EnqueuePacket(NetworkPacket packet)
 {
     Debug.WriteLine("Enqueuing packet");
     return(_outboundPackets.TryAdd(packet));
 }
Ejemplo n.º 57
0
 public DjiNetworkPacket(NetworkPacket networkPacket, DjiPacket djiPacket) : base(networkPacket) => _djiPacket = djiPacket;
Ejemplo n.º 58
0
        public void Start()
        {
            string ip = ((IPEndPoint)Socket.RemoteEndPoint).Address.ToString();

            Console.WriteLine("Client connected from {0}", ip);

            var packet = new NetworkPacket();

            Vector3 leprechaunPosition = Server.Terrain.GetHeight(Config.PlayerPositions[PlayerId]);

            try
            {
                Send(new NetworkPacketWelcome(PlayerId, Config.PlayerColors[PlayerId], leprechaunPosition, Config.RainbowPositions[PlayerId]));

                Server.ItemsManager.SendAll(this);
                Server.TrapManager.AddPlayer(this);

                const float goldpotRadius = Config.GoldpotCylinderRadius * Config.GoldpotScale;
                const float goldpotHeight = Config.GoldpotCylinderHeight * Config.GoldpotScale;

                Rainbow = new BoundingCylinder(Config.RainbowCylinderRadius, Config.RainbowCylinderHeight, Config.RainbowPositions[PlayerId]);
                Goldpot = new BoundingCylinder(goldpotRadius, goldpotHeight, Config.GoldpotPosition);

                var buffer = new byte[Config.BufferSize];

                while (true)
                {
                    if (Socket.Receive(buffer, 1, SocketFlags.None) == 0)
                    {
                        return;
                    }

                    packet.Type = buffer[0];

                    if (Socket.Receive(buffer, 1, SocketFlags.None) == 0)
                    {
                        return;
                    }

                    packet.Size = buffer[0];

                    int received = 0;

                    while (received < packet.Size)
                    {
                        int count;

                        if ((count = Socket.Receive(packet.Data, received, packet.Size - received, SocketFlags.None)) == 0)
                        {
                            return;
                        }

                        received += count;
                    }

                    ProcessPacket(packet);

                    Server.Send(packet, this);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                Console.WriteLine("Client disconnected from {0}", ip);

                Server.OnClientFinish(this);
            }
        }
        //System.Diagnostics.Stopwatch sw_timer = new System.Diagnostics.Stopwatch();

        async Task ProcessIncomingUserInternal(IncomingClient iClient, TransportPacket p)
        {
            BinaryReader reader = new BinaryReader(iClient.client.GetStream());
            //BinaryWriter writer = new BinaryWriter(iClient.client.GetStream());

            NetworkStream writer = iClient.client.GetStream();

            //DisplayUtils.Display("Packet Received: " + p.Type);

            switch (p.Type)
            {
                case TransportPacketType.Initialize:

                    iClient.ConnTimeStart = DateTime.UtcNow.Ticks;

                    //DisplayUtils.Display("Init Received", DisplayType.Info);

                    if ((!iClient.WorkProven) && (!iClient.KeyExchanged))
                    {
                        await PacketSender.SendTransportPacket(writer, TransportPacketType.WorkProofRequest, iClient.WorkTask);
                    }

                    break;

                case TransportPacketType.WorkProofKeyResponse:
                    //DisplayUtils.Display("WorkProofResponse Received : " + p.Data.Length, DisplayType.Info);

                    if ((!iClient.WorkProven) && (!iClient.KeyExchanged))
                    {
                        if (p.Data.Length == 60)
                        {
                            Constants.SERVER_GLOBAL_AUTH_PACKETS++;

                            byte[] Proof = new byte[4];
                            byte[] DHClientPublic = new byte[32];
                            byte[] AuthRandom = new byte[24];

                            Array.Copy(p.Data, 0, Proof, 0, 4);
                            Array.Copy(p.Data, 4, DHClientPublic, 0, 32);
                            Array.Copy(p.Data, 36, AuthRandom, 0, 24);

                            iClient.WorkProven = WorkProof.VerifyProof(iClient.WorkTask, Proof, Constants.Difficulty);

                            if (iClient.WorkProven)
                            {
                                //DisplayUtils.Display("Work Proved", DisplayType.Info);
                                Common.rngCsp.GetBytes(iClient.DHRandomBytes);

                                iClient.DHPrivateKey = Curve25519.ClampPrivateKey(iClient.DHRandomBytes);
                                iClient.DHPublicKey = Curve25519.GetPublicKey(iClient.DHPrivateKey);

                                // Generate the shared-secret using the provided client Public Key
                                byte[] sharedSecret = (new SHA512Managed()).ComputeHash(Curve25519.GetSharedSecret(iClient.DHPrivateKey, DHClientPublic));

                                Array.Copy(sharedSecret, iClient.TransportKey, 32);
                                Array.Copy(sharedSecret, 32, iClient.AuthenticationKey, 0, 32);

                                // Sign the data using the Node-Private key, so that the client can know that the connection is secure.
                                // This thwarts MITM attacks.
                                byte[] Client_ServerAuthSignature = nodeConfig.SignDataWithPrivateKey(AuthRandom);

                                // 64 bytes Signature
                                byte[] signPlain = Client_ServerAuthSignature;

                                if (signPlain.Length != 64) throw new Exception("Improbable Assertion failed : 1");

                                // Encrypt the Signature and Identifier using Salsa20
                                byte[] signCrypted = Salsa20.ProcessSalsa20(signPlain, iClient.TransportKey, new byte[8], 0);

                                // EtM -> Encrypt then MAC
                                byte[] signMAC = (new HMACSHA256(iClient.AuthenticationKey)).ComputeHash(signCrypted);

                                // SERVER_PUBLIC[32] || signMAC[32] || signCrypted[64] => 128 bytes
                                byte[] KeysSignature = iClient.DHPublicKey.Concat(signMAC).Concat(signCrypted).ToArray();

                                await PacketSender.SendTransportPacket(writer, TransportPacketType.ServerPublicTransfer, KeysSignature);
                            }
                            else
                            {
                                DisplayUtils.Display("Work Proof invalid : " + p.Data.Length, DisplayType.Exception);
                                await PacketSender.SendTransportPacket(writer, TransportPacketType.InvalidAuthDisconnect, new byte[0]);
                            }
                        }
                        else
                        {
                            DisplayUtils.Display("Invalid Packet Length : " + p.Data.Length, DisplayType.Exception);
                            await PacketSender.SendTransportPacket(writer, TransportPacketType.InvalidAuthDisconnect, new byte[0]);
                        }
                    }

                    break;

                case TransportPacketType.KeyExComplete_1:

                    if ((iClient.WorkProven) && (!iClient.KeyExchanged))
                    {
                        if (p.Data.Length == 128)
                        {
                            // cryptedSigPK_MAC[32] || cryptedSigPK[96] = 128 bytes

                            byte[] cryptedSigPK_MAC = new byte[32];
                            byte[] cryptedSigPK = new byte[96];

                            Array.Copy(p.Data, 0, cryptedSigPK_MAC, 0, 32);
                            Array.Copy(p.Data, 32, cryptedSigPK, 0, 96);

                            byte[] cryptedSigPK_MAC_Expected = (new HMACSHA256(iClient.AuthenticationKey)).ComputeHash(cryptedSigPK);

                            if (CryptoBytes.ConstantTimeEquals(cryptedSigPK_MAC_Expected, cryptedSigPK_MAC))
                            {
                                byte[] workSignPK = Salsa20.ProcessSalsa20(cryptedSigPK, iClient.TransportKey, new byte[8], 0);

                                // workSignPK[96]  = workSign[64] || nodeConfig.PublicKey[32]

                                byte[] workSign = new byte[64];
                                byte[] remotePK = new byte[32];

                                Array.Copy(workSignPK, 0, workSign, 0, 64);
                                Array.Copy(workSignPK, 64, remotePK, 0, 32);

                                bool serverVerified = Ed25519.Verify(workSign, iClient.WorkTask, remotePK);

                                if (serverVerified)
                                {
                                    iClient.PublicKey = new Hash(remotePK);

                                    if (Constants.NetworkVerbosity >= Verbosity.Info)
                                    {
                                        /*DisplayUtils.Display(NodeSocketData.GetString(nodeSocketData) + " : Key Exchanged 1: Shared KEY [TransportKey] : {" +
                                            (HexUtil.ToString(TransportKey)) + "}", DisplayType.Info);*/

                                        DisplayUtils.Display(iClient.PublicKey.ToString() + " Client Authenticated", DisplayType.Info);
                                    }

                                    await PacketSender.SendTransportPacket(writer, TransportPacketType.KeyExComplete_2, new byte[0]);

                                    iClient.KeyExchanged = true;

                                    IncomingConnections.Add(iClient.PublicKey, iClient);

                                    DisplayUtils.Display("Exchange Complete 2, Shared KEY [TransportKey] : " + HexUtil.ToString(iClient.TransportKey), DisplayType.Info);

                                }
                            }
                        }
                    }

                    break;

                case TransportPacketType.DataCrypted:

                    if (iClient.KeyExchanged && p.Data.Length > 28)
                    {
                        Constants.SERVER_GLOBAL_DATA_PACKETS++;

                        byte[] nonce = new byte[8];
                        byte[] hmac = new byte[16];
                        byte[] crypted_data = new byte[p.Data.Length - 24];

                        Array.Copy(p.Data, 0, nonce, 0, 8);
                        Array.Copy(p.Data, 8, hmac, 0, 16);
                        Array.Copy(p.Data, 24, crypted_data, 0, crypted_data.Length);

                        byte[] MAC_EXPECTED = (new HMACSHA256(iClient.AuthenticationKey)).ComputeHash(crypted_data).Take(16).ToArray();

                        if (CryptoBytes.ConstantTimeEquals(MAC_EXPECTED, hmac))
                        {
                            byte[] DeCryptedData = Salsa20.ProcessSalsa20(crypted_data, iClient.TransportKey, nonce, 0);

                            byte[] counter = new byte[4];
                            byte[] rec_data = new byte[p.Data.Length - 28];

                            Array.Copy(DeCryptedData, 0, counter, 0, 4);
                            Array.Copy(DeCryptedData, 4, rec_data, 0, rec_data.Length);

                            Array.Copy(DeCryptedData, 0, counter, 0, 4);
                            Array.Copy(DeCryptedData, 4, rec_data, 0, rec_data.Length);

                            NetworkPacket np = new NetworkPacket();

                            np.Deserialize(rec_data);

                            if (iClient.PublicKey == np.PublicKeySource)
                            {
                                if (PacketReceived != null)
                                    PacketReceived(np);
                            }
                            else
                            {
                                DisplayUtils.Display("Packet Source Incoming Mismatch", DisplayType.Warning);
                            }

                        }
                        else
                        {
                            DisplayUtils.Display("HMAC FAILED : ");
                        }
                    }

                    break;
            }
        }
Ejemplo n.º 60
0
 public void RaiseNewPacket(NetworkPacket networkPacket)
 {
     // THIRD PARTY
     PluginHost.Instance.RaiseNewNetworkPacket(networkPacket);
 }