private static void crypto(byte[] key, CipherMode mode, PaddingMode padding, byte[] iv, int opMode, byte[] i, int inOffset, int len, byte[] o, int outOffset) { try { RijndaelManaged cipher = new RijndaelManaged(); cipher.Padding = padding; cipher.Mode = mode; cipher.KeySize = 0x80; cipher.BlockSize = 0x80; cipher.Key = key; if (iv != null) { cipher.IV = iv; } byte[] aux = null; if (opMode == DECRYPT_MODE) { aux = cipher.CreateDecryptor().TransformFinalBlock(i, inOffset, len); } else if (opMode == ENCRYPT_MODE) { aux = cipher.CreateEncryptor().TransformFinalBlock(i, inOffset, len); } else { fail("NOT SUPPORTED OPMODE"); } ConversionUtils.arraycopy(aux, 0, o, outOffset, len); } catch (Exception ex) { fail(ex.Message); } }
public byte[] getrifKey(String rifIn, String actIn, String idps) { if (rifIn == null || actIn == null) { return(null); } byte[] result = null; FileStream rifFile = File.Open(rifIn, FileMode.Open); byte[] rif0x40 = new byte[0x10]; byte[] rif0x50 = new byte[0x10]; byte[] encrif0x40 = new byte[0x10]; byte[] encrif0x50 = new byte[0x10]; rifFile.Seek(0x40, SeekOrigin.Begin); rifFile.Read(encrif0x40, 0, encrif0x40.Length); rifFile.Read(encrif0x50, 0, encrif0x50.Length); rifFile.Close(); ToolsImpl.aesecbDecrypt(RIFKEY, encrif0x40, 0x00, rif0x40, 0, 0x10); long index = ConversionUtils.be32(rif0x40, 0xC); // if (index < 0x80) { byte[] actDat = decryptACTDAT(actIn, idps); byte[] datKey = new byte[0x10]; result = new byte[0x10]; ConversionUtils.arraycopy(actDat, (int)index * 16, datKey, 0, 0x10); ToolsImpl.aesecbDecrypt(datKey, encrif0x50, 0, result, 0, 0x10); } return(result); }
public override void doUpdate(byte[] i, int inOffset, int len) { byte[] data; if (nonProcessed != null) { int totalLen = len + nonProcessed.Length; data = new byte[totalLen]; ConversionUtils.arraycopy(nonProcessed, 0, data, 0, nonProcessed.Length); ConversionUtils.arraycopy(i, inOffset, data, nonProcessed.Length, len); } else { data = new byte[len]; ConversionUtils.arraycopy(i, inOffset, data, 0, len); } int count = 0; while (count < data.Length - 0x10) { byte[] aux = new byte[0x10]; ConversionUtils.arraycopy(data, count, aux, 0, aux.Length); ToolsImpl.XOR(aux, aux, previous); ToolsImpl.aesecbEncrypt(key, aux, 0, previous, 0, aux.Length); count += 0x10; } nonProcessed = new byte[data.Length - count]; ConversionUtils.arraycopy(data, count, nonProcessed, 0, nonProcessed.Length); }
private void getCryptoKeys(int cryptoFlag, byte[] calculatedKey, byte[] calculatedIV, byte[] key, byte[] iv) { switch (((uint)(cryptoFlag & -268435456))) { case 0: ConversionUtils.arraycopy(key, 0, calculatedKey, 0L, calculatedKey.Length); ConversionUtils.arraycopy(iv, 0, calculatedIV, 0L, calculatedIV.Length); Debug.WriteLine("MODE: Unencrypted ERK"); break; case 0x10000000: ToolsImpl.aescbcDecrypt(EDATKeys.EDATKEY, EDATKeys.EDATIV, key, 0, calculatedKey, 0, calculatedKey.Length); ConversionUtils.arraycopy(iv, 0, calculatedIV, 0L, calculatedIV.Length); Debug.WriteLine("MODE: Encrypted ERK"); break; case 0x20000000: ConversionUtils.arraycopy(EDATKeys.EDATKEY, 0, calculatedKey, 0L, calculatedKey.Length); ConversionUtils.arraycopy(EDATKeys.EDATIV, 0, calculatedIV, 0L, calculatedIV.Length); Debug.WriteLine("MODE: Default ERK"); break; default: throw new Exception("Crypto mode is not valid: Undefined keys calculator"); } }
public static byte[] CMAC128(byte[] key, byte[] i, int inOffset, int len) { byte[] buffer = new byte[0x10]; byte[] buffer2 = new byte[0x10]; calculateSubkey(key, buffer, buffer2); byte[] dest = new byte[0x10]; byte[] inputB = new byte[0x10]; int srcPos = inOffset; int length = len; while (length > 0x10) { ConversionUtils.arraycopy(i, srcPos, dest, 0L, 0x10); XOR(dest, dest, inputB); aesecbEncrypt(key, dest, 0, inputB, 0, dest.Length); srcPos += 0x10; length -= 0x10; } dest = new byte[0x10]; ConversionUtils.arraycopy(i, srcPos, dest, 0L, length); if (length == 0x10) { XOR(dest, dest, inputB); XOR(dest, dest, buffer); } else { dest[length] = 0x80; XOR(dest, dest, inputB); XOR(dest, dest, buffer2); } aesecbEncrypt(key, dest, 0, inputB, 0, dest.Length); return(inputB); }
public byte[] getrifKey(string rifIn, string actIn, string idps) { if ((rifIn == null) || (actIn == null)) { return(null); } byte[] o = null; FileStream stream = File.Open(rifIn, FileMode.Open); byte[] buffer2 = new byte[0x10]; byte[] buffer3 = new byte[0x10]; byte[] buffer = new byte[0x10]; byte[] buffer5 = new byte[0x10]; stream.Seek(0x40L, SeekOrigin.Begin); stream.Read(buffer, 0, buffer.Length); stream.Read(buffer5, 0, buffer5.Length); stream.Close(); ToolsImpl.aesecbDecrypt(RIFKEY, buffer, 0, buffer2, 0, 0x10); long num = ConversionUtils.be32(buffer2, 12); if (num < 0x80L) { byte[] src = decryptACTDAT(actIn, idps); byte[] dest = new byte[0x10]; o = new byte[0x10]; ConversionUtils.arraycopy(src, ((int)num) * 0x10, dest, 0L, 0x10); ToolsImpl.aesecbDecrypt(dest, buffer5, 0, o, 0, 0x10); } return(o); }
private void getHashKeys(int hashFlag, byte[] calculatedHash, byte[] hash) { uint mode = (uint)hashFlag & 0xF0000000; switch (mode) { case 0x10000000: ToolsImpl.aescbcDecrypt(EDATKeys.EDATKEY, EDATKeys.EDATIV, hash, 0, calculatedHash, 0, calculatedHash.Length); Debug.WriteLine("MODE: Encrypted HASHKEY"); break; case 0x20000000: ConversionUtils.arraycopy(EDATKeys.EDATHASH, 0, calculatedHash, 0, calculatedHash.Length); Debug.WriteLine("MODE: Default HASHKEY"); break; case 0x00000000: ConversionUtils.arraycopy(hash, 0, calculatedHash, 0, calculatedHash.Length); Debug.WriteLine("MODE: Unencrypted HASHKEY"); break; default: throw new Exception("Hash mode is not valid: Undefined keys calculator"); } }
private int validateNPD(String filename, byte[] devKLic, NPD[] npdPtr, FileStream i) { i.Seek(0, SeekOrigin.Begin); byte[] npd = new byte[0x80]; i.Read(npd, 0, npd.Length); byte[] extraData = new byte[0x04]; i.Read(extraData, 0, extraData.Length); long flag = ConversionUtils.be32(extraData, 0); if ((flag & FLAG_SDAT) != 0) { Console.WriteLine("INFO: SDAT detected. NPD header is not validated"); } else if (!checkNPDHash1(filename, npd)) { Console.WriteLine("ERROR: Hashing Title ID Name"); return(STATUS_ERROR_HASHTITLEIDNAME); } else if (devKLic == null) { Console.WriteLine("WARNING: Can not validate devklic header"); } else if (!checkNPDHash2(devKLic, npd)) { Console.WriteLine("ERROR: Hashing devklic"); return(STATUS_ERROR_HASHDEVKLIC); } npdPtr[0] = NPD.createNPD(npd); return(STATUS_OK); }
private int validateNPD(string filename, byte[] devKLic, NPD[] npdPtr, FileStream i) { i.Seek(0L, SeekOrigin.Begin); byte[] buffer = new byte[0x80]; i.Read(buffer, 0, buffer.Length); byte[] buffer2 = new byte[4]; i.Read(buffer2, 0, buffer2.Length); if ((ConversionUtils.be32(buffer2, 0) & FLAG_SDAT) != 0L) { Console.WriteLine("INFO: SDAT detected. NPD header is not validated"); } else { if (!this.checkNPDHash1(filename, buffer)) { Console.WriteLine("ERROR: Hashing Title ID Name"); return(STATUS_ERROR_HASHTITLEIDNAME); } if (devKLic == null) { Console.WriteLine("WARNING: Can not validate devklic header"); } else if (!this.checkNPDHash2(devKLic, buffer)) { Console.WriteLine("ERROR: Hashing devklic"); return(STATUS_ERROR_HASHDEVKLIC); } } npdPtr[0] = NPD.createNPD(buffer); return(STATUS_OK); }
private byte[] writeValidNPD(string filename, byte[] devKLic, NPD[] npdPtr, FileStream fin, byte[] contentID, byte[] flags, byte[] version, byte[] type) { int num; byte[] dest = new byte[0x80]; dest[0] = 0x4e; dest[1] = 80; dest[2] = 0x44; dest[3] = 0; dest[4] = 0; dest[5] = 0; dest[6] = 0; dest[7] = version[0]; dest[8] = 0; dest[9] = 0; dest[10] = 0; dest[11] = 3; dest[12] = 0; dest[13] = 0; dest[14] = 0; dest[15] = type[0]; for (num = 0; num < 0x30; num++) { dest[0x10 + num] = contentID[num]; } ConversionUtils.arraycopy(ConversionUtils.charsToByte("FixedLicenseEDAT".ToCharArray()), 0, dest, 0x40L, 0x10); ConversionUtils.arraycopy(this.createNPDHash1(filename, dest), 0, dest, 80L, 0x10); ConversionUtils.arraycopy(this.createNPDHash2(devKLic, dest), 0, dest, 0x60L, 0x10); for (num = 0; num < 0x10; num++) { dest[0x70 + num] = 0; } npdPtr[0] = NPD.createNPD(dest); return(dest); }
private static void crypto(byte[] key, CipherMode mode, PaddingMode padding, byte[] iv, int opMode, byte[] i, int inOffset, int len, byte[] o, int outOffset) { try { RijndaelManaged managed = new RijndaelManaged { Padding = padding, Mode = mode, KeySize = 0x80, BlockSize = 0x80, Key = key }; if (iv != null) { managed.IV = iv; } byte[] src = null; if (opMode == DECRYPT_MODE) { src = managed.CreateDecryptor().TransformFinalBlock(i, inOffset, len); } else if (opMode == ENCRYPT_MODE) { src = managed.CreateEncryptor().TransformFinalBlock(i, inOffset, len); } else { fail("NOT SUPPORTED OPMODE"); } ConversionUtils.arraycopy(src, 0, o, (long)outOffset, len); } catch (Exception exception) { fail(exception.Message); } }
public override void doUpdate(byte[] i, int inOffset, int len) { byte[] buffer; if (this.nonProcessed != null) { int num = len + this.nonProcessed.Length; buffer = new byte[num]; ConversionUtils.arraycopy(this.nonProcessed, 0, buffer, 0L, this.nonProcessed.Length); ConversionUtils.arraycopy(i, inOffset, buffer, (long)this.nonProcessed.Length, len); } else { buffer = new byte[len]; ConversionUtils.arraycopy(i, inOffset, buffer, 0L, len); } int srcPos = 0; while (srcPos < (buffer.Length - 0x10)) { byte[] dest = new byte[0x10]; ConversionUtils.arraycopy(buffer, srcPos, dest, 0L, dest.Length); ToolsImpl.XOR(dest, dest, this.previous); ToolsImpl.aesecbEncrypt(this.key, dest, 0, this.previous, 0, dest.Length); srcPos += 0x10; } this.nonProcessed = new byte[buffer.Length - srcPos]; ConversionUtils.arraycopy(buffer, srcPos, this.nonProcessed, 0L, this.nonProcessed.Length); }
public static EDATData createEDATData(byte[] data) { EDATData result = new EDATData(); result.flags = ConversionUtils.be32(data, 0); result.blockSize = ConversionUtils.be32(data, 4); result.fileLen = ConversionUtils.be64(data, 0x8); return(result); }
private byte[] calculateBlockKey(int blk, NPD npd) { byte[] baseKey = (npd.getVersion() <= 1) ? (new byte[0x10]) : npd.getDevHash(); byte[] result = new byte[0x10]; ConversionUtils.arraycopy(baseKey, 0, result, 0, 0xC); result[0xC] = (byte)(blk >> 24 & 0xFF); result[0xD] = (byte)(blk >> 16 & 0xFF); result[0xE] = (byte)(blk >> 8 & 0xFF); result[0xF] = (byte)(blk & 0xFF); return(result); }
private byte[] calculateBlockKey(int blk, NPD npd) { byte[] src = (npd.getVersion() <= 1L) ? new byte[0x10] : npd.getDevHash(); byte[] dest = new byte[0x10]; ConversionUtils.arraycopy(src, 0, dest, 0L, 12); dest[12] = (byte)((blk >> 0x18) & 0xff); dest[13] = (byte)((blk >> 0x10) & 0xff); dest[14] = (byte)((blk >> 8) & 0xff); dest[15] = (byte)(blk & 0xff); return(dest); }
private byte[] createNPDHash2(byte[] klicensee, byte[] npd) { byte[] output = new byte[0x10]; ToolsImpl.XOR(output, klicensee, EDATKeys.npdrm_omac_key2); byte[] src = ToolsImpl.CMAC128(output, npd, 0, 0x60); ConversionUtils.arraycopy(src, 0, npd, 0x60L, 0x10); if (this.compareBytes(src, 0, npd, 0x60, 0x10)) { return(src); } return(null); }
private bool checkNPDHash2(byte[] klicensee, byte[] npd) { byte[] output = new byte[0x10]; ToolsImpl.XOR(output, klicensee, EDATKeys.npdrm_omac_key2); byte[] buffer2 = ToolsImpl.CMAC128(output, npd, 0, 0x60); bool flag = this.compareBytes(buffer2, 0, npd, 0x60, 0x10); if (flag) { Console.WriteLine("NPD hash 2 is valid (" + ConversionUtils.getHexString(buffer2) + ")"); } return(flag); }
private bool checkNPDHash2(byte[] klicensee, byte[] npd) { byte[] xoredKey = new byte[0x10]; ToolsImpl.XOR(xoredKey, klicensee, EDATKeys.npdrm_omac_key2); byte[] calculated = ToolsImpl.CMAC128(xoredKey, npd, 0, 0x60); bool result2 = compareBytes(calculated, 0, npd, 0x60, 0x10); if (result2) { Console.WriteLine("NPD hash 2 is valid (" + ConversionUtils.getHexString(calculated) + ")"); } return(result2); }
private byte[] createNPDHash2(byte[] klicensee, byte[] npd) { byte[] xoredKey = new byte[0x10]; ToolsImpl.XOR(xoredKey, klicensee, EDATKeys.npdrm_omac_key2); byte[] calculated = ToolsImpl.CMAC128(xoredKey, npd, 0, 0x60); ConversionUtils.arraycopy(calculated, 0, npd, 0x60, 0x10); bool result2 = compareBytes(calculated, 0, npd, 0x60, 0x10); if (result2) { return(calculated); } return(null); }
private byte[] createNPDHash1(string filename, byte[] npd) { byte[] src = ConversionUtils.charsToByte(filename.ToCharArray()); byte[] dest = new byte[0x30 + src.Length]; ConversionUtils.arraycopy(npd, 0x10, dest, 0L, 0x30); ConversionUtils.arraycopy(src, 0, dest, 0x30L, src.Length); byte[] buffer3 = ToolsImpl.CMAC128(EDATKeys.npdrm_omac_key3, dest, 0, dest.Length); ConversionUtils.arraycopy(buffer3, 0, npd, 80L, 0x10); if (this.compareBytes(buffer3, 0, npd, 80, 0x10)) { return(buffer3); } return(null); }
/* KDSBEST END */ public int decryptFile(String inFile, String outFile, byte[] devKLic, byte[] keyFromRif) { FileStream fin = File.Open(inFile, FileMode.Open); string[] fn = fin.Name.Split('\\'); //string[] fn = fin.Name.Split('/'); Console.WriteLine(fn[fn.Length - 1]); NPD[] ptr = new NPD[1]; //Ptr to Ptr int result = validateNPD(fn[fn.Length - 1], devKLic, ptr, fin); //Validate NPD hashes if (result < 0) { fin.Close(); return(result); } NPD npd = ptr[0]; EDATData data = getEDATData(fin); //Get flags, blocksize and file len byte[] rifkey = getKey(npd, data, devKLic, keyFromRif); //Obtain the key for decryption (result of sc471 or sdatkey) if (rifkey == null) { Console.WriteLine("ERROR: Key for decryption is missing"); fin.Close(); return(STATUS_ERROR_MISSINGKEY); } else { Console.WriteLine("DECRYPTION KEY: " + ConversionUtils.getHexString(rifkey)); } result = checkHeader(rifkey, data, npd, fin); if (result < 0) { fin.Close(); return(result); } FileStream o = File.Open(outFile, FileMode.Create); result = decryptData(fin, o, npd, data, rifkey); if (result < 0) { fin.Close(); return(result); } fin.Close(); o.Close(); Console.WriteLine("COMPLETE: File Written to disk"); return(STATUS_OK); }
private bool checkNPDHash1(string filename, byte[] npd) { byte[] src = ConversionUtils.charsToByte(filename.ToCharArray()); byte[] dest = new byte[0x30 + src.Length]; ConversionUtils.arraycopy(npd, 0x10, dest, 0L, 0x30); ConversionUtils.arraycopy(src, 0, dest, 0x30L, src.Length); byte[] buffer3 = ToolsImpl.CMAC128(EDATKeys.npdrm_omac_key3, dest, 0, dest.Length); bool flag = this.compareBytes(buffer3, 0, npd, 80, 0x10); if (flag) { Console.WriteLine("NPD hash 1 is valid (" + ConversionUtils.getHexString(buffer3) + ")"); } return(flag); }
public void doInit(int hashFlag, int cryptoFlag, byte[] key, byte[] iv, byte[] hashKey) { byte[] calculatedKey = new byte[key.Length]; byte[] calculatedIV = new byte[iv.Length]; byte[] calculatedHash = new byte[hashKey.Length]; this.getCryptoKeys(cryptoFlag, calculatedKey, calculatedIV, key, iv); this.getHashKeys(hashFlag, calculatedHash, hashKey); this.setDecryptor(cryptoFlag); this.setHash(hashFlag); Debug.WriteLine("ERK: " + ConversionUtils.getHexString(calculatedKey)); Debug.WriteLine("IV: " + ConversionUtils.getHexString(calculatedIV)); Debug.WriteLine("HASH: " + ConversionUtils.getHexString(calculatedHash)); this.dec.doInit(calculatedKey, calculatedIV); this.hash.doInit(calculatedHash); }
private bool checkNPDHash1(String filename, byte[] npd) { byte[] fileBytes = ConversionUtils.charsToByte(filename.ToCharArray()); byte[] data1 = new byte[0x30 + fileBytes.Length]; ConversionUtils.arraycopy(npd, 0x10, data1, 0, 0x30); ConversionUtils.arraycopy(fileBytes, 0x00, data1, 0x30, fileBytes.Length); byte[] hash1 = ToolsImpl.CMAC128(EDATKeys.npdrm_omac_key3, data1, 0, data1.Length); bool result1 = compareBytes(hash1, 0, npd, 0x50, 0x10); if (result1) { Console.WriteLine("NPD hash 1 is valid (" + ConversionUtils.getHexString(hash1) + ")"); } return(result1); }
private byte[] createNPDHash1(String filename, byte[] npd) { byte[] fileBytes = ConversionUtils.charsToByte(filename.ToCharArray()); byte[] data1 = new byte[0x30 + fileBytes.Length]; ConversionUtils.arraycopy(npd, 0x10, data1, 0, 0x30); ConversionUtils.arraycopy(fileBytes, 0x00, data1, 0x30, fileBytes.Length); byte[] hash1 = ToolsImpl.CMAC128(EDATKeys.npdrm_omac_key3, data1, 0, data1.Length); ConversionUtils.arraycopy(hash1, 0, npd, 0x50, 0x10); bool result1 = compareBytes(hash1, 0, npd, 0x50, 0x10); if (result1) { return(hash1); } return(null); }
public string makeedat(String inFile) { String strAppDir = Path.GetDirectoryName( Assembly.GetExecutingAssembly().GetName().CodeBase); string path = strAppDir.Replace("file:\\", ""); byte[] CID = Encoding.UTF8.GetBytes(inFile); byte[] contentID = new byte[48]; byte[] contentID2 = new byte[inFile.Length]; ConversionUtils.arraycopy(CID, 0, contentID, 0, CID.Length); ConversionUtils.arraycopy(CID, 0, contentID2, 0, inFile.Length); string cid3 = Encoding.UTF8.GetString(contentID2); if (path != null) { outFile = path + "/edats/" + inFile + ".edat"; } else { outFile = "edats/" + inFile + ".edat"; } FileStream dat = File.Open(inFile + ".dat", FileMode.Create); dat.Write(pad, 0, 0x10); dat.Write(contentID, 0, contentID.Length); dat.Close(); String input = inFile + ".dat"; DirectoryInfo di = Directory.CreateDirectory(path + "/edats"); byte[] flags = ConversionUtils.getByteArray("0C"); byte[] type = ConversionUtils.getByteArray("00"); byte[] version = ConversionUtils.getByteArray("02"); byte[] devKLic = ConversionUtils.getByteArray("72F990788F9CFF745725F08E4C128387"); byte[] keyFromRif = null; EDAT instance = new EDAT(); instance.encryptFile(input, outFile, devKLic, keyFromRif, contentID, flags, type, version); if (File.Exists(inFile + ".dat")) { File.Delete(inFile + ".dat"); } return(inFile + ".edat"); }
private static void calculateSubkey(byte[] key, byte[] K1, byte[] K2) { byte[] zero = new byte[0x10]; byte[] L = new byte[0x10]; ToolsImpl.aesecbEncrypt(key, zero, 0, L, 0, zero.Length); BigInteger aux = new BigInteger(ConversionUtils.reverseByteWithSizeFIX(L)); if ((L[0] & 0x80) != 0) { //Case MSB is set aux = (aux << 1) ^ (new BigInteger(0x87)); } else { aux = aux << 1; } byte[] aux1 = ConversionUtils.reverseByteWithSizeFIX(aux.ToByteArray()); if (aux1.Length >= 0x10) { ConversionUtils.arraycopy(aux1, aux1.Length - 0x10, K1, 0, 0x10); } else { ConversionUtils.arraycopy(zero, 0, K1, 0, zero.Length); ConversionUtils.arraycopy(aux1, 0, K1, 0x10 - aux1.Length, aux1.Length); } aux = new BigInteger(ConversionUtils.reverseByteWithSizeFIX(K1)); if ((K1[0] & 0x80) != 0) { aux = (aux << 1) ^ (new BigInteger(0x87)); } else { aux = aux << 1; } aux1 = ConversionUtils.reverseByteWithSizeFIX(aux.ToByteArray()); if (aux1.Length >= 0x10) { ConversionUtils.arraycopy(aux1, aux1.Length - 0x10, K2, 0, 0x10); } else { ConversionUtils.arraycopy(zero, 0, K2, 0, zero.Length); ConversionUtils.arraycopy(aux1, 0, K2, 0x10 - aux1.Length, aux1.Length); } }
private int encryptData(FileStream ii, FileStream o, NPD npd, EDATData data, byte[] rifkey) { int num = (int)(((data.getFileLen() + data.getBlockSize()) - 1) / data.getBlockSize()); byte[] dest = new byte[num * 0x10]; byte[] buffer2 = new byte[ii.Length + 15L]; for (int i = 0; i < num; i++) { long offset = i * data.getBlockSize(); ii.Seek(offset, SeekOrigin.Begin); int length = (int)data.getBlockSize(); if (i == (num - 1)) { length = (int)(data.getFileLen() % new BigInteger(data.getBlockSize())); } int num5 = length; length = (length + 15) & -16; byte[] buffer3 = new byte[length]; byte[] buffer4 = new byte[length]; for (int j = num5; j > 0; j -= ii.Read(buffer4, num5 - j, j)) { } for (int k = num5; k < length; k++) { buffer4[k] = 0; } byte[] buffer5 = new byte[0x10]; byte[] buffer6 = new byte[0x10]; byte[] buffer7 = this.calculateBlockKey(i, npd); ToolsImpl.aesecbEncrypt(rifkey, buffer7, 0, buffer5, 0, buffer7.Length); ConversionUtils.arraycopy(buffer5, 0, buffer6, 0L, buffer5.Length); int cryptoFlag = 2; int hashFlag = 2; AppLoaderReverse reverse = new AppLoaderReverse(); byte[] iv = npd.getDigest(); byte[] generatedHash = new byte[0x10]; reverse.doAll(hashFlag, cryptoFlag, buffer4, 0, buffer3, 0, buffer4.Length, buffer5, iv, buffer6, generatedHash, 0); ConversionUtils.arraycopy(buffer3, 0, buffer2, offset, length); ConversionUtils.arraycopy(generatedHash, 0, dest, (long)(i * 0x10), 0x10); } byte[] buffer = ConversionUtils.getByteArray("4D6164652062792052325220546F6F6C"); o.Write(dest, 0, dest.Length); o.Write(buffer2, 0, buffer2.Length - 15); o.Write(buffer, 0, buffer.Length); return(STATUS_OK); }
public override bool doFinal(byte[] generateHash) { byte[] dest = new byte[0x10]; ConversionUtils.arraycopy(this.nonProcessed, 0, dest, 0L, this.nonProcessed.Length); if (this.nonProcessed.Length == 0x10) { ToolsImpl.XOR(dest, dest, this.K1); } else { dest[this.nonProcessed.Length] = 0x80; ToolsImpl.XOR(dest, dest, this.K2); } ToolsImpl.XOR(dest, dest, this.previous); ToolsImpl.aesecbEncrypt(this.key, dest, 0, generateHash, 0, dest.Length); return(true); }
public override bool doFinal(byte[] generateHash) { byte[] aux = new byte[0x10]; ConversionUtils.arraycopy(nonProcessed, 0, aux, 0, nonProcessed.Length); if (nonProcessed.Length == 0x10) { ToolsImpl.XOR(aux, aux, K1); } else { aux[nonProcessed.Length] = (byte)0x80; ToolsImpl.XOR(aux, aux, K2); } ToolsImpl.XOR(aux, aux, previous); ToolsImpl.aesecbEncrypt(key, aux, 0, generateHash, 0, aux.Length); return(true); }