PrimeFieldCurve.cs

using System;
using System.Numerics;
 
namespace Waher.Security.EllipticCurves
{
    public abstract class PrimeFieldCurve : EllipticCurve
    {
        protected readonly ModulusP modP;
 
        protected readonly ModulusP modN;
 
        protected readonly BigInteger p;
 
        public PrimeFieldCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger Order,
            int Cofactor)
            : this(Prime, BasePoint, Order, Cofactor, (byte[])null)
        {
        }
 
        public PrimeFieldCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger Order,
            int Cofactor, byte[] Secret)
            : base(BasePoint, Order, Cofactor, Secret)
        {
            if (Prime <= BigInteger.One)
                throw new ArgumentException("Invalid prime base.", nameof(Prime));
 
            this.p = Prime;
            this.modP = new ModulusP(Prime);
            this.modN = new ModulusP(Order);
        }
 
        public PrimeFieldCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger Order,
            int Cofactor, uint[] Secret)
            : this(Prime, BasePoint, Order, Cofactor, ToByteSecret(Secret))
        {
        }
 
        public BigInteger Prime => this.p;
 
        public virtual HashFunctionArray HashFunction => Hashes.ComputeSHA256Hash;
 
        public virtual HashFunctionStream HashFunctionStream => Hashes.ComputeSHA256Hash;
 
        public static BigInteger ToBigInteger(uint[] BigEndianDWords)
        {
            return ToInt(ToByteSecret(BigEndianDWords));
        }
 
        public static byte[] ToByteSecret(uint[] BigEndianDWords)
        {
            int i, c = BigEndianDWords.Length;
            int j = c << 2;
            byte[] B = new byte[((BigEndianDWords[0] & 0x80000000) != 0) ? j + 1 : j];
            uint k;
 
            for (i = 0; i < c; i++)
            {
                k = BigEndianDWords[i];
 
                B[j - 4] = (byte)k;
                k >>= 8;
                B[j - 3] = (byte)k;
                k >>= 8;
                B[j - 2] = (byte)k;
                k >>= 8;
                B[j - 1] = (byte)k;
 
                j -= 4;
            }
 
            return B;
        }
 
        public override PointOnCurve ScalarMultiplication(byte[] N, PointOnCurve P, bool Normalize)
        {
            PointOnCurve Result = base.ScalarMultiplication(N, P, Normalize);
 
            if (Normalize)
                Result.Normalize(this);
 
            return Result;
        }
 
        public override byte[] GenerateSecret()
        {
            byte[] B = new byte[this.bigIntegerBytes];
            BigInteger D;
 
            do
            {
                lock (rnd)
                {
                    rnd.GetBytes(B);
                }
 
                B[this.bigIntegerBytes - 1] &= this.msbOrderMask;
 
                D = ToInt(B);
            }
            while (D.IsZero || D >= this.n);
 
            return B;
        }
 
        public ModulusP ModulusP => this.modP;
 
        public ModulusP ModulusN => this.modN;
 
    }
}