418 lines
11 KiB
C#
418 lines
11 KiB
C#
using System;
|
|
using Org.BouncyCastle.Math.Raw;
|
|
using Org.BouncyCastle.Utilities;
|
|
|
|
namespace Org.BouncyCastle.Math.EC;
|
|
|
|
public class FpFieldElement : AbstractFpFieldElement
|
|
{
|
|
private readonly BigInteger q;
|
|
|
|
private readonly BigInteger r;
|
|
|
|
private readonly BigInteger x;
|
|
|
|
public override string FieldName => "Fp";
|
|
|
|
public override int FieldSize => q.BitLength;
|
|
|
|
public BigInteger Q => q;
|
|
|
|
internal static BigInteger CalculateResidue(BigInteger p)
|
|
{
|
|
int bitLength = p.BitLength;
|
|
if (bitLength >= 96)
|
|
{
|
|
BigInteger bigInteger = p.ShiftRight(bitLength - 64);
|
|
if (bigInteger.LongValue == -1)
|
|
{
|
|
return BigInteger.One.ShiftLeft(bitLength).Subtract(p);
|
|
}
|
|
if ((bitLength & 7) == 0)
|
|
{
|
|
return BigInteger.One.ShiftLeft(bitLength << 1).Divide(p).Negate();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
[Obsolete("Use ECCurve.FromBigInteger to construct field elements")]
|
|
public FpFieldElement(BigInteger q, BigInteger x)
|
|
: this(q, CalculateResidue(q), x)
|
|
{
|
|
}
|
|
|
|
internal FpFieldElement(BigInteger q, BigInteger r, BigInteger x)
|
|
{
|
|
if (x == null || x.SignValue < 0 || x.CompareTo(q) >= 0)
|
|
{
|
|
throw new ArgumentException("value invalid in Fp field element", "x");
|
|
}
|
|
this.q = q;
|
|
this.r = r;
|
|
this.x = x;
|
|
}
|
|
|
|
public override BigInteger ToBigInteger()
|
|
{
|
|
return x;
|
|
}
|
|
|
|
public override ECFieldElement Add(ECFieldElement b)
|
|
{
|
|
return new FpFieldElement(q, r, ModAdd(x, b.ToBigInteger()));
|
|
}
|
|
|
|
public override ECFieldElement AddOne()
|
|
{
|
|
BigInteger bigInteger = x.Add(BigInteger.One);
|
|
if (bigInteger.CompareTo(q) == 0)
|
|
{
|
|
bigInteger = BigInteger.Zero;
|
|
}
|
|
return new FpFieldElement(q, r, bigInteger);
|
|
}
|
|
|
|
public override ECFieldElement Subtract(ECFieldElement b)
|
|
{
|
|
return new FpFieldElement(q, r, ModSubtract(x, b.ToBigInteger()));
|
|
}
|
|
|
|
public override ECFieldElement Multiply(ECFieldElement b)
|
|
{
|
|
return new FpFieldElement(q, r, ModMult(x, b.ToBigInteger()));
|
|
}
|
|
|
|
public override ECFieldElement MultiplyMinusProduct(ECFieldElement b, ECFieldElement x, ECFieldElement y)
|
|
{
|
|
BigInteger bigInteger = this.x;
|
|
BigInteger val = b.ToBigInteger();
|
|
BigInteger bigInteger2 = x.ToBigInteger();
|
|
BigInteger val2 = y.ToBigInteger();
|
|
BigInteger bigInteger3 = bigInteger.Multiply(val);
|
|
BigInteger n = bigInteger2.Multiply(val2);
|
|
return new FpFieldElement(q, r, ModReduce(bigInteger3.Subtract(n)));
|
|
}
|
|
|
|
public override ECFieldElement MultiplyPlusProduct(ECFieldElement b, ECFieldElement x, ECFieldElement y)
|
|
{
|
|
BigInteger bigInteger = this.x;
|
|
BigInteger val = b.ToBigInteger();
|
|
BigInteger bigInteger2 = x.ToBigInteger();
|
|
BigInteger val2 = y.ToBigInteger();
|
|
BigInteger bigInteger3 = bigInteger.Multiply(val);
|
|
BigInteger value = bigInteger2.Multiply(val2);
|
|
BigInteger bigInteger4 = bigInteger3.Add(value);
|
|
if (r != null && r.SignValue < 0 && bigInteger4.BitLength > q.BitLength << 1)
|
|
{
|
|
bigInteger4 = bigInteger4.Subtract(q.ShiftLeft(q.BitLength));
|
|
}
|
|
return new FpFieldElement(q, r, ModReduce(bigInteger4));
|
|
}
|
|
|
|
public override ECFieldElement Divide(ECFieldElement b)
|
|
{
|
|
return new FpFieldElement(q, r, ModMult(x, ModInverse(b.ToBigInteger())));
|
|
}
|
|
|
|
public override ECFieldElement Negate()
|
|
{
|
|
if (x.SignValue != 0)
|
|
{
|
|
return new FpFieldElement(q, r, q.Subtract(x));
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public override ECFieldElement Square()
|
|
{
|
|
return new FpFieldElement(q, r, ModMult(x, x));
|
|
}
|
|
|
|
public override ECFieldElement SquareMinusProduct(ECFieldElement x, ECFieldElement y)
|
|
{
|
|
BigInteger bigInteger = this.x;
|
|
BigInteger bigInteger2 = x.ToBigInteger();
|
|
BigInteger val = y.ToBigInteger();
|
|
BigInteger bigInteger3 = bigInteger.Multiply(bigInteger);
|
|
BigInteger n = bigInteger2.Multiply(val);
|
|
return new FpFieldElement(q, r, ModReduce(bigInteger3.Subtract(n)));
|
|
}
|
|
|
|
public override ECFieldElement SquarePlusProduct(ECFieldElement x, ECFieldElement y)
|
|
{
|
|
BigInteger bigInteger = this.x;
|
|
BigInteger bigInteger2 = x.ToBigInteger();
|
|
BigInteger val = y.ToBigInteger();
|
|
BigInteger bigInteger3 = bigInteger.Multiply(bigInteger);
|
|
BigInteger value = bigInteger2.Multiply(val);
|
|
BigInteger bigInteger4 = bigInteger3.Add(value);
|
|
if (r != null && r.SignValue < 0 && bigInteger4.BitLength > q.BitLength << 1)
|
|
{
|
|
bigInteger4 = bigInteger4.Subtract(q.ShiftLeft(q.BitLength));
|
|
}
|
|
return new FpFieldElement(q, r, ModReduce(bigInteger4));
|
|
}
|
|
|
|
public override ECFieldElement Invert()
|
|
{
|
|
return new FpFieldElement(q, r, ModInverse(x));
|
|
}
|
|
|
|
public override ECFieldElement Sqrt()
|
|
{
|
|
if (IsZero || IsOne)
|
|
{
|
|
return this;
|
|
}
|
|
if (!q.TestBit(0))
|
|
{
|
|
throw Platform.CreateNotImplementedException("even value of q");
|
|
}
|
|
if (q.TestBit(1))
|
|
{
|
|
BigInteger e = q.ShiftRight(2).Add(BigInteger.One);
|
|
return CheckSqrt(new FpFieldElement(q, r, this.x.ModPow(e, q)));
|
|
}
|
|
if (q.TestBit(2))
|
|
{
|
|
BigInteger bigInteger = this.x.ModPow(q.ShiftRight(3), q);
|
|
BigInteger x = ModMult(bigInteger, this.x);
|
|
BigInteger bigInteger2 = ModMult(x, bigInteger);
|
|
if (bigInteger2.Equals(BigInteger.One))
|
|
{
|
|
return CheckSqrt(new FpFieldElement(q, r, x));
|
|
}
|
|
BigInteger x2 = BigInteger.Two.ModPow(q.ShiftRight(2), q);
|
|
BigInteger bigInteger3 = ModMult(x, x2);
|
|
return CheckSqrt(new FpFieldElement(q, r, bigInteger3));
|
|
}
|
|
BigInteger bigInteger4 = q.ShiftRight(1);
|
|
if (!this.x.ModPow(bigInteger4, q).Equals(BigInteger.One))
|
|
{
|
|
return null;
|
|
}
|
|
BigInteger bigInteger5 = this.x;
|
|
BigInteger bigInteger6 = ModDouble(ModDouble(bigInteger5));
|
|
BigInteger k = bigInteger4.Add(BigInteger.One);
|
|
BigInteger obj = q.Subtract(BigInteger.One);
|
|
while (true)
|
|
{
|
|
BigInteger bigInteger7 = BigInteger.Arbitrary(q.BitLength);
|
|
if (bigInteger7.CompareTo(q) < 0 && ModReduce(bigInteger7.Multiply(bigInteger7).Subtract(bigInteger6)).ModPow(bigInteger4, q).Equals(obj))
|
|
{
|
|
BigInteger[] array = LucasSequence(bigInteger7, bigInteger5, k);
|
|
BigInteger bigInteger8 = array[0];
|
|
BigInteger bigInteger9 = array[1];
|
|
if (ModMult(bigInteger9, bigInteger9).Equals(bigInteger6))
|
|
{
|
|
return new FpFieldElement(q, r, ModHalfAbs(bigInteger9));
|
|
}
|
|
if (!bigInteger8.Equals(BigInteger.One) && !bigInteger8.Equals(obj))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private ECFieldElement CheckSqrt(ECFieldElement z)
|
|
{
|
|
if (!z.Square().Equals(this))
|
|
{
|
|
return null;
|
|
}
|
|
return z;
|
|
}
|
|
|
|
private BigInteger[] LucasSequence(BigInteger P, BigInteger Q, BigInteger k)
|
|
{
|
|
int bitLength = k.BitLength;
|
|
int lowestSetBit = k.GetLowestSetBit();
|
|
BigInteger bigInteger = BigInteger.One;
|
|
BigInteger bigInteger2 = BigInteger.Two;
|
|
BigInteger bigInteger3 = P;
|
|
BigInteger bigInteger4 = BigInteger.One;
|
|
BigInteger bigInteger5 = BigInteger.One;
|
|
for (int num = bitLength - 1; num >= lowestSetBit + 1; num--)
|
|
{
|
|
bigInteger4 = ModMult(bigInteger4, bigInteger5);
|
|
if (k.TestBit(num))
|
|
{
|
|
bigInteger5 = ModMult(bigInteger4, Q);
|
|
bigInteger = ModMult(bigInteger, bigInteger3);
|
|
bigInteger2 = ModReduce(bigInteger3.Multiply(bigInteger2).Subtract(P.Multiply(bigInteger4)));
|
|
bigInteger3 = ModReduce(bigInteger3.Multiply(bigInteger3).Subtract(bigInteger5.ShiftLeft(1)));
|
|
}
|
|
else
|
|
{
|
|
bigInteger5 = bigInteger4;
|
|
bigInteger = ModReduce(bigInteger.Multiply(bigInteger2).Subtract(bigInteger4));
|
|
bigInteger3 = ModReduce(bigInteger3.Multiply(bigInteger2).Subtract(P.Multiply(bigInteger4)));
|
|
bigInteger2 = ModReduce(bigInteger2.Multiply(bigInteger2).Subtract(bigInteger4.ShiftLeft(1)));
|
|
}
|
|
}
|
|
bigInteger4 = ModMult(bigInteger4, bigInteger5);
|
|
bigInteger5 = ModMult(bigInteger4, Q);
|
|
bigInteger = ModReduce(bigInteger.Multiply(bigInteger2).Subtract(bigInteger4));
|
|
bigInteger2 = ModReduce(bigInteger3.Multiply(bigInteger2).Subtract(P.Multiply(bigInteger4)));
|
|
bigInteger4 = ModMult(bigInteger4, bigInteger5);
|
|
for (int i = 1; i <= lowestSetBit; i++)
|
|
{
|
|
bigInteger = ModMult(bigInteger, bigInteger2);
|
|
bigInteger2 = ModReduce(bigInteger2.Multiply(bigInteger2).Subtract(bigInteger4.ShiftLeft(1)));
|
|
bigInteger4 = ModMult(bigInteger4, bigInteger4);
|
|
}
|
|
return new BigInteger[2] { bigInteger, bigInteger2 };
|
|
}
|
|
|
|
protected virtual BigInteger ModAdd(BigInteger x1, BigInteger x2)
|
|
{
|
|
BigInteger bigInteger = x1.Add(x2);
|
|
if (bigInteger.CompareTo(q) >= 0)
|
|
{
|
|
bigInteger = bigInteger.Subtract(q);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
protected virtual BigInteger ModDouble(BigInteger x)
|
|
{
|
|
BigInteger bigInteger = x.ShiftLeft(1);
|
|
if (bigInteger.CompareTo(q) >= 0)
|
|
{
|
|
bigInteger = bigInteger.Subtract(q);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
protected virtual BigInteger ModHalf(BigInteger x)
|
|
{
|
|
if (x.TestBit(0))
|
|
{
|
|
x = q.Add(x);
|
|
}
|
|
return x.ShiftRight(1);
|
|
}
|
|
|
|
protected virtual BigInteger ModHalfAbs(BigInteger x)
|
|
{
|
|
if (x.TestBit(0))
|
|
{
|
|
x = q.Subtract(x);
|
|
}
|
|
return x.ShiftRight(1);
|
|
}
|
|
|
|
protected virtual BigInteger ModInverse(BigInteger x)
|
|
{
|
|
int fieldSize = FieldSize;
|
|
int len = fieldSize + 31 >> 5;
|
|
uint[] p = Nat.FromBigInteger(fieldSize, q);
|
|
uint[] array = Nat.FromBigInteger(fieldSize, x);
|
|
uint[] z = Nat.Create(len);
|
|
Mod.Invert(p, array, z);
|
|
return Nat.ToBigInteger(len, z);
|
|
}
|
|
|
|
protected virtual BigInteger ModMult(BigInteger x1, BigInteger x2)
|
|
{
|
|
return ModReduce(x1.Multiply(x2));
|
|
}
|
|
|
|
protected virtual BigInteger ModReduce(BigInteger x)
|
|
{
|
|
if (r == null)
|
|
{
|
|
x = x.Mod(q);
|
|
}
|
|
else
|
|
{
|
|
bool flag = x.SignValue < 0;
|
|
if (flag)
|
|
{
|
|
x = x.Abs();
|
|
}
|
|
int bitLength = q.BitLength;
|
|
if (r.SignValue > 0)
|
|
{
|
|
BigInteger n = BigInteger.One.ShiftLeft(bitLength);
|
|
bool flag2 = r.Equals(BigInteger.One);
|
|
while (x.BitLength > bitLength + 1)
|
|
{
|
|
BigInteger bigInteger = x.ShiftRight(bitLength);
|
|
BigInteger value = x.Remainder(n);
|
|
if (!flag2)
|
|
{
|
|
bigInteger = bigInteger.Multiply(r);
|
|
}
|
|
x = bigInteger.Add(value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num = ((bitLength - 1) & 0x1F) + 1;
|
|
BigInteger bigInteger2 = r.Negate();
|
|
BigInteger bigInteger3 = bigInteger2.Multiply(x.ShiftRight(bitLength - num));
|
|
BigInteger bigInteger4 = bigInteger3.ShiftRight(bitLength + num);
|
|
BigInteger bigInteger5 = bigInteger4.Multiply(q);
|
|
BigInteger bigInteger6 = BigInteger.One.ShiftLeft(bitLength + num);
|
|
bigInteger5 = bigInteger5.Remainder(bigInteger6);
|
|
x = x.Remainder(bigInteger6);
|
|
x = x.Subtract(bigInteger5);
|
|
if (x.SignValue < 0)
|
|
{
|
|
x = x.Add(bigInteger6);
|
|
}
|
|
}
|
|
while (x.CompareTo(q) >= 0)
|
|
{
|
|
x = x.Subtract(q);
|
|
}
|
|
if (flag && x.SignValue != 0)
|
|
{
|
|
x = q.Subtract(x);
|
|
}
|
|
}
|
|
return x;
|
|
}
|
|
|
|
protected virtual BigInteger ModSubtract(BigInteger x1, BigInteger x2)
|
|
{
|
|
BigInteger bigInteger = x1.Subtract(x2);
|
|
if (bigInteger.SignValue < 0)
|
|
{
|
|
bigInteger = bigInteger.Add(q);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj == this)
|
|
{
|
|
return true;
|
|
}
|
|
if (!(obj is FpFieldElement other))
|
|
{
|
|
return false;
|
|
}
|
|
return Equals(other);
|
|
}
|
|
|
|
public virtual bool Equals(FpFieldElement other)
|
|
{
|
|
if (q.Equals(other.q))
|
|
{
|
|
return base.Equals(other);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return q.GetHashCode() ^ base.GetHashCode();
|
|
}
|
|
}
|