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

Code:

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.

Code:

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.