Пример #1
0
        /// <summary>
        /// Handles packet
        /// </summary>
        public static void HandlePacket(Packet packet)
        {
            // Known packet => Parse it
            if (JsonPackets.ContainsKey(packet.ID))
            {
                wrapper = JsonPackets[packet.ID];
                pp      = JsonParseHelper.ParsePacket(wrapper, packet);
            }
            // Unknown packet => Save payload
            else
            {
                pp               = new ParsedPacket();
                pp.PacketID      = packet.ID;
                pp.PacketName    = "Unknown";
                pp.PayloadLength = packet.DecryptedPayload.Length;
                pp.ParsedFields  = Fields;

                // Payload
                pp.ParsedFields.Add(new ParsedField <object>
                {
                    FieldLength = packet.DecryptedPayload.Length,
                    FieldName   = "Payload",
                    FieldType   = FieldType.String,
                    FieldValue  = packet.DecryptedPayload.ToHexString()
                });
            }

            // Check if the packet is known
            if (Config.JSON_Logging && pp.PacketName != "Unknown")
            {
                foreach (var v in pp.ParsedFields)
                {
                    Logger.Log(v.FieldName + " : " + v.FieldValue, LogType.JSON);
                }

                var path = @"JsonPackets\\" + Config.Game + "_" + pp.PacketID + "_" +
                           string.Format("{0:dd-MM_hh-mm-ss}", DateTime.Now) + ".json";
                using (var file = File.CreateText(path))
                {
                    var serializer = new JsonSerializer();
                    serializer.Formatting = Formatting.Indented;
                    serializer.Serialize(file, pp);
                }
            }
        }
Пример #2
0
        /// <summary>
        /// Parses a packet
        /// </summary>
        public static ParsedPacket ParsePacket(JSONPacketWrapper wrapper, Packet p)
        {
            var pack = new ParsedPacket();

            pack.PacketID      = p.ID;
            pack.PacketName    = wrapper.PacketName;
            pack.PayloadLength = p.DecryptedPayload.Length;

            var parsedFields = new List <ParsedField <object> >();

            using (var br = new BinaryReader(new MemoryStream(p.DecryptedPayload)))
            {
                foreach (var field in wrapper.Fields)
                {
                    try
                    {
                        if (field.FieldType == FieldType.Bytes)
                        {
                            int    toRead   = 0;
                            string replaced = ReplaceWildcards(field.BytesToRead, parsedFields);

                            if (replaced != null)
                            {
                                if (IsNumber(replaced))
                                {
                                    toRead = Convert.ToInt32(replaced);
                                }
                            }
                            else
                            {
                                if (IsNumber(field.BytesToRead))
                                {
                                    toRead = Convert.ToInt32(field.BytesToRead);
                                }
                            }
                            if (toRead > 0)
                            {
                                var value = br.ReadBytes(toRead);

                                parsedFields.Add(new ParsedField <object>()
                                {
                                    FieldLength = value.Length,
                                    FieldName   = field.FieldName,
                                    FieldType   = FieldType.Bytes,
                                    FieldValue  = BitConverter.ToString(value)
                                });
                            }
                        }
                        else
                        {
                            var value = br.ReadField(field.FieldType);
                            parsedFields.Add(new ParsedField <object>
                            {
                                FieldLength = GetObjectSize(value),
                                FieldName   = field.FieldName,
                                FieldType   = field.FieldType,
                                FieldValue  = value
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.Log("Exception occured while Parsing Packet: " + ex);
                    }
                }
            }
            pack.ParsedFields = parsedFields.Count > 0 ? parsedFields : null;
            return(pack);
        }