using System;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Web;

namespace Core.OAuth.Attributes

{

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Hello World");

            Cryptography.Decrypt3("6tDI9RpJwTOWDIzWVf+HGpwoaP0A4j2vNCahQ6qhRxSkBosIy3VbGudRGjorQyE9Ko2V96DUgnBZWP8oJVqUlg==:TFCz1JRd/i5v0v4imDzbzg==");

        }

​

    }

​

    public static class Cryptography

    {

​

        public static string Decrypt3(this string literalString)

        {

​

            var slides = literalString.Split(':');

            /*var clearText = this.decryptoHelper(slides[0], key, iv);*/

            var clearTextBytes = Convert.FromBase64String(slides[0]);

            /*  return CryptoJS.AES.decrypt(encryptedText, key,

             {

               keySize: 128 / 8,

               iv: iv,

               mode: CryptoJS.mode.CBC,

               padding: CryptoJS.pad.Pkcs7

             });*/

            Console.WriteLine(Convert.FromBase64String("hH4LluCc1nN0G3n0").Length);

            RijndaelManaged rijndaelManaged = new RijndaelManaged();

            rijndaelManaged.Mode = CipherMode.CBC;

            rijndaelManaged.Padding = PaddingMode.PKCS7;

            rijndaelManaged.FeedbackSize = 24;

            rijndaelManaged.Key = Convert.FromBase64String("hH4LluCc1nN0G3n0");

            rijndaelManaged.IV = Convert.FromBase64String("hH4LluCc1nN0G3n0");

            ICryptoTransform transform = rijndaelManaged.CreateDecryptor(rijndaelManaged.Key, rijndaelManaged.IV);

            try

            {

                MemoryStream stream = new MemoryStream(clearTextBytes);

                CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Read);

                StreamReader streamReader = new StreamReader(stream2);

                return streamReader.ReadToEnd();

            }

            catch

            {

                return "keyError";

            }   

​

        }

        public static string Encrypt(this string LiteralString, string keyString = "", string ivString = "")

        {

            if (LiteralString != "")

            {

                using (Aes aes = Aes.Create())

                {

                    if (!string.IsNullOrEmpty(keyString))

                    {

                        aes.Key = Encoding.UTF8.GetBytes(keyString);

                    }

​

                    if (!string.IsNullOrEmpty(ivString))

                    {

                        aes.IV = Encoding.UTF8.GetBytes(ivString);

                    }

​

                    ICryptoTransform transform = aes.CreateEncryptor();

                    string arg = Convert.ToBase64String(aes.Key);

                    string arg2 = Convert.ToBase64String(aes.IV);

                    byte[] source;

                    using (MemoryStream memoryStream = new MemoryStream())

                    {

                        CryptoStream stream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);

                        using (StreamWriter streamWriter = new StreamWriter(stream))

                        {

                            streamWriter.Write(LiteralString);

                        }

​

                        source = memoryStream.ToArray();

                    }

​

                    string arg3 = Convert.ToBase64String(Enumerable.ToArray(source));

                    return $"{arg3}:{arg}:{arg2}";

                }

            }

​

            throw new ArgumentNullException("La cadena no puede estar vacia.");

        }

​

        public static string Decrypt(this string CryptoString)

        {

            string text = "";

            if (CryptoString != "")

            {

                string[] array = CryptoString.Split(':');

                byte[] rgbKey = Convert.FromBase64String(array[1]);

                byte[] rgbIV = Convert.FromBase64String(array[2]);

                byte[] array2 = Convert.FromBase64String(array[0]);

                _ = new byte[array2.Length];

                RijndaelManaged rijndaelManaged = new RijndaelManaged();

                MemoryStream stream = new MemoryStream(array2);

                CryptoStream stream2 = new CryptoStream(stream, rijndaelManaged.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Read);

                StreamReader streamReader = new StreamReader(stream2, detectEncodingFromByteOrderMarks: true);

                return streamReader.ReadToEnd();

            }

​

            throw new ArgumentNullException("La cadena no puede estar vacia.");

        }

​

        public static string Decrypt(this string cipherText, string keyString, string ivString)

        {

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

            byte[] bytes2 = Encoding.UTF8.GetBytes(ivString);

            var z = Convert.FromBase64String(cipherText);

            var s = DecryptStringFromBytes(Convert.FromBase64String(cipherText), bytes, bytes2);

            return DecryptStringFromBytes(Convert.FromBase64String(cipherText), bytes, bytes2);

        }

​

        private static string DecryptStringFromBytes(byte[] cipherText, byte[] key, byte[] iv)

        {

            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("key");

            }

​

            string text = null;

            RijndaelManaged rijndaelManaged = new RijndaelManaged();

            rijndaelManaged.Mode = CipherMode.CBC;

            rijndaelManaged.Padding = PaddingMode.PKCS7;

            rijndaelManaged.FeedbackSize = 128;

            rijndaelManaged.Key = key;

            rijndaelManaged.IV = iv;

            ICryptoTransform transform = rijndaelManaged.CreateDecryptor(rijndaelManaged.Key, rijndaelManaged.IV);

            try

            {

                MemoryStream stream = new MemoryStream(cipherText);

                CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Read);

                StreamReader streamReader = new StreamReader(stream2);

                return streamReader.ReadToEnd();

            }

            catch

            {

                return "keyError";

            }

        }

    }

​

}