EdwardsCurve.cs

using System;
using System.Security.Cryptography;
using System.Numerics;
 
namespace Waher.Security.EllipticCurves
{
    public abstract class EdwardsCurve : EdwardsCurveBase
    {
        private readonly BigInteger p34;
 
        public EdwardsCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger d,
            BigInteger Order, int Cofactor)
            : this(Prime, BasePoint, d, Order, Cofactor, null)
        {
        }
 
        public EdwardsCurve(BigInteger Prime, PointOnCurve BasePoint, BigInteger d, 
            BigInteger Order, int Cofactor, byte[] Secret)
            : base(Prime, BasePoint, d, Order, Cofactor, Secret)
        {
            this.p34 = (this.p - 3) / 4;
        }
 
        protected abstract BigInteger D
        {
            get;
        }
 
        public override PointOnCurve Zero
        {
            get
            {
                return new PointOnCurve(BigInteger.Zero, BigInteger.One);
            }
        }
 
        public override void AddTo(ref PointOnCurve P, PointOnCurve Q)
        {
            if (!P.IsHomogeneous)
                P.Z = BigInteger.One;
 
            if (!Q.IsHomogeneous)
                Q.Z = BigInteger.One;
 
            BigInteger A = this.modP.Multiply(P.Z, Q.Z);
            BigInteger B = this.modP.Multiply(A, A);
            BigInteger C = this.modP.Multiply(P.X, Q.X);
            BigInteger D = this.modP.Multiply(P.Y, Q.Y);
            BigInteger E = this.modP.Multiply(this.modP.Multiply(this.D, C), D);
            BigInteger F = this.modP.Subtract(B, E);
            BigInteger G = this.modP.Add(B, E);
            BigInteger H = this.modP.Multiply(P.X + P.Y, Q.X + Q.Y);
 
            P.X = this.modP.Multiply(A, this.modP.Multiply(F, H - C - D));
            P.Y = this.modP.Multiply(A, this.modP.Multiply(G, D - C));
            P.Z = this.modP.Multiply(F, G);
        }
 
        public override void Double(ref PointOnCurve P)
        {
            if (!P.IsHomogeneous)
                P.Z = BigInteger.One;
 
            BigInteger A = this.modP.Add(P.X, P.Y);
            BigInteger B = this.modP.Multiply(A, A);
            BigInteger C = this.modP.Multiply(P.X, P.X);
            BigInteger D = this.modP.Multiply(P.Y, P.Y);
            BigInteger E = this.modP.Add(C, D);
            BigInteger H = this.modP.Multiply(P.Z, P.Z);
            BigInteger J = this.modP.Subtract(E, H << 1);
 
            P.X = this.modP.Multiply(B - E, J);
            P.Y = this.modP.Multiply(E, C - D);
            P.Z = this.modP.Multiply(E, J);
        }
 
        public override BigInteger GetX(BigInteger Y, bool X0)
        {
            BigInteger y2 = this.modP.Multiply(Y, Y);
            BigInteger u = y2 - BigInteger.One;
            if (u.Sign < 0)
                u += this.p;
 
            BigInteger v = this.modP.Multiply(this.D, y2) - BigInteger.One;
            BigInteger v2 = this.modP.Multiply(v, v);
            BigInteger v3 = this.modP.Multiply(v, v2);
            BigInteger u2 = this.modP.Multiply(u, u);
            BigInteger u3 = this.modP.Multiply(u, u2);
            BigInteger u5 = this.modP.Multiply(u2, u3);
            BigInteger x = this.modP.Multiply(this.modP.Multiply(u3, v),
                BigInteger.ModPow(this.modP.Multiply(u5, v3), this.p34, this.p));
 
            BigInteger x2 = this.modP.Multiply(x, x);
            BigInteger Test = this.modP.Multiply(v, x2);
            if (Test.Sign < 0)
                Test += this.p;
 
            if (Test != u)
                throw new ArgumentException("Not a valid point.", nameof(Y));
 
            if (X0)
            {
                if (x.IsZero)
                    throw new ArgumentException("Not a valid point.", nameof(Y));
 
                if (x.IsEven)
                    x = this.p - x;
            }
            else if (!x.IsEven)
                x = this.p - x;
 
            return x;
        }
 
    }
}