Best Compression Methods for 'Specific' Games. Q&A

[ozerune]

Anonymous;Code help

I applied Precomp+Srep+Lolz on the whole thing and I got a ratio of 93.3%. I have tried it on individual file types as well and can't figure this out. The two main file types that are taking up space are .bin and .mzv. Any ideas on what I could use for this game?

[Masquerade]

^^
Anonymous;Code is an encrypted game and the only way you can repack it is by unpacking the archives using FreeMote and rebuilding them during installation.

https://github.com/UlyssesWu/FreeMote/releases

The key for the game is in plaintext inside the executable (visible with hex editor).

The key is "5fWhAHt4zVn2X" (game.exe, 0x5CEFCC)

[Masquerade]

ANONYMOUS;CODE bin Decrypt+Repack

The archives for ANONYMOUS;CODE are encrypted+compressed. The first 3 bytes are mdf.

The archives are a combination of .bin and .psb.m files.

sound_body.bin and voice_en_body.bin are not encrypted or compressed.

Step one is finding the key in the executable file. This is easy since the key is stored in plaintext (idiot gamedevs).

Search for ".bin" and search until you see the key:



The key for ANONYMOUS;CODE is:

5fWhAHt4zVn2X

Second step is to download Freemote:
https://github.com/UlyssesWu/FreeMote/releases/latest

You can unpack the archive using this command:

PsbDecompile info-psb -k 5fWhAHt4zVn2X <.psb.m file>

You can repack the archive from the unpacked data using this command:

PsBuild info-pdb <.psb.m.json file>

Repackaged files are CRC correct to original archives so no need to use HDiffZ or XDelta to patch any bytes (probably wouldn't work anyway due to encryption).

[Hexagon123]

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Dantora
{
	// Token: 0x02000253 RID: 595
	public class Crypt
	{
		// Token: 0x06000E77 RID: 3703 RVA: 0x0007A8A4 File Offset: 0x00078CA4
		public static string Encrypt(string text)
		{
			RijndaelManaged rijndaelManaged = new RijndaelManaged
			{
				BlockSize = 128,
				KeySize = 128,
				Padding = PaddingMode.Zeros,
				Mode = CipherMode.CBC,
				Key = Encoding.UTF8.GetBytes("giVJrbHRlWBDIggF"),
				IV = Encoding.UTF8.GetBytes("jCddaOybW3zEh0Kl")
			};
			ICryptoTransform transform = rijndaelManaged.CreateEncryptor();
			MemoryStream memoryStream = new MemoryStream();
			CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
			byte[] bytes = Encoding.UTF8.GetBytes(text);
			cryptoStream.Write(bytes, 0, bytes.Length);
			cryptoStream.FlushFinalBlock();
			byte[] inArray = memoryStream.ToArray();
			return Convert.ToBase64String(inArray);
		}

		// Token: 0x06000E78 RID: 3704 RVA: 0x0007A950 File Offset: 0x00078D50
		public static byte[] Encrypt(byte[] data)
		{
			RijndaelManaged rijndaelManaged = new RijndaelManaged
			{
				BlockSize = 128,
				KeySize = 128,
				Padding = PaddingMode.Zeros,
				Mode = CipherMode.CBC,
				Key = Encoding.UTF8.GetBytes("giVJrbHRlWBDIggF"),
				IV = Encoding.UTF8.GetBytes("jCddaOybW3zEh0Kl")
			};
			ICryptoTransform transform = rijndaelManaged.CreateEncryptor();
			MemoryStream memoryStream = new MemoryStream();
			CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
			cryptoStream.Write(data, 0, data.Length);
			cryptoStream.FlushFinalBlock();
			return memoryStream.ToArray();
		}

		// Token: 0x06000E79 RID: 3705 RVA: 0x0007A9E4 File Offset: 0x00078DE4
		public static string Decrypt(string cryptText)
		{
			RijndaelManaged rijndaelManaged = new RijndaelManaged
			{
				BlockSize = 128,
				KeySize = 128,
				Padding = PaddingMode.Zeros,
				Mode = CipherMode.CBC,
				Key = Encoding.UTF8.GetBytes("giVJrbHRlWBDIggF"),
				IV = Encoding.UTF8.GetBytes("jCddaOybW3zEh0Kl")
			};
			ICryptoTransform transform = rijndaelManaged.CreateDecryptor();
			byte[] array = Convert.FromBase64String(cryptText);
			byte[] array2 = new byte[array.Length];
			MemoryStream stream = new MemoryStream(array);
			CryptoStream cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Read);
			cryptoStream.Read(array2, 0, array2.Length);
			return Encoding.UTF8.GetString(array2);
		}

		// Token: 0x06000E7A RID: 3706 RVA: 0x0007AA90 File Offset: 0x00078E90
		public static byte[] Decrypt(byte[] data)
		{
			RijndaelManaged rijndaelManaged = new RijndaelManaged
			{
				BlockSize = 128,
				KeySize = 128,
				Padding = PaddingMode.Zeros,
				Mode = CipherMode.CBC,
				Key = Encoding.UTF8.GetBytes("giVJrbHRlWBDIggF"),
				IV = Encoding.UTF8.GetBytes("jCddaOybW3zEh0Kl")
			};
			ICryptoTransform transform = rijndaelManaged.CreateDecryptor();
			byte[] array = new byte[data.Length];
			MemoryStream stream = new MemoryStream(data);
			CryptoStream cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Read);
			cryptoStream.Read(array, 0, array.Length);
			return array;
		}

		// Token: 0x04000BC6 RID: 3014
		private const string AesIV = "jCddaOybW3zEh0Kl";

		// Token: 0x04000BC7 RID: 3015
		private const string AesKey = "giVJrbHRlWBDIggF";
	}
}

Heroland (2019) Game is using Unity and it is encrypted with AES IV and compressed with LZ4.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

// Token: 0x02000B1A RID: 2842
public static class CryptoUtility
{
	// Token: 0x060049E1 RID: 18913 RVA: 0x00156E24 File Offset: 0x00155224
	public static byte[] Crypto(string key, byte[] src, bool encode = false)
	{
		string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(key);
		byte[] bytes = Encoding.UTF8.GetBytes(CryptoUtility.salt);
		Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(fileNameWithoutExtension + CryptoUtility.pw, bytes);
		rfc2898DeriveBytes.IterationCount = 1103;
		RijndaelManaged rijndaelManaged = new RijndaelManaged();
		rijndaelManaged.Padding = PaddingMode.Zeros;
		rijndaelManaged.Mode = CipherMode.CBC;
		rijndaelManaged.KeySize = CryptoUtility.KeySize;
		rijndaelManaged.BlockSize = CryptoUtility.BlockSize;
		rijndaelManaged.Key = rfc2898DeriveBytes.GetBytes(rijndaelManaged.KeySize / 8);
		rijndaelManaged.IV = rfc2898DeriveBytes.GetBytes(rijndaelManaged.BlockSize / 8);
		ICryptoTransform cryptoTransform;
		if (encode)
		{
			cryptoTransform = rijndaelManaged.CreateEncryptor();
		}
		else
		{
			cryptoTransform = rijndaelManaged.CreateDecryptor();
		}
		byte[] result = cryptoTransform.TransformFinalBlock(src, 0, src.Length);
		cryptoTransform.Dispose();
		return result;
	}

	// Token: 0x060049E2 RID: 18914 RVA: 0x00156EEC File Offset: 0x001552EC
	public static bool CryptoFile(string srcPath, string dstPath, bool encode = false, bool checkFS = false)
	{
		bool result;
		using (FileStream fileStream = File.OpenRead(srcPath))
		{
			if (fileStream == null)
			{
				result = false;
			}
			else
			{
				byte[] array = new byte[fileStream.Length];
				fileStream.Read(array, 0, (int)fileStream.Length);
				if (checkFS)
				{
					string text = Encoding.ASCII.GetString(array).Substring(0, 7);
					if (text != "UnityFS")
					{
						fileStream.Close();
						Debug.LogError("Not Asset Bunddle File[" + text + "]" + srcPath);
						return false;
					}
				}
				byte[] array2;
				if (encode)
				{
					Debug.Log("Encode\n" + srcPath + "\n" + dstPath);
					array2 = CryptoUtility.Crypto(srcPath, array, true);
				}
				else
				{
					Debug.Log("Decode\n" + srcPath + "\n" + dstPath);
					array2 = CryptoUtility.Crypto(srcPath, array, false);
				}
				fileStream.Close();
				using (FileStream fileStream2 = File.OpenWrite(dstPath))
				{
					if (fileStream2 == null)
					{
						result = false;
					}
					else
					{
						fileStream2.Write(array2, 0, array2.Length);
						fileStream2.Close();
						result = true;
					}
				}
			}
		}
		return result;
	}

	// Token: 0x0400401D RID: 16413
	private static string pw = "c4GXA8FT";

	// Token: 0x0400401E RID: 16414
	private static string salt = "t4ChYLcH";

	// Token: 0x0400401F RID: 16415
	private static int KeySize = 128;

	// Token: 0x04004020 RID: 16416
	private static int BlockSize = 128;
}

Super Bomberman R (2017) game is using Unity and it is encrypted with Salt.