/**
* D.3.2 pg 101
* @see org.bouncycastle.math.ec.multiplier.ECMultiplier#multiply(org.bouncycastle.math.ec.ECPoint, java.math.BigInteger)
*/
public ECPoint Multiply(ECPoint p, BigInteger k, PreCompInfo preCompInfo)
{
// TODO Probably should try to add this
// BigInteger e = k.Mod(n); // n == order of p
BigInteger e = k;
BigInteger h = e.Multiply(BigInteger.Three);
ECPoint neg = p.Negate();
ECPoint R = p;
for (int i = h.BitLength - 2; i > 0; --i)
{
R = R.Twice();
bool hBit = h.TestBit(i);
bool eBit = e.TestBit(i);
if (hBit != eBit)
{
R = R.Add(hBit ? p : neg);
}
}
return R;
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECCurve curve = p.Curve;
ECCurve eCCurve = this.ConfigureCurve(curve, this.additionCoord);
ECCurve eCCurve2 = this.ConfigureCurve(curve, this.doublingCoord);
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = eCCurve.Infinity;
ECPoint eCPoint2 = eCCurve2.ImportPoint(p);
int num = 0;
for (int i = 0; i < array.Length; i++)
{
int num2 = array[i];
int num3 = num2 >> 16;
num += (num2 & 65535);
eCPoint2 = eCPoint2.TimesPow2(num);
ECPoint eCPoint3 = eCCurve.ImportPoint(eCPoint2);
if (num3 < 0)
{
eCPoint3 = eCPoint3.Negate();
}
eCPoint = eCPoint.Add(eCPoint3);
num = 1;
}
return(curve.ImportPoint(eCPoint));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECCurve curve = p.Curve;
ECCurve eCCurve = ConfigureCurve(curve, additionCoord);
ECCurve eCCurve2 = ConfigureCurve(curve, doublingCoord);
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = eCCurve.Infinity;
ECPoint eCPoint2 = eCCurve2.ImportPoint(p);
int num = 0;
foreach (int num2 in array)
{
int num3 = num2 >> 16;
num += (num2 & 0xFFFF);
eCPoint2 = eCPoint2.TimesPow2(num);
ECPoint eCPoint3 = eCCurve.ImportPoint(eCPoint2);
if (num3 < 0)
{
eCPoint3 = eCPoint3.Negate();
}
eCPoint = eCPoint.Add(eCPoint3);
num = 1;
}
return(curve.ImportPoint(eCPoint));
}
/**
* D.3.2 pg 101
* @see org.bouncycastle.math.ec.multiplier.ECMultiplier#multiply(org.bouncycastle.math.ec.ECPoint, java.math.BigInteger)
*/
public ECPoint Multiply(ECPoint p, BigInteger k, PreCompInfo preCompInfo)
{
// TODO Probably should try to add this
// BigInteger e = k.Mod(n); // n == order of p
BigInteger e = k;
BigInteger h = e.Multiply(BigInteger.Three);
ECPoint neg = p.Negate();
ECPoint R = p;
for (int i = h.BitLength - 2; i > 0; --i)
{
R = R.Twice();
bool hBit = h.TestBit(i);
bool eBit = e.TestBit(i);
if (hBit != eBit)
{
R = R.Add(hBit ? p : neg);
}
}
return(R);
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECCurve curveOrig = p.Curve;
ECCurve curveAdd = ConfigureCurve(curveOrig, additionCoord);
ECCurve curveDouble = ConfigureCurve(curveOrig, doublingCoord);
int[] naf = WNafUtilities.GenerateCompactNaf(k);
ECPoint Ra = curveAdd.Infinity;
ECPoint Td = curveDouble.ImportPoint(p);
int zeroes = 0;
for (int i = 0; i < naf.Length; ++i)
{
int ni = naf[i];
int digit = ni >> 16;
zeroes += ni & 0xFFFF;
Td = Td.TimesPow2(zeroes);
ECPoint Tj = curveAdd.ImportPoint(Td);
if (digit < 0)
{
Tj = Tj.Negate();
}
Ra = Ra.Add(Tj);
zeroes = 1;
}
return(curveOrig.ImportPoint(Ra));
}
public override ECPoint Subtract(ECPoint b)
{
if (b.IsInfinity)
{
return(this);
}
return(Add(b.Negate()));
}
/**
* Tests <code>ECPoint.add()</code> and <code>ECPoint.subtract()</code>
* for the given point and the given point at infinity.
*
* @param p
* The point on which the tests are performed.
* @param infinity
* The point at infinity on the same curve as <code>p</code>.
*/
private void ImplTestAddSubtract(ECPoint p, ECPoint infinity)
{
AssertPointsEqual("Twice and Add inconsistent", p.Twice(), p.Add(p));
AssertPointsEqual("Twice p - p is not p", p, p.Twice().Subtract(p));
AssertPointsEqual("TwicePlus(p, -p) is not p", p, p.TwicePlus(p.Negate()));
AssertPointsEqual("p - p is not infinity", infinity, p.Subtract(p));
AssertPointsEqual("p plus infinity is not p", p, p.Add(infinity));
AssertPointsEqual("infinity plus p is not p", p, infinity.Add(p));
AssertPointsEqual("infinity plus infinity is not infinity ", infinity, infinity.Add(infinity));
AssertPointsEqual("Twice infinity is not infinity ", infinity, infinity.Twice());
}
public virtual ECPoint Multiply(ECPoint p, BigInteger k)
{
int sign = k.SignValue;
if (sign == 0 || p.IsInfinity)
{
return(p.Curve.Infinity);
}
ECPoint positive = MultiplyPositive(p, k.Abs());
return(sign > 0 ? positive : positive.Negate());
}
public virtual ECPoint Multiply(ECPoint p, BigInteger k)
{
int signValue = k.SignValue;
if (signValue == 0 || p.IsInfinity)
{
return(p.Curve.Infinity);
}
ECPoint eCPoint = MultiplyPositive(p, k.Abs());
ECPoint p2 = (signValue <= 0) ? eCPoint.Negate() : eCPoint;
return(ECAlgorithms.ValidatePoint(p2));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECPoint eCPoint = p.Curve.Infinity;
int bitLength = k.BitLength;
int lowestSetBit = k.GetLowestSetBit();
ECPoint eCPoint2 = p.TimesPow2(lowestSetBit);
int num = lowestSetBit;
while (++num < bitLength)
{
eCPoint = eCPoint.Add(k.TestBit(num) ? eCPoint2 : eCPoint2.Negate());
eCPoint2 = eCPoint2.Twice();
}
return(eCPoint.Add(eCPoint2));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECPoint eCPoint = p.Normalize();
ECPoint eCPoint2 = eCPoint.Negate();
ECPoint eCPoint3 = eCPoint;
int bitLength = k.BitLength;
int lowestSetBit = k.GetLowestSetBit();
int num = bitLength;
while (--num > lowestSetBit)
{
eCPoint3 = eCPoint3.TwicePlus(k.TestBit(num) ? eCPoint : eCPoint2);
}
return(eCPoint3.TimesPow2(lowestSetBit));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = p.Curve.Infinity;
ECPoint eCPoint2 = p;
int num = 0;
foreach (int num2 in array)
{
int num3 = num2 >> 16;
num += (num2 & 0xFFFF);
eCPoint2 = eCPoint2.TimesPow2(num);
eCPoint = eCPoint.Add((num3 < 0) ? eCPoint2.Negate() : eCPoint2);
num = 1;
}
return(eCPoint);
}
public virtual ECPoint Multiply(ECPoint p, BigInteger k)
{
int sign = k.SignValue;
if (sign == 0 || p.IsInfinity)
{
return(p.Curve.Infinity);
}
ECPoint positive = MultiplyPositive(p, k.Abs());
ECPoint result = sign > 0 ? positive : positive.Negate();
/*
* Although the various multipliers ought not to produce invalid output under normal
* circumstances, a final check here is advised to guard against fault attacks.
*/
return(ECAlgorithms.ValidatePoint(result));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = p.Normalize();
ECPoint eCPoint2 = eCPoint.Negate();
ECPoint eCPoint3 = p.Curve.Infinity;
int num = array.Length;
while (--num >= 0)
{
int num2 = array[num];
int num3 = num2 >> 16;
int e = num2 & 65535;
eCPoint3 = eCPoint3.TwicePlus((num3 < 0) ? eCPoint2 : eCPoint);
eCPoint3 = eCPoint3.TimesPow2(e);
}
return(eCPoint3);
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = p.Curve.Infinity;
ECPoint eCPoint2 = p;
int num = 0;
for (int i = 0; i < array.Length; i++)
{
int num2 = array[i];
int num3 = num2 >> 16;
num += (num2 & 65535);
eCPoint2 = eCPoint2.TimesPow2(num);
eCPoint = eCPoint.Add((num3 < 0) ? eCPoint2.Negate() : eCPoint2);
num = 1;
}
return(eCPoint);
}
/**
* 'Zeroless' Signed Digit Left-to-Right.
*/
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECPoint addP = p.Normalize(), subP = addP.Negate();
ECPoint R0 = addP;
int n = k.BitLength;
int s = k.GetLowestSetBit();
int i = n;
while (--i > s)
{
R0 = R0.TwicePlus(k.TestBit(i) ? addP : subP);
}
R0 = R0.TimesPow2(s);
return(R0);
}
/**
* 'Zeroless' Signed Digit Right-to-Left.
*/
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECPoint R0 = p.Curve.Infinity, R1 = p;
int n = k.BitLength;
int s = k.GetLowestSetBit();
R1 = R1.TimesPow2(s);
int i = s;
while (++i < n)
{
R0 = R0.Add(k.TestBit(i) ? R1 : R1.Negate());
R1 = R1.Twice();
}
R0 = R0.Add(R1);
return R0;
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] naf = WNafUtilities.GenerateCompactNaf(k);
ECPoint addP = p.Normalize(), subP = addP.Negate();
ECPoint R = p.Curve.Infinity;
int i = naf.Length;
while (--i >= 0)
{
int ni = naf[i];
int digit = ni >> 16, zeroes = ni & 0xFFFF;
R = R.TwicePlus(digit < 0 ? subP : addP);
R = R.TimesPow2(zeroes);
}
return(R);
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] naf = WNafUtilities.GenerateCompactNaf(k);
ECPoint R0 = p.Curve.Infinity, R1 = p;
int zeroes = 0;
for (int i = 0; i < naf.Length; ++i)
{
int ni = naf[i];
int digit = ni >> 16;
zeroes += ni & 0xFFFF;
R1 = R1.TimesPow2(zeroes);
R0 = R0.Add(digit < 0 ? R1.Negate() : R1);
zeroes = 1;
}
return(R0);
}
public override ECPoint Subtract(ECPoint b)
{
if (b.IsInfinity)
return this;
return Add(b.Negate());
}
