'#무관심/##Unity3d' 카테고리의 글 목록

« 2024/12 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

'#무관심/##Unity3d'에 해당되는 글 2건

2015.04.08 [Unity3D] CompareBaseObjectsInternal can only be called from the main thread
2015.04.08 UserPref 암호화

[Unity3D] CompareBaseObjectsInternal can only be called from the main thread

| #무관심/##Unity3d 2015. 4. 8. 21:32

Posted by D

출처 : http://lazli.tistory.com/entry/Unity3D-CompareBaseObjectsInternal-can-only-be-called-from-the-main-thread

저작자표시 비영리

And

UserPref 암호화

| #무관심/##Unity3d 2015. 4. 8. 19:09

Posted by D

출처 : http://ikpil.com/1342

포스팅 목적

기록하기 위해
피드백을 받기 위해. 버그 있을 때, 수정 할 수 있습니다. 링크도 가져 가세요.
공유 - 불펌 개념이 없으니, 마음데로 사용하세요.

개발 이유

게임 정보를 서버에 다 저장해서 쓰려고 했는데, 회의 중 인터넷이 끊어져도 게임하는데 지장이 없어야 한다는 결론이 내려졌습니다. 그래서 로컬에 데이터를 저장해야 하는데, 유니티가 기본 제공하는 PlayerPrefs 은 손 쉽게 변조가 가능하기 때문에, 변조를 못하게 막아야 할 필요가 있었습니다.

그래서 유니티 보안 문서들을 보았고, 그 중에 PlayerPrefs 먼저 할 필요가 있어서, 기존에 다른 사람이 만든 코드를 찾아 보았습니다. 하지만 키를 숨기는 개념이나 value 암호화 개념을 사용하는건 찾지 못했습니다. 그래서 직접 개발(짜집기)을 하게 되었습니다.

다음에는 모듈(DLL) 암호화를 할 필요가 있습니다.

링크 1 : http://unitystudy.net/bbs/board.php?bo_table=newwriting&wr_id=355
링크 2 : ?http://www.slideshare.net/williamyang3910/unitekorea2013-protecting-your-android-content-21713675?

설명

Unity PlayerPrefs 특성상 key-value 형태로 로컬에 데이터를 저장하는데, 암호화가 되어 있지 않습니다. 그래서 다음과 같은 절차를 거쳐 PlayerPrefs 를 사용합니다.

저장 할 때

저장 할 Key 의 해쉬값을 얻고, 그 해쉬를 hideKey 로 사용합니다. 왜냐하면, 해커가 Key 를 보고, 용도를 파악 할 수 있기 때문입니다. 추가로 salt 가 있는 이유는 공개 해쉬 알고리즘을 사용하기 때문에, 무작위 대입으로 키를 손쉽게 알 수 있기 때문입니다.
예) hideKey = Hash(Key + salt)
저장해야 할 Value 의 해쉬값을 얻고, Value + Hash(Value) 로 만든 뒤 암호화 합니다.
Value 의 Hash 를 얻는 이유는 복호화 후 Value 가 변조되었는지 확인이 필요하기 때문이다.
예) encryptValue = Encrypt(Value + Hash(Value))

3. 이렇게 얻어진 hideKey - encryptValue 를 PlayerPrefs 으로 저장합니다.

불러 올 때

hideKey 를 똑같이 만듭니다.
hideKey 로 암호화된 값을 얻고, 복호화 후 원본 saved Value + saved Hash(Value) 를 구합니다.
saved Value, saved Hash(Value) 로 분리 한 뒤, 서로 비교하여 변했는지 검사합니다.
예) Hash(saved Value) == saved Hash(Value)

코드 : SecurityPlayerPrefs , 갱신 : 2015.03.03 23:16

using UnityEngine;
using System.Security.Cryptography;
using System.Text;
using System.IO;
  
public class SecurityPlayerPrefs
{
    // http://www.codeproject.com/Articles/769741/Csharp-AES-bits-Encryption-Library-with-Salt
    // http://ikpil.com/1342
 
    private static string _saltForKey;
 
    private static byte[] _keys;
    private static byte[] _iv;
    private static int keySize = 256;
    private static int blockSize = 128;
    private static int _hashLen = 32;
 
    static SecurityPlayerPrefs()
    {
        // 8 바이트로 하고, 변경해서 쓸것
        byte[] saltBytes = new byte[] { 25, 36, 77, 51, 43, 14, 75, 93 };
 
        // 길이 상관 없고, 키를 만들기 위한 용도로 씀
        string randomSeedForKey = "5b6fcb4aaa0a42acae649eba45a506ec";
 
        // 길이 상관 없고, aes에 쓸 key 와 iv 를 만들 용도
        string randomSeedForValue = "2e327725789841b5bb5c706d6b2ad897";
 
        {
            Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(randomSeedForKey, saltBytes, 1000);
            _saltForKey = System.Convert.ToBase64String(key.GetBytes(blockSize / 8));
        }
 
        {
            Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(randomSeedForValue, saltBytes, 1000);
            _keys = key.GetBytes(keySize / 8);
            _iv = key.GetBytes(blockSize / 8);
        }
    }
 
    public static string MakeHash(string original)
    {
        using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
        {
            byte[] bytes = System.Text.Encoding.UTF8.GetBytes(original);
            byte[] hashBytes = md5.ComputeHash(bytes);
 
            string hashToString = "";
            for (int i = 0; i < hashBytes.Length; ++i)
                hashToString += hashBytes[i].ToString("x2");
 
            return hashToString;
        }
    }
 
    public static byte[] Encrypt(byte[] bytesToBeEncrypted)
    {
        using (RijndaelManaged aes = new RijndaelManaged())
        {
            aes.KeySize = keySize;
            aes.BlockSize = blockSize;
 
            aes.Key = _keys;
            aes.IV = _iv;
 
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
 
            using (ICryptoTransform ct = aes.CreateEncryptor())
            {
                return ct.TransformFinalBlock(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
            }
        }
    }
 
    public static byte[] Decrypt(byte[] bytesToBeDecrypted)
    {
        using (RijndaelManaged aes = new RijndaelManaged())
        {
            aes.KeySize = keySize;
            aes.BlockSize = blockSize;
 
            aes.Key = _keys;
            aes.IV = _iv;
 
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
 
            using (ICryptoTransform ct = aes.CreateDecryptor())
            {
                return ct.TransformFinalBlock(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length);
            }
        }
    }
 
    public static string Encrypt(string input)
    {
        byte[] bytesToBeEncrypted = Encoding.UTF8.GetBytes(input);
        byte[] bytesEncrypted = Encrypt(bytesToBeEncrypted);
 
        return System.Convert.ToBase64String(bytesEncrypted);
    }
 
    public static string Decrypt(string input)
    {
        byte[] bytesToBeDecrypted = System.Convert.FromBase64String(input);
        byte[] bytesDecrypted = Decrypt(bytesToBeDecrypted);
 
        return Encoding.UTF8.GetString(bytesDecrypted);
    }
 
    private static void SetSecurityValue(string key, string value)
    {
        string hideKey = MakeHash(key + _saltForKey);
        string encryptValue = Encrypt(value + MakeHash(value));
 
        PlayerPrefs.SetString(hideKey, encryptValue);
    }
 
    private static string GetSecurityValue(string key)
    {
        string hideKey = MakeHash(key + _saltForKey);
 
        string encryptValue = PlayerPrefs.GetString(hideKey);
        if (true == string.IsNullOrEmpty(encryptValue))
            return string.Empty;
 
        string valueAndHash = Decrypt(encryptValue);
        if (_hashLen > valueAndHash.Length)
            return string.Empty;
 
        string savedValue = valueAndHash.Substring(0, valueAndHash.Length - _hashLen);
        string savedHash = valueAndHash.Substring(valueAndHash.Length - _hashLen);
 
        if (MakeHash(savedValue) != savedHash)
            return string.Empty;
 
        return savedValue;
    }
 
    public static void DeleteKey(string key)
    {
        PlayerPrefs.DeleteKey(MakeHash(key + _saltForKey));
    }
 
    public static void DeleteAll()
    {
        PlayerPrefs.DeleteAll();
    }
 
    public static void Save()
    {
        PlayerPrefs.Save();
    }
 
    public static void SetInt(string key, int value)
    {
        SetSecurityValue(key, value.ToString());
    }
 
    public static void SetLong(string key, long value)
    {
        SetSecurityValue(key, value.ToString());
    }
 
    public static void SetFloat(string key, float value)
    {
        SetSecurityValue(key, value.ToString());
    }
 
    public static void SetString(string key, string value)
    {
        SetSecurityValue(key, value);
    }
 
    public static int GetInt(string key, int defaultValue)
    {
        string originalValue = GetSecurityValue(key);
        if (true == string.IsNullOrEmpty(originalValue))
            return defaultValue;
 
        int result = defaultValue;
        if (false == int.TryParse(originalValue, out result))
            return defaultValue;
 
        return result;
    }
 
    public static long GetLong(string key, long defaultValue)
    {
        string originalValue = GetSecurityValue(key);
        if (true == string.IsNullOrEmpty(originalValue))
            return defaultValue;
 
        long result = defaultValue;
        if (false == long.TryParse(originalValue, out result))
            return defaultValue;
 
        return result;
    }
 
    public static float GetFloat(string key, float defaultValue)
    {
        string originalValue = GetSecurityValue(key);
        if (true == string.IsNullOrEmpty(originalValue))
            return defaultValue;
 
        float result = defaultValue;
        if (false == float.TryParse(originalValue, out result))
            return defaultValue;
 
        return result;
    }
 
    public static string GetString(string key, string defaultValue)
    {
        string originalValue = GetSecurityValue(key);
        if (true == string.IsNullOrEmpty(originalValue))
            return defaultValue;
 
        return originalValue;
    }
}