/** * 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()); }