Edwards448.cs

using System;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;
using Waher.Runtime.Temporary;
using Waher.Security.SHA3;
 
namespace Waher.Security.EllipticCurves
{
    public class Edwards448 : EdwardsCurve
    {
        private static readonly BigInteger p0 = BigInteger.Pow(2, 448) - BigInteger.Pow(2, 224) - 1;
        private static readonly BigInteger d0 = p0 - 39081;
        private static readonly BigInteger n0 = BigInteger.Pow(2, 446) - BigInteger.Parse("008335dc163bb124b65129c96fde933d8d723a70aadc873d6d54a7bb0d", NumberStyles.HexNumber);
        private static readonly BigInteger BasePointX = BigInteger.Parse("224580040295924300187604334099896036246789641632564134246125461686950415467406032909029192869357953282578032075146446173674602635247710");
        private static readonly BigInteger BasePointY = BigInteger.Parse("298819210078481492676017930443930673437544040154080242095928241372331506189835876003536878655418784733982303233503462500531545062832660");
        private readonly SHAKE256 shake256_114;
        private readonly bool hashSecret;
 
        public Edwards448()
            : this(null, true)
        {
        }
 
        public Edwards448(byte[] Secret)
            : this(Secret, true)
        {
        }
 
        public Edwards448(byte[] Secret, bool HashSecret)
            : base(p0, new PointOnCurve(BasePointX, BasePointY), d0, n0, 4, Secret)
        {
            this.shake256_114 = new SHAKE256(114 << 3);
            this.hashSecret = HashSecret;
        }
 
        public override string CurveName => "Edwards448";
 
        public override int CoordinateBits => 447;
 
        public override Tuple<byte[], byte[]> CalculatePrivateKey(byte[] Secret)
        {
            byte[] Bin = this.shake256_114.ComputeVariable(Secret);
            byte[] AdditionalInfo = new byte[57];
            byte[] PrivateKey = new byte[57];
 
            if (this.hashSecret)
                Buffer.BlockCopy(Bin, 0, PrivateKey, 0, 57);
            else
                Buffer.BlockCopy(Secret, 0, PrivateKey, 0, Math.Min(57, Secret.Length));
 
            Buffer.BlockCopy(Bin, 57, AdditionalInfo, 0, 57);
 
            PrivateKey[0] &= 0xfc;
            PrivateKey[55] |= 0x80;
            PrivateKey[56] = 0;
 
            return new Tuple<byte[], byte[]>(PrivateKey, AdditionalInfo);
        }
 
        public override byte[] Sign(byte[] Data, bool BigEndian)
        {
            return EdDSA.Sign(Data, BigEndian, this.PrivateKey, this.AdditionalInfo, this.H_dom4, this);
        }
 
 
        public override byte[] Sign(Stream Data, bool BigEndian)
        {
            return EdDSA.Sign(Data, BigEndian, this.PrivateKey, this.AdditionalInfo, this.H_dom4, this);
        }
 
        public override bool Verify(byte[] Data, byte[] PublicKey, bool BigEndian, byte[] Signature)
        {
            return EdDSA.Verify(Data, PublicKey, BigEndian, this.H_dom4, this, Signature);
        }
 
        public override bool Verify(Stream Data, byte[] PublicKey, bool BigEndian, byte[] Signature)
        {
            return EdDSA.Verify(Data, PublicKey, BigEndian, this.H_dom4, this, Signature);
        }
 
        private byte[] H_dom4(byte[] Data)
        {
            int c = Data.Length;
            byte[] Bin = new byte[10 + c];
 
            Buffer.BlockCopy(preamble, 0, Bin, 0, 8);
            Bin[8] = 0;                         // x=phflag=0
            Bin[9] = 0;                         // y=context=empty string
            Buffer.BlockCopy(Data, 0, Bin, 10, c);
 
            return this.shake256_114.ComputeVariable(Bin);
        }
 
        private byte[] H_dom4(Stream Data)
        {
            using (TemporaryStream TempFile = new TemporaryStream())
            {
                TempFile.Write(preamble, 0, 8);
                TempFile.WriteByte(0);              // x=phflag=0
                TempFile.WriteByte(0);              // y=context=empty string
 
                Data.Position = 0;
                Data.CopyTo(TempFile);
 
                TempFile.Position = 0;
                return this.shake256_114.ComputeVariable(TempFile);
            }
        }
 
        private static readonly byte[] preamble = Encoding.ASCII.GetBytes("SigEd448");
 
    }
}