using System;

using System.Collections.Generic;

using System.Globalization;

using System.IdentityModel.Tokens.Jwt;

using System.IO;

using System.IO.Compression;

using System.Linq;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Text;

​

using Microsoft.AspNetCore.Http;

using Microsoft.Identity.Client;

using Microsoft.IdentityModel.Tokens;

public class Program

{

     private const string secretKey = "046A0CAED97541FD954BEEBB53F459F5";

    public static void Main()

    {

        Console.WriteLine(DecipherToken("W2MguP/QU6JR3widVObUL3ZOuLuQ6P5eH8LRmQcCaNfi5140EqV1fHmi5MbM35ciR1WUEfntVygTaW5rkxXhLnOHlTaWf83ILcZcNMPjBf9ARDr9KbsR2UlFLGdFYtfNxC7LDRdPORSyjV5iOXdrxZsYL1VfNiDbrBecIK6TcHN5FRTOEJDIamTwTb9bbj++gloB7PiyqRjnDtX4ZtTZ0F7fMfn82xbxy2GgIuU2ohE+h4HC7EGYOdVN6eJ2plY+dg7MrNCCr8KkbtEZ5SVgZRSnd+8h/mlu2Y4P+d7+XEgd5R4gXH5b65FDNVyOgRfcbmy3pNKNzYCuHjh1qvPZbkjLTOJ7MzxGulCRPpkDV4AFZplc3joQikRfSgu8ho+WjM5RURj7UuT25va6QH5jHXMcDb/b0EKuHdClQ1Pndm90BoYnsRFEm/yWi92/TFAxH2LYwiN3Oo4KLNHZsYhUSw=="));

    }

    public static string CipherToken(string token)

    {

        try

        {

            token = token.Replace(

                "Bearer ",

                string.Empty);

            byte[] iv = new byte[16];

            byte[] array;

​

            var zipped = ZipFileHelper.Zip(token);

            string tokenZipped = Convert.ToBase64String(zipped);

​

            using (Aes aes = Aes.Create())

            {

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

                aes.IV = iv;

​

                ICryptoTransform encryptor = aes.CreateEncryptor(

                    aes.Key,

                    aes.IV);

​

                using (MemoryStream memoryStream = new MemoryStream())

                {

                    using (CryptoStream cryptoStream = new CryptoStream(

                        memoryStream,

                        encryptor,

                        CryptoStreamMode.Write))

                    {

                        using (StreamWriter streamWriter = new StreamWriter(cryptoStream))

                        {

                            streamWriter.Write(tokenZipped);

                        }

​

                        array = memoryStream.ToArray();

                    }

                }

            }

​

            string tokenCiphered = Convert.ToBase64String(array);

            return tokenCiphered;

        }

        catch (Exception ex)

        {

            // Ignore exceptions

        }

​

        return string.Empty;

    }

    public static string DecipherToken(string cipheredToken)

    {

        try

        {

            byte[] iv = new byte[16];

            byte[] buffer = Convert.FromBase64String(cipheredToken);

​

            using (Aes aes = Aes.Create())

            {

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

                aes.IV = iv;

                ICryptoTransform decryptor = aes.CreateDecryptor(

                    aes.Key,

                    aes.IV);

​

                using (MemoryStream memoryStream = new MemoryStream(buffer))

                {

                    using (CryptoStream cryptoStream = new CryptoStream(

                        memoryStream,

                        decryptor,

                        CryptoStreamMode.Read))

                    {

                        using (StreamReader streamReader = new StreamReader(cryptoStream))

                        {

                            var decipheredToken = streamReader.ReadToEnd();

                            var bytes = Convert.FromBase64String(decipheredToken);

                            var unzippedToken = ZipFileHelper.Unzip(bytes);

​

                            return unzippedToken;

                        }

                    }

                }

            }

        }

        catch (Exception)

        {

            // bearer might not be encoded, so send it back as is.

            return cipheredToken;

        }

    }

}

​

/// <summary>

/// This class allows to interact with zip file.

/// </summary>

public class ZipFileHelper : IDisposable

{

    private ZipArchive zipArchive;

​

    /// <summary>

    /// Initializes a new instance of the <see cref="ZipFileHelper" /> class.

    /// </summary>

    /// <param name="stream">The stream.</param>

    public ZipFileHelper(Stream stream)

    {

        this.zipArchive = new ZipArchive(

            stream,

            ZipArchiveMode.Read,

            false,

            Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage));

    }

​

    /// <summary>

    /// Initializes a new instance of the <see cref="ZipFileHelper"/> class.

    /// </summary>

    /// <param name="byteContent">Content of the byte.</param>

    public ZipFileHelper(byte[] byteContent) :

        this(new MemoryStream(byteContent))

    {

    }

​

    /// <summary>

    /// Determines whether the specified content is empty.

    /// </summary>

    /// <param name="content">The content.</param>

    /// <returns>

    ///   <c>true</c> if the specified content is empty; otherwise, <c>false</c>.

    /// </returns>

    public static bool IsEmpty(string content)

    {

        byte[] byteContent = Encoding.Default.GetBytes(content);

        return IsEmpty(byteContent);

    }

​

    /// <summary>

    /// Determines whether the specified byte content is empty.

    /// </summary>

    /// <param name="byteContent">Content of the byte.</param>

    /// <returns>

    ///   <c>true</c> if the specified byte content is empty; otherwise, <c>false</c>.

    /// </returns>

    public static bool IsEmpty(byte[] byteContent)

    {

        return IsEmpty(new MemoryStream(byteContent));

    }

​

    /// <summary>

    /// Determines whether the specified stream is empty.

    /// </summary>

    /// <param name="stream">The stream.</param>

    /// <returns>

    ///   <c>true</c> if the specified stream is empty; otherwise, <c>false</c>.

    /// </returns>

    private static bool IsEmpty(Stream stream)

    {

        using (ZipArchive zip = new ZipArchive(

            stream,

            ZipArchiveMode.Read,

            false,

            Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage)))

        {

            ZipArchiveEntry zipArchiveEntry = zip.Entries.FirstOrDefault();

            return zipArchiveEntry == null;

        }

    }

​

    /// <summary>

    /// Get Zip file contents.

    /// </summary>

    /// <returns>List of file entries.</returns>

    public IEnumerable<ZipArchiveEntry> GetContents()

    {

        return this.zipArchive.Entries;

    }

​

    /// <summary>

    /// Zips a string into a zipped byte array.

    /// </summary>

    /// <param name="textToZip">The text to be zipped.</param>

    /// <returns>byte[] representing a zipped stream.</returns>

    public static byte[] Zip(string textToZip)

    {

        using (var memoryStream = new MemoryStream())

        {

            using (var zipArchived = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))

            {

                var demoFile = zipArchived.CreateEntry("zipped.txt");

​

                using (var entryStream = demoFile.Open())

                {

                    using (var streamWriter = new StreamWriter(entryStream))

                    {

                        streamWriter.Write(textToZip);

                    }

                }

            }

​

            return memoryStream.ToArray();

        }

    }

​

    /// <summary>

    /// Unzip a zipped byte array into a string.

    /// </summary>

    /// <param name="zippedBuffer">The byte array to be unzipped.</param>

    /// <returns>string representing the original stream.</returns>

    public static string Unzip(byte[] zippedBuffer)

    {

        using (var zippedStream = new MemoryStream(zippedBuffer))

        {

            using (var archive = new ZipArchive(zippedStream))

            {

                var entry = archive.Entries.FirstOrDefault();

​

                if (entry != null)

                {

                    using (var unzippedEntryStream = entry.Open())

                    {

                        using (var ms = new MemoryStream())

                        {

                            unzippedEntryStream.CopyTo(ms);

                            var unzippedArray = ms.ToArray();

​

                            return Encoding.Default.GetString(unzippedArray);

                        }

                    }

                }

​

                return null;

            }

        }

    }

​

    /// <inheritdoc />

    public void Dispose()

    {

        if (this.zipArchive != null)

        {

            this.zipArchive.Dispose();

        }

    }

}