Class BigIntegers

java.lang.Object
org.bouncycastle.util.BigIntegers
public final class BigIntegers extends Object
BigInteger utilities.

  • Field Details

  • Constructor Details

    • BigIntegers

      public BigIntegers()

  • Method Details

    • asUnsignedByteArray

      public static byte[] asUnsignedByteArray(BigInteger value)
      Return the passed in value as an unsigned byte array.
      Parameters:
      value - the value to be converted.
      Returns:
      a byte array without a leading zero byte if present in the signed encoding.

    • asUnsignedByteArray

      public static byte[] asUnsignedByteArray(int length, BigInteger value)
      Return the passed in value as an unsigned byte array of the specified length, padded with leading zeros as necessary..
      Parameters:
      length - the fixed length of the result
      value - the value to be converted.
      Returns:
      a byte array padded to a fixed length with leading zeros.

    • asUnsignedByteArray

      public static void asUnsignedByteArray(BigInteger value, byte[] buf, int off, int len)
      Write the passed in value as unsigned bytes to the specified buffer range, padded with leading zeros as necessary.
      Parameters:
      value - the value to be converted.
      buf - the buffer to which the value is written.
      off - the start offset in array buf at which the data is written.
      len - the fixed length of data written (possibly padded with leading zeros).

    • createRandomInRange

      public static BigInteger createRandomInRange(BigInteger min, BigInteger max, SecureRandom random)
      Return a random BigInteger not less than 'min' and not greater than 'max'
      Parameters:
      min - the least value that may be generated
      max - the greatest value that may be generated
      random - the source of randomness
      Returns:
      a random BigInteger value in the range [min,max]

    • fromUnsignedByteArray

      public static BigInteger fromUnsignedByteArray(byte[] buf)

    • fromUnsignedByteArray

      public static BigInteger fromUnsignedByteArray(byte[] buf, int off, int length)

    • byteValueExact

      public static byte byteValueExact(BigInteger x)

    • shortValueExact

      public static short shortValueExact(BigInteger x)

    • intValueExact

      public static int intValueExact(BigInteger x)

    • longValueExact

      public static long longValueExact(BigInteger x)

    • areSecretValuesEqual

      public static boolean areSecretValuesEqual(int maxLen, BigInteger a, BigInteger b)
      Compare two non-negative values for equality without an early exit. Both are laid out as unsigned big-endian byte arrays of the fixed public length maxLen before the comparison, so the comparison itself is length-uniform.

      Fixed-width encoding drops the two's-complement sign byte that BigInteger.toByteArray() prepends when the most-significant bit is set: without that, two values could serialise to different lengths (e.g. 256 vs 257 bytes for a 2048-bit value) purely according to that high bit, and the variable-time comparison would leak it. This is not perfectly constant-time — java.math.BigInteger has no constant-time serialisation, so the underlying toByteArray() still runs in time proportional to each value's magnitude — but the comparison no longer differs in length on the value's high bit. Intended for secret key material (RSA d and the CRT factors, DSA/DH/ElGamal/GOST x, EC d), which are all non-negative; the temporary unsigned encodings holding that secret material are zeroed before returning.

      Both arguments must be non-null and non-negative; a negative value does not produce a meaningful result (and may throw IllegalArgumentException), and a null value throws NullPointerException.

      Parameters:
      maxLen - the public unsigned byte length both values are encoded to (e.g. from a group order or modulus).
      a - the first value, non-null and non-negative.
      b - the second value, non-null and non-negative.
      Returns:
      true if a and b are numerically equal, false otherwise.

    • hasAnySmallFactors

      public static boolean hasAnySmallFactors(BigInteger x)

    • modOddInverse

      public static BigInteger modOddInverse(BigInteger M, BigInteger X)

    • modOddInverseVar

      public static BigInteger modOddInverseVar(BigInteger M, BigInteger X)

    • modOddIsCoprime

      public static boolean modOddIsCoprime(BigInteger M, BigInteger X)

    • modOddIsCoprimeVar

      public static boolean modOddIsCoprimeVar(BigInteger M, BigInteger X)

    • getUnsignedByteLength

      public static int getUnsignedByteLength(BigInteger n)

    • createRandomBigInteger

      public static BigInteger createRandomBigInteger(int bitLength, SecureRandom random)
      Return a positive BigInteger in the range of 0 to 2**bitLength - 1.
      Parameters:
      bitLength - maximum bit length for the generated BigInteger.
      random - a source of randomness.
      Returns:
      a positive BigInteger

    • createRandomPrime

      public static BigInteger createRandomPrime(int bitLength, int certainty, SecureRandom random)
      Return a prime number candidate of the specified bit length.
      Parameters:
      bitLength - bit length for the generated BigInteger.
      random - a source of randomness.
      Returns:
      a positive BigInteger of numBits length

    • writeUnsignedByteArray

      public static void writeUnsignedByteArray(OutputStream out, BigInteger n) throws IOException
      Throws:
      IOException