Serializable
public abstract class SecureRandomSpi extends Object implements Serializable
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.
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:
orput("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 | Constructor | Description |
---|---|---|
Constructor without a parameter. |
||
protected |
Constructor with a parameter. |
Modifier and Type | Method | Description |
---|---|---|
protected abstract byte[] |
engineGenerateSeed |
Returns the given number of seed bytes. |
protected SecureRandomParameters |
engineGetParameters() |
Returns the effective SecureRandomParameters for this SecureRandom instance. |
protected abstract void |
engineNextBytes |
Generates a user-specified number of random bytes. |
protected void |
engineNextBytes |
Generates a user-specified number of random bytes with additional parameters. |
protected void |
engineReseed |
Reseeds this random object with entropy input read from its entropy source with additional parameters. |
protected abstract void |
engineSetSeed |
Reseeds this random object with the given seed. |
String |
toString() |
Returns a Human-readable string representation of this SecureRandom . |
public SecureRandomSpi()
protected SecureRandomSpi(SecureRandomParameters params)
params
- the SecureRandomParameters
object. This argument can be null
.IllegalArgumentException
- if params
is unrecognizable or unsupported by this SecureRandom
protected abstract void engineSetSeed(byte[] seed)
seed
- the seed.protected abstract void engineNextBytes(byte[] bytes)
Some random number generators can only generate a limited amount of random bytes per invocation. If the size of bytes
is greater than this limit, the implementation should invoke its generation process multiple times to completely fill the buffer before returning from this method.
bytes
- the array to be filled in with random bytes.protected void engineNextBytes(byte[] bytes, SecureRandomParameters params)
Some random number generators can only generate a limited amount of random bytes per invocation. If the size of bytes
is greater than this limit, the implementation should invoke its generation process multiple times to completely fill the buffer before returning from this method.
UnsupportedOperationException
.bytes
- the array to be filled in with random bytesparams
- additional parametersUnsupportedOperationException
- if the implementation has not overridden this methodIllegalArgumentException
- if params
is null
, illegal or unsupported by this SecureRandom
protected abstract byte[] engineGenerateSeed(int numBytes)
numBytes
- the number of seed bytes to generate.protected void engineReseed(SecureRandomParameters params)
If this method is called by SecureRandom.reseed()
, params
will be null
.
Do not override this method if the implementation does not support reseeding.
UnsupportedOperationException
.params
- extra parameters, can be null
.UnsupportedOperationException
- if the implementation has not overridden this methodIllegalArgumentException
- if params
is illegal or unsupported by this SecureRandom
protected SecureRandomParameters engineGetParameters()
SecureRandomParameters
for this SecureRandom
instance.null
.SecureRandomParameters
parameters, or null
if no parameters were used.public String toString()
SecureRandom
.
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/SecureRandomSpi.html