C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Globalization;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
					
public class Program
{
	public async static Task Main()
	{
		var guid = "1ab4e20c-a2d1-40dd-a47e-b7da9c8a6e4d";
		var encryptedPassword = await RijndaelSimple.EncryptAsync(guid, "resetPassword", "salesForceId");
		var encryptClientData = Convert.ToBase64String(encryptedPassword);
		var testArr = Convert.FromBase64String(encryptClientData.Replace(" ", "+"));
		
		// decrypt the data to get the original plaintext
        var originalPlainText = await RijndaelSimple.DecryptAsync(testArr, "resetPassword", "salesForceId");
		
         // check if the encrypted string is equal to the original one
         var isEqual = string.Equals(guid, originalPlainText);
		
		Console.WriteLine(isEqual);
	}
	
	public static class RijndaelSimple
    {
        private static string HashAlgorithm
        {
            get
            {
                return "SHA1";
            }
        }
        private static int PasswordIterations
        {
            get
            {
                return 2;
            }
        }

        private static string InitVector
        {
            get
            {
                return "@1B2c3D4e5F6g7H8";
            }
        }

        private static int KeySize
        {
            get
            {
                return 256;   // can be 192 or 128
            }
        }

        /// <summary>
        /// Encrypts specified plaintext using Rijndael symmetric key algorithm
        /// and returns a base64-encoded result.
        /// </summary>
        /// <param name="plainText">
        /// Plaintext value to be encrypted.
        /// </param>
        /// <param name="passPhrase">
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// </param>
        /// <param name="saltValue">
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// </param>
        /// <param name="hashAlgorithm">
        /// Hash algorithm used to generate password. Allowed values are: "MD5" and
        /// "SHA1". SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// </param>
        /// <param name="passwordIterations">
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// </param>
        /// <param name="initVector">
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be 
        /// exactly 16 ASCII characters long.
        /// </param>
        /// <param name="keySize">
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256. 
        /// Longer keys are more secure than shorter keys.
        /// </param>
        /// <returns>
        /// Encrypted value formatted as a base64-encoded string.
        /// </returns>
        public static byte[] Encrypt(string plainText,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            // Convert strings into byte arrays.
            // Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

            // Convert our plaintext into a byte array.
            // Let us assume that plaintext contains UTF8-encoded characters.
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

            // First, we must create a password, from which the key will be derived.
            // This password will be generated from the specified passphrase and 
            // salt value. The password will be created using the specified hash 
            // algorithm. Password creation can be done in several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                            passPhrase,
                                                            saltValueBytes,
                                                            hashAlgorithm,
                                                            passwordIterations);

            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);

            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged()
            {

                // It is reasonable to set encryption mode to Cipher Block Chaining
                // (CBC). Use default options for other symmetric key parameters.
                Mode = CipherMode.CBC
            };

            // Generate encryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
                                                             keyBytes,
                                                             initVectorBytes);

            // Define memory stream which will be used to hold encrypted data.


            // Define cryptographic stream (always use Write mode for encryption).
            MemoryStream memoryStream = null;
            CryptoStream cryptoStream = null;
            try
            {
                memoryStream = new MemoryStream();
                cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);

                // Start encrypting.
                cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

                // Finish encrypting.
                cryptoStream.FlushFinalBlock();
                memoryStream.Flush();
                // Convert our encrypted data from a memory stream into a byte array.
                byte[] cipherTextBytes = memoryStream.ToArray();

                // Close both streams.
                //cryptoStream.Close();
                //memoryStream.Close();

                return cipherTextBytes;
            }
            finally
            {
                if (memoryStream != null) memoryStream.Dispose();
                if (cryptoStream != null) cryptoStream.Dispose();
            }
        }

        public static async Task<byte[]> EncryptAsync(string plainText, string passPhrase, string saltValue, string hashAlgorithm, int passwordIterations, string initVector, int keySize, CancellationToken cancellationToken = default)
        {
            byte[] initVectorBytes = Encoding.UTF8.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.UTF8.GetBytes(saltValue);

            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

            using PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);
            byte[] keyBytes = password.GetBytes(keySize / 8);

            using RijndaelManaged symmetricKey = new RijndaelManaged
            {
                Mode = CipherMode.CBC
            };

            using ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);
            using MemoryStream memoryStream = new MemoryStream();
            using CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);

            try
            {
                await cryptoStream.WriteAsync(plainTextBytes, 0, plainTextBytes.Length, cancellationToken).ConfigureAwait(false);
                await cryptoStream.FlushFinalBlockAsync(cancellationToken).ConfigureAwait(false);
                await memoryStream.FlushAsync(cancellationToken).ConfigureAwait(false);
                return memoryStream.ToArray();
            }
            finally
            {
                await cryptoStream.DisposeAsync().ConfigureAwait(false);
                await memoryStream.DisposeAsync().ConfigureAwait(false);
            }
        }
     
        /// <summary>
        /// Decrypts specified ciphertext using Rijndael symmetric key algorithm.
        /// </summary>
        /// <param name="cipherText">
        /// Base64-formatted ciphertext value.
        /// </param>
        /// <param name="passPhrase">
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// </param>
        /// <param name="saltValue">
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// </param>
        /// <param name="hashAlgorithm">
        /// Hash algorithm used to generate password. Allowed values are: "MD5" and
        /// "SHA1". SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// </param>
        /// <param name="passwordIterations">
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// </param>
        /// <param name="initVector">
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be
        /// exactly 16 ASCII characters long.
        /// </param>
        /// <param name="keySize">
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256.
        /// Longer keys are more secure than shorter keys.
        /// </param>
        /// <returns>
        /// Decrypted string value.
        /// </returns>
        /// <remarks>
        /// Most of the logic in this function is similar to the Encrypt
        /// logic. In order for decryption to work, all parameters of this function
        /// - except cipherText value - must match the corresponding parameters of
        /// the Encrypt function which was called to generate the
        /// ciphertext.
        /// </remarks>
        public static string Decrypt(byte[] cipherTextBytes,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            // Convert strings defining encryption key characteristics into byte
            // arrays. Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

            // Convert our ciphertext into a byte array.
            //(if the paramater was string data
            //byte[] cipherTextBytes = Convert.FromBase64String(cipherText);

            // First, we must create a password, from which the key will be 
            // derived. This password will be generated from the specified 
            // passphrase and salt value. The password will be created using
            // the specified hash algorithm. Password creation can be done in
            // several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                            passPhrase,
                                                            saltValueBytes,
                                                            hashAlgorithm,
                                                            passwordIterations);

            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);

            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged()
            {

                // It is reasonable to set encryption mode to Cipher Block Chaining
                // (CBC). Use default options for other symmetric key parameters.
                Mode = CipherMode.CBC
            };

            // Generate decryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
                                                             keyBytes,
                                                             initVectorBytes);

            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = null;
            string plainText = null;
            try
            {
                memoryStream = new MemoryStream(cipherTextBytes);
                // Define cryptographic stream (always use Read mode for encryption).
                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                {
                    memoryStream = null;
                    // Since at this point we don't know what the size of decrypted data
                    // will be, allocate the buffer long enough to hold ciphertext;
                    // plaintext is never longer than ciphertext.
                    byte[] plainTextBytes = new byte[cipherTextBytes.Length];

                    // Start decrypting.
                    int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);

                    // Convert decrypted data into a string. 
                    // Let us assume that the original plaintext string was UTF8-encoded.
                    plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
                }
            }
            finally
            {
                if (memoryStream != null) memoryStream.Dispose();
            }
            // Return decrypted string.   
            return plainText;
        }

        public static async Task<string> DecryptAsync(byte[] cipherTextBytes,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            byte[] initVectorBytes = Encoding.UTF8.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.UTF8.GetBytes(saltValue);

            using PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);
            byte[] keyBytes = password.GetBytes(keySize / 8);

            using RijndaelManaged symmetricKey = new RijndaelManaged
            {
                Mode = CipherMode.CBC
            };

            using ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);
            using MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
            using CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);

            try
            {
                using StreamReader streamReader = new StreamReader(cryptoStream);
                return await streamReader.ReadToEndAsync().ConfigureAwait(false);
            }
            finally
            {
                await cryptoStream.DisposeAsync().ConfigureAwait(false);
                await memoryStream.DisposeAsync().ConfigureAwait(false);
            }
        }

        public static byte[] Encrypt(string message, string passPhrase, string salt)
        {
            return Encrypt(message, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize);
        }

        public static byte[] Encrypt(string plainText, DateTime registrationDate)
        {
            return Encrypt(plainText, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture));
        }

        public static string Decrypt(byte[] encryptedMessage, string passPhrase, string salt)
        {
            return Decrypt(encryptedMessage, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize);
        }

        public static string Decrypt(byte[] encryptedMessage, DateTime registrationDate)
        {
            return Decrypt(encryptedMessage, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture));
        }

        public static async Task<string> DecryptAsync(byte[] encryptedMessage, string passPhrase, string salt)
        {
            return await DecryptAsync(encryptedMessage, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize).ConfigureAwait(false);
        }

        public static async Task<string> DecryptAsync(byte[] encryptedMessage, DateTime registrationDate)
        {
            return await DecryptAsync(encryptedMessage, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
        }

        public static async Task<byte[]> EncryptAsync(string message, string passPhrase, string salt, CancellationToken cancellationToken = default)
        {
            return await EncryptAsync(message, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize, cancellationToken).ConfigureAwait(false);
        }

        public static async Task<byte[]> EncryptAsync(string plainText, DateTime registrationDate, CancellationToken cancellationToken = default)
        {
            string registrationDateStr = registrationDate.ToString(CultureInfo.InvariantCulture);

            return await EncryptAsync(plainText, registrationDateStr, registrationDateStr, cancellationToken).ConfigureAwait(false);
        }
    }
}

​x
 
using System;
using System.Globalization;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
                    
public class Program
{
    public async static Task Main()
    {
        var guid = "1ab4e20c-a2d1-40dd-a47e-b7da9c8a6e4d";
        var encryptedPassword = await RijndaelSimple.EncryptAsync(guid, "resetPassword", "salesForceId");
        var encryptClientData = Convert.ToBase64String(encryptedPassword);
        var testArr = Convert.FromBase64String(encryptClientData.Replace(" ", "+"));
        
        // decrypt the data to get the original plaintext
        var originalPlainText = await RijndaelSimple.DecryptAsync(testArr, "resetPassword", "salesForceId");
        
         // check if the encrypted string is equal to the original one
         var isEqual = string.Equals(guid, originalPlainText);
        
        Console.WriteLine(isEqual);
    }
    
    public static class RijndaelSimple
    {
        private static string HashAlgorithm
        {
            get
            {
                return "SHA1";
            }
        }
        private static int PasswordIterations
        {
            get
            {
                return 2;
            }
        }
​
        private static string InitVector
        {
            get
            {
                return "@1B2c3D4e5F6g7H8";
            }
        }
​
        private static int KeySize
        {
            get
            {
                return 256;   // can be 192 or 128
            }
        }
​
        /// <summary>
        /// Encrypts specified plaintext using Rijndael symmetric key algorithm
        /// and returns a base64-encoded result.
        /// </summary>
        /// <param name="plainText">
        /// Plaintext value to be encrypted.
        /// </param>
        /// <param name="passPhrase">
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// </param>
        /// <param name="saltValue">
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// </param>
        /// <param name="hashAlgorithm">
        /// Hash algorithm used to generate password. Allowed values are: "MD5" and
        /// "SHA1". SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// </param>
        /// <param name="passwordIterations">
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// </param>
        /// <param name="initVector">
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be 
        /// exactly 16 ASCII characters long.
        /// </param>
        /// <param name="keySize">
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256. 
        /// Longer keys are more secure than shorter keys.
        /// </param>
        /// <returns>
        /// Encrypted value formatted as a base64-encoded string.
        /// </returns>
        public static byte[] Encrypt(string plainText,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            // Convert strings into byte arrays.
            // Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
​
            // Convert our plaintext into a byte array.
            // Let us assume that plaintext contains UTF8-encoded characters.
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
​
            // First, we must create a password, from which the key will be derived.
            // This password will be generated from the specified passphrase and 
            // salt value. The password will be created using the specified hash 
            // algorithm. Password creation can be done in several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                            passPhrase,
                                                            saltValueBytes,
                                                            hashAlgorithm,
                                                            passwordIterations);
​
            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);
​
            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged()
            {
​
                // It is reasonable to set encryption mode to Cipher Block Chaining
                // (CBC). Use default options for other symmetric key parameters.
                Mode = CipherMode.CBC
            };
​
            // Generate encryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
                                                             keyBytes,
                                                             initVectorBytes);
​
            // Define memory stream which will be used to hold encrypted data.
​
​
            // Define cryptographic stream (always use Write mode for encryption).
            MemoryStream memoryStream = null;
            CryptoStream cryptoStream = null;
            try
            {
                memoryStream = new MemoryStream();
                cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
​
                // Start encrypting.
                cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
​
                // Finish encrypting.
                cryptoStream.FlushFinalBlock();
                memoryStream.Flush();
                // Convert our encrypted data from a memory stream into a byte array.
                byte[] cipherTextBytes = memoryStream.ToArray();
​
                // Close both streams.
                //cryptoStream.Close();
                //memoryStream.Close();
​
                return cipherTextBytes;
            }
            finally
            {
                if (memoryStream != null) memoryStream.Dispose();
                if (cryptoStream != null) cryptoStream.Dispose();
            }
        }
​
        public static async Task<byte[]> EncryptAsync(string plainText, string passPhrase, string saltValue, string hashAlgorithm, int passwordIterations, string initVector, int keySize, CancellationToken cancellationToken = default)
        {
            byte[] initVectorBytes = Encoding.UTF8.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.UTF8.GetBytes(saltValue);
​
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
​
            using PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);
            byte[] keyBytes = password.GetBytes(keySize / 8);
​
            using RijndaelManaged symmetricKey = new RijndaelManaged
            {
                Mode = CipherMode.CBC
            };
​
            using ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);
            using MemoryStream memoryStream = new MemoryStream();
            using CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
​
            try
            {
                await cryptoStream.WriteAsync(plainTextBytes, 0, plainTextBytes.Length, cancellationToken).ConfigureAwait(false);
                await cryptoStream.FlushFinalBlockAsync(cancellationToken).ConfigureAwait(false);
                await memoryStream.FlushAsync(cancellationToken).ConfigureAwait(false);
                return memoryStream.ToArray();
            }
            finally
            {
                await cryptoStream.DisposeAsync().ConfigureAwait(false);
                await memoryStream.DisposeAsync().ConfigureAwait(false);
            }
        }
     
        /// <summary>
        /// Decrypts specified ciphertext using Rijndael symmetric key algorithm.
        /// </summary>
        /// <param name="cipherText">
        /// Base64-formatted ciphertext value.
        /// </param>
        /// <param name="passPhrase">
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// </param>
        /// <param name="saltValue">
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// </param>
        /// <param name="hashAlgorithm">
        /// Hash algorithm used to generate password. Allowed values are: "MD5" and
        /// "SHA1". SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// </param>
        /// <param name="passwordIterations">
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// </param>
        /// <param name="initVector">
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be
        /// exactly 16 ASCII characters long.
        /// </param>
        /// <param name="keySize">
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256.
        /// Longer keys are more secure than shorter keys.
        /// </param>
        /// <returns>
        /// Decrypted string value.
        /// </returns>
        /// <remarks>
        /// Most of the logic in this function is similar to the Encrypt
        /// logic. In order for decryption to work, all parameters of this function
        /// - except cipherText value - must match the corresponding parameters of
        /// the Encrypt function which was called to generate the
        /// ciphertext.
        /// </remarks>
        public static string Decrypt(byte[] cipherTextBytes,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            // Convert strings defining encryption key characteristics into byte
            // arrays. Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
​
            // Convert our ciphertext into a byte array.
            //(if the paramater was string data
            //byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
​
            // First, we must create a password, from which the key will be 
            // derived. This password will be generated from the specified 
            // passphrase and salt value. The password will be created using
            // the specified hash algorithm. Password creation can be done in
            // several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                                                            passPhrase,
                                                            saltValueBytes,
                                                            hashAlgorithm,
                                                            passwordIterations);
​
            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);
​
            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged()
            {
​
                // It is reasonable to set encryption mode to Cipher Block Chaining
                // (CBC). Use default options for other symmetric key parameters.
                Mode = CipherMode.CBC
            };
​
            // Generate decryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
                                                             keyBytes,
                                                             initVectorBytes);
​
            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = null;
            string plainText = null;
            try
            {
                memoryStream = new MemoryStream(cipherTextBytes);
                // Define cryptographic stream (always use Read mode for encryption).
                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                {
                    memoryStream = null;
                    // Since at this point we don't know what the size of decrypted data
                    // will be, allocate the buffer long enough to hold ciphertext;
                    // plaintext is never longer than ciphertext.
                    byte[] plainTextBytes = new byte[cipherTextBytes.Length];
​
                    // Start decrypting.
                    int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
​
                    // Convert decrypted data into a string. 
                    // Let us assume that the original plaintext string was UTF8-encoded.
                    plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
                }
            }
            finally
            {
                if (memoryStream != null) memoryStream.Dispose();
            }
            // Return decrypted string.   
            return plainText;
        }
​
        public static async Task<string> DecryptAsync(byte[] cipherTextBytes,
                                     string passPhrase,
                                     string saltValue,
                                     string hashAlgorithm,
                                     int passwordIterations,
                                     string initVector,
                                     int keySize)
        {
            byte[] initVectorBytes = Encoding.UTF8.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.UTF8.GetBytes(saltValue);
​
            using PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);
            byte[] keyBytes = password.GetBytes(keySize / 8);
​
            using RijndaelManaged symmetricKey = new RijndaelManaged
            {
                Mode = CipherMode.CBC
            };
​
            using ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);
            using MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
            using CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);
​
            try
            {
                using StreamReader streamReader = new StreamReader(cryptoStream);
                return await streamReader.ReadToEndAsync().ConfigureAwait(false);
            }
            finally
            {
                await cryptoStream.DisposeAsync().ConfigureAwait(false);
                await memoryStream.DisposeAsync().ConfigureAwait(false);
            }
        }
​
        public static byte[] Encrypt(string message, string passPhrase, string salt)
        {
            return Encrypt(message, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize);
        }
​
        public static byte[] Encrypt(string plainText, DateTime registrationDate)
        {
            return Encrypt(plainText, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture));
        }
​
        public static string Decrypt(byte[] encryptedMessage, string passPhrase, string salt)
        {
            return Decrypt(encryptedMessage, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize);
        }
​
        public static string Decrypt(byte[] encryptedMessage, DateTime registrationDate)
        {
            return Decrypt(encryptedMessage, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture));
        }
​
        public static async Task<string> DecryptAsync(byte[] encryptedMessage, string passPhrase, string salt)
        {
            return await DecryptAsync(encryptedMessage, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize).ConfigureAwait(false);
        }
​
        public static async Task<string> DecryptAsync(byte[] encryptedMessage, DateTime registrationDate)
        {
            return await DecryptAsync(encryptedMessage, registrationDate.ToString(CultureInfo.InvariantCulture),
                registrationDate.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
        }
​
        public static async Task<byte[]> EncryptAsync(string message, string passPhrase, string salt, CancellationToken cancellationToken = default)
        {
            return await EncryptAsync(message, passPhrase, salt, HashAlgorithm, PasswordIterations, InitVector, KeySize, cancellationToken).ConfigureAwait(false);
        }
​
        public static async Task<byte[]> EncryptAsync(string plainText, DateTime registrationDate, CancellationToken cancellationToken = default)
        {
            string registrationDateStr = registrationDate.ToString(CultureInfo.InvariantCulture);
​
            return await EncryptAsync(plainText, registrationDateStr, registrationDateStr, cancellationToken).ConfigureAwait(false);
        }
    }
}

NDZUEBWUU

Cached Result
Last Run:	7:54:00 pm
Compile:	0.008s
Execute:	0.05s
Memory:	2.97Mb
CPU:	0.058s

View IL Code