internal void Decrypt() { if (!Obscured) { return; } if (!IsEditableObscuredValue()) { return; } bool success = true; switch (obscuredType) { case ObscuredPrefs.DataType.Int: prefType = PrefsType.Int; break; case ObscuredPrefs.DataType.String: prefType = PrefsType.String; break; case ObscuredPrefs.DataType.Float: prefType = PrefsType.Float; break; case ObscuredPrefs.DataType.UInt: case ObscuredPrefs.DataType.Double: case ObscuredPrefs.DataType.Long: case ObscuredPrefs.DataType.Bool: case ObscuredPrefs.DataType.ByteArray: case ObscuredPrefs.DataType.Vector2: case ObscuredPrefs.DataType.Vector3: case ObscuredPrefs.DataType.Quaternion: case ObscuredPrefs.DataType.Color: case ObscuredPrefs.DataType.Rect: instance.ShowNotification(new GUIContent("Type " + obscuredType + " isn't supported")); success = false; break; case ObscuredPrefs.DataType.Unknown: instance.ShowNotification(new GUIContent("Can't decrypt " + key)); success = false; break; default: throw new ArgumentOutOfRangeException(); } if (success) { Obscured = false; obscuredType = ObscuredPrefs.DataType.Unknown; dirtyValue = dirtyKey = true; } }
internal PrefsRecord(string newKey, string value, bool encrypted) { key = savedKey = newKey; stringValue = value; prefType = PrefsType.String; if (encrypted) { obscuredType = ObscuredPrefs.DataType.String; Obscured = true; } }
internal PrefsRecord(string newKey, float value, bool encrypted) { key = savedKey = newKey; floatValue = value; if (encrypted) { prefType = PrefsType.String; obscuredType = ObscuredPrefs.DataType.Float; Obscured = true; } else { prefType = PrefsType.Float; } }
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)); }
internal PrefsRecord(string originalKey) { key = savedKey = originalKey; ReadValue(); // only string prefs may be obscured if (prefType == PrefsType.String) { Obscured = IsValueObscured(stringValue); if (Obscured) { key = DecryptKey(key); if (obscuredType == ObscuredPrefs.DataType.String) { stringValue = ObscuredPrefs.DecryptStringValue(key, stringValue, DEFAULT_STRING); if (stringValue == DEFAULT_STRING) { stringValue = CANT_DECRYPT; } } else if (obscuredType == ObscuredPrefs.DataType.Int) { intValue = ObscuredPrefs.DecryptIntValue(key, stringValue, DEFAULT_INT); if (intValue == DEFAULT_INT) { obscuredType = ObscuredPrefs.DataType.String; stringValue = CANT_DECRYPT; } } else if (obscuredType == ObscuredPrefs.DataType.Float) { floatValue = ObscuredPrefs.DecryptFloatValue(key, stringValue, DEFAULT_FLOAT); if (floatValue == DEFAULT_FLOAT) { obscuredType = ObscuredPrefs.DataType.String; stringValue = CANT_DECRYPT; } } } } }
internal PrefsRecord(string originalKey) { key = savedKey = originalKey; ReadValue(); // only string prefs may be obscured if (prefType == PrefsType.String) { Obscured = IsValueObscured(stringValue); if (Obscured) { key = DecryptKey(key); if (obscuredType == ObscuredPrefs.DataType.String) { stringValue = ObscuredPrefs.DecryptStringValue(key, stringValue, DefaultString); if (stringValue == DefaultString) { stringValue = CantDecrypt; } } else if (obscuredType == ObscuredPrefs.DataType.Int) { intValue = ObscuredPrefs.DecryptIntValue(key, stringValue, DefaultInt); if (intValue == DefaultInt) { obscuredType = ObscuredPrefs.DataType.String; stringValue = CantDecrypt; } } else if (obscuredType == ObscuredPrefs.DataType.Float) { floatValue = ObscuredPrefs.DecryptFloatValue(key, stringValue, DefaultFloat); if (Math.Abs(floatValue - DefaultFloat) < 0.00001f) { obscuredType = ObscuredPrefs.DataType.String; stringValue = CantDecrypt; } } } } }
private bool IsValueObscured(string value) { bool validBase64String = (value.Length % 4 == 0) && Regex.IsMatch(value, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None); if (!validBase64String) { return(false); } ObscuredPrefs.DataType dataType = ObscuredPrefs.GetRawValueType(value); if (!Enum.IsDefined(typeof(ObscuredPrefs.DataType), dataType) || dataType == ObscuredPrefs.DataType.Unknown) { return(false); } obscuredType = dataType; return(true); }
private static string EncryptData(string key, byte[] cleanBytes, ObscuredPrefs.DataType type) { int length1 = cleanBytes.Length; byte[] numArray1 = ObscuredPrefs.EncryptDecryptBytes(cleanBytes, length1, key + ObscuredPrefs.encryptionKey); uint hash = xxHash.CalculateHash(cleanBytes, length1, 0U); byte[] numArray2 = new byte[4] { (byte)(hash & (uint)byte.MaxValue), (byte)(hash >> 8 & (uint)byte.MaxValue), (byte)(hash >> 16 & (uint)byte.MaxValue), (byte)(hash >> 24 & (uint)byte.MaxValue) }; byte[] numArray3 = (byte[])null; int length2; if (ObscuredPrefs.lockToDevice != ObscuredPrefs.DeviceLockLevel.None) { length2 = length1 + 11; uint deviceIdHash = ObscuredPrefs.DeviceIdHash; numArray3 = new byte[4] { (byte)(deviceIdHash & (uint)byte.MaxValue), (byte)(deviceIdHash >> 8 & (uint)byte.MaxValue), (byte)(deviceIdHash >> 16 & (uint)byte.MaxValue), (byte)(deviceIdHash >> 24 & (uint)byte.MaxValue) }; } else { length2 = length1 + 7; } byte[] inArray = new byte[length2]; Buffer.BlockCopy((Array)numArray1, 0, (Array)inArray, 0, length1); if (numArray3 != null) { Buffer.BlockCopy((Array)numArray3, 0, (Array)inArray, length1, 4); } inArray[length2 - 7] = (byte)type; inArray[length2 - 6] = (byte)2; inArray[length2 - 5] = (byte)ObscuredPrefs.lockToDevice; Buffer.BlockCopy((Array)numArray2, 0, (Array)inArray, length2 - 4, 4); return(Convert.ToBase64String(inArray)); }
internal void Encrypt() { if (Obscured) { return; } bool success = true; switch (prefType) { case PrefsType.Unknown: success = false; Debug.LogError(ActEditorGlobalStuff.LOG_PREFIX + "Can't encrypt pref of unknown type!"); break; case PrefsType.String: obscuredType = ObscuredPrefs.DataType.String; break; case PrefsType.Int: obscuredType = ObscuredPrefs.DataType.Int; break; case PrefsType.Float: obscuredType = ObscuredPrefs.DataType.Float; break; default: throw new ArgumentOutOfRangeException(); } if (success) { prefType = PrefsType.String; Obscured = true; dirtyValue = dirtyKey = true; } }
internal static ObscuredPrefs.DataType GetRawValueType(string value) { ObscuredPrefs.DataType dataType = ObscuredPrefs.DataType.Unknown; byte[] array; try { array = Convert.FromBase64String(value); } catch (Exception) { ObscuredPrefs.DataType result = dataType; return(result); } if (array.Length < 7) { return(dataType); } int num = array.Length; dataType = (ObscuredPrefs.DataType)array[num - 7]; return(dataType); }