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 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); } }
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 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); }
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 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 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"); } }
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); }
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 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); }
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); }
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); } }
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); }
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); }
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); }
private static void calculateSubkey(byte[] key, byte[] K1, byte[] K2) { byte[] i = new byte[0x10]; byte[] o = new byte[0x10]; aesecbEncrypt(key, i, 0, o, 0, i.Length); BigInteger integer = new BigInteger(ConversionUtils.reverseByteWithSizeFIX(o)); if ((o[0] & 0x80) != 0) { integer = (integer << 1) ^ new BigInteger(0x87); } else { integer = integer << 1; } byte[] src = ConversionUtils.reverseByteWithSizeFIX(integer.ToByteArray()); if (src.Length >= 0x10) { ConversionUtils.arraycopy(src, src.Length - 0x10, K1, 0L, 0x10); } else { ConversionUtils.arraycopy(i, 0, K1, 0L, i.Length); ConversionUtils.arraycopy(src, 0, K1, (long)(0x10 - src.Length), src.Length); } integer = new BigInteger(ConversionUtils.reverseByteWithSizeFIX(K1)); if ((K1[0] & 0x80) != 0) { integer = (integer << 1) ^ new BigInteger(0x87); } else { integer = integer << 1; } src = ConversionUtils.reverseByteWithSizeFIX(integer.ToByteArray()); if (src.Length >= 0x10) { ConversionUtils.arraycopy(src, src.Length - 0x10, K2, 0L, 0x10); } else { ConversionUtils.arraycopy(i, 0, K2, 0L, i.Length); ConversionUtils.arraycopy(src, 0, K2, (long)(0x10 - src.Length), src.Length); } }
public override bool doFinal(byte[] expectedhash, int hashOffset, bool hashDebug) { 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); byte[] o = new byte[0x10]; ToolsImpl.aesecbEncrypt(this.key, dest, 0, o, 0, dest.Length); return(hashDebug || base.compareBytes(expectedhash, hashOffset, o, 0, this.hashLen)); }
public override bool doFinal(byte[] expectedhash, int hashOffset, bool hashDebug) { 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); byte[] calculatedhash = new byte[0x10]; ToolsImpl.aesecbEncrypt(key, aux, 0, calculatedhash, 0, aux.Length); return(hashDebug || compareBytes(expectedhash, hashOffset, calculatedhash, 0, hashLen)); }
public static NPD createNPD(byte[] npd) { NPD result = new NPD(); ConversionUtils.arraycopy(npd, 0, result.magic, 0, 4); result.version = ConversionUtils.be32(npd, 4); result.license = ConversionUtils.be32(npd, 8); result.type = ConversionUtils.be32(npd, 0xC); ConversionUtils.arraycopy(npd, 0x10, result.content_id, 0, 0x30); ConversionUtils.arraycopy(npd, 0x40, result.digest, 0, 0x10); ConversionUtils.arraycopy(npd, 0x50, result.titleHash, 0, 0x10); ConversionUtils.arraycopy(npd, 0x60, result.devHash, 0, 0x10); result.unknown3 = ConversionUtils.be64(npd, 0x70); result.unknown4 = ConversionUtils.be64(npd, 0x78); if (!result.validate()) { result = null; } return(result); }
public static NPD createNPD(byte[] npd) { NPD npd2 = new NPD(); ConversionUtils.arraycopy(npd, 0, npd2.magic, 0L, 4); npd2.version = ConversionUtils.be32(npd, 4); npd2.license = ConversionUtils.be32(npd, 8); npd2.type = ConversionUtils.be32(npd, 12); ConversionUtils.arraycopy(npd, 0x10, npd2.content_id, 0L, 0x30); ConversionUtils.arraycopy(npd, 0x40, npd2.digest, 0L, 0x10); ConversionUtils.arraycopy(npd, 80, npd2.titleHash, 0L, 0x10); ConversionUtils.arraycopy(npd, 0x60, npd2.devHash, 0L, 0x10); npd2.unknown3 = ConversionUtils.be64(npd, 0x70); npd2.unknown4 = ConversionUtils.be64(npd, 120); if (!npd2.validate()) { npd2 = null; } return(npd2); }
public static byte[] CMAC128(byte[] key, byte[] i, int inOffset, int len) { byte[] K1 = new byte[0x10]; byte[] K2 = new byte[0x10]; calculateSubkey(key, K1, K2); byte[] input = new byte[0x10]; byte[] previous = new byte[0x10]; int currentOffset = inOffset; int remaining = len; //System.out.println(ConversionUtils.getHexString(key)); while (remaining > 0x10) { ConversionUtils.arraycopy(i, currentOffset, input, 0, 0x10); //System.out.println(ConversionUtils.getHexString(previous) + " - " + ConversionUtils.getHexString(input)); XOR(input, input, previous); ToolsImpl.aesecbEncrypt(key, input, 0, previous, 0, input.Length); currentOffset += 0x10; remaining -= 0x10; } //System.out.println(ConversionUtils.getHexString(previous)); input = new byte[0x10]; //Memset 0 ConversionUtils.arraycopy(i, currentOffset, input, 0, remaining); if (remaining == 0x10) { XOR(input, input, previous); XOR(input, input, K1); } else { input[remaining] = (byte)0x80; XOR(input, input, previous); XOR(input, input, K2); } //System.out.println(" - " + ConversionUtils.getHexString(input)); ToolsImpl.aesecbEncrypt(key, input, 0, previous, 0, input.Length); return(previous); }
public string makeedat(string inFile, string outFile) { if (!File.Exists(inFile)) { Console.WriteLine(inFile + " not found"); return(inFile); } string str2 = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase).Replace(@"file:\", ""); StreamReader reader = new StreamReader(inFile); string c = reader.ReadToEnd(); if (c.Contains("HG\0\0")) { if (c.Contains("Library")) { byte[] buffer = new byte[c.Length]; string str5 = this.GetSubstringByString("HG\0\0", "Library", c).Replace("HG\0\0", ""); int index = 0; index = str5.IndexOf("\0"); int num2 = str5.Length - index; int length = str5.Length - num2; reader.Close(); string s = str5.Replace("\0", ""); if (length > 0x23) { byte[] bytes = Encoding.UTF8.GetBytes(s); byte[] dest = new byte[0x30]; byte[] buffer4 = new byte[length]; ConversionUtils.arraycopy(bytes, 0, dest, 0L, bytes.Length); ConversionUtils.arraycopy(bytes, 0, buffer4, 0L, length); string str7 = Encoding.UTF8.GetString(buffer4); if (str2 != null) { outFile = str2 + "/edats/" + str7 + ".edat"; } else { outFile = "edats/" + str7 + ".edat"; } FileStream stream = File.Open(str7 + ".dat", FileMode.Create); stream.Write(pad, 0, 0x10); stream.Write(dest, 0, dest.Length); stream.Close(); string str8 = str7 + ".dat"; DirectoryInfo info = Directory.CreateDirectory(str2 + "/edats"); byte[] flags = ConversionUtils.getByteArray("0C"); byte[] type = ConversionUtils.getByteArray("00"); byte[] version = ConversionUtils.getByteArray("02"); byte[] devKLic = ConversionUtils.getByteArray("72F990788F9CFF745725F08E4C128387"); byte[] keyFromRif = null; new EDAT().encryptFile(str8, outFile, devKLic, keyFromRif, dest, flags, type, version); if (File.Exists(str7 + ".dat")) { File.Delete(str7 + ".dat"); } if (str8.EndsWith(".Dec")) { File.Delete(str8); } return(str7 + ".edat"); } Console.WriteLine("Content_ID not found."); return(""); } Console.WriteLine("Content_ID not found."); return(""); } Console.WriteLine("Content_ID not found."); return(""); }