SecureRandom class.
All the abstract methods in this class must be implemented by each service provider who wishes to supply the implementation of a cryptographically strong pseudo-random number generator.
Implementation Specification
If the SecureRandomSpi(SecureRandomParameters)
constructor is overridden in an implementation, it will always be called
whenever a SecureRandom is instantiated. Precisely, if an object is
instantiated with one of SecureRandom's getInstance methods
without a SecureRandomParameters parameter,
the constructor will be called with a null argument and the
implementation is responsible for creating its own
SecureRandomParameters parameter for use when
engineGetParameters() is called. If an object
is instantiated with one of SecureRandom's getInstance
methods with a SecureRandomParameters argument,
the constructor will be called with that argument. The
engineGetParameters() method must not return null.
Otherwise, if the SecureRandomSpi(SecureRandomParameters)
constructor is not overridden in an implementation, the
SecureRandomSpi() constructor must be overridden, and it will be
called if an object is instantiated with one of SecureRandom's
getInstance methods without a
SecureRandomParameters argument. Calling one of
SecureRandom's getInstance methods with
a SecureRandomParameters argument will never
return an instance of this implementation. The
engineGetParameters() method must return null.
See SecureRandom for additional details on thread safety. By
default, a SecureRandomSpi implementation is considered to be
not safe for use by multiple concurrent threads and SecureRandom
will synchronize access to each of the applicable engine methods
(see SecureRandom for the list of methods). However, if a
SecureRandomSpi implementation is thread-safe, the
service provider attribute "ThreadSafe" should be set to "true" during
its registration, as follows:
put("SecureRandom.AlgName ThreadSafe", "true");
putService(new Service(this, "SecureRandom", "AlgName", className,
null, Map.of("ThreadSafe", "true")));
SecureRandom will call the applicable engine methods
without any synchronization.
| Modifier and Type | Field and Description |
|---|---|
| private static final long |
| Access | Constructor and Description |
|---|---|
| public | |
| protected | SecureRandomSpi(SecureRandomParameters
the params)SecureRandomParameters object.
This argument can be null.Constructor with a parameter. |
| Modifier and Type | Method and Description |
|---|---|
| protected abstract byte[] | Returns: the seed bytes.the number of seed bytes to generate. numBytes)Returns the given number of seed bytes. |
| protected SecureRandomParameters | |
| protected abstract void | engineNextBytes(byte[]
the array to be filled in with random bytes. bytes)Generates a user-specified number of random bytes. |
| protected void | engineNextBytes(byte[]
the array to be filled in with random bytes bytes, SecureRandomParameters additional parameters params)Generates a user-specified number of random bytes with additional parameters. |
| protected void | engineReseed(SecureRandomParameters
extra parameters, can be params)null.Reseeds this random object with entropy input read from its entropy source with additional parameters. |
| protected abstract void | |
| public String | Returns: the string representationOverrides java. Returns a Human-readable string representation of this
|
| serialVersionUID | back to summary |
|---|---|
| private static final long serialVersionUID
| |
| SecureRandomSpi | back to summary |
|---|---|
| public SecureRandomSpi() Constructor without a parameter. | |
| SecureRandomSpi | back to summary |
|---|---|
| protected SecureRandomSpi(SecureRandomParameters params) Constructor with a parameter.
| |
| engineGenerateSeed | back to summary |
|---|---|
| protected abstract byte[] engineGenerateSeed(int numBytes) Returns the given number of seed bytes. This call may be used to seed other random number generators.
| |
| engineGetParameters | back to summary |
|---|---|
| protected SecureRandomParameters engineGetParameters() Returns the effective Implementation Specification The default implementation returns
| |
| engineNextBytes | back to summary |
|---|---|
| protected abstract void engineNextBytes(byte[] bytes) Generates a user-specified number of random bytes.
Some random number generators can only generate a limited amount
of random bytes per invocation. If the size of
| |
| engineNextBytes | back to summary |
|---|---|
| protected void engineNextBytes(byte[] bytes, SecureRandomParameters params) Generates a user-specified number of random bytes with additional parameters.
Some random number generators can only generate a limited amount
of random bytes per invocation. If the size of Implementation Specification The default implementation throws
an
| |
| engineReseed | back to summary |
|---|---|
| protected void engineReseed(SecureRandomParameters params) Reseeds this random object with entropy input read from its entropy source with additional parameters.
If this method is called by Do not override this method if the implementation does not support reseeding. Implementation Specification The default implementation throws
an
| |
| engineSetSeed | back to summary |
|---|---|
| protected abstract void engineSetSeed(byte[] seed) Reseeds this random object with the given seed. The seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
| |
| toString | back to summary |
|---|---|
| public String toString() Overrides java. Returns a Human-readable string representation of this
| |