사용자:Aidenk(비교)

=== 예전 코드 ===

아래 신규 코드가 이상하면 이걸 쓰기위해

{{{#!syntax csharp

using System;

using System.IO;

using System.Security.Cryptography;

using System.Text;

using UnityEngine;

using System.Runtime.CompilerServices;

[Serializable]

public class PlayerData

{

public string playerName;

public int score;

}

public class SecureManager : MonoBehaviour

{

public static SecureManager Instance { get; private set; }

public bool EnableHardening = true;

public bool EnableAntiDebugChecks = true;

public bool EnableRootDetection = true;

public bool EnableDummyMix = false;

public bool EnableFileNameObfuscation = true;

public bool EnableRotation = true;

private const string Magic = "SJMP";

private const byte Version = 1;

private const int SaltLenDefault = 12;

private const int IvLen = 16;

private const int HmacLen = 32;

private const int KeyMaterialLen = 64;

private const int AesKeyLen = 32;

private const int HmacKeyLen = 32;

private const int Pbkdf2Iterations = 20000;

private readonly byte[] obfPartA = new byte[] { 0x4A, 0x5F, 0x33, 0x29, 0x11, 0x7C, 0x6D, 0x3E, 0x2D, 0x7A, 0x5B, 0x1C };

private readonly byte[] obfPartB = new byte[] { 0x91, 0x20, 0x55, 0x12, 0x44, 0x38, 0x77, 0x0A, 0x6F, 0x21, 0x9D, 0xEE };

private const byte Mask = 0xAA;

private string filePath;

private byte[] sessionNonce;

void Awake()

{

if (Instance != null && Instance != this)

{

Destroy(gameObject);

return;

}

Instance = this;

DontDestroyOnLoad(gameObject);

sessionNonce = LoadOrCreateSessionNonce();

filePath = Path.Combine(Application.persistentDataPath, ResolveFileName("playerData"));

Warmup();

}

private byte[] LoadOrCreateSessionNonce()

{

const string key = "SecureManager_SessionNonce_v1";

try

{

if (PlayerPrefs.HasKey(key))

{

string b64 = PlayerPrefs.GetString(key);

byte[] stored = Convert.FromBase64String(b64);

if (stored != null && stored.Length > 0) return stored;

}

}

catch { }

byte[] nonce = GenerateRandomBytes(16);

try

{

PlayerPrefs.SetString(key, Convert.ToBase64String(nonce));

PlayerPrefs.Save();

}

catch { }

return nonce;

}

private void Warmup()

{

try { _ = GetSecretBytes(); } catch { }

}

[MethodImpl(MethodImplOptions.NoInlining)]

private byte[] DumbMixA(byte[] input)

{

byte[] outb = new byte[input.Length];

for (int i = 0; i < input.Length; i++)

{

int v = input[i];

v = ((v << 3) | (v >> 5)) & 0xFF;

v ^= (i * 37) & 0xFF;

outb[i] = (byte)v;

}

return outb;

}

[MethodImpl(MethodImplOptions.NoInlining)]

private byte[] DumbMixB(byte[] input, int seed)

{

byte[] outb = new byte[input.Length];

for (int i = 0; i < input.Length; i++)

{

int v = input[i] ^ (seed >> (i % 8));

v = (v * 13 + (i * 7)) & 0xFF;

v = (v ^ 0x5A) & 0xFF;

outb[i] = (byte)v;

}

return outb;

}

[MethodImpl(MethodImplOptions.NoInlining)]

private byte[] DumbMixC(byte[] input, byte[] nonce)

{

byte[] outb = new byte[input.Length];

for (int i = 0; i < input.Length; i++)

{

int n = nonce[i % nonce.Length];

int v = input[i];

v = ((v + n) ^ (n >> (i % 4))) & 0xFF;

outb[i] = (byte)v;

}

return outb;

}

private byte[] GetSecretBytes()

{

byte[] k = new byte[obfPartA.Length + obfPartB.Length];

for (int i = 0; i < obfPartA.Length; i++) k[i] = (byte)(obfPartA[i] ^ Mask);

for (int i = 0; i < obfPartB.Length; i++) k[i + obfPartA.Length] = (byte)(obfPartB[i] ^ Mask);

if (!EnableHardening || !EnableDummyMix)

{

byte[] simple = new byte[k.Length];

Buffer.BlockCopy(k, 0, simple, 0, k.Length);

Array.Clear(k, 0, k.Length);

return simple;

}

byte[] s1 = DumbMixA(k);

// 시간 의존 제거, 디바이스 기반 결정적 시드

int deviceSeed = Application.identifier.GetHashCode() ^ SystemInfo.deviceUniqueIdentifier.GetHashCode();

byte[] s2 = DumbMixB(s1, deviceSeed);

byte[] s3 = DumbMixC(s2, sessionNonce);

for (int r = 0; r < 2; r++)

{

byte[] t = DumbMixA(s3);

byte[] u = DumbMixB(t, deviceSeed ^ r);

for (int i = 0; i < k.Length; i++) s3[i] = (byte)(s3[i] ^ u[i % u.Length]);

Array.Clear(t, 0, t.Length);

Array.Clear(u, 0, u.Length);

}

Array.Clear(s1, 0, s1.Length);

Array.Clear(s2, 0, s2.Length);

byte[] result = new byte[k.Length];

for (int i = 0; i < k.Length; i++) result[i] = (byte)(k[i] ^ s3[i % s3.Length]);

Array.Clear(k, 0, k.Length);

Array.Clear(s3, 0, s3.Length);

return result;

}

private (byte[] aesKey, byte[] hmacKey) DeriveKeysRotating(byte[] salt, byte[] rotationNonce)

{

byte[] secret = GetSecretBytes();

string secretStr = EnableHardening ? Convert.ToBase64String(secret) + Application.identifier : Encoding.UTF8.GetString(secret) + Application.identifier;

Array.Clear(secret, 0, secret.Length);

using (var kdf = new Rfc2898DeriveBytes(secretStr, salt, Pbkdf2Iterations, HashAlgorithmName.SHA256))

{

byte[] km = kdf.GetBytes(KeyMaterialLen);

if (EnableHardening && EnableRotation && rotationNonce != null)

{

for (int i = 0; i < km.Length; i++) km[i] ^= rotationNonce[i % rotationNonce.Length];

}

byte[] aesKey = new byte[AesKeyLen];

byte[] hmacKey = new byte[HmacKeyLen];

Buffer.BlockCopy(km, 0, aesKey, 0, AesKeyLen);

Buffer.BlockCopy(km, AesKeyLen, hmacKey, 0, HmacKeyLen);

Array.Clear(km, 0, km.Length);

return (aesKey, hmacKey);

}

}

public void Save<T>(T data)

{

if (EnableHardening && (EnableAntiDebugChecks || EnableRootDetection) && IsTamperedOrDebug()) return;

try

{

string json = JsonUtility.ToJson(data);

byte[] salt = GenerateRandomBytes(SaltLenDefault);

byte[] rotation = (EnableHardening && EnableRotation) ? GenerateRandomBytes(16) : new byte[16];

var keys = DeriveKeysRotating(salt, (EnableRotation ? rotation : null));

byte[] aesKey = keys.aesKey;

byte[] hmacKey = keys.hmacKey;

byte[] plain = Encoding.UTF8.GetBytes(json);

byte[] iv;

byte[] cipher;

using (Aes aes = Aes.Create())

{

aes.KeySize = 256;

aes.Mode = CipherMode.CBC;

aes.Padding = PaddingMode.PKCS7;

aes.Key = aesKey;

aes.GenerateIV();

iv = aes.IV;

using (var enc = aes.CreateEncryptor(aes.Key, iv))

cipher = enc.TransformFinalBlock(plain, 0, plain.Length);

}

byte[] ivCipher = new byte[iv.Length + cipher.Length];

Buffer.BlockCopy(iv, 0, ivCipher, 0, iv.Length);

Buffer.BlockCopy(cipher, 0, ivCipher, iv.Length, cipher.Length);

byte[] hmac;

using (var h = new HMACSHA256(hmacKey)) hmac = h.ComputeHash(ivCipher);

using (MemoryStream ms = new MemoryStream())

{

ms.Write(Encoding.ASCII.GetBytes(Magic), 0, 4);

ms.WriteByte(Version);

ms.WriteByte((byte)salt.Length);

ms.Write(salt, 0, salt.Length);

ms.WriteByte(EnableRotation ? (byte)rotation.Length : (byte)0);

if (EnableRotation) ms.Write(rotation, 0, rotation.Length);

ms.Write(iv, 0, iv.Length);

byte[] cipherLenBytes = BitConverter.GetBytes((Int32)cipher.Length);

if (!BitConverter.IsLittleEndian) Array.Reverse(cipherLenBytes);

ms.Write(cipherLenBytes, 0, 4);

ms.Write(cipher, 0, cipher.Length);

ms.Write(hmac, 0, hmac.Length);

string outBlob = Convert.ToBase64String(ms.ToArray());

File.WriteAllText(filePath, outBlob);

}

ClearBytes(aesKey);

ClearBytes(hmacKey);

ClearBytes(plain);

ClearBytes(iv);

ClearBytes(cipher);

ClearBytes(ivCipher);

ClearBytes(hmac);

ClearBytes(salt);

ClearBytes(rotation);

}

catch { }

}

public T Load<T>()

{

if (EnableHardening && (EnableAntiDebugChecks || EnableRootDetection) && IsTamperedOrDebug()) return default;

if (!File.Exists(filePath)) return default;

string blob = File.ReadAllText(filePath);

byte[] total;

try { total = Convert.FromBase64String(blob); } catch { return default; }

try

{

using (MemoryStream ms = new MemoryStream(total))

using (BinaryReader br = new BinaryReader(ms))

{

byte[] magic = br.ReadBytes(4);

if (Encoding.ASCII.GetString(magic) != Magic) return default;

byte ver = br.ReadByte();

if (ver != Version) return default;

int saltLen = br.ReadByte();

if (saltLen <= 0 || saltLen > 64) return default;

byte[] salt = br.ReadBytes(saltLen);

int rotationLen = br.ReadByte();

byte[] rotation = rotationLen > 0 ? br.ReadBytes(rotationLen) : new byte[16];

byte[] iv = br.ReadBytes(IvLen);

int cipherLen = br.ReadInt32();

if (!BitConverter.IsLittleEndian) cipherLen = System.Net.IPAddress.NetworkToHostOrder(cipherLen);

if (cipherLen <= 0 || cipherLen > total.Length) return default;

byte[] cipher = br.ReadBytes(cipherLen);

byte[] hmac = br.ReadBytes(HmacLen);

byte[] ivCipher = new byte[iv.Length + cipher.Length];

Buffer.BlockCopy(iv, 0, ivCipher, 0, iv.Length);

Buffer.BlockCopy(cipher, 0, ivCipher, iv.Length, cipher.Length);

var keys = DeriveKeysRotating(salt, (EnableRotation ? rotation : null));

byte[] aesKey = keys.aesKey;

byte[] hmacKey = keys.hmacKey;

byte[] expected;

using (var h = new HMACSHA256(hmacKey)) expected = h.ComputeHash(ivCipher);

bool ok = CryptographicOperations.FixedTimeEquals(expected, hmac);

if (!ok)

{

ClearBytes(aesKey);

ClearBytes(hmacKey);

ClearBytes(expected);

return default;

}

byte[] plain;

using (Aes aes = Aes.Create())

{

aes.KeySize = 256;

aes.Mode = CipherMode.CBC;

aes.Padding = PaddingMode.PKCS7;

aes.Key = aesKey;

aes.IV = iv;

using (var dec = aes.CreateDecryptor(aes.Key, aes.IV))

plain = dec.TransformFinalBlock(cipher, 0, cipher.Length);

}

string json = Encoding.UTF8.GetString(plain);

ClearBytes(aesKey);

ClearBytes(hmacKey);

ClearBytes(expected);

ClearBytes(plain);

ClearBytes(iv);

ClearBytes(cipher);

ClearBytes(salt);

ClearBytes(rotation);

return JsonUtility.FromJson<T>(json);

}

}

catch { return default; }

}

private static byte[] GenerateRandomBytes(int len)

{

byte[] b = new byte[len];

using (var rng = RandomNumberGenerator.Create()) rng.GetBytes(b);

return b;

}

private static void ClearBytes(byte[] b)

{

if (b == null) return;

Array.Clear(b, 0, b.Length);

}

private string ResolveFileName(string baseName)

{

if (!EnableHardening || !EnableFileNameObfuscation) return baseName + ".dat";

byte[] nameBytes = Encoding.UTF8.GetBytes(baseName + Application.identifier);

using (var sha = SHA256.Create())

{

byte[] hash = sha.ComputeHash(nameBytes);

string b64 = Convert.ToBase64String(hash);

string safe = b64.Replace('+', '-').Replace('/', '_').Replace('=', 'x');

ClearBytes(hash);

return safe.Substring(0, Math.Min(28, safe.Length)) + ".dat";

}

}

private bool IsTamperedOrDebug()

{

if (!EnableHardening) return false;

try

{

if (EnableAntiDebugChecks)

{

if (System.Diagnostics.Debugger.IsAttached) return true;

if (System.Diagnostics.Process.GetCurrentProcess().ProcessName.ToLower().Contains("debug")) return true;

}

}

catch { }

try

{

if (EnableRootDetection)

{

string[] suspectPaths = new string[] { "/system/bin/su", "/system/xbin/su", "/sbin/su" };

foreach (var p in suspectPaths) if (File.Exists(p)) return true;

}

}

catch { }

return false;

}

}

}}}