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