WeierstrassCurve.cs

using System.IO;
using System.Numerics;
 
namespace Waher.Security.EllipticCurves
{
    public abstract class WeierstrassCurve : PrimeFieldCurve
    {
        private readonly BigInteger a;
        private readonly BigInteger b;
 
        public WeierstrassCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger a, 
            BigInteger b, BigInteger Order, int Cofactor)
            : this(Prime, BasePoint, a, b, Order, Cofactor, (byte[])null)
        {
        }
 
        public WeierstrassCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger a,
            BigInteger b, BigInteger Order, int Cofactor, byte[] Secret)
            : base(Prime, BasePoint, Order, Cofactor, Secret)
        {
            this.a = a;
            this.b = b;
        }
 
        public WeierstrassCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger a,
            BigInteger b, BigInteger Order, int Cofactor, uint[] Secret)
            : base(Prime, BasePoint, Order, Cofactor, Secret)
        {
            this.a = a;
            this.b = b;
        }
 
        public BigInteger A => this.a;
 
        public BigInteger B => this.b;
 
        public void Negate(ref PointOnCurve P)
        {
            P.Y = this.p - P.Y;
        }
 
        public override void AddTo(ref PointOnCurve P, PointOnCurve Q)
        {
            if (P.NonZero)
            {
                if (Q.NonZero)
                {
                    BigInteger sDividend = this.modP.Subtract(P.Y, Q.Y);
                    BigInteger sDivisor = this.modP.Subtract(P.X, Q.X);
                    BigInteger s, xR, yR;
 
                    if (sDivisor.IsZero)
                    {
                        if (sDividend.IsZero)   // P=Q
                            this.Double(ref P);
                        else
                            P = this.Zero;
                    }
                    else
                    {
                        s = this.modP.Divide(sDividend, sDivisor);
                        xR = this.modP.Subtract(this.modP.Multiply(s, s), this.modP.Add(P.X, Q.X));
                        yR = this.modP.Add(P.Y, this.modP.Multiply(s, this.modP.Subtract(xR, P.X)));
 
                        P.X = xR;
                        P.Y = this.p - yR;
                    }
                }
            }
            else
                P.CopyFrom(Q);
        }
 
        public override void Double(ref PointOnCurve P)
        {
            if (P.NonZero)
            {
                BigInteger sDividend = this.modP.Add(3 * this.modP.Multiply(P.X, P.X), this.a);
                BigInteger sDivisor = this.modP.Multiply(Two, P.Y);
 
                BigInteger s = this.modP.Divide(sDividend, sDivisor);
                BigInteger xR = this.modP.Subtract(this.modP.Multiply(s, s), this.modP.Add(P.X, P.X));
                BigInteger yR = this.modP.Add(P.Y, this.modP.Multiply(s, this.modP.Subtract(xR, P.X)));
 
                P.X = xR;
                P.Y = this.p - yR;
            }
        }
 
        public override bool IsPoint(PointOnCurve Point)
        {
            // Check if point matches y²=x³+ax+b=x(x²+a)+b
 
            BigInteger Left = this.modP.Multiply(Point.Y, Point.Y);
 
            BigInteger Right = this.modP.Add(
                this.modP.Multiply(
                    Point.X,
                    this.modP.Add(
                        this.modP.Multiply(Point.X, Point.X),
                        this.a)),
                this.b);
 
            return Left == Right;
        }
 
        public override byte[] Sign(byte[] Data, bool BigEndian)
        {
            return ECDSA.Sign(Data, BigEndian, this.PrivateKey, this.HashFunction, this);
        }
 
        public override byte[] Sign(Stream Data, bool BigEndian)
        {
            return ECDSA.Sign(Data, BigEndian, this.PrivateKey, this.HashFunctionStream, this);
        }
 
        public override bool Verify(byte[] Data, byte[] PublicKey, bool BigEndian, byte[] Signature)
        {
            return ECDSA.Verify(Data, PublicKey, BigEndian, this.HashFunction, this, Signature);
        }
 
        public override bool Verify(Stream Data, byte[] PublicKey, bool BigEndian, byte[] Signature)
        {
            return ECDSA.Verify(Data, PublicKey, BigEndian, this.HashFunctionStream, this, Signature);
        }
    }
}