using System;

using System.IO;

using System.Security.Cryptography;

using System.Text;

public class Program

{

    public class CryptoProvider

    {

        private ICryptoTransform encryptor = (ICryptoTransform)null;

        private ICryptoTransform decryptor = (ICryptoTransform)null;

        private int minSaltLen = -1;

        private int maxSaltLen = -1;

        public CryptoProvider(string passPhrase, string initVector)

          : this(passPhrase, initVector, -1, -1, -1, (string)null, (string)null, 3)

        {

        }

​

        public CryptoProvider(

          string passPhrase,

          string initVector,

          int minSaltLen,

          int maxSaltLen,

          int keySize,

          string hashAlgorithm,

          string saltValue,

          int passwordIterations)

        {

            this.minSaltLen = 4; 

            this.maxSaltLen = 8;

            keySize = 256;

            hashAlgorithm = "SHA512";

​

            byte[] rgbIV = Encoding.ASCII.GetBytes(initVector);

            byte[] rgbSalt = new byte[0];

            byte[] bytes = new PasswordDeriveBytes(passPhrase, rgbSalt, hashAlgorithm, passwordIterations).GetBytes(keySize / 8);

​

            RijndaelManaged rijndaelManaged = new RijndaelManaged();

​

            if (rgbIV.Length == 0)

                rijndaelManaged.Mode = CipherMode.ECB;

            else

                rijndaelManaged.Mode = CipherMode.CBC;

​

            this.encryptor = rijndaelManaged.CreateEncryptor(bytes, rgbIV);

            this.decryptor = rijndaelManaged.CreateDecryptor(bytes, rgbIV);

        }

​

        public string Decrypt(string cipherText) {

            return this.Decrypt(Convert.FromBase64String(cipherText));

        }

        public string Decrypt(byte[] cipherTextBytes) {

            return Encoding.UTF8.GetString(this.DecryptToBytes(cipherTextBytes));

        }

​

        public byte[] DecryptToBytes(string cipherText) {

            return this.DecryptToBytes(Convert.FromBase64String(cipherText));

        }

​

        public byte[] DecryptToBytes(byte[] cipherTextBytes)

        {

            int num = 0;

            int sourceIndex = 0;

            MemoryStream memoryStream = new MemoryStream(cipherTextBytes);

            byte[] numArray = new byte[cipherTextBytes.Length];

            lock (this)

            {

                CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, this.decryptor, CryptoStreamMode.Read);

                num = cryptoStream.Read(numArray, 0, numArray.Length);

                memoryStream.Close();

                cryptoStream.Close();

            }

            if (this.maxSaltLen > 0 && this.maxSaltLen >= this.minSaltLen)

                sourceIndex = (int)numArray[0] & 3 | (int)numArray[1] & 12 | (int)numArray[2] & 48 | (int)numArray[3] & 192;

            byte[] destinationArray = new byte[num - sourceIndex];

            Array.Copy((Array)numArray, sourceIndex, (Array)destinationArray, 0, num - sourceIndex);

            return destinationArray;

        }

    }

    public static void Main()

    {

        string Key = "HybR!dPaYT3ch";

        string IV = "HYbR!d@yTech!@#$%"; // 17 bytes => System.ArgumentException: Specified initialization vector (IV) does not match the block size for this algorithm. (Parameter 'rgbIV') 

        //string IV = "HYbR!d@yTech!@#$"; // 16 bytes => works

​

        string encryptedUserData = "u7uENpFfpQhMXiTThL/ajA==";

        string decryptedUserData;

​

        CryptoProvider crypto = new CryptoProvider(Key, IV);

        decryptedUserData = crypto.Decrypt(encryptedUserData.Trim());

​

        Console.WriteLine(decryptedUserData);

    }

}