Class ECAlgorithms

java.lang.Object
org.bouncycastle.math.ec.ECAlgorithms
public class ECAlgorithms extends Object

  • Constructor Details

    • ECAlgorithms

      public ECAlgorithms()

  • Method Details

    • isF2mCurve

      public static boolean isF2mCurve(ECCurve c)

    • isF2mField

      public static boolean isF2mField(FiniteField field)

    • isFpCurve

      public static boolean isFpCurve(ECCurve c)

    • isFpField

      public static boolean isFpField(FiniteField field)

    • sumOfMultiplies

      public static ECPoint sumOfMultiplies(ECPoint[] ps, BigInteger[] ks)

    • sumOfTwoMultiplies

      public static ECPoint sumOfTwoMultiplies(ECPoint P, BigInteger a, ECPoint Q, BigInteger b)

    • shamirsTrick

      public static ECPoint shamirsTrick(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)

    • importPoint

      public static ECPoint importPoint(ECCurve c, ECPoint p)

    • montgomeryTrick

      public static void montgomeryTrick(ECFieldElement[] zs, int off, int len)

    • montgomeryTrick

      public static void montgomeryTrick(ECFieldElement[] zs, int off, int len, ECFieldElement scale)

    • referenceMultiply

      public static ECPoint referenceMultiply(ECPoint p, BigInteger k)
      Simple shift-and-add multiplication. Serves as reference implementation to verify (possibly faster) implementations, and for very small scalars. CAUTION: This implementation is NOT constant-time in any way. It is only intended to be used for diagnostics.
      Parameters:
      p - The point to multiply.
      k - The multiplier.
      Returns:
      The result of the point multiplication kP.

    • multiplySecret

      public static ECPoint multiplySecret(ECPoint p, BigInteger k)
      Multiply a point by a scalar that must not be leaked - a private key, or any value derived from one - without exposing the scalar through control flow or memory-access pattern.

      ECPoint.multiply(BigInteger) uses the curve's configured multiplier, which for most curves is a windowed-NAF implementation whose timing depends on the scalar; it is the right choice for a public scalar (verification, for instance) but not for a secret one. Use this method wherever the scalar is secret and the point is supplied by a peer.

      The result is the same point ECPoint.multiply(BigInteger) would return; only the timing profile differs. See ECConstantTimeMultiplier for what is and is not covered.

      Parameters:
      p - the point to multiply, typically a peer's public key; must lie in the subgroup whose order is the curve's.
      k - the secret scalar; must be less than the curve order.
      Returns:
      kP.

    • multiplySecret

      public static ECPoint multiplySecret(ECPoint p, BigInteger k, BigInteger order)
      As multiplySecret(ECPoint, BigInteger), with the group order supplied rather than taken from the curve. Prefer this form wherever the order is to hand - domain parameters always carry it, whereas ECCurve.getOrder() is null for a curve built without one.
      Parameters:
      p - the point to multiply, typically a peer's public key; must lie in the subgroup of order order.
      k - the secret scalar; must be less than order.
      order - the group order; must be odd, as every standard EC group order is.
      Returns:
      kP.

    • validatePoint

      public static ECPoint validatePoint(ECPoint p)

    • cleanPoint

      public static ECPoint cleanPoint(ECCurve c, ECPoint p)