GetAlgorithms.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.P2P.E2E;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Crypto
{
    public class GetAlgorithms : AgentPostResource
    {
        public GetAlgorithms()
            : base("Crypto/GetAlgorithms",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(GetAlgorithms).Namespace + ".JSON.GetAlgorithms.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(GetAlgorithms).Namespace + ".XML.GetAlgorithms.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AssertUserAuthenticated(Request);
 
            List<NamedDictionary<string, object>> Algorithms = new List<NamedDictionary<string, object>>();
 
            lock (endpoints)
            {
                foreach (EllipticCurveEndpoint Endpoint in endpoints.Values)
                {
                    Algorithms.Add(new NamedDictionary<string, object>("Algorithm", AgentNamespace)
                    {
                        { "localName", Endpoint.LocalName },
                        { "namespace", Endpoint.Namespace },
                        { "securityStrength", Endpoint.SecurityStrength },
                        { "safe", Endpoint.Safe },
                        { "slow", Endpoint.Slow },
                        { "pqc", Endpoint.PostQuantumCryptography },
                        { "score", Endpoint.Score }
                    });
                }
            }
 
            await Response.Return(new NamedDictionary<string, object>("AlgorithmsResult", AgentNamespace)
            {
                { "Algorithms", Algorithms.ToArray() }
            });
        }
 
        private readonly static Dictionary<string, EllipticCurveEndpoint> endpoints = new Dictionary<string, EllipticCurveEndpoint>();
 
        static GetAlgorithms()
        {
            GetEndpointsLocked();
 
            Types.OnInvalidated += (Sender, e) =>
            {
                lock (endpoints)
                {
                    endpoints.Clear();
                    GetEndpointsLocked();
                }
            };
        }
 
        private static void GetEndpointsLocked()
        {
            foreach (Type T in Types.GetTypesImplementingInterface(typeof(IE2eEndpoint)))
            {
                if (T.IsAbstract)
                    continue;
 
                try
                {
                    IE2eEndpoint Endpoint = (IE2eEndpoint)Types.Instantiate(true, T);
                    if (Endpoint is null)
                        continue;
 
                    if (!Endpoint.SupportsSignatures)
                        continue;
 
                    // TODO: Add Support for PQC.
 
                    if (!(Endpoint is EllipticCurveEndpoint EllipticCurveEndpoint))
                        continue;
 
                    string Fqn = Endpoint.Namespace + "#" + Endpoint.LocalName;
                    endpoints[Fqn] = EllipticCurveEndpoint;
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        public static bool TryGetAlgorithm(string LocalName, string Namespace,
            out EllipticCurveEndpoint Algorithm)
        {
            if (Namespace.StartsWith("urn:ieee:"))
                Namespace = Namespace.Replace("urn:ieee:", "urn:nf:");
 
            lock (endpoints)
            {
                return endpoints.TryGetValue(Namespace + "#" + LocalName, out Algorithm);
            }
        }
 
        public static bool TryGetAlgorithm(string CurveName, out EllipticCurveEndpoint Algorithm)
        {
            // TODO: Add Support for PQC.
 
            lock (endpoints)
            {
                foreach (EllipticCurveEndpoint Endpoint in endpoints.Values)
                {
                    if (Endpoint.Curve.CurveName == CurveName)
                    {
                        Algorithm = Endpoint;
                        return true;
                    }
                }
            }
 
            Algorithm = null;
            return false;
        }
    }
}