Overview | Package | Class | Tree | Deprecated | Index | Help
| Bouncy Castle Cryptography Library 1.85
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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`

Overview | Package | Class | Tree | Deprecated | Index | Help
| Bouncy Castle Cryptography Library 1.85
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD