JwsAlgorithm.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using Waher.Content;
using Waher.Events;
using Waher.Runtime.Inventory;
 
namespace Waher.Security.JWS
{
    public abstract class JwsAlgorithm : IJwsAlgorithm
    {
        public const string JwsContentType = "application/jose+json";
 
        public abstract string Name
        {
            get;
        }
 
        public abstract bool HasPublicWebKey
        {
            get;
        }
 
        public virtual IEnumerable<KeyValuePair<string, object>> PublicWebKey
        {
            get { throw new NotSupportedException("Algorithm does not have a public web key."); }
        }
 
        public abstract void Dispose();
 
        public virtual void Sign(IEnumerable<KeyValuePair<string, object>> Header,
            IEnumerable<KeyValuePair<string, object>> Payload, out string HeaderString,
            out string PayloadString, out string Signature)
        {
            string HeaderJson;
            bool HasKeyID = false;
 
            foreach (KeyValuePair<string, object> P in Header)
            {
                if (P.Key == "kid")
                {
                    HasKeyID = true;
                    break;
                }
            }
 
            if (this.HasPublicWebKey && !HasKeyID)
            {
                HeaderJson = JSON.Encode(Header, null,
                    new KeyValuePair<string, object>("alg", this.Name),
                    new KeyValuePair<string, object>("jwk", this.PublicWebKey));
            }
            else
                HeaderJson = JSON.Encode(Header, null, new KeyValuePair<string, object>("alg", this.Name));
 
            byte[] HeaderBin = Encoding.UTF8.GetBytes(HeaderJson);
            HeaderString = Base64Url.Encode(HeaderBin);
 
            string PayloadJson = Payload is null ? string.Empty : JSON.Encode(Payload, null);
            byte[] PayloadBin = Encoding.UTF8.GetBytes(PayloadJson);
            PayloadString = Base64Url.Encode(PayloadBin);
 
            Signature = this.Sign(HeaderString, PayloadString);
        }
 
        public abstract string Sign(string HeaderEncoded, string PayloadEncoded);
 
        public virtual bool IsValid(string HeaderEncoded, string PayloadEncoded, string SignatureEncoded)
        {
            return this.Sign(HeaderEncoded, PayloadEncoded) == SignatureEncoded;
        }
 
        public static bool TryGetAlgorithm(string Name, out IJwsAlgorithm Algorithm)
        {
            lock (algorithms)
            {
                if (!initialized)
                {
                    foreach (Type T in Types.GetTypesImplementingInterface(typeof(IJwsAlgorithm)))
                    {
                        ConstructorInfo CI = Types.GetDefaultConstructor(T);
                        if (CI is null)
                            continue;
 
                        try
                        {
                            Algorithm = (IJwsAlgorithm)CI.Invoke(Types.NoParameters);
 
                            if (algorithms.ContainsKey(Algorithm.Name))
                                Log.Warning("JWS algorithm with name " + Algorithm.Name + " already registered.");
                            else
                                algorithms[Algorithm.Name] = Algorithm;
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
 
                    if (!registered)
                    {
                        Types.OnInvalidated += Types_OnInvalidated;
                        registered = true;
                    }
 
                    initialized = true;
                }
 
                return algorithms.TryGetValue(Name, out Algorithm);
            }
        }
 
        private static void Types_OnInvalidated(object Sender, EventArgs e)
        {
            lock (algorithms)
            {
                algorithms.Clear();
                initialized = false;
            }
        }
 
        private static readonly Dictionary<string, IJwsAlgorithm> algorithms = new Dictionary<string, IJwsAlgorithm>();
        private static bool initialized = false;
        private static bool registered = false;
    }
}