private void AddPacket(byte[] data, PacketOrigin origin, ushort port)
{
var decryption = new Decryption(data);
if (!decryption.Decrypt())
{
return;
}
data = decryption.Data;
var newData = new byte[data.Length + 3];
using (var stream = new MemoryStream(newData.Length))
{
stream.WriteByte((byte)origin);
stream.Write(BitConverter.GetBytes(port), 0, 2);
stream.Write(data, 0, data.Length);
newData = stream.GetBuffer();
}
_packets.Add(newData);
var logReader = new LogReader(newData, _onFinish);
logReader.Parse();
}
public SourcePacket(PacketOrigin origin, PacketType type, int? sequenceId, SourceRequestType requestType, string string1, string string2)
: base(origin, type)
{
this.RequestId = sequenceId;
this.RequestType = requestType;
this.ResponseType = SourceResponseType.None;
this.String1 = string1;
this.String2 = string2;
this.Words = string1.Wordify();
}
/// <summary>
/// Creates a new <see cref="DicePacketSequence"/> instance based on the given values
/// </summary>
/// <param name="id"></param>
/// <param name="type"></param>
/// <param name="origin"></param>
public DicePacketSequence(uint id, PacketType type, PacketOrigin origin)
{
#region Contracts
if (id > MaxIdValue)
{
var message = string.Format(Resources.EXC_MSG_PARAMETER_EXCEEDS_VALUE, MaxIdValue);
throw new ArgumentOutOfRangeException("id", id, message);
}
#endregion
Id = id;
Type = type;
Origin = origin;
}
public byte[] GetPacketByOrder(int order, out PacketOrigin origin)
{
origin = PacketOrigin.None;
if (this.ClientConversation.ContainsKey(order))
{
origin = PacketOrigin.Client;
return(this.ClientConversation[order]);//.ElementAt(order).Value;
}
else if (this.ServerConversation.ContainsKey(order))
{
origin = PacketOrigin.Server;
return(this.ServerConversation[order]);//.ElementAt(order).Value;
}
return(null);
}
public Parser(byte[] data, PacketOrigin origin, ushort port, ushort opcode)
{
_data = data;
_origin = origin;
_port = port;
_opcode = opcode;
_pos = 0;
if (!Dumper.IsEnabled)
{
return;
}
switch (opcode)
{
case 0x3049:
Dumper.ParseNpcToFile(data);
break;
case 0x305e:
Dumper.ParseMobTofile(data);
break;
case 0x100e:
Dumper.ParseOpenChat(data);
break;
case 0x1015:
Dumper.ParsePlaySound(data);
break;
case 0x1012:
Dumper.ParseOption(data);
break;
case 0x100f:
Dumper.ParseCloseChat();
break;
case 0x1006:
Dumper.ParseStoreItems(data);
break;
}
}
public void WritePaket(byte[] packet, PacketOrigin origin)
{
switch (origin)
{
case PacketOrigin.Server:
{
Form1.WriteLine(string.Format("Server Packet {0} Packet ID: {1}\n{2}\n", this.ServerPacketsParsed, BitConverter.ToInt32(packet, 4), Tools.GlobalFunctions.FormatBytes(packet)), System.Drawing.Color.Red);
Form1.WriteLine(Tools.GlobalFunctions.NiceHexOutput(packet), System.Drawing.Color.Red);
Form1.WriteLine("-----------------------------------------------------------------------------------------------------------------------------", System.Drawing.Color.Red);
}
break;
case PacketOrigin.Client:
{
Form1.WriteLine(string.Format("Client Packet {0} Packet ID: {1}\n{2}\n", this.ClientPacketsParsed, BitConverter.ToInt32(packet, 4), Tools.GlobalFunctions.FormatBytes(packet)), System.Drawing.Color.Green);
Form1.WriteLine(Tools.GlobalFunctions.NiceHexOutput(packet), System.Drawing.Color.Green);
Form1.WriteLine("-----------------------------------------------------------------------------------------------------------------------------", System.Drawing.Color.Green);
}
break;
}
}
private static ListViewModel FormatData(byte[] data, PacketOrigin origin, ushort port, uint index)
{
var packet = new ListViewModel();
using (var ms = new MemoryStream(data))
{
using (var stream = new BinaryReader(ms))
{
var size = stream.ReadUInt16();
stream.ReadInt32();
var opcode = stream.ReadUInt16();
// TODO - Remove later
if (opcode == 0x3006 || opcode == 0x30c2 || opcode == 0x30bf)
{
return(null);
}
var time = stream.ReadUInt32();
var template = new PacketListView
{
Lenght = size,
Index = index,
Time = time.ToString(),
Opcode = $"{opcode:x2}",
Origin = origin,
Data = data,
Port = port,
Name = ""
};
var parser = new Parser(data, origin, port, opcode);
var packetName = "";
packet.PacketParseListView = parser.ParseData(ref packetName);
template.Name = packetName;
packet.PacketListView = template;
}
}
return(packet);
}
public void WritePacket(byte[] data, PacketOrigin origin, ushort port)
{
if (data.Length > 0 && data[0] == 0x11 && data[1] == 0xF3)
{
var newData = new byte[data.Length - 4];
Array.Copy(data, 4, newData, 0, data.Length - 4);
data = newData;
}
var fullData = new byte[storedData.Length + data.Length];
Buffer.BlockCopy(storedData, 0, fullData, 0, storedData.Length);
Buffer.BlockCopy(data, 0, fullData, storedData.Length, data.Length);
storedData = new byte[0];
using (var ms = new MemoryStream(fullData))
{
using (var stream = new BinaryReader(ms))
{
while (stream.BaseStream.Position < stream.BaseStream.Length)
{
var size = BitConverter.ToUInt16(stream.ReadBytes(2), 0);
stream.BaseStream.Position -= 2;
if (stream.BaseStream.Position + size > stream.BaseStream.Length)
{
var pData = stream.ReadBytes((int)(stream.BaseStream.Length - stream.BaseStream.Position));
storedData = pData;
}
else
{
var pData = stream.ReadBytes(size);
AddPacket(pData, origin, port);
}
}
}
}
}
public CallOfDutyPacket(PacketOrigin origin, PacketType type, string password, string message)
: base(origin, type) {
this.Password = password;
this.Message = message;
}
public void DecodePacket(byte[] packet, PacketOrigin origin)
{
int p_len = 0;
int crc = 0;
if (origin == PacketOrigin.Client)
{
if (this.ClientPacketsParsed == 0)
{
this.ClientKey = Tools.GlobalFunctions.GetKeyFromKnownPacketID(packet, 14);
byte[] toXor = Tools.GlobalFunctions.GetPortionsToXOR(packet, out p_len, out crc, true);
byte[] xored = Xor.decrypt(toXor, this.ClientKey);
byte[] len = BitConverter.GetBytes(p_len);
byte[] full = new byte[len.Length + toXor.Length + 8];
Array.Copy(len, full, len.Length);
Array.Copy(BitConverter.GetBytes(14), 0, full, 4, BitConverter.GetBytes(14).Length);
Array.Copy(xored, 0, full, 8, xored.Length);
WritePaket(full, PacketOrigin.Client);
}
else if (this.ClientKey != null)
{
byte[] toXor = Tools.GlobalFunctions.GetPortionsToXOR(packet, out p_len, out crc);
byte[] len = BitConverter.GetBytes(p_len);
byte[] xor = Xor.decrypt(toXor, this.ClientKey);
byte[] full = new byte[len.Length + toXor.Length + 4];
Array.Copy(len, full, len.Length);
Array.Copy(xor, 0, full, 4, xor.Length);
WritePaket(full, PacketOrigin.Client);
//WritePaket(packet, origin);
}
this.ClientPacketsParsed++;
}
else if (origin == PacketOrigin.Server)
{
if (this.ServerPacketsParsed == 1)
{
byte[] p1 = new byte[32];
// Get the last 32 bytes
Array.Copy(packet, (packet.Length - 32), p1, 0, p1.Length);
// This is our server decode packet
//int k = 0;
int t = 0;
int lnk = 0;
#region While
while (t < p1.Length)
{
lnk = BitConverter.ToInt32(p1, t);
lnk += 4;
bx = new byte[lnk];
Array.Copy(p1, t + 4, bx, 0, lnk);
t += lnk + 4;
//if (k == 0)
//{
this.uc = new cryption(bx);
uc.decript(bx, 0x19);
//}
//else
// {
// }
// Get the length -4
Int32 length = uc.data.Length - 4;
byte[] p_len2 = BitConverter.GetBytes(length);
byte[] fullPacket = new byte[p_len2.Length + uc.data.Length];
Array.Copy(p_len2, fullPacket, p_len2.Length);
Array.Copy(uc.data, 0, fullPacket, 4, uc.data.Length);
WritePaket(fullPacket, PacketOrigin.Server);
//rt_op.AppendText(FormatBytes(fullPacket));//.Text += FormatBytes(fullPacket);//(uc.data) + "\n";//ByteArrayToHexString(uc.data) + "\n";
//rt_op.SelectionColor = Color.Red;
//rt_op.AppendText(NiceHexOutput(fullPacket));
}
#endregion
}
else if (this.ServerPacketsParsed >= 2)
{
//this.uc.data = packet;
// remove first 4
byte[] data = new byte[packet.Length - 4];
Array.Copy(packet, 4, data, 0, data.Length);
//int pos = this.uc.data.Length;
//Array.Resize(ref this.uc.data, this.uc.data.Length + packet.Length);
//Array.Copy(packet, 0, this.uc.data, pos, packet.Length);
//this.uc.data = packet;
this.uc.decript(data);
//Form1.WriteLine(string.Format("Length of this packet divisible by 4 ? {0}", packet.Length % 4 == 0));
WritePaket(this.uc.data, PacketOrigin.Server);
}
this.ServerPacketsParsed++;
}
}
