GetPublicKey.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.P2P.E2E;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Security.JWT;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.NeuroLedger.Setup;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Crypto
{
    public class GetPublicKey : AgentPostResource
    {
        private JwtAuthentication jwtAuthentication;
 
        public GetPublicKey()
            : base("Crypto/GetPublicKey",
                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(GetPublicKey).Namespace + ".JSON.GetPublicKey.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(GetPublicKey).Namespace + ".XML.GetPublicKey.req");
 
        public override HttpAuthenticationScheme[] GetAuthenticationSchemes(HttpRequest Request)
        {
            foreach (HttpAuthenticationScheme Scheme in base.GetAuthenticationSchemes(Request))
            {
                if (Scheme is JwtAuthentication JwtAuth)
                {
                    this.jwtAuthentication = JwtAuth;
                    break;
                }
            }
 
            return null;
        }
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            EllipticCurveEndpoint Endpoint;
            string KeyId = null;
            string Namespace;
            byte[] PublicKey;
 
            if (Parameters.TryGetValue("PKeyId", out IElement E) && !(E is null) && E.AssociatedObjectValue is string s)
                KeyId = s;
 
            if (string.IsNullOrEmpty(KeyId))
            {
                if (!GetAlgorithms.TryGetAlgorithm(LedgerConfiguration.Instance.SignatureAlgorithm, out Endpoint))
                    throw new ServiceUnavailableException("Public key not configured.");
 
                PublicKey = LedgerConfiguration.Instance.PublicKey;
                Namespace = Endpoint.Namespace;
            }
            else
            {
                AccountUser User = (this.jwtAuthentication is null ? null : await this.jwtAuthentication.IsAuthenticated(Request) as AccountUser)
                    ?? throw new ForbiddenException(Request, "User not authenticated.");
 
                if (!User.Account.Enabled)
                    throw new ForbiddenException(Request, "Account not enabled.");
 
                AgentKey AgentKey = await Database.FindFirstDeleteRest<AgentKey>(new FilterAnd(
                    new FilterFieldEqualTo("Account", User.UserName),
                    new FilterFieldEqualTo("Id", KeyId)))
                    ?? throw new NotFoundException("Key not found.");
 
                if (!GetAlgorithms.TryGetAlgorithm(AgentKey.LocalName, AgentKey.Namespace, out Endpoint))
                    throw new ServiceUnavailableException("Key algorithm no longer supported.");
 
                PublicKey = AgentKey.PublicKey ?? Array.Empty<byte>();
                Namespace = AgentKey.Namespace;
            }
 
            await Response.Return(new NamedDictionary<string, object>("PublicKey", AgentNamespace)
            {
                { "key", Convert.ToBase64String(PublicKey) },
                { "Algorithm", new Dictionary<string, object>()
                    {
                        { "localName", Endpoint.LocalName },
                        { "namespace", Namespace },
                        { "securityStrength", Endpoint.SecurityStrength },
                        { "safe", Endpoint.Safe },
                        { "slow", Endpoint.Slow },
                        { "pqc", Endpoint.PostQuantumCryptography },
                        { "score", Endpoint.Score }
                    }
                }
            });
        }
 
    }
}