SecureRandomSpi
  public
  
  
  abstract
  class
  SecureRandomSpi
  
    extends Object
  
  
  
  
  
      implements
      
        Serializable
      
  
  
| java.lang.Object | |
| ↳ | java.security.SecureRandomSpi | 
This class defines the Service Provider Interface (SPI)
 for the 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.
Summary
Public constructors | |
|---|---|
      
      SecureRandomSpi()
      
      
        Constructor without a parameter.  | 
  |
Protected constructors | |
|---|---|
      
      SecureRandomSpi(SecureRandomParameters params)
      
      
        Constructor with a parameter.  | 
  |
Public methods | |
|---|---|
        
        
        
        
        
        String
     | 
  
    
      
      toString()
      
      
        Returns a Human-readable string representation of this
   | 
  
Protected methods | |
|---|---|
        abstract
        
        
        
        
        byte[]
     | 
  
    
      
      engineGenerateSeed(int numBytes)
      
      
        Returns the given number of seed bytes.  | 
  
        
        
        
        
        
        SecureRandomParameters
     | 
  
    
      
      engineGetParameters()
      
      
        Returns the effective   | 
  
        
        
        
        
        
        void
     | 
  
    
      
      engineNextBytes(byte[] bytes, SecureRandomParameters params)
      
      
        Generates a user-specified number of random bytes with additional parameters.  | 
  
        abstract
        
        
        
        
        void
     | 
  
    
      
      engineNextBytes(byte[] bytes)
      
      
        Generates a user-specified number of random bytes.  | 
  
        
        
        
        
        
        void
     | 
  
    
      
      engineReseed(SecureRandomParameters params)
      
      
        Reseeds this random object with entropy input read from its entropy source with additional parameters.  | 
  
        abstract
        
        
        
        
        void
     | 
  
    
      
      engineSetSeed(byte[] seed)
      
      
        Reseeds this random object with the given seed.  | 
  
Inherited methods | |
|---|---|
Public constructors
Protected constructors
SecureRandomSpi
protected SecureRandomSpi (SecureRandomParameters params)
Constructor with a parameter.
| Parameters | |
|---|---|
params | 
        
          SecureRandomParameters: the SecureRandomParameters object.
               This argument can be null. | 
      
| Throws | |
|---|---|
IllegalArgumentException | 
          if params is
         unrecognizable or unsupported by this SecureRandom | 
        
Public methods
toString
public String toString ()
Returns a Human-readable string representation of this
 SecureRandom.
| Returns | |
|---|---|
String | 
        the string representation | 
Protected methods
engineGenerateSeed
protected abstract byte[] engineGenerateSeed (int numBytes)
Returns the given number of seed bytes. This call may be used to seed other random number generators.
| Parameters | |
|---|---|
numBytes | 
        
          int: the number of seed bytes to generate. | 
      
| Returns | |
|---|---|
byte[] | 
        the seed bytes. | 
engineGetParameters
protected SecureRandomParameters engineGetParameters ()
Returns the effective SecureRandomParameters for this
 SecureRandom instance.
Implementation Requirements:
- The default implementation returns 
null. 
| Returns | |
|---|---|
SecureRandomParameters | 
        the effective SecureRandomParameters parameters,
 or null if no parameters were used. | 
      
engineNextBytes
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 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.
Implementation Requirements:
- The default implementation throws
 an 
UnsupportedOperationException. 
| Parameters | |
|---|---|
bytes | 
        
          byte: the array to be filled in with random bytes | 
      
params | 
        
          SecureRandomParameters: additional parameters | 
      
| Throws | |
|---|---|
UnsupportedOperationException | 
          if the implementation has not overridden this method | 
IllegalArgumentException | 
          if params is null,
         illegal or unsupported by this SecureRandom | 
        
engineNextBytes
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 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.
| Parameters | |
|---|---|
bytes | 
        
          byte: the array to be filled in with random bytes. | 
      
engineReseed
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 SecureRandom.reseed(),
 params will be null.
 
Do not override this method if the implementation does not support reseeding.
Implementation Requirements:
- The default implementation throws
           an 
UnsupportedOperationException. 
| Parameters | |
|---|---|
params | 
        
          SecureRandomParameters: extra parameters, can be null. | 
      
| Throws | |
|---|---|
UnsupportedOperationException | 
          if the implementation has not overridden this method | 
IllegalArgumentException | 
          if params is
         illegal or unsupported by this SecureRandom | 
        
engineSetSeed
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.
| Parameters | |
|---|---|
seed | 
        
          byte: the seed. |