ToBeSignedCertificate.cs

using NeuroAccess.Nfc.TravelDocuments.Security;
using NeuroAccess.Nfc.TravelDocuments.Security.Properties.Keys;
using NeuroAccess.Nfc.TravelDocuments.Security.PublicKeys;
using NeuroAccess.Nfc.TravelDocuments.Security.SignatureAlgorithms;
using System;
using System.Diagnostics.CodeAnalysis;
using System.Formats.Asn1;
 
namespace NeuroAccess.Nfc.TravelDocuments.Certificates
{
    public class ToBeSignedCertificate
    {
        private ToBeSignedCertificate(byte[] Binary, int Version, System.Numerics.BigInteger SerialNumber,
            ISignatureAlgorithm IssuerSignatureAlgorithm, Names Issuer, DateTimeOffset NotBefore,
            DateTimeOffset NotAfter, Names Subject, byte[]? AuthorityKeyIdentifier,
            byte[]? SubjectKeyIdentifier, IPublicKey CertificatePublicKey, Vector? Extensions)
        {
            this.Binary = Binary;
            this.Version = Version;
            this.SerialNumber = SerialNumber;
            this.IssuerSignatureAlgorithm = IssuerSignatureAlgorithm;
            this.Issuer = Issuer;
            this.NotBefore = NotBefore;
            this.NotAfter = NotAfter;
            this.Subject = Subject;
            this.AuthorityKeyIdentifier = AuthorityKeyIdentifier;
            this.SubjectKeyIdentifier = SubjectKeyIdentifier;
            this.PublicKey = CertificatePublicKey;
            this.Extensions = Extensions;
        }
 
        public static bool TryParse(Vector TbsCert, [NotNullWhen(true)] out ToBeSignedCertificate? Parsed)
        {
            Parsed = null;
 
            int c = TbsCert.Length;
            int i = 0;
            int Version = 0;
 
            if (i < c)
            {
                if (TbsCert.FirstElement is not System.Numerics.BigInteger V)
                {
                    if (TbsCert.FirstElement is not Vector VersionVector ||
                        VersionVector.Length != 1 ||
                        VersionVector.FirstElement is not System.Numerics.BigInteger V2)
                    {
                        return false;
                    }
 
                    V = V2;
                }
 
                if (V < int.MinValue || V > int.MaxValue)
                    return false;
 
                Version = (int)V;
                i++;
            }
 
            if (i >= c || TbsCert[i++] is not System.Numerics.BigInteger SerialNumber)
                return false;
 
            if (i >= c)
                return false;
 
            object? Obj = TbsCert[i++];
 
            if (Obj is not ISignatureAlgorithm IssuerSignatureAlgorithm)
            {
                if (Obj is not Vector AlgorithmIdentifier)
                    return false;
 
                ISignatureAlgorithm? IssuerSignatureAlgorithm2 = SignatureAlgorithm.TryDecode(AlgorithmIdentifier);
                if (IssuerSignatureAlgorithm2 is null)
                    return false;
 
                IssuerSignatureAlgorithm = IssuerSignatureAlgorithm2;
            }
 
            if (i >= c || TbsCert[i++] is not Vector Issuer)
                return false;
 
            if (i >= c ||
                TbsCert[i++] is not Vector Validity ||
                Validity.Length != 2 ||
                Validity.FirstElementNested is not DateTimeOffset NotBefore ||
                Validity.LastElementNested is not DateTimeOffset NotAfter)
            {
                return false;
            }
 
            if (i >= c || TbsCert[i++] is not Vector Subject)
                return false;
 
            if (i >= c || TbsCert[i++] is not Vector SubjectPublicKeyInfo)
                return false;
 
            if (SubjectPublicKeyInfo.Length != 2)
                return false;
 
            Obj = SubjectPublicKeyInfo.FirstElementNested;
 
            if (Obj is not IPublicKey PublicKey)
            {
                if (Obj is Vector v &&
                    v.FirstElement is IPublicKey PublicKey2)
                {
                    PublicKey = PublicKey2;
                }
                else
                    return false;
            }
 
            if (!PublicKey.IsConfigured ||
                !PublicKey.SetPublicKey(SubjectPublicKeyInfo.LastElement))
            {
                return false;
            }
 
            // TODO: Check for optional issuerUniqueID and subjectUniqueID 
 
            Vector? ListExtensions;
            byte[]? AuthorityKeyIdentifier = null;
            byte[]? SubjectKeyIdentifier = null;
 
            if (i < c && TbsCert[i] is byte[] ExtensionsBin)
            {
                if (!ASN1.TryDecodeDerAs(UniversalTagNumber.Sequence, ExtensionsBin, out object? Extensions2))
                    return false;
 
                TbsCert.Elements.SetValue(Extensions2, i);
            }
 
            if (i < c && TbsCert[i] is Vector ListExtensions2)
            {
                i++;
 
                if (ListExtensions2.Length == 1 &&
                    ListExtensions2.FirstElementNested is Vector ListExtensions3 &&
                    (ListExtensions2.SubSection[0] & 0x80) != 0)
                {
                    ListExtensions2 = ListExtensions3;
                }
 
                ListExtensions = ListExtensions2;
 
                foreach (object? Extension in ListExtensions2)
                {
                    if (Extension is AuthorityKeyIdentifier Aki)
                        AuthorityKeyIdentifier = Aki.Identifier;
                    else if (Extension is SubjectKeyIdentifier Ski)
                        SubjectKeyIdentifier = Ski.Identifier;
                }
            }
            else
                ListExtensions = null;
 
            if (i < c)
                return false;
 
            Parsed = new ToBeSignedCertificate(TbsCert.SubSection, Version, SerialNumber,
                IssuerSignatureAlgorithm, new Names(Issuer), NotBefore, NotAfter,
                new Names(Subject), AuthorityKeyIdentifier, SubjectKeyIdentifier,
                PublicKey, ListExtensions);
 
            return true;
        }
 
        public byte[] Binary { get; }
 
        public int Version { get; }
 
        public System.Numerics.BigInteger SerialNumber { get; }
 
        public ISignatureAlgorithm IssuerSignatureAlgorithm { get; }
 
        public Names Issuer { get; }
 
        public DateTimeOffset NotBefore { get; }
 
        public DateTimeOffset NotAfter { get; }
 
        public Names Subject { get; }
 
        public byte[]? AuthorityKeyIdentifier { get; }
 
        public byte[]? SubjectKeyIdentifier { get; }
 
        public IPublicKey PublicKey { get; }
 
        public Vector? Extensions { get; }
    }
}