public static byte[] WhatsappEncrypt(byte[] key, byte[] data, bool appendHash)
{
if (encryptionOutgoing == null)
{
encryptionOutgoing = new RC4(key, 256);
}
HMACSHA1 h = new HMACSHA1(key);
byte[] buff = new byte[data.Length];
Buffer.BlockCopy(data, 0, buff, 0, data.Length);
encryptionOutgoing.Cipher(buff);
byte[] hashByte = h.ComputeHash(buff);
byte[] response = new byte[4 + buff.Length];
if (appendHash)
{
Buffer.BlockCopy(buff, 0, response, 0, buff.Length);
Buffer.BlockCopy(hashByte, 0, response, buff.Length, 4);
}
else
{
Buffer.BlockCopy(hashByte, 0, response, 0, 4);
Buffer.BlockCopy(buff, 0, response, 4, buff.Length);
}
return(response);
}
private void Send(Packet packet, bool client)
{
lock (client ? _clientLock : _serverLock)
{
MemoryStream ms = new MemoryStream();
using (PacketWriter w = new PacketWriter(ms))
{
w.Write(0);
w.Write(packet.Id);
packet.Write(w);
}
byte[] data = ms.ToArray();
PacketWriter.BlockCopyInt32(data, data.Length);
if (client)
{
ConsoleUtilities.VerboseWriteLine($"Sent {packet.Type} to the client");
_clientSendCipher.Cipher(data);
LoggingUtilities.LogPacketToFile(packet, client);
if (!_closed)
{
_clientStream.Write(data, 0, data.Length);
}
}
else
{
ConsoleUtilities.VerboseWriteLine($"Sent {packet.Type} to the server");
_serverSendCipher.Cipher(data);
if (!_closed)
{
_serverStream.Write(data, 0, data.Length);
}
}
}
}
public void SendPacket(OutgoingPacket packet)
{
if (!_socket.Connected)
{
return;
}
MemoryStream ms = new MemoryStream();
using (PacketOutput output = new PacketOutput(ms))
{
output.Write(0);
output.Write(packet.GetPacketType().ToId());
packet.Write(output);
}
byte[] buffer = ms.ToArray();
_outgoingEncryption.Cipher(buffer, 5);
int size = buffer.Length;
byte[] a = BitConverter.GetBytes(IPAddress.NetworkToHostOrder(size));
buffer[0] = a[0];
buffer[1] = a[1];
buffer[2] = a[2];
buffer[3] = a[3];
_socket?.Send(buffer);
}
private void ReadCallback(IAsyncResult ar)
{
CustomBuffer cb = (ar.AsyncState as (NetworkStream _ns, CustomBuffer _cb)? ?? (null, null))._cb;
NetworkStream ns = (ar.AsyncState as (NetworkStream _ns, CustomBuffer _cb)? ?? (null, null))._ns;
bool isClient = ns == _clientStream;
RC4 currCipher = isClient ? _clientRecvCipher : _serverRecvCipher;
if (!ns.CanRead)
{
return;
}
int read = ns.EndRead(ar);
cb.Walk(read);
if (read == 0)
{
Dispose();
}
else if (cb.Idx == 4)
{
cb.ResizeBuffer(IPAddress.NetworkToHostOrder(BitConverter.ToInt32(cb.Buffer, 0)));
Read(cb.Idx, cb.Remaining, isClient);
}
else if (cb.Remaining > 0)
{
Read(cb.Idx, cb.Remaining, isClient);
}
else
{
currCipher.Cipher(cb.Buffer);
ConsoleUtilities.VerboseWriteLine("Received Data! Size: " + cb.Buffer.Length);
Packet p = Packet.Construct(cb.Buffer);
ConsoleUtilities.VerboseWriteLine("Received Data is a " + p.Type + " packet!");
if (isClient)
{
_proxy.ClientPacketSent(this, p);
}
else
{
_proxy.ServerPacketSent(this, p);
}
if (p.Send)
{
Send(p, !isClient);
}
cb.Clear();
Read(0, 4, isClient);
}
}
public static byte[] WhatsappDecrypt(byte[] key, byte[] data)
{
if (encryptionIncoming == null)
{
encryptionIncoming = new RC4(key, 256);
}
byte[] buff = new byte[data.Length];
Buffer.BlockCopy(data, 0, buff, 0, data.Length);
encryptionIncoming.Cipher(buff);
return(buff);
}
private void ProcessPacket(byte type, int size)
{
byte[] buffer = new byte[size];
int received = 0;
while (received < size)
{
int read = _socket.Receive(buffer, received, size - received, SocketFlags.None);
if (read == 0)
{
// eof
Disconnect();
return;
}
received += read;
}
_incomingEncryption.Cipher(buffer, 0);
PacketType packetType = (PacketType)type;
IncomingPacket packet = IncomingPacket.Create(packetType);
if (packet != null && _hooks.ContainsKey(packetType))
{
MemoryStream ms = new MemoryStream(buffer);
using (PacketInput pi = new PacketInput(ms))
{
packet.Read(pi);
}
foreach (var hook in _hooks[packetType].ToArray())
{
try
{
hook(packet);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
private void ProcessPacket(byte type, int size)
{
try
{
byte[] buffer = new byte[size];
int received = 0;
while (received < size)
{
int read = _socket.Receive(buffer, received, size - received, SocketFlags.None);
if (read == 0)
{
// eof
Disconnect(DisconnectReason.EofBody.SetDetails("Read was 0."));
return;
}
received += read;
}
_incomingEncryption.Cipher(buffer, 0);
PacketType packetType = type.ToPacketType();
if (packetType == PacketType.UNKNOWN)
{
return;
}
IncomingPacket packet = IncomingPacket.Create(packetType);
if (packet != null)
{
MemoryStream ms = new MemoryStream(buffer);
using (PacketInput pi = new PacketInput(ms))
{
packet.Read(pi);
if (DebugPackets)
{
Log.Info("Received " + packet.GetPacketType());
}
}
foreach (Action <IncomingPacket> action in _anyPacketHook)
{
action.Invoke(packet);
}
if (_hooks.ContainsKey(packetType))
{
foreach (var hook in _hooks[packetType].ToArray())
{
try
{
hook(packet);
}
catch (Exception e)
{
Log.Info(e);
}
}
}
}
}
catch (Exception e)
{
Disconnect(DisconnectReason.ExceptionOnProcessPacket.SetDetails(e.Message));
}
}
