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 |
---|---|---|
|
SecureRandomSpi() |
Constructor without a parameter.
|
protected |
SecureRandomSpi(SecureRandomParameters params) |
Constructor with a parameter.
|
Modifier and Type | Method | Description |
---|---|---|
protected abstract byte[] |
engineGenerateSeed(int numBytes) |
Returns the given number of seed bytes.
|
protected SecureRandomParameters |
engineGetParameters() |
Returns the effective
SecureRandomParameters for this
SecureRandom instance. |
protected abstract void |
engineNextBytes(byte[] bytes) |
Generates a user-specified number of random bytes.
|
protected void |
engineNextBytes(byte[] bytes,
SecureRandomParameters params) |
Generates a user-specified number of random bytes with
additional parameters.
|
protected void |
engineReseed(SecureRandomParameters params) |
Reseeds this random object with entropy input read from its
entropy source with additional parameters.
|
protected abstract void |
engineSetSeed(byte[] seed) |
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. Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
Redwood Shores, CA 94065 USA. All rights reserved.
DRAFT 9-internal+0-adhoc.mlchung.jdk9-jdeps