public static void SendWardenPacket(ref Packets.PacketClass Packet) { // START Warden Encryption var b = new byte[(Packet.Data.Length - 6)]; Buffer.BlockCopy(Packet.Data, 6, b, 0, b.Length); RC4.Crypt(ref b, Maiev.KeyOut); Buffer.BlockCopy(b, 0, Packet.Data, 6, b.Length); // END Worldserver.Send(Packet); }
public byte[] EncryptText(EncryptTextMessage message) { byte[] encryptedText = null; //Odradi se enkripcija if (message.Algorithm == AlgorithmType.RC4) { RC4 rc = new RC4(message.Key, message.IV); encryptedText = rc.Crypt(message.Data); } else if (message.Algorithm == AlgorithmType.RC4CTR) { RC4 rc = new RC4(message.Key, message.IV); encryptedText = rc.CryptWithCTR(message.Data); } else if (message.Algorithm == AlgorithmType.A52 || message.Algorithm == AlgorithmType.A52CTR) { A52 alg = new A52(); alg.SetKey(message.Key); alg.SetF(message.FKeyA52); if (message.Algorithm == AlgorithmType.A52) { encryptedText = alg.Crypt(message.Data); } else { alg.SetIV(message.IV); encryptedText = alg.CryptWithCTR(message.Data); } } else if (message.Algorithm == AlgorithmType.RSA) { RSA rsa = new RSA(); rsa.E = new BigInteger(message.Key); rsa.P = new BigInteger(message.P); rsa.Q = new BigInteger(message.Q); rsa.GenerateRSA(); //BigInteger result = rsa.Crypt(new BigInteger(message.Data)); //encryptedText = result.ToByteArray(); encryptedText = rsa.Crypt(message.Data); } else if (message.Algorithm == AlgorithmType.TigerHash) { TigerHash th = new TigerHash(); byte[] msg = message.Data; encryptedText = th.ComputeHash(message.Data); } return(encryptedText); }
public bool LoadModule(string Name, ref byte[] Data, byte[] Key) { Key = RC4.Init(Key); RC4.Crypt(ref Data, Key); var UncompressedLen = BitConverter.ToInt32(Data, 0); if (UncompressedLen < 0) { Console.WriteLine("[WARDEN] Failed to decrypt {0}, incorrect length.", Name); return(false); } var CompressedData = new byte[(Data.Length - 0x108)]; Array.Copy(Data, 4, CompressedData, 0, CompressedData.Length); var dataPos = 4 + CompressedData.Length; var Sign = Conversions.ToString((char)Data[dataPos + 3]) + (char)Data[dataPos + 2] + (char)Data[dataPos + 1] + (char)Data[dataPos]; if (Sign != "SIGN") { Console.WriteLine("[WARDEN] Failed to decrypt {0}, sign missing.", Name); return(false); } dataPos += 4; var Signature = new byte[256]; Array.Copy(Data, dataPos, Signature, 0, Signature.Length); // Check signature if (CheckSignature(Signature, Data, Data.Length - 0x104) == false) { Console.WriteLine("[WARDEN] Signature fail on Warden Module."); return(false); } var DecompressedData = new ZipService().DeCompress(CompressedData); MemoryStream ms = new(DecompressedData); BinaryReader br = new(ms); ModuleData = PrepairModule(ref br); ms.Close(); ms.Dispose(); br = null; Console.WriteLine("[WARDEN] Successfully prepaired Warden Module."); return(InitModule(ref ModuleData)); }
public Eeprom(string file) { Data = File.ReadAllBytes(file); if (Data.Length != Size) { throw new InvalidDataException("EEPROM must be 256 bytes."); } Stream = new MemoryStream(Data); Reader = new BinaryReader(Stream); Writer = new BinaryWriter(Stream); HmacSha1 sha = new HmacSha1(); RC4 rc4 = new RC4(); EepromVersion version = 0; // loop through each version attempting to decrypt the security data while (version <= EepromVersion.RetailLast) { byte[] origHash = Data.Subset(0, 20); // decrypt according to the specified version rc4.Init(sha.Compute(version, origHash)); byte[] decrypted = Data.Subset(0x14, 0x1C); rc4.Crypt(decrypted, 0, decrypted.Length); // if decrypted data hash matches the original then it's valid and the specific version is now known if (origHash.IsEqual(sha.Compute(version, decrypted))) { // update with the decrypted data Stream.Position = 0x14; Writer.Write(decrypted); // set the detected version Version = version; break; } version++; } }
/// <summary> /// Saves the eeprom contents to file. /// If the version is unknown the security section will not be overwritten. /// </summary> /// <param name="file"></param> public void Save(string file) { UpdateChecksums(); // skip writing security section if version is unknown if (Version == EepromVersion.Unknown) { using (FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Write, FileShare.None)) { fs.Position = 0x30; fs.Write(Data, 0x30, Size - 0x30); } } else { // copy data to a separate buffer byte[] eepromCopy = new byte[Size]; Data.CopyTo(eepromCopy, 0); // update security section of copy if (Version != EepromVersion.Unknown) { HmacSha1 sha = new HmacSha1(); RC4 rc4 = new RC4(); // hash decrypted confounder/hddkey/region byte[] hash = sha.Compute(Version, eepromCopy.Subset(0x14, 0x1C)); hash.CopyTo(eepromCopy, 0); // re-encrypt data rc4.Init(sha.Compute(Version, hash)); rc4.Crypt(eepromCopy, 20, 28); } File.WriteAllBytes(file, eepromCopy); } }
public static void On_SMSG_WARDEN_DATA(ref Packets.PacketClass Packet) { // START Warden Decryption var b = new byte[(Packet.Data.Length - 4)]; Buffer.BlockCopy(Packet.Data, 4, b, 0, b.Length); RC4.Crypt(ref b, Maiev.KeyIn); Buffer.BlockCopy(b, 0, Packet.Data, 4, b.Length); // END var WardenData = new byte[(Packet.Data.Length - 4)]; Buffer.BlockCopy(Packet.Data, 4, WardenData, 0, WardenData.Length); MaievOpcode Opcode = (MaievOpcode)Packet.GetInt8(); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("SMSG_WARDEN_DATA [{0}]", Opcode); Console.ForegroundColor = ConsoleColor.White; switch (Opcode) { case MaievOpcode.MAIEV_MODULE_INFORMATION: { var Name = Packet.GetByteArray(16); var Key = Packet.GetByteArray(16); var Size = Packet.GetUInt32(); Maiev.ModuleName = BitConverter.ToString(Name).Replace("-", ""); Maiev.ModuleKey = Key; ModuleLength = (int)Size; Maiev.ModuleData = Array.Empty <byte>(); if (File.Exists(@"modules\" + Maiev.ModuleName + ".mod") == false) { Console.WriteLine("[{0}][WARDEN] Module is missing.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddInt8((byte)MaievResponse.MAIEV_RESPONSE_FAILED_OR_MISSING); SendWardenPacket(ref response); response.Dispose(); } else { Console.WriteLine("[{0}][WARDEN] Module is initiated.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); Maiev.ModuleData = File.ReadAllBytes(@"modules\" + Maiev.ModuleName + ".mod"); if (Maiev.LoadModule(Maiev.ModuleName, ref Maiev.ModuleData, Maiev.ModuleKey)) { Console.WriteLine("[{0}][WARDEN] Successfully loaded the module.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddInt8((byte)MaievResponse.MAIEV_RESPONSE_SUCCESS); SendWardenPacket(ref response); response.Dispose(); } else { Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddInt8((byte)MaievResponse.MAIEV_RESPONSE_FAILED_OR_MISSING); SendWardenPacket(ref response); response.Dispose(); } } break; } case MaievOpcode.MAIEV_MODULE_TRANSFER: { var Size = Packet.GetUInt16(); var Data = Packet.GetByteArray(Size); Maiev.ModuleData = Realmserver.Concat(Maiev.ModuleData, Data); ModuleLength -= Size; if (ModuleLength <= 0) { Console.WriteLine("[{0}][WARDEN] Module is fully transfered.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); if (Directory.Exists("modules") == false) { Directory.CreateDirectory("modules"); } File.WriteAllBytes(@"modules\" + Maiev.ModuleName + ".mod", Maiev.ModuleData); if (Maiev.LoadModule(Maiev.ModuleName, ref Maiev.ModuleData, Maiev.ModuleKey)) { Console.WriteLine("[{0}][WARDEN] Successfully loaded the module.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddInt8((byte)MaievResponse.MAIEV_RESPONSE_SUCCESS); SendWardenPacket(ref response); response.Dispose(); } } else { Console.WriteLine("[{0}][WARDEN] Module transfer. Bytes left: {1}", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss"), ModuleLength); } break; } case MaievOpcode.MAIEV_MODULE_RUN: { Console.WriteLine("[{0}][WARDEN] Requesting a scan.", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss")); // TODO: Encrypt? Maiev.ReadKeys2(); RC4.Crypt(ref WardenData, Maiev.ModKeyIn); var HandledBytes = Maiev.HandlePacket(WardenData); if (HandledBytes <= 0) { return; } var thePacket = Maiev.ReadPacket(); if (thePacket.Length == 0) { return; } RC4.Crypt(ref WardenData, Maiev.ModKeyOut); // TODO: Decrypt? Packets.DumpPacket(thePacket); Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddByteArray(thePacket); SendWardenPacket(ref response); response.Dispose(); break; } case MaievOpcode.MAIEV_MODULE_UNK: { // TODO: Encrypt? Maiev.ReadKeys2(); RC4.Crypt(ref WardenData, Maiev.ModKeyIn); var HandledBytes = Maiev.HandlePacket(WardenData); if (HandledBytes <= 0) { return; } var thePacket = Maiev.ReadPacket(); if (thePacket.Length == 0) { return; } RC4.Crypt(ref WardenData, Maiev.ModKeyOut); // TODO: Decrypt? Packets.DumpPacket(thePacket); Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddByteArray(thePacket); SendWardenPacket(ref response); response.Dispose(); break; } case MaievOpcode.MAIEV_MODULE_SEED: { Maiev.GenerateNewRC4Keys(Realmserver.SS_Hash); var HandledBytes = Maiev.HandlePacket(WardenData); if (HandledBytes <= 0) { return; } var thePacket = Maiev.ReadPacket(); Maiev.ModKeyIn = new byte[258]; Maiev.ModKeyOut = new byte[258]; Packets.PacketClass response = new(OPCODES.CMSG_WARDEN_DATA); response.AddByteArray(thePacket); SendWardenPacket(ref response); response.Dispose(); Maiev.ReadKeys(); break; } default: { Console.WriteLine("[{0}][WARDEN] Unhandled Opcode [{1}] 0x{2:X}", Strings.Format(DateAndTime.TimeOfDay, "HH:mm:ss"), Opcode, Conversions.ToInteger(Opcode)); break; } } }
public void On_CMSG_WARDEN_DATA(ref Packets.PacketClass packet, ref WS_Network.ClientClass client) { byte[] b = new byte[checked (packet.Data.Length - 6 - 1 + 1)]; Buffer.BlockCopy(packet.Data, 6, b, 0, b.Length); RC4.Crypt(ref b, client.Character.WardenData.KeyOut); Buffer.BlockCopy(b, 0, packet.Data, 6, b.Length); packet.GetInt16(); MaievResponse Response = (MaievResponse)packet.GetInt8(); WorldServiceLocator._WorldServer.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_WARDEN_DATA [{2}]", client.IP, client.Port, Response); if (!client.Character.WardenData.Ready) { return; } switch (Response) { case MaievResponse.MAIEV_RESPONSE_FAILED_OR_MISSING: MaievSendTransfer(ref client.Character); break; case MaievResponse.MAIEV_RESPONSE_SUCCESS: MaievSendSeed(ref client.Character); break; case MaievResponse.MAIEV_RESPONSE_RESULT: MaievResult(ref client.Character, ref packet); break; case MaievResponse.MAIEV_RESPONSE_HASH: { byte[] hash = new byte[20]; Buffer.BlockCopy(packet.Data, packet.Offset, hash, 0, 20); WorldServiceLocator._WS_Warden.Maiev.GenerateNewRC4Keys(client.Character.WardenData.K); byte[] PacketData = new byte[17] { 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; Buffer.BlockCopy(client.Character.WardenData.Seed, 0, PacketData, 1, 16); int HandledBytes = WorldServiceLocator._WS_Warden.Maiev.HandlePacket(PacketData); if (HandledBytes <= 0) { WorldServiceLocator._WorldServer.Log.WriteLine(LogType.CRITICAL, "[WARDEN] Failed to handle 0x05 packet."); break; } byte[] thePacket = WorldServiceLocator._WS_Warden.Maiev.ReadPacket(); byte[] ourHash = new byte[20]; Array.Copy(thePacket, 1, ourHash, 0, ourHash.Length); WorldServiceLocator._WS_Warden.Maiev.ReadXorByte(ref client.Character); WorldServiceLocator._WS_Warden.Maiev.ReadKeys(ref client.Character); WorldServiceLocator._WorldServer.Log.WriteLine(LogType.DEBUG, "[WARDEN] XorByte: {0}", client.Character.WardenData.xorByte); bool HashCorrect = true; int i = 0; do { if (hash[i] != ourHash[i]) { HashCorrect = false; break; } i = checked (i + 1); }while (i <= 19); if (!HashCorrect) { WorldServiceLocator._WorldServer.Log.WriteLine(LogType.CRITICAL, "[WARDEN] Hashes in packet 0x05 didn't match. Cheater?"); } break; } case (MaievResponse)3: break; default: break; } }
/////end RSA --------------------------------------------------------- /////RC4 --------------------------------------------------------- public byte[] RC4Crypt(byte[] input) { return(rc4.Crypt(input)); }