using System;

using System.Text;

using System.Security.Cryptography;

​

​

​

public class CryptLib

    {

    public static void Main ()

        {

            CryptLib _crypt = new CryptLib ();

            string plainText = "This is the text to be encrypted";

            String iv = CryptLib.GenerateRandomIV (16); //16 bytes = 128 bits

            string key = CryptLib.getHashSha256("my secret key", 256); //32 bytes = 256 bits

            String cypherText = _crypt.encrypt (plainText, key, iv);

            Console.WriteLine ("iv="+iv);

            Console.WriteLine ("key=" + key);

            Console.WriteLine("Cypher text=" + cypherText);

            Console.WriteLine ("Plain text =" + _crypt.decrypt (cypherText, key, iv));

        }

        UTF8Encoding _enc;

        RijndaelManaged _rcipher;

        byte[] _key, _pwd, _ivBytes, _iv;

        /***

         * Encryption mode enumeration

         */

        private enum EncryptMode {ENCRYPT, DECRYPT};

        static readonly char[] CharacterMatrixForRandomIVStringGeneration = {

            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 

            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 

            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 

            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 

            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'

        };

        internal static string GenerateRandomIV(int length) {

            char[] _iv = new char[length];

            byte[] randomBytes = new byte[length];

​

            using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider()) {

                rng.GetBytes(randomBytes); //Fills an array of bytes with a cryptographically strong sequence of random values. 

            }

​

            for (int i = 0; i < _iv.Length; i++) {

                int ptr = randomBytes[i] % CharacterMatrixForRandomIVStringGeneration.Length;

                _iv[i] = CharacterMatrixForRandomIVStringGeneration[ptr];

            }

​

            return new string(_iv);

        }

​

        public CryptLib()

        {

            _enc = new UTF8Encoding();

            _rcipher =  new RijndaelManaged();

            _rcipher.Mode = CipherMode.CBC;

            _rcipher.Padding = PaddingMode.PKCS7;

            _rcipher.KeySize = 256;

            _rcipher.BlockSize = 128;

            //_key = new byte[_rcipher.KeySize/8];

            //_iv = new byte[_rcipher.BlockSize/8]; //128 bit / 8 = 16 bytes

            _ivBytes =  new byte[16];

        }

​

        private String encryptDecrypt (string _inputText, string _encryptionKey, EncryptMode _mode, string _initVector)

        {

​

            string _out = "";// output string

            //_encryptionKey = MD5Hash (_encryptionKey);

            _pwd = Encoding.UTF8.GetBytes(_encryptionKey);

            _ivBytes = Encoding.UTF8.GetBytes (_initVector);

            byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };

             var key = new Rfc2898DeriveBytes(_pwd, saltBytes, 1000);

                        _key = key.GetBytes(_rcipher.KeySize / 8);

                        _iv = key.GetBytes(_rcipher.BlockSize / 8);

​

            /*int len = _pwd.Length;

            if (len > _key.Length)

            {

                len = _key.Length;

            }

            int ivLenth = _ivBytes.Length;

            if (ivLenth > _iv.Length) 

            {

                ivLenth = _iv.Length;       

            }

​

            Array.Copy(_pwd, _key, len);

            Array.Copy (_ivBytes, _iv, ivLenth);*/

            _rcipher.Key = _key;

            _rcipher.IV = _iv;

​

            if (_mode.Equals (EncryptMode.ENCRYPT)) {

                //encrypt

                byte[] plainText = _rcipher.CreateEncryptor().TransformFinalBlock(_enc.GetBytes(_inputText) , 0, _inputText.Length);

                _out = Convert.ToBase64String(plainText);

            }

            if (_mode.Equals (EncryptMode.DECRYPT)) {

                //decrypt

                byte[] plainText = _rcipher.CreateDecryptor().TransformFinalBlock(Convert.FromBase64String(_inputText), 0, Convert.FromBase64String(_inputText).Length);

                _out = _enc.GetString(plainText);

            }

            _rcipher.Dispose();

            return _out;// return encrypted/decrypted string

        }

​

        public string encrypt (string _plainText, string _key, string _initVector)

        {

            return encryptDecrypt(_plainText, _key, EncryptMode.ENCRYPT, _initVector);

        }

​

        public string decrypt(string _encryptedText, string _key, string _initVector)

        {

            return encryptDecrypt(_encryptedText, _key, EncryptMode.DECRYPT, _initVector);

        }

​

        public static string getHashSha256(string text, int length)

        {

            byte[] bytes = Encoding.UTF8.GetBytes(text);

            SHA256Managed hashstring = new SHA256Managed();

            byte[] hash = hashstring.ComputeHash(bytes);

            string hashString = string.Empty;

            foreach (byte x in hash)

            {

                hashString += String.Format("{0:x2}", x); //covert to hex string

            }

            if (length > hashString.Length)

                return hashString;

            else

                return hashString.Substring (0, length);

        }

    }