CertificateStore.cs

using NeuroAccess.Nfc.TravelDocuments.RevocationLists;
using System;
using System.Globalization;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.Networking;
using Waher.Runtime.Settings;
using Waher.Security;
 
namespace NeuroAccess.Nfc.TravelDocuments.Certificates
{
    public static class CertificateStore
    {
        private const int maxDaysInCache = 7;
 
        public static Task<Certificate?> TryLoadCertificate(string IdDomain, string Country, byte[] KeyReference)
        {
            return TryLoadCertificate(IdDomain, Country, KeyReference, null);
        }
 
        public static async Task<Certificate?> TryLoadCertificate(string IdDomain, string Country, byte[] KeyReference,
            ICommunicationLayer? Client)
        {
            Country = Country.ToUpper(CultureInfo.InvariantCulture);
            string KeyReferenceString = Hashes.BinaryToString(KeyReference).ToUpper(CultureInfo.InvariantCulture);
 
            string Uri = "https://" + IdDomain + "/IcaoPki/" + Country + "/" + KeyReferenceString + ".cer";
 
            Client?.Information("Loading certificate from " + Uri);
 
            ContentResponse? Response = await TryCachedGet(Uri, Client);
 
            if (Response is null)
                return null;
 
            try
            {
                if (Certificate.TryParse(Response.Encoded, out Certificate? Result))
                    return Result;
                else
                {
                    Client?.Error("Unable to parse certificate.");
                    return null;
                }
            }
            catch (Exception ex)
            {
                if (Client is null)
                    Log.Exception(ex);
                else
                    Client?.Error(ex.Message);
 
                return null;
            }
        }
 
        public static Task<CertificateList?> TryLoadCrl(string Url)
        {
            return TryLoadCrl(Url, null);
        }
 
        public static async Task<CertificateList?> TryLoadCrl(string Url, ICommunicationLayer? Client)
        {
            Client?.Information("Loading CRL from " + Url);
 
            ContentResponse? Response = await TryCachedGet(Url, Client);
 
            if (Response is null || Response.Decoded is not CertificateList Crl)
                return null;
 
            return Crl;
        }
 
        public static Task<ContentResponse?> TryCachedGet(string Uri)
        {
            return TryCachedGet(Uri, null);
        }
 
        public static async Task<ContentResponse?> TryCachedGet(string Url, ICommunicationLayer? Client)
        {
            string UriKey = "Cache.Uri." + Url;
            string TimestampKey = "Cache.Timestamp." + Url;
            string ContentTypeKey = "Cache.ContentType." + Url;
            DateTime Now = DateTime.UtcNow;
            Uri Uri = new(Url);
            ContentResponse Response;
 
            try
            {
                string Base64 = await RuntimeSettings.GetAsync(UriKey, string.Empty);
                DateTime Timestamp = await RuntimeSettings.GetAsync(TimestampKey, DateTime.MinValue);
                string ContentType = await RuntimeSettings.GetAsync(ContentTypeKey, string.Empty);
 
                if (!string.IsNullOrEmpty(Base64) &&
                    (Now - Timestamp).TotalDays < maxDaysInCache &&
                    !string.IsNullOrEmpty(ContentType))
                {
                    byte[] Bin = Convert.FromBase64String(Base64);
                    Response = await InternetContent.DecodeAsync(ContentType, Bin, Uri);
 
                    if (!Response.HasError)
                    {
                        Client?.Information("Using cached result for " + Url);
 
                        return Response;
                    }
                }
            }
            catch (Exception)
            {
                // Ignore
            }
 
            Client?.Information("Retrieving " + Url);
 
            Response = await InternetContent.GetAsync(Uri);
 
            if (Response.HasError)
            {
                if (Client is null)
                    Log.Exception(Response.Error);
                else
                    Client?.Error(Response.Error.Message);
 
                return null;
            }
 
            Client?.Information("Storing content in cache.");
 
            await RuntimeSettings.SetAsync(UriKey, Convert.ToBase64String(Response.Encoded));
            await RuntimeSettings.SetAsync(TimestampKey, Now);
            await RuntimeSettings.SetAsync(ContentTypeKey, Response.ContentType);
 
            return Response;
        }
    }
}