using System;

using System.Security.Cryptography;                 

using System.IO;

using System.Text;

using System.Linq;

using Microsoft.IdentityModel.Tokens;

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

        /*

        string testStr = "asdl kasdlkfj 3lka e-0-09 asdh jk3hk asdfkj hakjshd fkjah sdfas{{}ASdfasdfasd";

        var encodedTest = Base64EncodeUrlSafe(testStr);

        Console.WriteLine(encodedTest);

        Console.WriteLine(testStr);

        var decodedTest = Base64DecodeUrlSafe(encodedTest);

        Console.WriteLine(decodedTest);

        */

        // sample querystring 

        // &crptdata=dp79Nm0qZaOuXTcDH4qI_E5cCWz9OcPncGyVsJvsNuIM3H32xcEPXZ8Di2JVOgyiucQtc1AiC7smMZZ7SJMTTOT4fTl-Oisa1InvP7_xtsyjtBkNl_cVSNLo3CSBhyAou1I0D9ozPufPHMXnTq9tAkKOk16rd3SYzmwitrorUUw7AxzB302wDwDs-5PYvqUfr_6GSGvStFiVJsfX43KQcGE6r7tbqaunYEIIEaGYL9E&crptiv=2-nBhTJTt6pCR8c3Muu9eQ

        // decoded value: {"first_name":"Jimmy","last_name":"Neutron","email":"jimbo123@gmail.com","phone":null,"address1":null,"address2":null,"postal_code":"02108","city":"Boston","state":"MA"}

        string data = "dp79Nm0qZaOuXTcDH4qI_E5cCWz9OcPncGyVsJvsNuIM3H32xcEPXZ8Di2JVOgyiucQtc1AiC7smMZZ7SJMTTOT4fTl-Oisa1InvP7_xtsyjtBkNl_cVSNLo3CSBhyAou1I0D9ozPufPHMXnTq9tAkKOk16rd3SYzmwitrorUUw7AxzB302wDwDs-5PYvqUfr_6GSGvStFiVJsfX43KQcGE6r7tbqaunYEIIEaGYL9E";

        string iv = "2-nBhTJTt6pCR8c3Muu9eQ";

        string key = "4a1800974ba097ec75cb10e7deab8bef6508549b12b53c2b30173b5592b036b6";

​

        data = "kxzelHyCLZALxdyPXCInYXyRK5Jxpmak5bMvWWNRDAfqz_7iPtR3qYda7QFWc6Hx4IBH10mE_F5JQ8taq_rFq-D1SCFLSA-ZGF-hbYQMzJ5MKD5em5zxTu-aKJFMP9f3ZjoKXtncSiCcUcNguaLGFkub2ywKDDJGvXxChRGxL6JCWqGOGWriTCKxm5wNQF0paxwvdNeg1y2OIpbp4QouVoHAn2upGW-ELJQknIAX7rc=";

        iv =  "T0ZSbmE3M20qYXplMDF4WQ==";

        key = "2b1804974ca297ec75cb10e7deab8bef6508549b12b53c2b30173b5592b036b6";

        byte[] key_bytes = StringToByteArray(key);

​

        string key_string = System.Text.Encoding.UTF8.GetString(key_bytes);

        //Console.WriteLine(key_string);

        //Console.WriteLine(PadBase64(iv.Replace("-", "+").Replace("_", "/")));

        byte[] text_bytes = System.Convert.FromBase64String(PadBase64(data.Replace("-", "+").Replace("_", "/")));

        byte[] iv_bytes = System.Convert.FromBase64String(PadBase64(iv.Replace("-", "+").Replace("_", "/")));

        string iv_string = System.Text.Encoding.UTF8.GetString(iv_bytes);

        string str = DecryptStringFromBytes_Aes(text_bytes, key_bytes, iv_bytes);

​

        Console.WriteLine(str);

        /// =================================================================

        /// testing encryption

        /// =================================================================

        Console.WriteLine("Encryption TEST");

        string data2 = "{\"first_name\":\"Jimmy\",\"last_name\":\"Fucker\",\"email\":\"jimbo123@gmail.com\",\"phone\":null,\"address1\":null,\"address2\":null,\"postal_code\":\"02108\",\"city\":\"Boston\",\"state\":\"MA\"}";

        string iv2 = "OFRna73m*aze01xY"; // Needs to be 16 ASCII characters long

        byte[] iv2Bytes = System.Text.Encoding.UTF8.GetBytes(iv2);

        //var data2Bytes = System.Text.Encoding.UTF8.GetBytes(data2);

        //var data2Base64 = System.Convert.ToBase64String(data2Bytes).Replace("+", "-").Replace("/", "_");

        //Console.WriteLine(data2Base64);

        //string key2 = "This is a test key";

        //HexEncode(key2);

        string key2_hex = "2b1804974ca297ec75cb10e7deab8bef6508549b12b53c2b30173b5592b036b6"; //  64 lengh string in Hex encoded

        //byte[] key2Bytes = System.Text.Encoding.UTF8.GetBytes(key2);

        byte[] key2_bytes = StringToByteArray(key2_hex);

        Console.WriteLine(key2_hex);

        byte[] encrypted = EncryptStringToBytes_Aes(data2, key2_bytes, iv2Bytes);

        string encryptedBase64 = Base64EncodeUrlSafe(encrypted);

        Console.WriteLine(encryptedBase64);

        string iv2Base64 = Base64EncodeUrlSafe(iv2);

        Console.WriteLine(iv2Base64);

​

    }

    public static string PadBase64(string encodedValue)

    {

        string output = encodedValue;

        while (output.Length % 4 != 0){

            output += "=";

        }   

        return output;  

    }

    public static string Base64EncodeUrlSafe(byte[] textBytes) 

    {

      return System.Convert.ToBase64String(textBytes).Replace("+", "-").Replace("/", "_");;

    }

    public static string Base64EncodeUrlSafe(string plainText) 

    {

      var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);

      return System.Convert.ToBase64String(plainTextBytes).Replace("+", "-").Replace("/", "_");;

    }

    public static string Base64DecodeUrlSafe(string base64EncodedData) 

    {

      var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData.Replace("-", "+").Replace("_", "/"));

      return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);

    }

    public static byte[] StringToByteArray(string hex)

    {

        return System.Linq.Enumerable.Range(0, hex.Length)

            .Where(x => x % 2 == 0)

            .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))

            .ToArray();

    }

    public static string HexEncode(string inputString)

    {

        byte[] byteArray = Encoding.Default.GetBytes(inputString);

        string hexString = BitConverter.ToString(byteArray).Replace("-", "");

        return hexString;

    }

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

    {

        // Check arguments.

        if (cipherText == null || cipherText.Length <= 0)

            throw new ArgumentNullException("cipherText");

        if (Key == null || Key.Length <= 0)

            throw new ArgumentNullException("Key");

        if (IV == null || IV.Length <= 0)

            throw new ArgumentNullException("IV");

​

        // Declare the string used to hold

        // the decrypted text.

        string plaintext = null;

​

        // Create an AesManaged object

        // with the specified key and IV.

        using (AesManaged aesAlg = new AesManaged())

        {

            aesAlg.Mode = CipherMode.CBC;

            aesAlg.Padding = PaddingMode.PKCS7;

            //aesAlg.KeySize = 256;

            aesAlg.Key = Key;

            aesAlg.IV = IV;

​

            byte[] decryptedBytes = null;

​

            //using (ICryptoTransform decryptor = aesAlg.CreateDecryptor())

            //{

            //    decryptedBytes = decryptor.TransformFinalBlock(cipherText, 0, cipherText.Length);

            //}

​

            // Create a decryptor to perform the stream transform.

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

​

​

            //// Create the streams used for decryption.

            using (MemoryStream msDecrypt = new MemoryStream(cipherText))

            {

                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))

                {

                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))

                    {

​

            //            // Read the decrypted bytes from the decrypting stream

            //            // and place them in a string.

                        plaintext = srDecrypt.ReadToEnd();

                    }

                }

            }

​

        }

​

        return plaintext;

​

    }

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

    {

        // Check arguments.

        if (plainText == null || plainText.Length <= 0)

            throw new ArgumentNullException("plainText");

        if (Key == null || Key.Length <= 0)

            throw new ArgumentNullException("Key");

        if (IV == null || IV.Length <= 0)

            throw new ArgumentNullException("IV");

        byte[] encrypted;

​

        // Create an AesManaged object

        // with the specified key and IV.

        using (AesManaged aesAlg = new AesManaged())

        {

            aesAlg.Mode = CipherMode.CBC;

            aesAlg.Padding = PaddingMode.PKCS7;

            aesAlg.Key = Key;

            aesAlg.IV = IV;

​

            // Create an encryptor to perform the stream transform.

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

​

            // Create the streams used for encryption.

            using (MemoryStream msEncrypt = new MemoryStream())

            {

                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))

                {

                    using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))

                    {

                        //Write all data to the stream.

                        swEncrypt.Write(plainText);

                    }

                    encrypted = msEncrypt.ToArray();

                }

            }

        }

​

​

        // Return the encrypted bytes from the memory stream.

        return encrypted;

​

    }

}