Example #1
0
        public override void InitBuild(MemoryStream stream)
        {
            MessageBuffer informations = Informations as MessageBuffer;

            if (stream.Length > 0)
            {
                Reader.Add(stream.ToArray(), 0, (int)stream.Length);
            }

            if (informations.Build(Reader, ClientSide))
            {
                if (BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.protocolID == informations.MessageId] is NetworkElement message)
                {
                    IDataReader         reader  = new BigEndianReader(informations.Data);
                    ProtocolJsonContent content = FromByte(null, message, reader);
                    reader.Dispose();
                    OnMessageParsed?.Invoke(message, content);
                }

                Informations = null;
                Informations = new MessageBuffer();

                stream.Close();
                stream = new MemoryStream(Reader.ReadBytes((int)Reader.BytesAvailable));

                Reader.Dispose();
                Reader = null;
                Reader = new BigEndianReader();

                InitBuild(stream);
            }
        }
Example #2
0
        private void ClientTreatment_OnMessageParsed(NetworkElement arg1, ProtocolJsonContent arg2)
        {
            var hooker = HookManager <T> .Instance[LocalClient.localIp.Port];

            if (hooker is null)
            {
                logger.Error("no proxy found");
                return;
            }

            if (ClientTreatment.Informations is MessageBuffer informations)
            {
                hooker.Proxy.LAST_GLOBAL_INSTANCE_ID = informations.InstanceId;
            }

            uint instance_id = hooker.Proxy.LAST_GLOBAL_INSTANCE_ID + hooker.Proxy.FAKE_MESSAGE_SENT;
            StartupConfiguration configuration = Configurations.ConfigurationManager.Instance.Startup;

            if (configuration.show_message)
            {
                logger.Info($"[client {RemoteClient.remoteIp}] {arg1.BasicString()}");
                if (configuration.show_message_content)
                {
                    logger.Info($"{arg2}");
                }
            }

            HandlerManager.Instance.Handle(arg1.protocolID, LocalClient, RemoteClient, arg2);
            RemoteClient.Send(ClientTreatment.Informations.ReWriteInstanceId(instance_id));
        }
Example #3
0
        public async void Test(Hooker <MessageInformation> hook, CustomClientPage page)
        {
            if (page is null)
            {
                return;
            }

            await Task.Run(() =>
            {
                page.Dispatcher.Invoke(() =>
                {
                    ProtocolJsonContent content = Content["infos"]["entityLook"];
                    Bitmap image = content.FromWeb();
                    SetModel(page.CharacterInformation, hook.Player, image);

                    if (UIManager.Instance.UI.Container[hook.Proxy.ProcessId] is CustomButton btn)
                    {
                        btn.ButtonText = $"{hook.Player.Name}";
                        UIManager.Instance.UI.Container[hook.Proxy.ProcessId, true] = btn;
                    }

                    if (UIManager.Instance.UI.SelectedId == hook.Proxy.ProcessId)
                    {
                        UIManager.Instance.UI.Navigate(page, hook.Proxy.ProcessId);
                    }
                });
            });
        }
 public static SubEntity FromSubEntity(this ProtocolJsonContent content)
 {
     return(new SubEntity()
     {
         BindingPointCategory = content["bindingPointCategory"],
         BindingPointIndex = content["bindingPointIndex"],
         SubEntityLook = content["subEntityLook"].FromEntityLook()
     });
 }
Example #5
0
        public void Handle(Type type, CustomClient local, CustomClient remote, ProtocolJsonContent content)
        {
            if (type is null)
            {
                return;
            }
            MessageHandler handler = (MessageHandler)Activator.CreateInstance(type, new object[] { local, remote, content });

            new Action(handler.Handle).Run(handler.EndHandle, handler.Error);
        }
Example #6
0
        private void Handle(MethodInfo method, ProxyElement proxy, ProtocolJsonContent content)
        {
            if (method is null)
            {
                return;
            }
            object obj = Activator.CreateInstance(method.DeclaringType);

            method.Invoke(obj, new object[] { proxy, method.GetCustomAttribute <HandlerAttribute>().Message, content });
        }
Example #7
0
        public void Send(NetworkElement message, ProtocolJsonContent content, bool clientSide)
        {
            if (message is null)
            {
                return;
            }

            using (BigEndianWriter writer = new BigEndianWriter())
            {
                byte[] data = ProtocolTreatmentExtension.FromContent(content, message);

                int cmpLen = _cmpLen(data.Length);
                writer.WriteShort((short)((message.protocolID << 2) | cmpLen));

                if (clientSide)
                {
                    writer.WriteUnsignedInt(GetCustomInstanceId());
                }

                switch (cmpLen)
                {
                case 0:
                    break;

                case 1:
                    writer.WriteByte((byte)data.Length);
                    break;

                case 2:
                    writer.WriteShort((short)data.Length);
                    break;

                case 3:
                    writer.WriteByte((byte)((data.Length >> 16) & 255));
                    writer.WriteShort((short)(data.Length & 65535));
                    break;
                }

                writer.WriteBytes(data);
                Send(writer.Data);

                OnCustomMessageSent?.Invoke(message, content);

                StartupConfiguration configuration = Configurations.ConfigurationManager.Instance.Startup;
                if (configuration.show_fake_message)
                {
                    logger.Info($"fake message sent to {remoteIp} |{message.BasicString()}]");
                    if (configuration.show_fake_message_content)
                    {
                        logger.Info($"{content}");
                    }
                }
            }
        }
        public static PlayerModel FromBaseInformations(this ProtocolJsonContent content)
        {
            return(new PlayerModel()
            {
                Id = content["infos"]["id"],
                Name = content["infos"]["name"],
                Level = content["infos"]["level"],
                IsMerchant = false,
                Sex = content["infos"]["sex"],

                BreedId = content["infos"]["breed"],
                //Look = content["infos"]["look"].FromEntityLook()
            });
        }
Example #9
0
        public void Send(int processId, NetworkElementField message, ProtocolJsonContent content, bool clientSide)
        {
            if (message is null)
            {
                return;
            }

            using (BigEndianWriter writer = new BigEndianWriter())
            {
                byte[] data = message.ToByte(content);

                int cmpLen = _cmpLen(data.Length);
                writer.WriteShort((short)((message.protocolID << 2) | cmpLen));
                ProxyManager.Instance[processId].FAKE_MESSAGE_SENT++;
                if (clientSide)
                {
                    writer.WriteUnsignedInt(ProxyManager.Instance[processId].FAKE_MSG_INSTANCE_ID);
                }
                switch (cmpLen)
                {
                case 0:
                    break;

                case 1:
                    writer.WriteByte((byte)data.Length);
                    break;

                case 2:
                    writer.WriteShort((short)data.Length);
                    break;

                case 3:
                    writer.WriteByte((byte)((data.Length >> 16) & 255));
                    writer.WriteShort((short)(data.Length & 65535));
                    break;
                }

                writer.WriteBytes(data);
                Send(writer.Data);
                if (ConfigurationManager.Instance.Startup.show_fake_message_sent)
                {
                    Console.WriteLine($"Fake Message sent to ({RemoteIP}) : (n°{ProxyManager.Instance[processId].FAKE_MSG_INSTANCE_ID}) [{message.name} ({message.protocolID})]");
                    if (ConfigurationManager.Instance.Startup.show_message_content)
                    {
                        Console.WriteLine($"{content}");
                    }
                }
            }
        }
Example #10
0
        public static byte[] FromContent(ProtocolJsonContent content, NetworkElement field)
        {
            if (content is null)
            {
                return(new byte[0]);
            }
            if (field is null)
            {
                throw new Exception("field cannot be null");
            }

            try
            {
                using (BigEndianWriter writer = new BigEndianWriter())
                {
                    if (field.super_serialize)
                    {
                        NetworkElement super      = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.MessagesAndTypes, x => x.name == field.super];
                        byte[]         super_data = FromContent(content, super);
                        writer.WriteBytes(super_data);
                    }

                    IEnumerable <ClassField> boolWrapper = field.fields.Where(x => x.use_boolean_byte_wrapper).OrderBy(x => x.boolean_byte_wrapper_position);
                    IEnumerable <ClassField> vars        = field.fields.Where(x => !boolWrapper.Contains(x)).OrderBy(x => x.position);

                    if (boolWrapper.Count() > 0)
                    {
                        byte[] flags = new byte[boolWrapper.LastOrDefault().position.Value + 1];

                        foreach (ClassField _bool in boolWrapper)
                        {
                            flags[_bool.position.Value] = BooleanByteWrapper.SetFlag(flags[_bool.position.Value], (byte)((_bool.boolean_byte_wrapper_position.Value - 1) % 8), content[_bool.name]);
                        }
                    }

                    foreach (ClassField _var in vars)
                    {
                        Parse(_var, content[_var.name], writer);
                    }

                    return(writer.Data);
                }
            }
            catch (Exception e)
            {
                logger.Error(e);
                return(new byte[0]);
            }
        }
Example #11
0
        private void ServerTreatment_OnMessageParsed(NetworkElement arg1, ProtocolJsonContent arg2)
        {
            StartupConfiguration configuration = Configurations.ConfigurationManager.Instance.Startup;

            if (configuration.show_message)
            {
                logger.Info($"[server {RemoteClient.remoteIp}] {arg1.BasicString()}");
                if (configuration.show_message_content)
                {
                    logger.Info($"{arg2}");
                }
            }

            HandlerManager.Instance.Handle(arg1.protocolID, LocalClient, RemoteClient, arg2);
        }
Example #12
0
        public static ProtocolJsonContent FromBytes(ProtocolJsonContent content, NetworkElement field, IDataReader reader)
        {
            if (content is null)
            {
                content = new ProtocolJsonContent();
            }
            if (field is null)
            {
                return(content);
            }

            try
            {
                if (field.super_serialize)
                {
                    NetworkElement super = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.MessagesAndTypes, x => x.name == field.super];
                    content = FromBytes(content, super, reader);
                }
                IEnumerable <ClassField> boolWrapper = field.fields.Where(x => x.use_boolean_byte_wrapper).OrderBy(x => x.boolean_byte_wrapper_position);
                IEnumerable <ClassField> vars        = field.fields.Where(x => !boolWrapper.Contains(x)).OrderBy(x => x.position);

                byte flag = 0;

                for (byte i = 0; i < boolWrapper.Count(); i++)
                {
                    ClassField _bool = boolWrapper.ElementAt(i);

                    if (i % 8 == 0)
                    {
                        flag = reader.ReadByte();
                    }

                    content[_bool.name] = BooleanByteWrapper.GetFlag(flag, i);
                }

                foreach (ClassField _var in vars)
                {
                    content[_var.name] = _var.Parse(ref reader);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"{e}");
            }

            return(content);
        }
        public static EntityLook FromEntityLook(this ProtocolJsonContent content)
        {
            EntityLook look = new EntityLook()
            {
                BonesId       = content["bonesId"],
                Skins         = content["skins"],
                IndexedColors = content["indexedColors"],
                Scales        = content["scales"],
                SubEntityLook = new SubEntity[content["subEntityLook"].Length]
            };

            for (int i = 0; i < look.SubEntityLook.Length; i++)
            {
                look.SubEntityLook[i] = content["subEntityLook"][i].FromSubEntity();
            }

            return(look);
        }
        public static string EntityLookToString(this ProtocolJsonContent content)
        {
            string bonesId = $"{content["bonesId"]}";
            string skins   = "";

            for (int i = 0; i < content["skins"].Length; i++)
            {
                skins += $"{content["skins"][i]}{(i < content["skins"].Length - 1 ? "," : "")}";
            }

            string indexedColors;

            try
            {
                indexedColors = $"1={content["indexedColors"][0]},2={content["indexedColors"][1]},3={content["indexedColors"][2]},4={content["indexedColors"][3]},5={content["indexedColors"][4]}";
            }
            catch
            {
                indexedColors = "";
            }
            string scales = "";

            for (int i = 0; i < content["scales"].Length; i++)
            {
                scales += $"{content["scales"][i]}{(i < content["scales"].Length - 1 ? "," : "")}";
            }

            string result = "{" + bonesId;

            if (skins != "")
            {
                result += $"|{skins}";
            }
            if (indexedColors != "")
            {
                result += $"|{indexedColors}";
            }
            if (scales != "")
            {
                result += $"|{scales}";
            }

            return(result + "}");
        }
Example #15
0
        private static dynamic _readElement(this ClassField field, ref IDataReader reader)
        {
            if (IsPrimitiv(field.type))
            {
                string read_method = $"Read{field.write_method.Replace("write", "")}";
                return(read_method._readMethod(ref reader));
            }
            else
            {
                NetworkElement      network_element = null;
                ProtocolJsonContent content         = null;

                bool is_null = false;
                if (field.write_false_if_null_method != null && field.write_false_if_null_method != "")
                {
                    string check_null_method = $"Read{field.write_false_if_null_method.Replace("write", "")}";
                    is_null = check_null_method._readMethod(ref reader) == 0;
                }

                if (is_null)
                {
                    return(null);
                }

                if (!field.prefixed_by_type_id)
                {
                    network_element = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.Types, x => x.name == field.type];
                }
                else
                {
                    string  read_id_method = $"Read{field.write_type_id_method.Replace("write", "")}";
                    dynamic protocol_id    = read_id_method._readMethod(ref reader);
                    content = new ProtocolJsonContent();
                    content["protocol_id"] = protocol_id;

                    network_element = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.Types, x => x.protocolID == protocol_id];
                }

                return(FromBytes(content, network_element, reader));
            }
        }
        public static Bitmap FromWeb(this ProtocolJsonContent content)
        {
            byte[] data     = Encoding.ASCII.GetBytes(content.EntityLookToString());
            string data_str = data.ToHexString(false).ToLower();
            string url      = $"https://static.ankama.com/dofus/renderer/look/{data_str}/full/1/150_220-10.png";

            using (WebClient client = new WebClient())
            {
                client.Headers.Set(HttpRequestHeader.Host, "static.ankama.com");
                client.Headers.Set(HttpRequestHeader.Accept, "image/webp,image/apng,image/*,*/*;q=0.8");

                try
                {
                    Stream stream = client.OpenRead(new Uri(url));
                    return(new Bitmap(stream));
                }
                catch
                {
                    return(null);
                }
            }
        }
Example #17
0
        private ActorModel Parse(ProtocolJsonContent content, double mapId)
        {
            // GameRolePlayCharacterInformations or
            // GameRolePlayMerchantInformations
            if (content["protocol_id"] == 36 || content["protocol_id"] == 129)
            {
                ProtocolJsonContent humanoidInfo   = content["humanoidInfo"];
                ProtocolJsonContent alignmentInfos = content["alignmentInfos"];
                short level = (short)(alignmentInfos is null ? 0 : (alignmentInfos["characterPower"] - content["contextualId"]));

                return(new PlayerModel()
                {
                    Id = content["contextualId"],
                    Level = level,
                    Name = content["name"],
                    IsMerchant = content["protocol_id"] == 129,
                    MapId = mapId
                });
            }

            return(null);
        }
        public static ActorModel FromActorRolePlayInformation(this ProtocolJsonContent content)
        {
            if (content["protocol_id"] == 36 || content["protocol_id"] == 129)
            {
                ProtocolJsonContent alignmentInfos = content["alignmentInfos"];
                ProtocolJsonContent humanoidInfos  = content["humanoidInfo"];
                short level = (short)(alignmentInfos is null ? 0 : (alignmentInfos["characterPower"] - content["contextualId"]));

                return(new PlayerModel()
                {
                    Id = content["contextualId"],
                    Level = level,
                    Name = content["name"],
                    IsMerchant = content["protocol_id"] == 129,
                    Sex = humanoidInfos["sex"],

                    BreedId = 0,
                    Look = content["look"]
                });
            }

            return(null);
        }
Example #19
0
        private void ClientMessageInformation_OnMessageParsed(NetworkElementField obj, ProtocolJsonContent con)
        {
            ProxyManager.Instance[ProcessId].LAST_GLOBAL_INSTANCE_ID = ClientMessageInformation.Information.InstanceId;
            ProxyManager.Instance[ProcessId].SERVER_MESSAGE_RCV      = 0;
            uint instance_id = ClientMessageInformation.Information.InstanceId + ProxyManager.Instance[ProcessId].FAKE_MESSAGE_SENT;

            if (ConfigurationManager.Instance.Startup.show_message)
            {
                Console.WriteLine($"[Client({FakeClient.RemoteIP})] (n°{instance_id} | ({ClientMessageInformation.Information.InstanceId} + {ProxyManager.Instance[ProcessId].FAKE_MESSAGE_SENT})) {obj.name} ({obj.protocolID})");
                if (ConfigurationManager.Instance.Startup.show_message_content)
                {
                    Console.WriteLine($"{con}");
                }
            }

            FakeClient.Send(ClientMessageInformation.Information.ReWriteInstanceId(instance_id));
            HandlerManager.Instance.Handle((uint)obj.protocolID, this, con);
        }
Example #20
0
 private void RemoteClient_OnCustomMessageSent(NetworkElement arg1, ProtocolJsonContent arg2)
 {
     FAKE_MESSAGE_SENT++;
 }
Example #21
0
        public void Handle(string protocolName, ProxyElement proxy, ProtocolJsonContent content)
        {
            MethodInfo method = _handlers.FirstOrDefault(x => x.GetCustomAttribute <HandlerAttribute>().ProtocolName == protocolName);

            Handle(method, proxy, content);
        }
Example #22
0
        public void HandleCharacterSelectedSuccessMessage(ProxyElement proxy, NetworkElementField message, ProtocolJsonContent content)
        {
            PlayerModel model = new PlayerModel()
            {
                Id         = content["infos"]["id"],
                Name       = content["infos"]["name"],
                Level      = content["infos"]["level"],
                IsMerchant = false
            };

            ProxyManager.Instance[proxy.ProcessId].CharacterSelected = model;

            FastEventManager.Instance.Handle(FastEventEnum.PlayerSelected, model);
        }
Example #23
0
        public void Handle(string protocolName, CustomClient local, CustomClient remote, ProtocolJsonContent content)
        {
            Type type = handlersType.FirstOrDefault(x => x.GetCustomAttribute <HandlerAttribute>().ProtocolName.ToLower() == protocolName.ToLower());

            Handle(type, local, remote, content);
        }
Example #24
0
        public void Handle(int protocolId, CustomClient local, CustomClient remote, ProtocolJsonContent content)
        {
            Type type = handlersType.FirstOrDefault(x => x.GetCustomAttribute <HandlerAttribute>().ProtocolId == protocolId);

            Handle(type, local, remote, content);
        }
Example #25
0
        public void HandleGameContextRemoveElementMessage(ProxyElement proxy, NetworkElementField message, ProtocolJsonContent content)
        {
            double mapId = ProxyManager.Instance[proxy.ProcessId].CharacterSelected.MapId;

            FastEventManager.Instance.Handle(FastEventEnum.ElementRemovedMap, content["id"], mapId);
        }
Example #26
0
        public void HandleGameRolePlayShowActorMessage(ProxyElement proxy, NetworkElementField message, ProtocolJsonContent content)
        {
            double     mapId = ProxyManager.Instance[proxy.ProcessId].CharacterSelected.MapId;
            ActorModel model = Parse(content["informations"], mapId);

            if (model != null)
            {
                FastEventManager.Instance.Handle(FastEventEnum.PlayerEnterMap, model);
            }
        }
Example #27
0
        public void HandleMapComplementaryInformationsDataMessage(ProxyElement proxy, NetworkElementField message, ProtocolJsonContent content)
        {
            MapModel map = new MapModel()
            {
                MapId = content["mapId"]
            };

            ProxyManager.Instance[proxy.ProcessId].CharacterSelected.MapId = map.MapId;

            foreach (ProtocolJsonContent actor in content["actors"])
            {
                ActorModel model = Parse(actor, content["mapId"]);
                if (model != null)
                {
                    map.Actors.Add(model);
                }
            }

            FastEventManager.Instance.Handle(FastEventEnum.PlayerSelectedEnterMap, map);
        }
Example #28
0
 public void SendClient(dynamic value, ProtocolJsonContent content)
 {
     Client.Send(ProcessId, value, content, false);
 }
Example #29
0
 public void SendServer(dynamic value, ProtocolJsonContent content)
 {
     FakeClient.Send(ProcessId, value, content);
 }
Example #30
0
        private void ServerMessageInformation_OnMessageParsed(NetworkElementField obj, ProtocolJsonContent con)
        {
            ProxyManager.Instance[ProcessId].SERVER_MESSAGE_RCV++;
            if (ConfigurationManager.Instance.Startup.show_message)
            {
                Console.WriteLine($"[Server({FakeClient.RemoteIP})] {obj.name} ({obj.protocolID})");
                if (ConfigurationManager.Instance.Startup.show_message_content)
                {
                    Console.WriteLine($"{con}");
                }
            }

            HandlerManager.Instance.Handle((uint)obj.protocolID, this, con);
        }