Curve25519.cs

using System;
using System.Globalization;
using System.IO;
using System.Numerics;
 
namespace Waher.Security.EllipticCurves
{
    public class Curve25519 : MontgomeryCurve
    {
        private static readonly BigInteger p0 = BigInteger.Pow(2, 255) - 19;
        private static readonly BigInteger A0 = 486662;
        private static readonly BigInteger A24 = (A0 - 2) / 4;
        private static readonly BigInteger n0 = BigInteger.Pow(2, 252) + BigInteger.Parse("14def9dea2f79cd65812631a5cf5d3ed", NumberStyles.HexNumber);
        private static readonly BigInteger BasePointU = 9;
        private static readonly BigInteger BasePointV = BigInteger.Parse("14781619447589544791020593568409986887264606134616475288964881837755586237401");
        private static readonly BigInteger SqrtMinus486664 = ModulusP.SqrtModP(-486664, p0);
 
        public Curve25519()
            : base(p0, new PointOnCurve(BasePointU, BasePointV), n0, 8)
        {
        }
 
        public Curve25519(byte[] Secret)
            : base(p0, new PointOnCurve(BasePointU, BasePointV), n0, 8, Secret)
        {
        }
 
        public override string CurveName => "Curve25519";
 
        protected override BigInteger A => A0;
 
        public override PointOnCurve ToXY(PointOnCurve UV)
        {
            BigInteger X = this.modP.Multiply(SqrtMinus486664, this.modP.Divide(UV.X, UV.Y));
            BigInteger Y = this.modP.Divide(UV.X - BigInteger.One, UV.X + BigInteger.One);
 
            if (X.Sign < 0)
                X += this.p;
 
            if (Y.Sign < 0)
                Y += this.p;
 
            return new PointOnCurve(X, Y);
        }
 
        public override PointOnCurve ToUV(PointOnCurve XY)
        {
            BigInteger U = this.modP.Divide(XY.Y + BigInteger.One, BigInteger.One - XY.Y);
            BigInteger V = this.modP.Multiply(SqrtMinus486664, this.modP.Divide(U, XY.X));
 
            if (U.Sign < 0)
                U += this.p;
 
            if (V.Sign < 0)
                V += this.p;
 
            return new PointOnCurve(U, V);
        }
 
        public override BigInteger ScalarMultiplication(byte[] N, BigInteger U)
        {
            return XFunction(N, U, A24, this.p, 255);
        }
 
        public override Tuple<byte[], byte[]> CalculatePrivateKey(byte[] Secret)
        {
            byte[] Bin = Secret;
 
            if (Bin.Length != 32)
                Bin = Hashes.ComputeSHA256Hash(Secret);
 
            Bin[0] &= 0xf8;
            Bin[31] &= 0x3f;
            Bin[31] |= 0x40;
 
            return new Tuple<byte[], byte[]>(Bin, null);
        }
 
        public override EdwardsCurveBase CreatePair()
        {
            PointOnCurve PublicKeyUV = this.PublicKeyPoint;
            PointOnCurve PublicKeyXY = this.ToXY(PublicKeyUV);
 
            Edwards25519 Candidate = new Edwards25519(this.PrivateKey, false);
            PointOnCurve PublicKeyXY2 = Candidate.PublicKeyPoint;
 
            if (!PublicKeyXY.Y.Equals(PublicKeyXY2.Y))
                throw new InvalidOperationException("Unable to create pair curve.");
 
            return Candidate;
        }
 
        public override byte[] Sign(byte[] Data)
        {
            throw new NotSupportedException("Signatures not supported.");
            // return XEdDSA.Sign(Data, this.PrivateKey, Hashes.ComputeSHA512Hash, this);
        }
 
        public override byte[] Sign(Stream Data)
        {
            throw new NotSupportedException("Signatures not supported.");
            // return XEdDSA.Sign(Data, this.PrivateKey, Hashes.ComputeSHA512Hash, this);
        }
 
        /*/// <summary>
        public byte[] Sign(byte[] Data, GetRandomBytesHandler GetRandomBytes)
        {
            return XEdDSA.Sign(Data, this.PrivateKey, Hashes.ComputeSHA512Hash, this, 
                GetRandomBytes);
        }*/
 
        public override bool Verify(byte[] Data, byte[] PublicKey, byte[] Signature)
        {
            throw new NotSupportedException("Signatures not supported.");
            //return XEdDSA.Verify(Data, PublicKey, Hashes.ComputeSHA512Hash, this, 
            //    Signature, 255, 253);
        }
 
        public override bool Verify(Stream Data, byte[] PublicKey, byte[] Signature)
        {
            throw new NotSupportedException("Signatures not supported.");
            //return XEdDSA.Verify(Data, PublicKey, Hashes.ComputeSHA512Hash, this, 
            //    Signature, 255, 253);
        }
 
    }
}