public static void Eval(AresClient client, TCPPacket packet, ulong time)
        {
            if (client.Quarantined)
            {
                return;
            }

            packet.Packet.SkipBytes(2);
            TCPMsg msg = (TCPMsg)(byte)packet.Packet;

            switch (msg)
            {
            case TCPMsg.MSG_CHAT_CLIENT_CUSTOM_ADD_TAGS:
                AddClientTag(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_CUSTOM_REM_TAGS:
                RemClientTag(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_SUPPORTED:
                VCSupported(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_FIRST:
                VCFirst(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_FIRST_TO:
                VCFirstTo(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_CHUNK:
                VCChunk(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_CHUNK_TO:
                VCChunkTo(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_VC_IGNORE:
                VCIgnore(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_CUSTOM_FONT:
                Font(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_SCRIBBLEROOM_FIRST:
                ScribbleRoomFirst(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_SCRIBBLEROOM_CHUNK:
                ScribbleRoomChunk(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_BLOCK_CUSTOMNAMES:
                client.BlockCustomNames = ((byte)packet.Packet) == 1;
                break;

            default:
                Events.UnhandledProtocol(client, true, packet.Msg, packet.Packet, time);
                break;
            }
        }
Exemple #2
0
        private void ServiceAresSockets(ulong time)
        {
            foreach (AresClient client in UserPool.AUsers)
            {
                if (!String.IsNullOrEmpty(client.DNS))
                {
                    if (client.IsHTML)
                    {
                        if (Settings.Get <bool>("enabled", "web"))
                        {
                            UserPool.CreateIb0tClient(client, time);
                        }
                        else
                        {
                            client.Disconnect();
                        }
                        break;
                    }

                    if (client.IsWebWorker)
                    {
                        UserPool.CreateWW(client);
                        client.Disconnect();
                        break;
                    }

                    TCPPacket packet = null;

                    while ((packet = client.NextReceivedPacket) != null && client.SocketConnected)
                    {
                        if (packet.Msg == TCPMsg.MSG_CHAT_CLIENTCOMPRESSED)
                        {
                            client.InsertUnzippedData(Zip.Decompress(packet.Packet.ToArray()));
                        }
                        else
                        {
                            try
                            {
                                TCPProcessor.Eval(client, packet, time);

                                if (client.IsLeaf)
                                {
                                    break;
                                }
                            }
                            catch (Exception e)
                            {
                                client.Disconnect();

                                if (packet.Msg != TCPMsg.MSG_CHAT_ADVANCED_FEATURES_PROTOCOL)
                                {
                                    Log("packet read fail from " + client.ExternalIP + " " + packet.Msg, e);
                                }
                                else if (packet.Packet.ToArray().Length >= 3)
                                {
                                    Log(
                                        "packet read fail from " + client.ExternalIP + " " +
                                        (TCPMsg)packet.Packet.ToArray()[2], e);
                                }
                                else
                                {
                                    Log("packet read fail from " + client.ExternalIP + " (Advanced Protocol Exploit)", e);
                                }


                                break;
                            }
                        }
                    }

                    if (client.IsLeaf)
                    {
                        continue;
                    }

                    client.SendReceive();

                    if (client.SocketConnected)
                    {
                        client.EnforceRules(time);
                    }
                }
            }

            UserPool.AUsers.ForEachWhere(x => x.Disconnect(), x => !x.SocketConnected);
            UserPool.AUsers.RemoveAll(x => !x.SocketConnected || x.IsLeaf);
        }
Exemple #3
0
        public static void Eval(AresClient client, TCPPacket packet, ulong time)
        {
            if (!client.LoggedIn && (packet.Msg > TCPMsg.MSG_CHAT_CLIENT_LOGIN && packet.Msg != TCPMsg.MSG_LINK_PROTO))
            {
                throw new Exception("unordered login routine");
            }

            if (client.LoggedIn)
            {
                if (FloodControl.IsFlooding(client, packet.Msg, packet.Packet.ToArray(), time))
                {
                    if (Events.Flooding(client, (byte)packet.Msg))
                    {
                        Events.Flooded(client);
                        client.Disconnect();
                        return;
                    }
                }
            }

            switch (packet.Msg)
            {
            case TCPMsg.MSG_CHAT_CLIENT_LOGIN:
            case TCPMsg.MSG_CHAT_CLIENT_RELOGIN:
                Login(client, packet.Packet, time, packet.Msg == TCPMsg.MSG_CHAT_CLIENT_RELOGIN);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_UPDATE_STATUS:
                client.Time = time;
                client.SendPacket(TCPOutbound.UpdateUserStatus(client, client));
                break;

            case TCPMsg.MSG_CHAT_CLIENT_AVATAR:
                Avatar(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_PERSONAL_MESSAGE:
                PersonalMessage(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_FASTPING:
                client.FastPing = true;
                break;

            case TCPMsg.MSG_CHAT_CLIENT_CUSTOM_DATA:
                CustomData(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_CUSTOM_DATA_ALL:
                CustomDataAll(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_ADVANCED_FEATURES_PROTOCOL:
                TCPAdvancedProcessor.Eval(client, packet, time);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_PUBLIC:
                Public(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_EMOTE:
                Emote(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_COMMAND:
                Command(client, packet.Packet.ReadString(client));
                break;

            case TCPMsg.MSG_CHAT_CLIENT_PVT:
                Private(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_IGNORELIST:
                IgnoreList(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_ADDSHARE:
                FileBrowseProcessor.AddShare(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_REMSHARE:
                FileBrowseProcessor.RemShare(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_BROWSE:
                FileBrowseProcessor.Browse(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_SEARCH:
                FileBrowseProcessor.Search(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_AUTHLOGIN:
                Command(client, "login " + packet.Packet.ReadString(client));
                break;

            case TCPMsg.MSG_CHAT_CLIENT_AUTHREGISTER:
                Command(client, "register " + packet.Packet.ReadString(client));
                break;

            case TCPMsg.MSG_CHAT_CLIENT_AUTOLOGIN:
                SecureLogin(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_DUMMY:
                Dummy(client);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_DIRCHATPUSH:
                DirChatPush(client, packet.Packet);
                break;

            case TCPMsg.MSG_CHAT_CLIENT_SEND_SUPERNODES:
                client.SendPacket(TCPOutbound.SuperNodes());
                break;

            case TCPMsg.MSG_LINK_PROTO:
                LinkProto(client, packet.Packet, time);
                break;

            default:
                Events.UnhandledProtocol(client, false, packet.Msg, packet.Packet, time);
                break;
            }
        }