/// <summary> /// Copies certain characteristics of this instance to the <paramref name="cipher"/> parameter. /// The goal is to produce a cipher with the same encryption/decryption behavior but saving the key encryption and decryption ceremony and overhead if possible. /// Here it creates a <see cref="SymmetricAlgorithm"/> object identical to the current <see cref="Symmetric"/> and assigns it to <paramref name="cipher"/>'s <see cref="Symmetric"/>. /// </summary> /// <param name="cipher">The cipher that gets the identical symmetric algorithm object.</param> protected virtual void CopyTo( SymmetricKeyCipherBase cipher) { if (cipher == null) { throw new ArgumentNullException(nameof(cipher)); } if (!IsSymmetricKeyInitialized) { return; } cipher._symmetric = SymmetricAlgorithm.Create(Symmetric.GetType().FullName); cipher.Symmetric.Mode = Symmetric.Mode; cipher.Symmetric.Padding = Symmetric.Padding; cipher.Symmetric.BlockSize = Symmetric.BlockSize; cipher.Symmetric.FeedbackSize = Symmetric.FeedbackSize; cipher.Symmetric.KeySize = Symmetric.KeySize; cipher.Symmetric.Key = (byte[])Symmetric.Key.Clone(); cipher.Symmetric.IV = (byte[])Symmetric.IV.Clone(); cipher.IsSymmetricKeyInitialized = true; cipher.ShouldEncryptIV = ShouldEncryptIV; }
internal static string EncryptValue(string value) { if (String.IsNullOrWhiteSpace(value)) { return(String.Empty); } using (var symmetricProvider = new Symmetric(SymmetricProvider.Rijndael, false)) { string result; try { symmetricProvider.IntializationVector = IV; result = symmetricProvider.Encrypt(new Data(value), SymmetricKey).Bytes.ToBase64(); } catch (CryptographicException) { // return the value as is result = value; } return(result); } }
public void Constructor_WithModeInvalidKeySizeAndValidSalt_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(0, 1024)] int keySize) { string salt = SymmetricTestsHelper.DEFAULT_SALT; Symmetric symmetricHelper = new Symmetric(mode, keySize, salt); }
public void TestProtectVerifyIntegrity() { var key = "eda8506c1fb0bbcc3f62626fef074bbf2d09a8c7c608f3fa1482c9a625d00f75".ToByteArray(); var message = Encoding.ASCII.GetBytes("hoy, how are you?"); var plaintextAndTag = Symmetric.ProtectIntegrity(key, message); var retrievedMessage = Symmetric.VerifyIntegrity(key, plaintextAndTag); if (!message.SequenceEqual(retrievedMessage)) { throw new Exception("Verify did not work"); } // Tamper plaintextAndTag[plaintextAndTag.Length - 1] ^= 1; bool tamperDetected; try { Symmetric.VerifyIntegrity(key, plaintextAndTag); tamperDetected = false; } catch (Exception) { tamperDetected = true; } if (!tamperDetected) { throw new Exception("Verify did not work"); } }
public void DivTest() { var perm = Symmetric.Create(new int[] { 1, 2, 3, 0 }); Assert.Equal(new[] { 2, 3, 4, 1 }, new[] { 1, 2, 3, 4 } / perm); Assert.Equal(new[] { 1, 2, 3, 4 }, new[] { 1, 2, 3, 4 } / (perm / perm)); }
public void MulTest() { var perm = Symmetric.Create(new int[] { 1, 2, 3, 0 }); Assert.Equal(new[] { 4, 1, 2, 3 }, new[] { 1, 2, 3, 4 } *perm); Assert.Equal(new[] { 3, 4, 1, 2 }, new[] { 1, 2, 3, 4 } *(perm * perm)); }
public void Constructor_DefaultConstructor_InitializesWithNewKeyAndIV() { Symmetric symmetricHelper = new Symmetric(); Assert.IsNotNull(symmetricHelper.Key); Assert.IsNotNull(symmetricHelper.IV); }
protected virtual async Task BeforeWriteEncryptedAsync( Stream encryptedStream) { if (encryptedStream == null) { throw new ArgumentNullException(nameof(encryptedStream)); } if (!encryptedStream.CanWrite) { throw new ArgumentException(Resources.StreamNotWritable, nameof(encryptedStream)); } if (!IsSymmetricKeyInitialized) { throw new InvalidOperationException(Resources.UninitializedSymmetricKey); } Symmetric.GenerateIV(); var encryptedIV = EncryptIV(); // write the length and the contents of the IV in the encrypted stream await encryptedStream.WriteAsync(BitConverter.GetBytes(encryptedIV.Length), 0, sizeof(int)); await encryptedStream.WriteAsync(encryptedIV, 0, encryptedIV.Length); }
private void Decrypt(IEnumerable <ClientSettings> value) { var symetricProvider = new Symmetric(SymmetricProvider.Rijndael, false) { IntializationVector = _iv }; foreach (var settings in value) { if (settings.Password.Length == 0) { continue; } try { settings.Password = symetricProvider.Decrypt(new Data(settings.Password.FromBase64()), _symmetricKey).ToString(); } catch (FormatException) { Logger.WarnFormat(Constants.ClientNameFormat, settings.Name, "Failed to decrypt password... loading clear value."); } catch (CryptographicException) { Logger.WarnFormat(Constants.ClientNameFormat, settings.Name, "Failed to decrypt password... loading clear value."); } } }
public string encrypt(string data) { var sym = new Symmetric(_p); sym.Key.Text = _k; return(sym.Encrypt(new Encryption.Data(data)).ToHex()); }
public void GenerateIV_Defaults() { var iv = Symmetric.GenerateIV("GenerateIV_Defau"); var ivB64 = Convert.ToBase64String(iv); Assert.AreEqual("R2VuZXJhdGVJVl9EZWZhdQ==", ivB64); }
public void SerializeDeserialize() { byte[] serializedBytes = Symmetric.Serialize(plainText); string deserializedValue = Symmetric.Deserialize <string>(serializedBytes); Assert.AreEqual(plainText, deserializedValue); }
public void Constructor_WithByteArray() { var key = Symmetric.GenerateKey("Constructor_WithByteArray", "salt"); var sut = new Symmetric(key); Assert.AreEqual(key, sut.Key); }
public void GenerateKey_Defaults() { var key = Symmetric.GenerateKey("GenerateKey_Defaults", "salt"); var keyB64 = Convert.ToBase64String(key); Assert.AreEqual("XMIqI9XOfHYsg0+y7vtLvGReLaWs1z6QwM+9faMjSXw=", keyB64); }
public void Constructor_WithBase64String() { var key = Convert.ToBase64String(Symmetric.GenerateKey("Constructor_WithByteArray", "salt")); var sut = new Symmetric(key); Assert.AreEqual(key, Convert.ToBase64String(sut.Key)); }
public void GenerateKey_KeySize128() { var key = Symmetric.GenerateKey("GenerateKey_KeySize128", "salt", keySize: KeySize.Bits128); var keyB64 = Convert.ToBase64String(key); Assert.AreEqual("MPkpMHyGEYhK9ymWaVSMfg==", keyB64); }
public void GenerateKey_MD5() { var key = Symmetric.GenerateKey("GenerateKey_MD5", "salt", TNT.Cryptography.Enumerations.HashAlgorithm.MD5); var keyB64 = Convert.ToBase64String(key); Assert.AreEqual("oaVJMDQueZox8TP9E9Wrz0Fwxquezw3Sw7JjmdRIBHs=", keyB64); }
public void GenerateKey_KeySize192() { var key = Symmetric.GenerateKey("GenerateKey_KeySize192", "salt", keySize: KeySize.Bits192); var keyB64 = Convert.ToBase64String(key); Assert.AreEqual("eJmnbYPLuu1cUx4WRfUgH/PXzhQI7NLp", keyB64); }
public void Constructor_WithModeValidKeySizeAndEmptySalt_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(64, 128, 48, 192)] int keySize) { string salt = String.Empty; Symmetric symmetricHelper = new Symmetric(mode, keySize, salt); }
public static string Encrypt(string strPlainText, string strKey24) { var sym = new Symmetric(Symmetric.Provider.TripleDES, true); var key = new Data(strKey24); Data encryptedData; encryptedData = sym.Encrypt(new Data(strPlainText), key); return encryptedData.ToBase64(); }
public void Constructor_WithMode_InitializesWithKeyAndIV( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { Symmetric symmetricHelper = new Symmetric(mode); Assert.IsNotNull(symmetricHelper.Key); Assert.IsNotNull(symmetricHelper.IV); }
public void EncryptDecryptString_AppendIV() { var symmetric = new Symmetric(key); var cipher = symmetric.Encrypt(plainText, iv); var decryptedText = symmetric.Decrypt(cipher); Assert.AreEqual(plainText, Symmetric.Deserialize <string>(decryptedText)); }
public void Decrypt_WithBase64CipherAndIV() { var symmetric = new Symmetric(key); var cipher = symmetric.Encrypt(plainText, iv); var decryptedText = symmetric.Decrypt(Convert.ToBase64String(cipher.EncryptedContent), iv); Assert.AreEqual(plainText, decryptedText); }
/// <summary> /// Encrypt plain text via Rijndael symmetric-key algorithm. Returns Base64 string representation of the encrypted text /// </summary> /// <param name="plainText">the plain text</param> /// <returns></returns> public string Encrypt(string plainText) { string eKey = this._key; var sym = new Symmetric(Symmetric.Provider.Rijndael); var key = new Data(eKey); var encryptedText = sym.Encrypt(new Data(plainText), key); return encryptedText.ToBase64(); }
public void PropertyKey_EmptyByteArray_SetsNullKey() { Symmetric symmetricHelper = new Symmetric(); symmetricHelper.Key = new byte[] { }; Assert.IsNull(symmetricHelper.Key); }
//private static readonly string embededKey = "MHA234@@$AV^&*^(ere5MHcc"; public static string Encrypt(string strPlainText, string strKey24) { Symmetric sym = new Symmetric(Symmetric.Provider.TripleDES, true); EncryptionClassLibrary.Encryption.Data key = new EncryptionClassLibrary.Encryption.Data(strKey24); EncryptionClassLibrary.Encryption.Data encryptedData; encryptedData = sym.Encrypt(new EncryptionClassLibrary.Encryption.Data(strPlainText), key); return encryptedData.ToBase64(); }
public void PropertyKey_NullValue_SetsNullKey() { Symmetric symmetricHelper = new Symmetric(); symmetricHelper.Key = null; Assert.IsNull(symmetricHelper.Key); }
public void EncryptToString_WithEmptyMessage_ReturnsEmptyString() { string message = String.Empty; Symmetric symmetricHelper = new Symmetric(); string actual = symmetricHelper.EncryptToString(message); Assert.IsNullOrEmpty(actual); }
public void Encrypt() { var plainText = "this is my plain text"; var passPhrase = "this is my pass phrase"; var encrypted = Symmetric.Encrypt(plainText, passPhrase); Assert.AreNotEqual(plainText, encrypted); }
public void BasicCanDecryptTest() { const string PLAINTEXT = "SmartEncryption Sym Test"; var key = Symmetric.GenerateKey(); var cipher = Symmetric.Encrypt(Encoding.UTF8.GetBytes(PLAINTEXT), key); var plain = Symmetric.Decrypt(cipher, key); Assert.AreEqual(PLAINTEXT, Encoding.UTF8.GetString(plain)); }
public static string Encrypt(string value) { Symmetric sym = new Symmetric(); CPM.Business.Global.Account.Encryption.Data encryptedData = default(CPM.Business.Global.Account.Encryption.Data); encryptedData = sym.Encrypt(new CPM.Business.Global.Account.Encryption.Data(value)); return(encryptedData.Base64); }
public void DeriveKeyStringIsDeterministicTest() { const string PASSWORD = "******"; const string SALT = "44071f6d181561670bda728d43fb79b443bb805afdebaf98622b5165e01b15fb"; var val1 = Symmetric.DeriveKey(PASSWORD, Utilities.HexToBinary(SALT)); var val2 = Symmetric.DeriveKey(PASSWORD, Utilities.HexToBinary(SALT)); CollectionAssert.AreEqual(val1, val2); }
/// <summary> /// Encrypt plain text via Rijndael symmetric-key algorithm. Returns Base64 string representation of the encrypted text /// </summary> /// <param name="plainText">the plain text</param> /// <returns></returns> public string Encrypt(string plainText) { string eKey = this.Key; var sym = new Symmetric(Symmetric.Provider.Rijndael); var key = new Data(eKey); var encryptedText = sym.Encrypt(new Data(plainText), key); return(encryptedText.ToBase64()); }
public void Constructor_FullConstructorWithEmptySalt_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(64, 128, 48, 192)] int keySize) { string salt = String.Empty; byte[] iv = SymmetricTestsHelper.GetDefaultIV(mode); byte[] key = SymmetricTestsHelper.CreateKey(keySize); Symmetric symmetricHelper = new Symmetric(mode, salt, iv, key); }
public void Constructor_FullConstructorWithInvalidKeyLength_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(16, 1024)] int keySize) { string salt = SymmetricTestsHelper.DEFAULT_SALT; byte[] iv = SymmetricTestsHelper.GetDefaultIV(mode); byte[] key = SymmetricTestsHelper.CreateKey(keySize); Symmetric symmetricHelper = new Symmetric(mode, salt, iv, key); }
public static string Decrypt(String strEncText, string strKey24) { Symmetric sym = new Symmetric(Symmetric.Provider.TripleDES, true); EncryptionClassLibrary.Encryption.Data key = new EncryptionClassLibrary.Encryption.Data(strKey24); EncryptionClassLibrary.Encryption.Data encryptedData = new EncryptionClassLibrary.Encryption.Data(); encryptedData.Base64 = strEncText; EncryptionClassLibrary.Encryption.Data decryptedData = new EncryptionClassLibrary.Encryption.Data(); decryptedData = sym.Decrypt(encryptedData, key); return decryptedData.ToString(); }
public static string Decrypt(String strEncText, string strKey24) { var sym = new Symmetric(Symmetric.Provider.TripleDES, true); var key = new Data(strKey24); var encryptedData = new Data(); encryptedData.Base64 = strEncText; var decryptedData = new Data(); decryptedData = sym.Decrypt(encryptedData, key); return decryptedData.ToString(); }
public void Constructor_FullConstructorWithEmptyIV_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(64, 128, 48, 192)] int keySize) { string salt = SymmetricTestsHelper.DEFAULT_SALT; byte[] iv = new byte[] { }; byte[] key = SymmetricTestsHelper.CreateKey(keySize); Symmetric symmetricHelper = new Symmetric(mode, salt, iv, key); }
/// <summary> /// Decrypt encrypted text via Rijndael symmetric-key algorithm. Returns the plain text /// </summary> /// <param name="encryptedText">Base64 string representation of the encrypted text</param> /// <returns></returns> public string Decrypt(string encryptedText) { try { string eKey = this._key; var sym = new Symmetric(Symmetric.Provider.Rijndael); var key = new Data(eKey); var encryptedData = new Data {Base64 = encryptedText}; return sym.Decrypt(encryptedData, key).ToString(); } catch(Exception) { return null; } }
public void PropertyKey_ValidKey_SetsKey() { byte[] key = SymmetricTestsHelper.CreateKey(64); Symmetric symmetricHelper = new Symmetric(); symmetricHelper.Key = key; Assert.AreEqual(key, symmetricHelper.Key); }
public void Constructor_WithModeValidKeySizeAndNullSalt_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(64, 128, 48, 192)] int keySize) { Symmetric symmetricHelper = new Symmetric(mode, keySize, null); }
public void Decrypt_WithDefaultSecretString_ReturnsEmptyString( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { string secret = SymmetricTestsHelper.GetDefaultSecretString(mode); string expected = SymmetricTestsHelper.DEFAULT_MESSAGE; Symmetric symmetricHelper = new Symmetric(mode); symmetricHelper.Salt = SymmetricTestsHelper.DEFAULT_SALT; symmetricHelper.IV = SymmetricTestsHelper.GetDefaultIV(mode); symmetricHelper.Key = SymmetricTestsHelper.GetDefaultKey(mode); string actual = symmetricHelper.Decrypt(secret); Assert.AreEqual(expected, actual); }
public void Decrypt_WithNullSecret_ReturnsEmptyString() { byte[] secret = null; Symmetric symmetricHelper = new Symmetric(); string actual = symmetricHelper.Decrypt(secret); Assert.IsNullOrEmpty(actual); }
public void PropertyIV_NullValue_DoesntChange() { byte[] newIV = null; Symmetric symmetricHelper = new Symmetric(); byte[] oldIV = symmetricHelper.IV; byte[] oldKey = symmetricHelper.Key; symmetricHelper.IV = newIV; Assert.AreEqual(oldIV, symmetricHelper.IV); Assert.AreEqual(oldKey, symmetricHelper.Key); }
public void EncryptToString_WithNullMessage_ReturnsEmptyString() { string message = null; Symmetric symmetricHelper = new Symmetric(); string actual = symmetricHelper.EncryptToString(message); Assert.IsNullOrEmpty(actual); }
public void PropertyKey_KeyWithInvalidLength_Throws([Values(16, 1024)] int keySize) { Symmetric symmetricHelper = new Symmetric(); symmetricHelper.Key = SymmetricTestsHelper.CreateKey(keySize); }
public void PropertyIV_DefaultIV_ChangesKeyAndIV( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { byte[] newIV = SymmetricTestsHelper.GetDefaultIV(mode); Symmetric symmetricHelper = new Symmetric(mode); byte[] oldIV = symmetricHelper.IV; byte[] oldKey = symmetricHelper.Key; symmetricHelper.IV = newIV; Assert.AreNotEqual(oldIV, symmetricHelper.IV); Assert.AreNotEqual(oldKey, symmetricHelper.Key); }
public void PropertyIV_EmptyByteArray_DoesntChange() { byte[] newIV = new byte[] { }; Symmetric symmetricHelper = new Symmetric(); byte[] oldIV = symmetricHelper.IV; byte[] oldKey = symmetricHelper.Key; symmetricHelper.IV = newIV; Assert.AreEqual(oldIV, symmetricHelper.IV); Assert.AreEqual(oldKey, symmetricHelper.Key); }
public void Constructor_FullConstructorWithNullKey_Throws( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { string salt = SymmetricTestsHelper.DEFAULT_SALT; byte[] iv = SymmetricTestsHelper.GetDefaultIV(mode); byte[] key = null; Symmetric symmetricHelper = new Symmetric(mode, salt, iv, key); }
public void Decrypt_WithNullString_ReturnsEmptyString( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { string secret = null; Symmetric symmetricHelper = new Symmetric(mode); symmetricHelper.Salt = SymmetricTestsHelper.DEFAULT_SALT; symmetricHelper.IV = SymmetricTestsHelper.GetDefaultIV(mode); symmetricHelper.Key = SymmetricTestsHelper.GetDefaultKey(mode); string actual = symmetricHelper.Decrypt(secret); Assert.IsNullOrEmpty(actual); }
public void Encrypt_WithNullMessage_ReturnsNull() { string message = null; Symmetric symmetricHelper = new Symmetric(); byte[] actual = symmetricHelper.Encrypt(message); Assert.IsNull(actual); }
public void Constructor_DefaultConstructor_InitializesWithDefaultAlgorithm() { Symmetric symmetricHelper = new Symmetric(); Assert.AreEqual(Symmetric.DEFAULT_ALGORITHM, symmetricHelper.Mode); }
public void Encrypt_WithMessage_ReturnsSecret( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode) { string message = SymmetricTestsHelper.DEFAULT_MESSAGE; byte[] expected = SymmetricTestsHelper.GetDefaultSecret(mode); Symmetric symmetricHelper = new Symmetric(mode); symmetricHelper.Salt = SymmetricTestsHelper.DEFAULT_SALT; symmetricHelper.IV = SymmetricTestsHelper.GetDefaultIV(mode); symmetricHelper.Key = SymmetricTestsHelper.GetDefaultKey(mode); byte[] actual = symmetricHelper.Encrypt(message); Assert.AreEqual(expected, actual); }
public void Constructor_WithModeValidKeySizeAndEmptySalt_InitializesWithSaltKeyAndIV( [Values(Algorithm.DES, Algorithm.TripleDES, Algorithm.RC2, Algorithm.Rijndael)] Algorithm mode, [Values(64, 128, 48, 192)] int keySize) { string salt = SymmetricTestsHelper.DEFAULT_SALT; Symmetric symmetricHelper = new Symmetric(mode, keySize, salt); Assert.AreEqual(mode, symmetricHelper.Mode); Assert.AreEqual(keySize, symmetricHelper.KeySize); Assert.AreEqual(salt, symmetricHelper.Salt); Assert.IsNotNull(symmetricHelper.Key); Assert.IsNotNull(symmetricHelper.IV); }