namespace TokenTest

{

    using Newtonsoft.Json;

    using Newtonsoft.Json.Linq;

    using System;

    using System.Collections.Generic;

    using System.Security.Cryptography;

    using System.Security.Cryptography.X509Certificates;

    using System.Text;

    //Install-Package System.IdentityModel.Tokens.Jwt

    public enum JwtHashAlgorithm

    {

        RS256,

        HS384,

        HS512

    }

    public class JsonWebToken

    {

        private static Dictionary<JwtHashAlgorithm, Func<byte[], byte[], byte[]>> HashAlgorithms;

        static JsonWebToken()

        {

            HashAlgorithms = new Dictionary<JwtHashAlgorithm, Func<byte[], byte[], byte[]>>

            {

                { JwtHashAlgorithm.RS256, (key, value) => { using (var sha = new HMACSHA256(key)) { return sha.ComputeHash(value); } } },

                { JwtHashAlgorithm.HS384, (key, value) => { using (var sha = new HMACSHA384(key)) { return sha.ComputeHash(value); } } },

                { JwtHashAlgorithm.HS512, (key, value) => { using (var sha = new HMACSHA512(key)) { return sha.ComputeHash(value); } } }

            };

        }

        public static string Encode(object payload, string key, JwtHashAlgorithm algorithm)

        {

            return Encode(payload, Encoding.UTF8.GetBytes(key), algorithm);

        }

        public static string Encode(object payload, byte[] keyBytes, JwtHashAlgorithm algorithm)

        {

            var segments = new List<string>();

            var header = new { alg = algorithm.ToString(), typ = "JWT" };

            byte[] headerBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(header, Formatting.None));

            byte[] payloadBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload, Formatting.None));

            //byte[] payloadBytes = Encoding.UTF8.GetBytes(@"{"iss":"761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com","scope":"https://www.googleapis.com/auth/prediction","aud":"https://accounts.google.com/o/oauth2/token","exp":1328554385,"iat":1328550785}");

            segments.Add(Base64UrlEncode(headerBytes));

            segments.Add(Base64UrlEncode(payloadBytes));

            var stringToSign = string.Join(".", segments.ToArray());

            var bytesToSign = Encoding.UTF8.GetBytes(stringToSign);

            byte[] signature = HashAlgorithms[algorithm](keyBytes, bytesToSign);

            segments.Add(Base64UrlEncode(signature));

            return string.Join(".", segments.ToArray());

        }

        public static object Decode(string token, string key)

        {

            return Decode(token, key, true);

        }

        public static object Decode(string token, string key, bool verify)

        {

            var parts = token.Split('.');

            var header = parts[];

            var payload = parts[];

            byte[] crypto = Base64UrlDecode(parts[]);

            var headerJson = Encoding.UTF8.GetString(Base64UrlDecode(header));

            var headerData = JObject.Parse(headerJson);

            var payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(payload));

            var payloadData = JObject.Parse(payloadJson);

            if (verify)

            {

                var bytesToSign = Encoding.UTF8.GetBytes(string.Concat(header, ".", payload));

                var keyBytes = Encoding.UTF8.GetBytes(key);

                var algorithm = (string)headerData["alg"];

                var signature = HashAlgorithms[GetHashAlgorithm(algorithm)](keyBytes, bytesToSign);

                var decodedCrypto = Convert.ToBase64String(crypto);

                var decodedSignature = Convert.ToBase64String(signature);

                if (decodedCrypto != decodedSignature)

                {

                    throw new ApplicationException(string.Format("Invalid signature. Expected {0} got {1}", decodedCrypto, decodedSignature));

                }

            }

            //return payloadData.ToString();

            return payloadData;

        }

        private static JwtHashAlgorithm GetHashAlgorithm(string algorithm)

        {

            switch (algorithm)

            {

                case "RS256": return JwtHashAlgorithm.RS256;

                case "HS384": return JwtHashAlgorithm.HS384;

                case "HS512": return JwtHashAlgorithm.HS512;

                default: throw new InvalidOperationException("Algorithm not supported.");

            }

        }

        // from JWT spec

        private static string Base64UrlEncode(byte[] input)

        {

            var output = Convert.ToBase64String(input);

            output = output.Split('=')[]; // Remove any trailing '='s

            output = output.Replace('+', '-'); // 62nd char of encoding

            output = output.Replace('/', '_'); // 63rd char of encoding

            return output;

        }

        // from JWT spec

        private static byte[] Base64UrlDecode(string input)

        {

            var output = input;

            output = output.Replace('-', '+'); // 62nd char of encoding

            output = output.Replace('_', '/'); // 63rd char of encoding

            switch (output.Length % ) // Pad with trailing '='s

            {

                case : break; // No pad chars in this case

                case : output += "=="; break; // Two pad chars

                case : output += "="; break; // One pad char

                default: throw new System.Exception("Illegal base64url string!");

            }

            var converted = Convert.FromBase64String(output); // Standard base64 decoder

            return converted;

        }

    }

}

 var obj = new { Name="Gavin", Age=, Email="gavin@abc.com"};

            var key = "SevenStarKey";

            var token = JsonWebToken.Encode(obj, key, JwtHashAlgorithm.HS512);

            var objStr = JsonWebToken.Decode(token, key);