public PacketEditor(WPacket packet)
{
this.packet = packet;
pro = new PacketPro(packet);
pro.onReadPropError += Pro_onReadPropError;
pro.onReadPropComplete += Pro_onReadPropComplete;
InitializeComponent();
}
public void OpenFile(string fileName)
{
if (!File.Exists(fileName))
{
return;
}
if (fileName.ToLower().EndsWith(".lrf"))
{
loading.Show("Wait..", "Parsing..");
string checkWDC = new FileInfo(fileName).Directory.FullName + "/" + Path.GetFileNameWithoutExtension(fileName) + ".wdc";
if (File.Exists(checkWDC))
{
OpenFile(checkWDC);
return;
}
ParseFile(fileName);
string newFile = new FileInfo(fileName).Directory.FullName + "/" + Path.GetFileNameWithoutExtension(fileName) + ".json";
OpenJSON(newFile);
}
else if (fileName.ToLower().EndsWith(".json"))
{
string checkWDC = new FileInfo(fileName).Directory.FullName + "/" + Path.GetFileNameWithoutExtension(fileName) + ".wdc";
if (File.Exists(checkWDC))
{
OpenFile(checkWDC);
return;
}
OpenJSON(fileName);
}
else if (fileName.ToLower().EndsWith(".wdc"))
{
OpenWDC(fileName);
}
else
{
//Fake packet
byte[] bts = File.ReadAllBytes(fileName);
WPacket fake = new WPacket();
fake.Head = 0;
fake.Bytes = bts;
PacketEditor editor = new PacketEditor(fake);
TabItem tbitem = new TabItem()
{
Header = fileName
};
tbitem.Content = editor;
tabControl.Items.Add(tbitem);
tabControl.SelectedItem = tbitem;
}
}
private List <WPacket> handleReliable2(BinaryReader reader, float time, bool C2S)
{
var len = reader.ReadUInt16(true);
//if (reader.BaseStream.Length - reader.BaseStream.Position < len)
// return;
List <WPacket> ret = new List <WPacket>();
var packet = reader.ReadBytes(len);
if (packet.Length < 1)
{
return(null);
}
var decrypted = decrypt(packet);
WPacket pck = new WPacket();
pck.Time = this.Time;
pck.Bytes = decrypted;
pck.Length = pck.Bytes.Length;
pck.Head = (PacketCmdS2C)decrypted[0];
ret.Add(pck);
printPacket(decrypted, time, C2S, false);
if (decrypted[0] == 0xFF)
{
logLine(Environment.NewLine + "===Printing batch===");
try
{
ret.AddRange(decodeBatch(decrypted, time, C2S));
}
catch
{
logLine("Batch parsing threw an exception.");
}
logLine("======================end batch==========================" + Environment.NewLine);
}
return(ret);
}
public void Load(WPacket packet)
{
this.packet = packet;
this.Head = (PacketCmdS2C)packet.Bytes[0];
//if (packet.Bytes.Length > 1)
//{
// byte[] nwbts = new byte[packet.Bytes.Length - 1];
// Buffer.BlockCopy(packet.Bytes, 1, nwbts, 0, nwbts.Length);
// packet.Bytes = nwbts;
//}
string f1 = AppDomain.CurrentDomain.BaseDirectory + "/Packets/" + Convert.ToInt32(this.Head) + "_" + this.packet.Length + ".json";
string f2 = AppDomain.CurrentDomain.BaseDirectory + "/Packets/" + Convert.ToInt32(this.Head) + ".json";
string f3 = AppDomain.CurrentDomain.BaseDirectory + "/Packets/" + this.Head.ToString() + ".json";
if (File.Exists(f1))
{
string rd = File.ReadAllText(f1);
var thisClass = JsonConvert.DeserializeObject <PacketPro>(rd);
setClass(thisClass);
LoadPropsValues();
return;
}
if (File.Exists(f2))
{
string rd = File.ReadAllText(f2);
var thisClass = JsonConvert.DeserializeObject <PacketPro>(rd);
setClass(thisClass);
LoadPropsValues();
return;
}
if (File.Exists(f3))
{
string rd = File.ReadAllText(f3);
var thisClass = JsonConvert.DeserializeObject <PacketPro>(rd);
setClass(thisClass);
LoadPropsValues();
return;
}
LoadPropsValues();
}
private List <WPacket> decodeBatch(byte[] decrypted, float time, bool C2S)
{
List <WPacket> ret = new List <WPacket>();
var reader = new BinaryReader(new MemoryStream(decrypted));
reader.ReadByte();
var packetCount = reader.ReadByte();
var size = reader.ReadByte();
var opCode = reader.ReadByte();
var netId = reader.ReadUInt32(true);
var firstPacket = new List <byte>();
firstPacket.Add(opCode);
firstPacket.AddRange(BitConverter.GetBytes(netId).Reverse());
if (size > 5)
{
firstPacket.AddRange(reader.ReadBytes(size - 5));
}
logLine("Packet 1, Length " + size);
printPacket(firstPacket.ToArray(), time, C2S, false);
WPacket pc = new WPacket();
pc.Time = this.Time;
pc.Bytes = firstPacket.ToArray();
pc.Length = pc.Bytes.Length;
pc.Head = (PacketCmdS2C)pc.Bytes[0];
ret.Add(pc);
for (int i = 2; i < packetCount + 1; i++)
{
var buffer = new List <byte>();
uint newId = 0;
bool netIdChanged = false;
byte command;
var flagsAndLength = reader.ReadByte(); // 6 first bits = size (if not 0xFC), 2 last bits = flags
size = (byte)(flagsAndLength >> 2);
if ((flagsAndLength & 0x01) > 0)
{ // additionnal byte, skip command
command = opCode;
if ((flagsAndLength & 0x02) > 0)
{
reader.ReadByte();
}
else
{
newId = reader.ReadUInt32(true);
netIdChanged = true;
}
}
else
{
command = reader.ReadByte();
if ((flagsAndLength & 0x02) > 0)
{
reader.ReadByte();
}
else
{
newId = reader.ReadUInt32(true);
netIdChanged = true;
}
}
if (size == 0x3F)
size = reader.ReadByte(); // size is too big to be on 6 bits, so instead it's stored later
}
logLine("Packet " + i + ", Length " + (size + 5));
buffer.Add(command);
if (netIdChanged)
{
buffer.AddRange(BitConverter.GetBytes(newId).Reverse());
netId = newId;
}
else
{
buffer.AddRange(BitConverter.GetBytes(netId).Reverse());
}
buffer.AddRange(reader.ReadBytes(size));
printPacket(buffer.ToArray(), time, C2S, false);
WPacket pc2 = new WPacket();
pc2.Time = this.Time;
pc2.Bytes = buffer.ToArray();
pc2.Length = pc2.Bytes.Length;
pc2.Head = (PacketCmdS2C)pc2.Bytes[0];
ret.Add(pc2);
opCode = command;
}
private List <WPacket> decodeBatch2(byte[] decrypted, float time, bool C2S)
{
var reader = new BinaryReader(new MemoryStream(decrypted));
var unk1 = reader.ReadByte();
List <WPacket> ret = new List <WPacket>();
try
{
var packetCount = reader.ReadByte();
var size = reader.ReadByte();
var opCode = reader.ReadByte();
var netId = reader.ReadUInt32(true);
var firstPacket = new List <byte>();
firstPacket.Add(opCode);
firstPacket.AddRange(BitConverter.GetBytes(netId).Reverse());
if (size > 5)
{
firstPacket.AddRange(reader.ReadBytes(size - 5));
}
logLine("Packet 1, Length " + size);
printPacket(firstPacket.ToArray(), time, C2S, false);
WPacket pck = new WPacket();
pck.Time = this.Time;
pck.Bytes = firstPacket.ToArray();
pck.Length = pck.Bytes.Length;
pck.Head = (PacketCmdS2C)pck.Bytes[0];
ret.Add(pck);
for (int i = 2; i < packetCount + 1; i++)
{
var buffer = new List <byte>();
uint newId = 0;
byte command;
var flagsAndLength = 0;
try
{
if (reader.BaseStream.Position + 1 > reader.BaseStream.Length)
{
break;
}
reader.ReadByte(); // 6 first bits = size (if not 0xFC), 2 last bits = flags
}
catch (Exception)
{
}
size = (byte)(flagsAndLength >> 2);
if ((flagsAndLength & 0x01) > 0)
{ // additionnal byte, skip command
command = opCode;
try
{
if (reader.BaseStream.Position + 1 > reader.BaseStream.Length)
{
break;
}
reader.ReadByte();
}
catch (Exception)
{
}
}
else
{
if (reader.BaseStream.Position + 1 > reader.BaseStream.Length)
{
break;
}
command = reader.ReadByte();
if ((flagsAndLength & 0x02) > 0)
{
try
{
if (reader.BaseStream.Position + 1 > reader.BaseStream.Length)
{
break;
}
reader.ReadByte();
}
catch (Exception)
{
}
}
else
{
try
{
if (reader.BaseStream.Position + 4 > reader.BaseStream.Length)
{
break;
}
newId = reader.ReadUInt32(true);
}
catch (Exception)
{
}
}
}
try
{
if (reader.BaseStream.Position + 1 > reader.BaseStream.Length)
{
break;
}
if (size == 0x3F)
{
size = reader.ReadByte(); // size is too big to be on 6 bits, so instead it's stored later
}
}
catch (Exception)
{
}
//logLine("Packet " + i + ", Length " + (size + 5));
buffer.Add(command);
if (newId > 0)
{
buffer.AddRange(BitConverter.GetBytes(newId).Reverse());
}
else
{
buffer.AddRange(BitConverter.GetBytes(netId).Reverse());
}
try
{
if (reader.BaseStream.Position + size > reader.BaseStream.Length)
{
break;
}
buffer.AddRange(reader.ReadBytes(size));
}
catch (Exception)
{ }
printPacket(buffer.ToArray(), time, C2S, false);
WPacket pck2 = new WPacket();
pck2.Time = this.Time;
pck2.Bytes = buffer.ToArray();
pck2.Length = pck2.Bytes.Length;
pck2.Head = (PacketCmdS2C)pck2.Bytes[0];
ret.Add(pck2);
opCode = command;
}
}
catch (Exception)
{
}
return(ret);
}
private WPacket handleFragment(BinaryReader reader, float time, bool C2S)
{
var fragmentGroup = reader.ReadUInt16(); // Fragment start number
var len = reader.ReadUInt16(true);
if (reader.BaseStream.Length - reader.BaseStream.Position < len + 16)
{
return(null);
}
var totalFragments = reader.ReadInt32(true);
var currentFragment = reader.ReadInt32(true);
var totalLen = reader.ReadInt32(true);
reader.ReadInt32(); // Offset
var payload = reader.ReadBytes(len);
if (!fragmentBuffer.ContainsKey(fragmentGroup))
{
fragmentBuffer.Add(fragmentGroup, new Dictionary <int, byte[]>());
}
var buff = fragmentBuffer[fragmentGroup];
if (buff.ContainsKey(currentFragment))
{
buff[currentFragment] = payload;
}
else
{
buff.Add(currentFragment, payload);
}
if (buff.Count == totalFragments)
{
var packet = new List <byte>();
var temp = buff.OrderBy(x => x.Key);
foreach (var t in temp)
{
packet.AddRange(t.Value);
}
if (totalLen != packet.Count)
{
return(null);// logLine("Fragment's fishy. " + totalLen + "!=" + packet.Count);
}
var decrypted = decrypt(packet.ToArray());
printPacket(decrypted, time, C2S);
WPacket pck = new WPacket();
pck.Time = time;
pck.Head = (PacketCmdS2C)decrypted[0];
pck.Bytes = decrypted;
pck.Length = pck.Bytes.Length;
fragmentBuffer.Remove(fragmentGroup);
return(pck);
}
return(null);
}
public PacketPro(WPacket packet)
{
this.Load(packet);
}
