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("");
}