EllipticCurvePublicKey.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using NeuroAccess.Nfc.TravelDocuments.Security.FieldTypes;
using NeuroAccess.Nfc.TravelDocuments.Security.NamedCurves;
using Waher.Security.EllipticCurves;
 
namespace NeuroAccess.Nfc.TravelDocuments.Security.PublicKeys
{
    public class EllipticCurvePublicKey : PublicKey
    {
        public override string Oid => "1.2.840.10045.2.1";
 
        private int version;
        private FieldType? field;
        private BigInteger a;
        private BigInteger b;
        private BigInteger order;
        private BigInteger coFactor;
        private PointOnCurve basePoint;
        private PointOnCurve? publicKey;
        private EllipticCurve? namedCurve;
 
        public override bool IsConfigured => this.field is not null || this.namedCurve is not null;
 
        public override bool Configure(Vector SecurityInfo)
        {
            if (SecurityInfo.Length != 2)
                return false;
 
            object? Obj = SecurityInfo.LastElementNested;
 
            if (Obj is Vector EcParameters)
            {
                if (EcParameters.Length < 5 || EcParameters.Length > 6)
                    return false;
 
                if (EcParameters.FirstElement is not BigInteger Version ||
                    Version < int.MinValue ||
                    Version > int.MaxValue ||
                    EcParameters[1] is not FieldType Field ||
                    EcParameters[2] is not Vector Curve ||
                    Curve.Length < 2 ||        // Curve may have an optional third parameter: seed, a BIT STRING, which is not use in the signature validation, but available for documentation, if available.
                    Curve.FirstElement is not byte[] A ||
                    Curve[1] is not byte[] B ||
                    EcParameters[3] is not byte[] BasePoint ||
                    EcParameters[4] is not BigInteger Order)
                {
                    return false;
                }
 
                BigInteger CoFactor;
 
                if (EcParameters.Length == 6)
                {
                    if (EcParameters[5] is BigInteger h)
                        CoFactor = h;
                    else
                        return false;
                }
                else
                    CoFactor = 1;
 
                if (BasePoint.Length == 0)
                    return false;
 
                if (!TryParsePoint(BasePoint, out PointOnCurve? G))
                    return false;
 
                this.version = (int)Version;
                this.field = Field;
                this.a = EllipticCurve.ToInt(A, true);
                this.b = EllipticCurve.ToInt(B, true);
                this.order = Order;
                this.coFactor = CoFactor;
                this.basePoint = G.Value;
 
                return true;
            }
            else if (Obj is INamedCurve NamedCurve)
            {
                this.namedCurve = NamedCurve.GetCurve();
 
                this.order = this.namedCurve.Order;
                this.coFactor = this.namedCurve.Cofactor;
                this.basePoint = this.namedCurve.BasePoint;
 
                if (this.namedCurve is PrimeFieldCurve PrimeFieldCurve)
                {
                    this.field = new PrimeField(PrimeFieldCurve.Prime);
 
                    if (this.namedCurve is WeierstrassCurve WeierstrassCurve)
                    {
                        this.a = WeierstrassCurve.A;
                        this.b = WeierstrassCurve.B;
                    }
                    else if (this.namedCurve is MontgomeryCurve MontgomeryCurve)
                        this.a = MontgomeryCurve.A;
                    else if (this.namedCurve is EdwardsCurve EdwardsCurve)
                        this.a = EdwardsCurve.D;
                    else if (this.namedCurve is EdwardsTwistedCurve EdwardsTwistedCurve)
                        this.a = EdwardsTwistedCurve.D;
                }
 
                return true;
            }
            else
                return false;
        }
 
        public static bool TryParsePoint(byte[] Data, [NotNullWhen(true)] out PointOnCurve? Result)
        {
            if (Data.Length == 0)
            {
                Result = null;
                return false;
            }
 
            switch (Data[0])
            {
                case 0: // Infinity
                    Result = new PointOnCurve();
                    return true;
 
                case 4:
                case 6:
                case 7:
                    int c = (Data.Length - 1) / 2;
                    byte[] Gx = new byte[c];
                    byte[] Gy = new byte[c];
 
                    Buffer.BlockCopy(Data, 1, Gx, 0, c);
                    Buffer.BlockCopy(Data, 1 + c, Gy, 0, c);
 
                    Result = new PointOnCurve(
                        EllipticCurve.ToInt(Gx, true),
                        EllipticCurve.ToInt(Gy, true));
                    return true;
 
                case 2: // Compressed, Y is even
                    c = Data.Length - 1;
                    Gx = new byte[c];
 
                    Buffer.BlockCopy(Data, 1, Gx, 0, c);
 
                    Result = new PointOnCurve(
                        EllipticCurve.ToInt(Gx, true),
                        0);
                    return true;
 
                case 3: // Compressed, Y is odd
                    c = Data.Length - 1;
                    Gx = new byte[c];
 
                    Buffer.BlockCopy(Data, 1, Gx, 0, c);
 
                    Result = new PointOnCurve(
                        EllipticCurve.ToInt(Gx, true),
                        1);
                    return true;
 
                default:
                    Result = null;
                    return false;
            }
        }
 
        public override bool SetPublicKey(object? PublicKey)
        {
            if (PublicKey is not byte[] PublicKeyData)
                return false;
 
            if (!TryParsePoint(PublicKeyData, out this.publicKey))
                return false;
 
            return true;
        }
 
        public bool HasNamedCurve => this.namedCurve is not null;
 
        public EllipticCurve NamedCurve => this.namedCurve!;
 
        public int Version => this.version;
 
        public FieldType Field => this.field!;
 
        public BigInteger A => this.a;
 
        public BigInteger B => this.b;
 
        public BigInteger Order => this.order;
 
        public BigInteger CoFactor => this.coFactor;
 
        public PointOnCurve BasePoint => this.basePoint;
 
        public PointOnCurve PublicKey => this.publicKey ?? new PointOnCurve();
 
        public override void GetParsedParameters(Dictionary<string, object?> Parameters)
        {
            if (this.namedCurve is not null)
                Parameters["NamedCurve"] = this.namedCurve.GetType().FullName;
 
            this.field?.GetParsedParameters(Parameters);
 
            Parameters["A"] = this.a;
            Parameters["B"] = this.b;
            Parameters["Order"] = this.order;
            Parameters["CoFactor"] = this.coFactor;
            Parameters["G.X"] = this.basePoint.X;
            Parameters["G.Y"] = this.basePoint.Y;
            Parameters["X"] = this.publicKey?.X;
            Parameters["Y"] = this.publicKey?.Y;
        }
    }
}