using System;

using System.Text;

using System.Security.Cryptography;

using System.IO;

​

public class Program

{

    //AES shared password (default) -> Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes("ebankIT | Omnichannel Innovation"))

​

        //salt must be SessionId Guid string sent on service inputheader

        //server will use that

        private const string C_MD5 = "MD5";

        private const string C_SHA = "SHA1";

        private const string C_TDS = "TDES";

        private const string C_AES = "AES";

​

​

        private static int _passwordIterations = 1;

        private static int _keySize = 128;

​

        /// <summary>  

        /// Encrypts a string  

        /// </summary>

        /// <param name="password">Password to encrypt with</param>  

        /// <param name="salt">Salt to encrypt with</param>  

        /// <returns>An encrypted string</returns>  

​

        //Generates the Initializaziot Vector from the Salt Parameter

        //Salt Parameter is Variable and BOTH end know it at a given time

        //Since the SALT parameter is known from BOTH sides, the generated Initialization Vectors will always be Equal

        private static byte[] GetGeneratedIVector(string password, string salt)

        {

            var saltValueBytes = Encoding.ASCII.GetBytes(salt);

            var iVectorGenerated = new Rfc2898DeriveBytes(password, saltValueBytes, _passwordIterations);

            var iVectorGeneratedBytes = iVectorGenerated.GetBytes(_keySize / 8);

            return iVectorGeneratedBytes;

        }

​

        ///<summary>

        ///Encript Data using a new generated Key from the internal 

        ///password and an external salt parameter (Tipically the Security Center SessionID)

        ///</summary>

        ///<param name="plainTextData"></param>

        ///<param name="password"></param>

        ///<param name="salt"></param>

        ///<returns></returns>

        public static string Encrypt(string plainTextData, string password, string salt)

        {

            var saltValueBytes = Encoding.ASCII.GetBytes(salt);

            var plainTextBytes = Encoding.UTF8.GetBytes(plainTextData);

​

            if (string.IsNullOrEmpty(plainTextData))

            {

                return string.Empty;

            }

​

            var derivedPassword = new Rfc2898DeriveBytes(password, saltValueBytes, _passwordIterations);

            var keyBytes = derivedPassword.GetBytes(_keySize / 8);

​

            var symmetricKey = new RijndaelManaged

            {

                Mode = CipherMode.CBC

            };

            byte[] cipherTextBytes;

​

            using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, GetGeneratedIVector(password, salt)))

            {

                using (var memStream = new MemoryStream())

                {

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

                    {

                        cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

                        cryptoStream.FlushFinalBlock();

                        cipherTextBytes = memStream.ToArray();

                        memStream.Close();

                        cryptoStream.Close();

                    }

                }

            }

            symmetricKey.Clear();

            return Convert.ToBase64String(cipherTextBytes);

        }

​

        ///<summary>

        ///Decrypt Data Generatig the same Key from 2 Parameters 

        /// - 1 So-Called Password (Defined Internally in this Class)

        /// - 1 known variable as Salt Parameter (Tipically Security Center Session ID)

        ///If one of these parameters is different from the original, the generated key will be different and therefore

        ///it will not be possible to decript the Input Data

        ///</summary>

        ///<param name="cipherText"></param>

        ///<param name="password"></param>

        ///<param name="salt"></param>

        ///<returns></returns>

        public static string Decrypt(string cipherText, string password, string salt)

        {

            var saltValueBytes = Encoding.ASCII.GetBytes(salt);

            var cipherTextBytes = Convert.FromBase64String(cipherText);

​

            if (string.IsNullOrEmpty(cipherText))

            {

                return string.Empty;

            }

​

            var derivedPassword = new Rfc2898DeriveBytes(password, saltValueBytes, _passwordIterations);

            var keyBytes = derivedPassword.GetBytes(_keySize / 8);

​

            var symmetricKey = new RijndaelManaged

            {

                Mode = CipherMode.CBC

            };

​

            var plainTextBytes = new byte[cipherTextBytes.Length];

            int byteCount;

​

            using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, GetGeneratedIVector(password, salt)))

            {

                using (var memStream = new MemoryStream(cipherTextBytes))

                {

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

                    {

                        byteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);

                        memStream.Close();

                        cryptoStream.Close();

                    }

                }

            }

            symmetricKey.Clear();

            return Encoding.UTF8.GetString(plainTextBytes, 0, byteCount);

​

        }

    public static void Main()

    {

        var encripted = Encrypt("myTEST","12345678","9BC8244735F7D4861493215BEFDFA5AC");

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

        var decripted = Decrypt(encripted,"12345678","9BC8244735F7D4861493215BEFDFA5AC");

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

    }

}