EllipticCurve.cs

using System;
using System.IO;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Xml;
 
namespace Waher.Security.EllipticCurves
{
    public abstract class EllipticCurve : ISignatureAlgorithm
    {
        public const string Namespace = "http://waher.se/Schema/EllipticCurves.xsd";
 
        public static readonly BigInteger Two = new BigInteger(2);
 
        public const string ElementName = "EllipticCurve";
 
        protected static readonly RandomNumberGenerator rnd = RandomNumberGenerator.Create();
 
        protected readonly PointOnCurve g;
 
        protected readonly BigInteger n;
 
        protected readonly int cofactor;
 
        protected readonly int orderBits;
 
        protected readonly int orderBytes;
 
        protected readonly int bigIntegerBytes;
 
        protected readonly byte msbOrderMask;
 
        private byte[] secret;
        private byte[] privateKey;
        private byte[] publicKey;
        private byte[] publicKeyBigEndian;
        private byte[] additionalInfo;
        private PointOnCurve publicKeyPoint;
 
        public EllipticCurve(PointOnCurve BasePoint, BigInteger Order, int Cofactor)
            : this(BasePoint, Order, Cofactor, null)
        {
        }
 
        public EllipticCurve(PointOnCurve BasePoint, BigInteger Order, int Cofactor,
            byte[] Secret)
        {
            this.g = BasePoint;
            this.n = Order;
            this.cofactor = Cofactor;
            this.secret = Secret;
            this.privateKey = null;
            this.publicKey = null;
            this.publicKeyBigEndian = null;
            this.additionalInfo = null;
 
            this.orderBits = ModulusP.CalcBits(this.n);
            this.orderBytes = this.bigIntegerBytes = (this.orderBits + 7) >> 3;
            this.msbOrderMask = 0xff;
 
            int MaskBits = (8 - this.orderBits) & 7;
            if (MaskBits == 0)
            {
                this.bigIntegerBytes++;
                this.msbOrderMask = 0;
            }
            else
                this.msbOrderMask >>= MaskBits;
        }
 
        protected virtual void Init()
        {
            if (this.secret is null)
                this.secret = this.GenerateSecret();
 
            this.SetPrivateKey(this.secret);
        }
 
        protected byte[] PrivateKey
        {
            get
            {
                if (this.privateKey is null)
                    this.Init();
 
                return this.privateKey;
            }
        }
 
        public virtual byte[] PublicKey
        {
            get
            {
                if (this.publicKey is null)
                    this.Init();
 
                return this.publicKey;
            }
        }
 
        public virtual byte[] PublicKeyBigEndian
        {
            get
            {
                if (this.publicKeyBigEndian is null)
                    this.Init();
 
                return this.publicKeyBigEndian;
            }
        }
 
        protected byte[] AdditionalInfo
        {
            get
            {
                if (this.additionalInfo is null)
                    this.Init();
 
                return this.additionalInfo;
            }
        }
 
        public virtual PointOnCurve PublicKeyPoint
        {
            get
            {
                if (this.publicKey is null)
                    this.Init();
 
                return this.publicKeyPoint;
            }
 
            internal set
            {
                this.publicKeyPoint = value;
            }
        }
 
        public abstract string CurveName
        {
            get;
        }
 
        public BigInteger Order => this.n;
 
        public int OrderBytes => this.orderBytes;
 
        public int BigIntegerBytes => this.bigIntegerBytes;
 
        public int OrderBits => this.orderBits;
 
        public int Cofactor => this.cofactor;
 
        public PointOnCurve BasePoint => this.g;
 
        public byte MsbOrderMask => this.msbOrderMask;
 
        public abstract byte[] GenerateSecret();
 
        public virtual void SetPrivateKey(byte[] Secret)
        {
            Tuple<byte[], byte[]> Info = this.CalculatePrivateKey(Secret);
            PointOnCurve P = this.ScalarMultiplication(Info.Item1, this.g, true);
 
            this.publicKey = this.Encode(P, false);
            this.publicKeyBigEndian = this.Encode(P, true);
            this.publicKeyPoint = P;
            this.privateKey = Info.Item1;
            this.additionalInfo = Info.Item2;
            this.secret = Secret;
        }
 
        public virtual Tuple<byte[], byte[]> CalculatePrivateKey(byte[] Secret)
        {
            return new Tuple<byte[], byte[]>(Secret, null);
        }
 
        public byte[] Encode(PointOnCurve Point)
        {
            return this.Encode(Point, false);
        }
 
        public virtual byte[] Encode(PointOnCurve Point, bool BigEndian)
        {
            byte[] X = Point.X.ToByteArray();   // Little endian
            byte[] Y = Point.Y.ToByteArray();   // Little endian
            byte[] Result = new byte[this.orderBytes << 1];
 
            if (X.Length != this.orderBytes)
                Array.Resize(ref X, this.orderBytes);
 
            if (Y.Length != this.orderBytes)
                Array.Resize(ref Y, this.orderBytes);
 
            if (BigEndian)
            {
                Array.Reverse(X);   // Big endian
                Array.Reverse(Y);   // Big endian
            }
 
            Buffer.BlockCopy(X, 0, Result, 0, this.orderBytes);
            Buffer.BlockCopy(Y, 0, Result, this.orderBytes, this.orderBytes);
 
            return Result;
        }
 
        public PointOnCurve Decode(byte[] Point)
        {
            return this.Decode(Point, false);
        }
 
        public virtual PointOnCurve Decode(byte[] Point, bool BigEndian)
        {
            if (Point.Length != this.orderBytes << 1)
                throw new ArgumentException("Invalid point.", nameof(Point));
 
            byte[] X = new byte[this.orderBytes];
            byte[] Y = new byte[this.orderBytes];
 
            Buffer.BlockCopy(Point, 0, X, 0, this.orderBytes);
            Buffer.BlockCopy(Point, this.orderBytes, Y, 0, this.orderBytes);
 
            return new PointOnCurve(ToInt(X, BigEndian), ToInt(Y, BigEndian));
        }
 
        public void GenerateKeys()
        {
            this.SetPrivateKey(this.GenerateSecret());
        }
 
        public PointOnCurve ScalarMultiplication(BigInteger N, PointOnCurve P, bool Normalize)
        {
            return this.ScalarMultiplication(N.ToByteArray(), P, Normalize);
        }
 
        public virtual PointOnCurve ScalarMultiplication(byte[] N, PointOnCurve P, bool Normalize)
        {
            PointOnCurve Result = this.Zero;
            int i, c = N.Length;
            byte b, Bit;
 
            for (i = 0; i < c; i++)
            {
                b = N[i];
 
                for (Bit = 1; Bit != 0; Bit <<= 1)
                {
                    if ((b & Bit) != 0)
                        this.AddTo(ref Result, P);
 
                    this.Double(ref P);
                }
            }
 
            return Result;
        }
 
        public virtual PointOnCurve Zero
        {
            get
            {
                return new PointOnCurve(BigInteger.Zero, BigInteger.Zero);
            }
        }
 
        public abstract void AddTo(ref PointOnCurve P, PointOnCurve Q);
 
        public abstract void Double(ref PointOnCurve P);
 
        public PointOnCurve GetSharedPoint(byte[] RemotePublicKey)
        {
            return this.GetSharedPoint(RemotePublicKey, false);
        }
 
        public virtual PointOnCurve GetSharedPoint(byte[] RemotePublicKey, bool BigEndian)
        {
            return ECDH.GetSharedPoint(this.PrivateKey, RemotePublicKey, BigEndian, this);
        }
 
        public virtual byte[] GetSharedKey(byte[] RemotePublicKey, HashFunctionArray HashFunction)
        {
            return this.GetSharedKey(RemotePublicKey, false, HashFunction);
        }
 
        public virtual byte[] GetSharedKey(byte[] RemotePublicKey, bool BigEndian,
            HashFunctionArray HashFunction)
        {
            return ECDH.GetSharedKey(this.PrivateKey, RemotePublicKey, BigEndian,
                HashFunction, this);
        }
 
        public byte[] Sign(byte[] Data)
        {
            return this.Sign(Data, false);
        }
 
        public abstract byte[] Sign(byte[] Data, bool BigEndian);
 
        public byte[] Sign(Stream Data)
        {
            return this.Sign(Data, false);
        }
 
        public abstract byte[] Sign(Stream Data, bool BigEndian);
 
        public bool Verify(byte[] Data, byte[] PublicKey, byte[] Signature)
        {
            return this.Verify(Data, PublicKey, false, Signature);
        }
 
        public abstract bool Verify(byte[] Data, byte[] PublicKey, bool BigEndian,
            byte[] Signature);
 
        public bool Verify(Stream Data, byte[] PublicKey, byte[] Signature)
        {
            return this.Verify(Data, PublicKey, false, Signature);
        }
 
        public abstract bool Verify(Stream Data, byte[] PublicKey, bool BigEndian, byte[] Signature);
 
        public virtual void Export(XmlWriter Output)
        {
            if (this.secret is null)
                this.Init();
 
            Output.WriteStartElement(ElementName, Namespace);
            Output.WriteAttributeString("type", this.GetType().FullName);
            Output.WriteAttributeString("d", Convert.ToBase64String(this.secret));
            Output.WriteEndElement();
        }
 
        public string Export()
        {
            XmlWriterSettings Settings = new XmlWriterSettings()
            {
                Indent = false,
                OmitXmlDeclaration = true
            };
            StringBuilder sb = new StringBuilder();
            using (XmlWriter w = XmlWriter.Create(sb, Settings))
            {
                this.Export(w);
                w.Flush();
            }
 
            return sb.ToString();
        }
 
        public static BigInteger ToInt(byte[] Binary, bool BigEndian)
        {
            if (BigEndian)
            {
                Binary = (byte[])Binary.Clone();
                Array.Reverse(Binary);
            }
 
            return ToInt(Binary);
        }
 
        public static BigInteger ToInt(byte[] Binary)
        {
            int c = Binary.Length;
            if ((Binary[c - 1] & 0x80) != 0)
                Array.Resize(ref Binary, c + 1);
 
            return new BigInteger(Binary);
        }
 
        public virtual bool IsPoint(byte[] Point)
        {
            return this.IsPoint(Point, false);
        }
 
        public virtual bool IsPoint(byte[] Point, bool BigEndian)
        {
            return this.IsPoint(this.Decode(Point, BigEndian));
        }
 
        public abstract bool IsPoint(PointOnCurve Point);
    }
}