JSAFE_SecureRandom
extends the java.security.SecureRandom
class so that it can be used to replace the Sun JavaSoft classes. All Crypto-J classes that use this class actually request a java.security.SecureRandom
Java class, so that you can use the standard Java classes instead of java.security.SecureRandom
.
See Overview of Crypto-J for background and reference material on using and understanding Crypto-J.
Copyright © RSA Security Inc., 1997-2005. All rights reserved.
Public Member Functions | |
String | getDevice () |
String[] | getDeviceList () |
int[] | getAlgorithmParameters () |
abstract String | getAlgorithm () |
abstract void | seed (byte[] seedBytes) |
void | extraSeed (byte[] extraSeedBytes) throws JSAFE_InputException |
abstract void | autoseed () |
void | setSeed (long seedLong) |
void | setSeed (byte[] seedBytes) |
void | nextBytes (byte[] bytes) |
short | nextShort () |
int | nextInt () |
long | nextLong () |
double | nextDouble () |
float | nextFloat () |
byte[] | generateRandomBytes (int numberOfBytes) |
abstract void | generateRandomBytes (byte[] randomOutput, int offset, int numberOfBytes) |
Object | clone () throws CloneNotSupportedException |
void | clearSensitiveData () |
Static Public Member Functions | |
static SecureRandom | getInstance (String transformation, String device) throws NoSuchAlgorithmException |
Protected Member Functions | |
void | prngCheck (byte[] previousBlock, int previousOffset, byte[] currentBlock, int currentOffset, int count) |
void | setJSAFELevelValues (JSAFE_SecureRandom original) throws CloneNotSupportedException |
Static Protected Member Functions | |
static SecureRandom | getSeeder () |
static byte[] | getRandomSeed (int numBytes) |
Package Functions | |
byte[] | serializeRandom () |
Static Package Functions | |
static final void | checkIntegrity () |
static final boolean | isInFIPSMode () |
static JSAFE_SecureRandom | deserializeRandom (String randomAlgorithm, byte[] oldRandom) |
Private Member Functions | |
void | setLongSeed (long seedLong) |
Static Private Member Functions | |
static synchronized SecureRandom | getSeederSync () |
static JSAFE_SecureRandom | getInstance (String[] transformationNames, String[] deviceNames, JSAFE_DeviceBuilder deviceBuilder, JSAFE_DeviceBuilder[] deviceObjects) throws JSAFE_InvalidParameterException |
Private Attributes | |
String | theDevice |
String[] | theDeviceList |
Static Private Attributes | |
static SecureRandom | seeder = null |
static final boolean[] | strictHW = { true, false } |
static final String[] | interfaceListHW |
static final boolean[] | strictChain = { true } |
static final String[] | interfaceListChain |
static final String | fullyQualClassName |
|
This method generates seed bytes and uses them to seed an object. The technique used is based on the autoseeding from This method may take four or five seconds. Note: JavaSoft provides the following cautionary statement regarding their autoseeding algorithm: We attempt to provide sufficient seed bytes to completely randomize the internal state of the generator (20 bytes). Note, however, that our seed generation algorithm has not been thoroughly studied or widely deployed. It relies on counting the number of times that the calling thread can yield while waiting for another thread to sleep for a specified interval. |
|
This method clears sensitive data from an object. Although the finalizer clears the data, there is no guarantee the garbage collector will quickly call the finalizer. Allows a user to clear data as soon as possible. After calling |
|
Overrides the default clone to produce a deep clone. Overrides clone in class
|
|
Convert the input byte array into a
|
|
Generates seed bytes and uses them to seed an object. Provides "extra" seed bytes for PRNGs that use two kinds of seed, such as an X9.31 random seed.
To generate a random seed that complies with the X9.31 specification, there must be two independent streams of seeding. A standard seed is supplied by calling
The size, in bytes, of the
|
|
Generates pseudorandom bytes, placing them into the given buffer. This method generates This method is used as the basis of all random entities returned by this class (except seed bytes).
|
|
Generates pseudorandom bytes, returning them in a new
|
|
Returns the standard algorithm name.
|
|
Returns a new
|
|
Returns the name of the device of record. Possible device values are:
|
|
Returns a
|
|
Build an object that performs the operation represented by the array
The
|
|
Builds an object that performs the Note: Due to a change in
If you are updating code from Crypto-J version 2.0 or earlier, see the section "Updating JSAFE_SecureRandom.getInstance()" under "Random Number Generation" of the Crypto-J Developer's Guide for more information.The value of transformation must be one of the following:
Note: "FIPS186Random" is a general purpose FIPS 140-2 compliant pseudo random number generator based on the on the FIPS 186 standard.
Note: Using "X931Random" will produce pseudo-random results in compliance with the X9.31 standard. If a hardware random number generator is not available, this software pseudo-random number generator is required to generate strong RSA key pairs. This pseudo-random number generator also requires a minimum number of seed bytes per stream.The value of digest when used with "HWRandom" must be one of the following:
Note: The digest value is for whitening the hardware results. To produce unwhitened bytes, use "NoDigest". Whitening the output of a random number generator means applying a post-processing algorithm to reduce patterns in the hardware bits and make them less predictable. The advantage of performing whitening in software as well as hardware is that an attacker must modify the hardware and the software to make the HRNG leak secret information. If you plan to use the random numbers directly, you should use "MD2", "MD5", or "SHA1" as the "HWRandom" digest value to apply additional whitening. If you are seeding a pseudo-random number generator, you can use "NoDigest" for optimal performance.The device value is as follows: choice1[/choice2[...[/choicen]]] where the choices for device value are as follows:
Crypto-J tries to instantiate a class using the first choice; if it cannot, it tries the other choices. Note: Do not attempt to use hardware versions of Crypto-J classes unless you are very familiar with the hardware. See the "Random Number Generation" section of the Crypto-J Developer's Guide, which describes hardware usage, its benefits, and its problems, as well as the Intel Security Hardware User's Guide.
Note: In JDK 1.1,Examples The first example demonstrates how to build a pseudo-random object in software:
The second example demonstrates how to build a random object using the HWRandom algorithm. This object can later be used to seed a Crypto-J pseudo-random number generator (PRNG). To get a JSAFE_SecureRandom object, you should cast the result with JSAFE_SecureRandom .
If the Intel hardware is not available, Crypto-J throws a NoSuchAlgorithmException . If the Intel hardware is available, Crypto-J creates an instance of JSAFE_SecureRandom that can perform Intel random number generation. If something goes wrong after this instance has been created, Crypto-J throws an IntelException . See the Intel Security Hardware User's Guide for further information.
|
|
Instantiates the global seed generator if it hasn't beeen done already. Synchronized methods are expensive so this will be called by an unsynchronized one only if the instance is null. |
|
Fills the input buffer with pseudorandom bytes.
|
|
Generates a pseudorandom
|
|
Generates a pseudorandom
|
|
Generates a pseudorandom
|
|
Generates a pseudorandom
|
|
Generates a pseudorandom
|
|
Seeds the pseudorandom number generator. This method uses the entire input buffer, and seeds an object. It uses all the bytes of the
|
|
Convert this object into a byte array for serialization.
|
|
Seeds the pseudorandom number generator with the long (8-byte integer) value.
|
|
Seeds the pseudorandom number generator. This method uses the entire input buffer.
|
|
Seeds the pseudorandom number generator with the
Reseeds this random object, using the eight bytes contained in the
|
|
Initial value:
"com.rsa.jsafe.JSAFE_SecureRandom"
|
|
Initial value: {
"com.rsa.jsafe.JA_AlgaeChainDigestRandom"
}
|
|
Initial value: { "com.rsa.jsafe.JA_AlgaeRandom", "com.rsa.jsafe.JA_AlgaeDigest" } |