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)
                    InitializeLocked();
 
                return algorithms.TryGetValue(Name, out Algorithm);
            }
        }
 
        public static IJwsAlgorithm[] GetAlgorithms()
        {
            lock (algorithms)
            {
                if (!initialized)
                    InitializeLocked();
 
                IJwsAlgorithm[] Result = new IJwsAlgorithm[algorithms.Count];
                algorithms.Values.CopyTo(Result, 0);
                return Result;
            }
        }
 
        public static string[] GetAlgorithmNames()
        {
            lock (algorithms)
            {
                if (!initialized)
                    InitializeLocked();
 
                int i = 0;
                int c = algorithms.Count;
                string[] Result = new string[c];
 
                foreach (IJwsAlgorithm Algorithm in algorithms.Values)
                    Result[i++] = Algorithm.Name;
 
                return Result;
            }
        }
 
        private static void InitializeLocked()
        {
            foreach (Type T in Types.GetTypesImplementingInterface(typeof(IJwsAlgorithm)))
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    IJwsAlgorithm 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;
        }
 
        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;
    }
}