org.bouncycastle.util
Class BigIntegers

java.lang.Object
  org.bouncycastle.util.BigIntegers

public final class BigIntegers

extends java.lang.Object

BigInteger utilities.

Nested Class Summary

static class

BigIntegers.Cache

Field Summary

static java.math.BigInteger	ONE
static java.math.BigInteger	TWO
static java.math.BigInteger	ZERO

Constructor Summary

BigIntegers()

Method Summary

static boolean	areSecretValuesEqual(int maxLen, java.math.BigInteger a, java.math.BigInteger b) Compare two non-negative values for equality without an early exit.
static byte[]	asUnsignedByteArray(java.math.BigInteger value) Return the passed in value as an unsigned byte array.
static void	asUnsignedByteArray(java.math.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.
static byte[]	asUnsignedByteArray(int length, java.math.BigInteger value) Return the passed in value as an unsigned byte array of the specified length, padded with leading zeros as necessary..
static byte	byteValueExact(java.math.BigInteger x)
static java.math.BigInteger	createRandomBigInteger(int bitLength, java.security.SecureRandom random) Return a positive BigInteger in the range of 0 to 2**bitLength - 1.
static java.math.BigInteger	createRandomInRange(java.math.BigInteger min, java.math.BigInteger max, java.security.SecureRandom random) Return a random BigInteger not less than 'min' and not greater than 'max'
static java.math.BigInteger	createRandomPrime(int bitLength, int certainty, java.security.SecureRandom random) Return a prime number candidate of the specified bit length.
static java.math.BigInteger	fromUnsignedByteArray(byte[] buf)
static java.math.BigInteger	fromUnsignedByteArray(byte[] buf, int off, int length)
static int	getUnsignedByteLength(java.math.BigInteger n)
static boolean	hasAnySmallFactors(java.math.BigInteger x)
static int	intValueExact(java.math.BigInteger x)
static long	longValueExact(java.math.BigInteger x)
static java.math.BigInteger	modOddInverse(java.math.BigInteger M, java.math.BigInteger X)
static java.math.BigInteger	modOddInverseVar(java.math.BigInteger M, java.math.BigInteger X)
static boolean	modOddIsCoprime(java.math.BigInteger M, java.math.BigInteger X)
static boolean	modOddIsCoprimeVar(java.math.BigInteger M, java.math.BigInteger X)
static short	shortValueExact(java.math.BigInteger x)
static void	writeUnsignedByteArray(java.io.OutputStream out, java.math.BigInteger n)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ZERO

public static final java.math.BigInteger ZERO

ONE

public static final java.math.BigInteger ONE

TWO

public static final java.math.BigInteger TWO

Constructor Detail

BigIntegers

public BigIntegers()

Method Detail

asUnsignedByteArray

public static byte[] asUnsignedByteArray(java.math.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,
                                         java.math.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(java.math.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 java.math.BigInteger createRandomInRange(java.math.BigInteger min,
                                                       java.math.BigInteger max,
                                                       java.security.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 java.math.BigInteger fromUnsignedByteArray(byte[] buf)

fromUnsignedByteArray

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

byteValueExact

public static byte byteValueExact(java.math.BigInteger x)

shortValueExact

public static short shortValueExact(java.math.BigInteger x)

intValueExact

public static int intValueExact(java.math.BigInteger x)

longValueExact

public static long longValueExact(java.math.BigInteger x)

areSecretValuesEqual

public static boolean areSecretValuesEqual(int maxLen,
                                           java.math.BigInteger a,
                                           java.math.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 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 — has no constant-time serialisation, so the underlying 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 and the CRT factors, DSA/DH/ElGamal/GOST , EC ), 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 and are numerically equal, false otherwise.

hasAnySmallFactors

public static boolean hasAnySmallFactors(java.math.BigInteger x)

modOddInverse

public static java.math.BigInteger modOddInverse(java.math.BigInteger M,
                                                 java.math.BigInteger X)

modOddInverseVar

public static java.math.BigInteger modOddInverseVar(java.math.BigInteger M,
                                                    java.math.BigInteger X)

modOddIsCoprime

public static boolean modOddIsCoprime(java.math.BigInteger M,
                                      java.math.BigInteger X)

modOddIsCoprimeVar

public static boolean modOddIsCoprimeVar(java.math.BigInteger M,
                                         java.math.BigInteger X)

getUnsignedByteLength

public static int getUnsignedByteLength(java.math.BigInteger n)

createRandomBigInteger

public static java.math.BigInteger createRandomBigInteger(int bitLength,
                                                          java.security.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 java.math.BigInteger createRandomPrime(int bitLength,
                                                     int certainty,
                                                     java.security.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(java.io.OutputStream out,
                                          java.math.BigInteger n)
                                   throws java.io.IOException

Throws:

java.io.IOException