Certificate.cs

using System;
using System.Diagnostics.CodeAnalysis;
using NeuroAccess.Nfc.TravelDocuments.Security;
using NeuroAccess.Nfc.TravelDocuments.Security.PublicKeys;
using NeuroAccess.Nfc.TravelDocuments.Security.SignatureAlgorithms;
 
namespace NeuroAccess.Nfc.TravelDocuments.Certificates
{
    public class Certificate
    {
        private Certificate(Vector Asn1Vector, ToBeSignedCertificate ToBeSignedCertificate,
            ISignatureAlgorithm IssuerSignatureAlgorithm, byte[] Signature)
        {
            this.Asn1Vector = Asn1Vector;
            this.ToBeSignedCertificate = ToBeSignedCertificate;
            this.IssuerSignatureAlgorithm = IssuerSignatureAlgorithm;
            this.Signature = Signature;
        }
 
        public static bool TryParse(byte[] RawCertificate, [NotNullWhen(true)] out Certificate? Parsed)
        {
            Parsed = null;
 
            if (!ASN1.TryDecodeDer(RawCertificate, out object? Content))
                return false;
 
            if (Content is not Vector CertificateVector)
                return false;
 
            return TryParse(CertificateVector, out Parsed);
        }
 
        public static bool TryParse(Vector CertificateVector, [NotNullWhen(true)] out Certificate? Parsed)
        {
            Parsed = null;
 
            if (CertificateVector.Length != 3)
                return false;
 
            if (CertificateVector.FirstElement is not Vector TbsCert)
                return false;
 
            if (CertificateVector[1] is not ISignatureAlgorithm IssuerSignatureAlgorithm)
            {
                if (CertificateVector[1] is not Vector AlgorithmIdentifier)
                    return false;
 
                ISignatureAlgorithm? IssuerSignatureAlgorithm2 = SignatureAlgorithm.TryDecode(AlgorithmIdentifier);
                if (IssuerSignatureAlgorithm2 is null)
                    return false;
 
                IssuerSignatureAlgorithm = IssuerSignatureAlgorithm2;
            }
 
            if (CertificateVector[2] is not byte[] Signature)
                return false;
 
            if (!ToBeSignedCertificate.TryParse(TbsCert, out ToBeSignedCertificate? ToBeSigned))
                return false;
 
            Parsed = new Certificate(CertificateVector, ToBeSigned, IssuerSignatureAlgorithm, Signature);
 
            return true;
        }
 
        public ToBeSignedCertificate ToBeSignedCertificate { get; }
 
        public ISignatureAlgorithm IssuerSignatureAlgorithm { get; }
 
        public byte[] Signature { get; }
 
        public Vector Asn1Vector { get; }
 
        public byte[] Binary => this.Asn1Vector.SubSection;
 
        public int? Version => this.ToBeSignedCertificate.Version;
 
        public System.Numerics.BigInteger SerialNumber => this.ToBeSignedCertificate.SerialNumber;
 
        public Names Issuer => this.ToBeSignedCertificate.Issuer;
 
        public DateTimeOffset NotBefore => this.ToBeSignedCertificate.NotBefore;
 
        public DateTimeOffset NotAfter => this.ToBeSignedCertificate.NotAfter;
 
        public Names Subject => this.ToBeSignedCertificate.Subject;
 
        public byte[]? AuthorityKeyIdentifier => this.ToBeSignedCertificate.AuthorityKeyIdentifier;
 
        public byte[]? SubjectKeyIdentifier => this.ToBeSignedCertificate.SubjectKeyIdentifier;
 
        public IPublicKey PublicKey => this.ToBeSignedCertificate.PublicKey;
 
        public Vector? Extensions => this.ToBeSignedCertificate.Extensions;
    }
}