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)
});
}
}
