using System;

using System.IO;

using System.Security.Cryptography;

using System.Text;

​

namespace CryptoServiceProject

{

    class Program

    {

        public const string SecretKeyHasing = "TWpOUVl3WVRFZFFPRlplaFZ6Z3pSUjB3R3c0N0NUdEM=";

        static void Main(string[] args)

        {

            string plainText = "CzDM9q5gFmVjhlLiZx3CLmIYn2vEplr2";

​

            string encrypted = CryptoService.AESHash(plainText, SecretKeyHasing);

            Console.WriteLine($"Encrypted: {encrypted}");

​

            string decrypted = CryptoService.AESDecrypt(encrypted, SecretKeyHasing);

            Console.WriteLine($"Decrypted: {decrypted}");

        }

    }

​

    public static class CryptoService

    {

        /// <summary>

        /// Size of salt.

        /// </summary>

        private const int SaltSize = 16;

​

        /// <summary>

        /// Size of hash.

        /// </summary>

        private const int HashSize = 20;

​

        /// <summary>

        /// Kiểm tra chuỗi không rỗng và khác null

        /// </summary>

        public static bool IsNotEmptyAndNull(this string text)

        {

            return !string.IsNullOrEmpty(text);

        }

​

        /// <summary>

        /// Giải mã chuỗi Base64

        /// </summary>

        public static string DecodeBase64(string encodedText)

        {

            try

            {

                byte[] data = Convert.FromBase64String(encodedText);

                return Encoding.UTF8.GetString(data);

            }

            catch (Exception)

            {

                return string.Empty;

            }

        }

​

        /// <summary>

        /// CryptoService.AESHash(model.Password, _secretKey)

        /// </summary>

        /// <param name="plainText"></param>

        /// <param name="key"></param>

        /// <param name="initialVector"></param>

        /// <param name="oldValue"></param>

        /// <param name="newValue"></param>

        /// <returns></returns>

        public static string AESHash(string plainText, string key, string initialVector = null, string oldValue = "", string newValue = "")

        {

            if (key.IsNotEmptyAndNull())

            {

                var encodeKey = DecodeBase64(key);

                key = encodeKey;

            }

​

            if (string.IsNullOrWhiteSpace(plainText))

                return null;

​

            var keyInBytes = Encoding.ASCII.GetBytes(key);

​

            using (var aes = Aes.Create())

            {

                aes.Key = keyInBytes;

                aes.Mode = CipherMode.CBC;

​

                if (initialVector == null)

                {

                    var initialVectorInBytes = new byte[aes.BlockSize / 8];

​

                    using (var rngCryptoServiceProvider = RandomNumberGenerator.Create())

                    {

                        rngCryptoServiceProvider.GetBytes(initialVectorInBytes);

                    }

​

                    aes.IV = initialVectorInBytes;

                }

                else

                {

                    aes.IV = Encoding.ASCII.GetBytes(initialVector);

                }

​

                using (var encryptor = aes.CreateEncryptor())

                {

                    using (var memStream = new MemoryStream())

                    {

                        using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))

                        {

                            cryptoStream.Write(aes.IV, 0, aes.IV.Length);

​

                            using (StreamWriter sw = new StreamWriter(cryptoStream, Encoding.UTF8))

                            {

                                sw.Write(plainText);

                            }

                            var encryptedText = memStream.ToArray();

​

                            string result = Convert.ToBase64String(encryptedText);

​

                            if (!string.IsNullOrWhiteSpace(oldValue))

                                result = result.Replace(oldValue, newValue);

​

                            return result;

                        }

                    }

                }

            }

        }

​

        /// <summary>

        /// AESDecrypt(result.Password, _secretKey);

        /// </summary>

        /// <param name="encryptedText"></param>

        /// <param name="key"></param>

        /// <returns></returns>

        public static string AESDecrypt(string encryptedText, string key)

        {

            if (key.IsNotEmptyAndNull())

            {

                var encodeKey = DecodeBase64(key);

                key = encodeKey;

            }

            if (string.IsNullOrWhiteSpace(encryptedText))

            {

                return null;

            }

​

            var keyInBytes = Encoding.ASCII.GetBytes(key);

            var encryptedPasswordInBytes = Convert.FromBase64String(encryptedText);

​

            using (var aes = Aes.Create())

            {

                aes.Key = keyInBytes;

                aes.Mode = CipherMode.CBC;

​

                using (var memStream = new MemoryStream(encryptedPasswordInBytes))

                {

                    var iv = new byte[aes.BlockSize / 8];

                    memStream.Read(iv, 0, iv.Length);

​

                    aes.IV = iv;

​

                    using (var decryptor = aes.CreateDecryptor())

                    {

                        using (var cryptoStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read))

                        {

                            using (var sr = new StreamReader(cryptoStream, Encoding.UTF8))

                            {

                                var plainText = sr.ReadToEnd();

                                return plainText;

                            }

                        }

                    }

                }

            }

        }

    }

}

​