using System;

using System.IO;

using System.Security.Cryptography;

using System.Text;

using System.Linq;

​

class ManagedAesSample

{

    public static void Main()

    {

        Console.WriteLine("Enter text that needs to be encrypted..");

        string data = Console.ReadLine();

        EncryptAesManaged(data);

        Console.ReadLine();

    }

​

    static string RandomString(int length)

    {

        //var datetime = DateTime.Parse("2024-12-31 23:59:59.999");//DateTime.UtcNow.ToLocalTime();

        var datetime = DateTime.UtcNow.ToLocalTime();

        var seed = datetime.Day + datetime.Month + datetime.Year + datetime.Hour + datetime.Minute + datetime.Second + datetime.Millisecond + datetime.Millisecond * 1000 + datetime.Millisecond * 1000000;

        Console.WriteLine($"Seed: {seed}");

        Random random = new Random(seed);

        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

        return new string(Enumerable.Repeat(chars, length)

            .Select(s => s[random.Next(s.Length)]).ToArray());

    }

    static void EncryptAesManaged(string raw)

    {

        try

        {

            // Create Aes that generates a new key and initialization vector (IV).

            // Same key must be used in encryption and decryption

            byte[] IV = Aes.Create().IV;

            var IV_As_String = Convert.ToBase64String(IV);//store in db

​

            var pw = RandomString(10);//store in db

            byte[] Key = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(pw));

​

            var aes = Aes.Create();

            aes.IV = Convert.FromBase64String(IV_As_String);

            aes.Key = Key;

            Console.WriteLine("Block size: " + aes.BlockSize);

            Console.WriteLine("Key size: " + aes.KeySize);

            // Encrypt string

            string encrypted = Convert.ToBase64String(Encrypt(raw, aes.Key, aes.IV));

            // Print encrypted string

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

            //decrypt the bytes to a string.

            aes = Aes.Create();

            aes.IV = Convert.FromBase64String(IV_As_String);

            Key = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(pw));

            aes.Key = Key;

            string decrypted = Decrypt(Convert.FromBase64String(encrypted), aes.Key, aes.IV);

            // Print decrypted string. It should be same as raw data

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

            Console.WriteLine($"Initialization vector that was used: {IV_As_String}");

            Console.WriteLine($"Key that was used: {Convert.ToBase64String(Key)} - Raw: {pw}");

        }

        catch (Exception exp)

        {

            Console.WriteLine(exp.Message);

        }

        Console.ReadKey();

    }

    static byte[] Encrypt(string plainText, byte[] Key, byte[] IV)

    {

        byte[] encrypted;

        // Create a new AesManaged.

        using (AesManaged aes = new AesManaged())

        {

            // Create encryptor

            ICryptoTransform encryptor = aes.CreateEncryptor(Key, IV);

            // Create MemoryStream

            using (MemoryStream ms = new MemoryStream())

            {

                // Create crypto stream using the CryptoStream class. This class is the key to encryption

                // and encrypts and decrypts data from any given stream. In this case, we will pass a memory stream

                // to encrypt

                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))

                {

                    // Create StreamWriter and write data to a stream

                    using (StreamWriter sw = new StreamWriter(cs))

                        sw.Write(plainText);

                    encrypted = ms.ToArray();

                    Console.WriteLine("Block size (Encrypt): " + aes.BlockSize);

                    Console.WriteLine("Key size (Encrypt): " + aes.KeySize);

                }

            }

        }

        // Return encrypted data

        return encrypted;

    }

    static string Decrypt(byte[] cipherText, byte[] Key, byte[] IV)

    {

        string plaintext = null;

        // Create AesManaged

        using (AesManaged aes = new AesManaged())

        {

            // Create a decryptor

            ICryptoTransform decryptor = aes.CreateDecryptor(Key, IV);

            // Create the streams used for decryption.

            using (MemoryStream ms = new MemoryStream(cipherText))

            {

                // Create crypto stream

                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))

                {

                    // Read crypto stream

                    using (StreamReader reader = new StreamReader(cs))

                        plaintext = reader.ReadToEnd();

                    Console.WriteLine("Block size (Decrypt): " + aes.BlockSize);

                    Console.WriteLine("Key size (Decrypt): " + aes.KeySize);                    

                }

            }

        }

        return plaintext;

    }

}