private static string EncryptVector2Value(string key, Vector2 value) { byte[] cleanBytes = new byte[8]; Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.x), 0, (Array)cleanBytes, 0, 4); Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.y), 0, (Array)cleanBytes, 4, 4); return(ObscuredPrefs.EncryptData(key, cleanBytes, ObscuredPrefs.DataType.Vector2)); }
private static string EncryptVector2Value(string key, Vector2 value) { byte[] array = new byte[8]; Buffer.BlockCopy(BitConverter.GetBytes(value.x), 0, array, 0, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.y), 0, array, 4, 4); return(ObscuredPrefs.EncryptData(key, array, ObscuredPrefs.DataType.Vector2)); }
private static Vector2 DecryptVector2Value(string key, string encryptedInput, Vector2 defaultValue) { if (encryptedInput.IndexOf(':') > -1) { string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput); if (text == string.Empty) { return(defaultValue); } string[] array = text.Split(new char[] { "|"[0] }); float x; float.TryParse(array[0], out x); float y; float.TryParse(array[1], out y); Vector2 vector = new Vector2(x, y); ObscuredPrefs.SetVector2(key, vector); return(vector); } else { byte[] array2 = ObscuredPrefs.DecryptData(key, encryptedInput); if (array2 == null) { return(defaultValue); } Vector2 result; result.x = BitConverter.ToSingle(array2, 0); result.y = BitConverter.ToSingle(array2, 4); return(result); } }
private static Vector3 DecryptVector3Value(string key, string encryptedInput, Vector3 defaultValue) { if (encryptedInput.IndexOf(':') > -1) { string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput); if (str == string.Empty) { return(defaultValue); } string[] strArray = str.Split("|"[0]); float result1; float.TryParse(strArray[0], out result1); float result2; float.TryParse(strArray[1], out result2); float result3; float.TryParse(strArray[2], out result3); Vector3 vector3; // ISSUE: explicit reference operation ((Vector3)@vector3).\u002Ector(result1, result2, result3); ObscuredPrefs.SetVector3(key, vector3); return(vector3); } byte[] numArray = ObscuredPrefs.DecryptData(key, encryptedInput); if (numArray == null) { return(defaultValue); } Vector3 vector3_1; vector3_1.x = (__Null)(double)BitConverter.ToSingle(numArray, 0); vector3_1.y = (__Null)(double)BitConverter.ToSingle(numArray, 4); vector3_1.z = (__Null)(double)BitConverter.ToSingle(numArray, 8); return(vector3_1); }
private static void SavesTampered() { if (ObscuredPrefs.onAlterationDetected != null) { ObscuredPrefs.onAlterationDetected(); ObscuredPrefs.onAlterationDetected = null; } }
private static void PossibleForeignSavesDetected() { if (ObscuredPrefs.onPossibleForeignSavesDetected != null && !ObscuredPrefs.foreignSavesReported) { ObscuredPrefs.foreignSavesReported = true; ObscuredPrefs.onPossibleForeignSavesDetected(); } }
public static void DeleteKey(string key) { PlayerPrefs.DeleteKey(ObscuredPrefs.EncryptKey(key)); if (!ObscuredPrefs.preservePlayerPrefs) { PlayerPrefs.DeleteKey(key); } }
public static bool HasKey(string key) { if (!PlayerPrefs.HasKey(key)) { return(PlayerPrefs.HasKey(ObscuredPrefs.EncryptKey(key))); } return(true); }
private static void SavesTampered() { if (ObscuredPrefs.onAlterationDetected == null) { return; } ObscuredPrefs.onAlterationDetected(); ObscuredPrefs.onAlterationDetected = (Action)null; }
private static string EncryptQuaternionValue(string key, Quaternion value) { byte[] array = new byte[16]; Buffer.BlockCopy(BitConverter.GetBytes(value.x), 0, array, 0, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.y), 0, array, 4, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.z), 0, array, 8, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.w), 0, array, 12, 4); return(ObscuredPrefs.EncryptData(key, array, ObscuredPrefs.DataType.Quaternion)); }
private static string EncryptRectValue(string key, Rect value) { byte[] array = new byte[16]; Buffer.BlockCopy(BitConverter.GetBytes(value.x), 0, array, 0, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.y), 0, array, 4, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.width), 0, array, 8, 4); Buffer.BlockCopy(BitConverter.GetBytes(value.height), 0, array, 12, 4); return(ObscuredPrefs.EncryptData(key, array, ObscuredPrefs.DataType.Rect)); }
private static string EncryptQuaternionValue(string key, Quaternion value) { byte[] cleanBytes = new byte[16]; Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.x), 0, (Array)cleanBytes, 0, 4); Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.y), 0, (Array)cleanBytes, 4, 4); Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.z), 0, (Array)cleanBytes, 8, 4); Buffer.BlockCopy((Array)BitConverter.GetBytes((float)value.w), 0, (Array)cleanBytes, 12, 4); return(ObscuredPrefs.EncryptData(key, cleanBytes, ObscuredPrefs.DataType.Quaternion)); }
private static void PossibleForeignSavesDetected() { if (ObscuredPrefs.onPossibleForeignSavesDetected == null || ObscuredPrefs.foreignSavesReported) { return; } ObscuredPrefs.foreignSavesReported = true; ObscuredPrefs.onPossibleForeignSavesDetected(); }
public static double GetDouble(string key, double defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptDoubleValue(key, encryptedPrefsString, defaultValue)); }
public static long GetLong(string key, long defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptLongValue(key, encryptedPrefsString, defaultValue)); }
public static byte[] GetByteArray(string key, byte defaultValue, int defaultLength) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength)); } return(ObscuredPrefs.DecryptByteArrayValue(key, encryptedPrefsString, defaultValue, defaultLength)); }
public static Quaternion GetQuaternion(string key, Quaternion defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptQuaternionValue(key, encryptedPrefsString, defaultValue)); }
public static bool GetBool(string key, bool defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptBoolValue(key, encryptedPrefsString, defaultValue)); }
public static Rect GetRect(string key, Rect defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptRectValue(key, encryptedPrefsString, defaultValue)); }
public static Vector3 GetVector3(string key, Vector3 defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } return(ObscuredPrefs.DecryptVector3Value(key, encryptedPrefsString, defaultValue)); }
public static void ForceLockToDeviceInit() { if (string.IsNullOrEmpty(ObscuredPrefs.deviceId)) { ObscuredPrefs.deviceId = ObscuredPrefs.GetDeviceId(); ObscuredPrefs.deviceIdHash = ObscuredPrefs.CalculateChecksum(ObscuredPrefs.deviceId); } else { Debug.LogWarning("[ACTk] ObscuredPrefs.ForceLockToDeviceInit() is called, but device ID is already obtained!"); } }
private static string EncryptRectValue(string key, Rect value) { byte[] cleanBytes = new byte[16]; // ISSUE: explicit reference operation Buffer.BlockCopy((Array)BitConverter.GetBytes(((Rect)@value).get_x()), 0, (Array)cleanBytes, 0, 4); // ISSUE: explicit reference operation Buffer.BlockCopy((Array)BitConverter.GetBytes(((Rect)@value).get_y()), 0, (Array)cleanBytes, 4, 4); // ISSUE: explicit reference operation Buffer.BlockCopy((Array)BitConverter.GetBytes(((Rect)@value).get_width()), 0, (Array)cleanBytes, 8, 4); // ISSUE: explicit reference operation Buffer.BlockCopy((Array)BitConverter.GetBytes(((Rect)@value).get_height()), 0, (Array)cleanBytes, 12, 4); return(ObscuredPrefs.EncryptData(key, cleanBytes, ObscuredPrefs.DataType.Rect)); }
public static Color32 GetColor(string key, Color32 defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } uint num1 = ObscuredPrefs.DecryptUIntValue(key, encryptedPrefsString, 16777216U); byte num2 = (byte)(num1 >> 24); return(new Color32((byte)(num1 >> 16), (byte)(num1 >> 8), (byte)num1, num2)); }
private static byte[] DecryptByteArrayValue(string key, string encryptedInput, byte defaultValue, int defaultLength) { if (encryptedInput.IndexOf(':') <= -1) { return(ObscuredPrefs.DecryptData(key, encryptedInput) ?? ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength)); } string s = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput); if (s == string.Empty) { return(ObscuredPrefs.ConstructByteArray(defaultValue, defaultLength)); } byte[] bytes = Encoding.UTF8.GetBytes(s); ObscuredPrefs.SetByteArray(key, bytes); return(bytes); }
public static Color32 GetColor(string key, Color32 defaultValue) { string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, ObscuredPrefs.EncryptKey(key)); if (encryptedPrefsString == "{not_found}") { return(defaultValue); } uint num = ObscuredPrefs.DecryptUIntValue(key, encryptedPrefsString, 16777216u); byte a = (byte)(num >> 24); byte r = (byte)(num >> 16); byte g = (byte)(num >> 8); byte b = (byte)num; return(new Color32(r, g, b, a)); }
private static string EncryptData(string key, byte[] cleanBytes, ObscuredPrefs.DataType type) { int num = cleanBytes.Length; byte[] src = ObscuredPrefs.EncryptDecryptBytes(cleanBytes, num, key + ObscuredPrefs.cryptoKey); uint num2 = xxHash.CalculateHash(cleanBytes, num, 0u); byte[] src2 = new byte[] { (byte)(num2 & 255u), (byte)(num2 >> 8 & 255u), (byte)(num2 >> 16 & 255u), (byte)(num2 >> 24 & 255u) }; byte[] array = null; int num3; if (ObscuredPrefs.lockToDevice != ObscuredPrefs.DeviceLockLevel.None) { num3 = num + 11; uint num4 = ObscuredPrefs.DeviceIdHash; array = new byte[] { (byte)(num4 & 255u), (byte)(num4 >> 8 & 255u), (byte)(num4 >> 16 & 255u), (byte)(num4 >> 24 & 255u) }; } else { num3 = num + 7; } byte[] array2 = new byte[num3]; Buffer.BlockCopy(src, 0, array2, 0, num); if (array != null) { Buffer.BlockCopy(array, 0, array2, num, 4); } array2[num3 - 7] = (byte)type; array2[num3 - 6] = 2; array2[num3 - 5] = (byte)ObscuredPrefs.lockToDevice; Buffer.BlockCopy(src2, 0, array2, num3 - 4, 4); return(Convert.ToBase64String(array2)); }
public static string GetString(string key, string defaultValue) { string text = ObscuredPrefs.EncryptKey(key); if (!PlayerPrefs.HasKey(text) && PlayerPrefs.HasKey(key)) { string @string = PlayerPrefs.GetString(key, defaultValue); if (!ObscuredPrefs.preservePlayerPrefs) { ObscuredPrefs.SetString(key, @string); PlayerPrefs.DeleteKey(key); } return(@string); } string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, text); return((!(encryptedPrefsString == "{not_found}")) ? ObscuredPrefs.DecryptStringValue(key, encryptedPrefsString, defaultValue) : defaultValue); }
public static float GetFloat(string key, float defaultValue) { string text = ObscuredPrefs.EncryptKey(key); if (!PlayerPrefs.HasKey(text) && PlayerPrefs.HasKey(key)) { float @float = PlayerPrefs.GetFloat(key, defaultValue); if (!ObscuredPrefs.preservePlayerPrefs) { ObscuredPrefs.SetFloat(key, @float); PlayerPrefs.DeleteKey(key); } return(@float); } string encryptedPrefsString = ObscuredPrefs.GetEncryptedPrefsString(key, text); return((!(encryptedPrefsString == "{not_found}")) ? ObscuredPrefs.DecryptFloatValue(key, encryptedPrefsString, defaultValue) : defaultValue); }
private static string DecryptStringValue(string key, string encryptedInput, string defaultValue) { if (encryptedInput.IndexOf(':') > -1) { string str = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput); if (str == string.Empty) { return(defaultValue); } ObscuredPrefs.SetString(key, str); return(str); } byte[] bytes = ObscuredPrefs.DecryptData(key, encryptedInput); if (bytes == null) { return(defaultValue); } return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
private static Rect DecryptRectValue(string key, string encryptedInput, Rect defaultValue) { if (encryptedInput.IndexOf(':') > -1) { string text = ObscuredPrefs.DeprecatedDecryptValue(encryptedInput); if (text == string.Empty) { return(defaultValue); } string[] array = text.Split(new char[] { "|"[0] }); float x; float.TryParse(array[0], out x); float y; float.TryParse(array[1], out y); float width; float.TryParse(array[2], out width); float height; float.TryParse(array[3], out height); Rect rect = new Rect(x, y, width, height); ObscuredPrefs.SetRect(key, rect); return(rect); } else { byte[] array2 = ObscuredPrefs.DecryptData(key, encryptedInput); if (array2 == null) { return(defaultValue); } return(new Rect { x = BitConverter.ToSingle(array2, 0), y = BitConverter.ToSingle(array2, 4), width = BitConverter.ToSingle(array2, 8), height = BitConverter.ToSingle(array2, 12) }); } }