using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace EncryptDemo
{
    /// <summary>
    /// Demonstrates encrypting and then decrypting a string using
    /// Microsofot's System.Security.Cryptography classes.
    /// </summary>
    class EncryptDemo
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {

            Console.WriteLine("Enter a string of text to encrypt: " );
            string plainText = Console.ReadLine();
            Console.WriteLine("Enter the password: " );
            string password = Console.ReadLine();

            // Encrypt the input text
            byte[] msgBytes = EncryptText(plainText, password);

            // Display the encryption results
            Console.WriteLine("\nEncrypted text with initialization vector prefixed:");
            Console.WriteLine(System.Text.Encoding.ASCII.GetString(msgBytes));

            // Decrypt the encrypted copy of the text
            string decryptedText = DecryptText(msgBytes, password);

            // Display the decryption results
            Console.WriteLine("\nDecrypted text: ");
            Console.WriteLine(decryptedText);
            Console.WriteLine("\nPress Enter to quit.");
            Console.ReadLine();
        }

        private static byte[] EncryptText(string plainText, string password)
        {
            RijndaelManaged rijndael = new RijndaelManaged();
//            ASCIIEncoding textConverter = new ASCIIEncoding();
            byte[] encrypted;
            byte[] plainBytes;

            // Get a 256 bit hash from the password string 
            byte[] pwBytes = Encoding.UTF8.GetBytes(password); 
            SHA256Managed sha = new SHA256Managed(); 

            // Set the encryption key to the password hash
            rijndael.Key = sha.ComputeHash(pwBytes); 

            //Create a new initialization vector.
            rijndael.GenerateIV();

            //Get an encryptor.
            ICryptoTransform thisEncryptor = rijndael.CreateEncryptor(rijndael.Key, rijndael.IV);
            
            //Encrypt the data.
            MemoryStream msEncrypt = new MemoryStream();
            CryptoStream csEncrypt = new CryptoStream(msEncrypt, thisEncryptor, CryptoStreamMode.Write);

            //Convert the data to a byte array.
            plainBytes = Encoding.UTF8.GetBytes(plainText);

            //Write all data to the crypto stream and flush it.
            csEncrypt.Write(plainBytes, 0, plainBytes.Length);
            csEncrypt.FlushFinalBlock();

            // Get encrypted array of bytes, add the IV at the beginning
            encrypted = msEncrypt.ToArray();
            byte[] cryptBytes = new byte[encrypted.Length + 16];
            rijndael.IV.CopyTo(cryptBytes,0);
            encrypted.CopyTo(cryptBytes,16);

            return cryptBytes;
        }

        private static string DecryptText(byte[] cryptText, string password)
        {
            RijndaelManaged rijndael = new RijndaelManaged();

//            ASCIIEncoding textConverter = new ASCIIEncoding();

            // Create an array to hold the initialization vector (IV)
            byte[] IV = new byte[16];

            // Create an array to hold the encrypted text
            byte[] cryptBytes = new byte[cryptText.Length - 16];

            // Extract the IV from the input byte array.
            Array.Copy(cryptText, 0, IV, 0, 16);

            // Extract the encrypted message from the input byte array.
            Array.Copy(cryptText, 16, cryptBytes, 0, cryptBytes.Length);

            // Get a 256 bit hash from the password string 
            byte[] pwBytes = Encoding.UTF8.GetBytes(password); 
            SHA256Managed sha = new SHA256Managed(); 

            // Set the encryption key to the password hash
            rijndael.Key = sha.ComputeHash(pwBytes); 

            //Get a decryptor that uses the same key and IV as the encryptor.
            ICryptoTransform decryptor = rijndael.CreateDecryptor(rijndael.Key, IV);

            //Now decrypt the previously encrypted message using the decryptor
            // obtained in the above step.
            MemoryStream msDecrypt = new MemoryStream(cryptBytes);
            CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);

            byte[] plainBytes = new byte[cryptBytes.Length];

            //Read the data out of the crypto stream.
            plainBytes = ReadFully(csDecrypt, cryptBytes.Length);

            //Convert the byte array back into a string.
            string plainText = Encoding.UTF8.GetString(plainBytes); //textConverter.GetString(plainBytes);

            return plainText;
        }

        // the ReadFully method is from Jon Skeet at
        // http://www.yoda.arachsys.com/csharp/readbinary.html
        /// <summary>
        /// Reads data from a stream until the end is reached. The
        /// data is returned as a byte array. An IOException is
        /// thrown if any of the underlying IO calls fail.
        /// </summary>
        /// <param name="stream">The stream to read data from</param>
        /// <param name="initialLength">The initial buffer length</param>
        public static byte[] ReadFully (Stream stream, int initialLength)
        {
            // If we've been passed an unhelpful initial length, just
            // use 32K.
            if (initialLength < 1)
            {
                initialLength = 32768;
            }
    
            byte[] buffer = new byte[initialLength];
            int read=0;
    
            int chunk;
            while ( (chunk = stream.Read(buffer, read, buffer.Length-read)) > 0)
            {
                read += chunk;
        
                // If we've reached the end of our buffer, check to see if there's
                // any more information
                if (read == buffer.Length)
                {
                    int nextByte = stream.ReadByte();
            
                    // End of stream? If so, we're done
                    if (nextByte==-1)
                    {
                        return buffer;
                    }
            
                    // Nope. Resize the buffer, put in the byte we've just
                    // read, and continue
                    byte[] newBuffer = new byte[buffer.Length*2];
                    Array.Copy(buffer, newBuffer, buffer.Length);
                    newBuffer[read]=(byte)nextByte;
                    buffer = newBuffer;
                    read++;
                }
            }
            // Buffer is now too big. Shrink it.
            byte[] ret = new byte[read];
            Array.Copy(buffer, ret, read);
            return ret;
        }
    }
}