java.security
Class SignatureSpi

java.lang.Object
  extended by java.security.SignatureSpi
Direct Known Subclasses:
Signature

public abstract class SignatureSpi
extends Object

SignatureSpi defines the Service Provider Interface (SPI) for the Signature class. The signature class provides an interface to a digital signature algorithm. Digital signatures are used for authentication and integrity of data.

Since:
1.2
See Also:
Signature

Field Summary
protected  SecureRandom appRandom
          Source of randomness.
 
Constructor Summary
SignatureSpi()
          Creates a new instance of SignatureSpi.
 
Method Summary
 Object clone()
          Returns a clone of this instance.
protected abstract  Object engineGetParameter(String param)
          Deprecated. use the other getParameter
protected  AlgorithmParameters engineGetParameters()
          The default implementaion of this method always throws a UnsupportedOperationException.
protected abstract  void engineInitSign(PrivateKey privateKey)
          Initializes this instance with the private key for signing purposes.
protected  void engineInitSign(PrivateKey privateKey, SecureRandom random)
          Initializes this instance with the private key and source of randomness for signing purposes.
protected abstract  void engineInitVerify(PublicKey publicKey)
          Initializes this instance with the public key for verification purposes.
protected  void engineSetParameter(AlgorithmParameterSpec params)
          Sets the signature engine with the specified AlgorithmParameterSpec.
protected abstract  void engineSetParameter(String param, Object value)
          Deprecated. use the other setParameter.
protected abstract  byte[] engineSign()
          Returns the signature bytes of all the data fed to this instance.
protected  int engineSign(byte[] outbuf, int offset, int len)
          Generates signature bytes of all the data fed to this instance and stores the result in the designated array.
protected abstract  void engineUpdate(byte b)
          Updates the data to be signed or verified with the specified byte.
protected abstract  void engineUpdate(byte[] b, int off, int len)
          Updates the data to be signed or verified with the specified bytes.
protected  void engineUpdate(ByteBuffer input)
          Update this signature with the Buffer.remaining() bytes of the given buffer.
protected abstract  boolean engineVerify(byte[] sigBytes)
          Verifies a designated signature.
protected  boolean engineVerify(byte[] sigBytes, int offset, int length)
          Convenience method which calls the method with the same name and one argument after copying the designated bytes into a temporary byte array.
 
Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

appRandom

protected SecureRandom appRandom
Source of randomness.

Constructor Detail

SignatureSpi

public SignatureSpi()
Creates a new instance of SignatureSpi.

Method Detail

engineInitVerify

protected abstract void engineInitVerify(PublicKey publicKey)
                                  throws InvalidKeyException
Initializes this instance with the public key for verification purposes.

Parameters:
publicKey - the public key to verify with.
Throws:
InvalidKeyException - if the key is invalid.

engineInitSign

protected abstract void engineInitSign(PrivateKey privateKey)
                                throws InvalidKeyException
Initializes this instance with the private key for signing purposes.

Parameters:
privateKey - the private key to sign with.
Throws:
InvalidKeyException - if the key is invalid.

engineInitSign

protected void engineInitSign(PrivateKey privateKey,
                              SecureRandom random)
                       throws InvalidKeyException
Initializes this instance with the private key and source of randomness for signing purposes.

This method cannot be abstract for backward compatibility reasons.

Parameters:
privateKey - the private key to sign with.
random - the SecureRandom to use.
Throws:
InvalidKeyException - if the key is invalid.
Since:
1.2

engineUpdate

protected abstract void engineUpdate(byte b)
                              throws SignatureException
Updates the data to be signed or verified with the specified byte.

Parameters:
b - byte to update with.
Throws:
SignatureException - if the engine is not properly initialized.

engineUpdate

protected abstract void engineUpdate(byte[] b,
                                     int off,
                                     int len)
                              throws SignatureException
Updates the data to be signed or verified with the specified bytes.

Parameters:
b - the array of bytes to use.
off - the offset to start at in the array.
len - the number of the bytes to use from the array.
Throws:
SignatureException - if the engine is not properly initialized.

engineUpdate

protected void engineUpdate(ByteBuffer input)
Update this signature with the Buffer.remaining() bytes of the given buffer.

Parameters:
input - The input buffer.
Throws:
IllegalStateException - if the engine is not properly initialized.

engineSign

protected abstract byte[] engineSign()
                              throws SignatureException
Returns the signature bytes of all the data fed to this instance. The format of the output depends on the underlying signature algorithm.

Returns:
the signature bytes.
Throws:
SignatureException - if the engine is not properly initialized.

engineSign

protected int engineSign(byte[] outbuf,
                         int offset,
                         int len)
                  throws SignatureException
Generates signature bytes of all the data fed to this instance and stores the result in the designated array. The format of the output depends on the underlying signature algorithm.

This method cannot be abstract for backward compatibility reasons. After calling this method, the signature is reset to its initial state and can be used to generate additional signatures.

IMPLEMENTATION NOTE:: Neither this method nor the GNU provider will return partial digests. If len is less than the signature length, this method will throw a SignatureException. If it is greater than or equal then it is ignored.

Parameters:
outbuf - the array of bytes to store the result in.
offset - the offset to start at in the array.
len - the number of the bytes to use in the array.
Returns:
the real number of bytes used.
Throws:
SignatureException - if the engine is not properly initialized.
Since:
1.2

engineVerify

protected abstract boolean engineVerify(byte[] sigBytes)
                                 throws SignatureException
Verifies a designated signature.

Parameters:
sigBytes - the signature bytes to verify.
Returns:
true if verified, false otherwise.
Throws:
SignatureException - if the engine is not properly initialized or if it is the wrong signature.

engineVerify

protected boolean engineVerify(byte[] sigBytes,
                               int offset,
                               int length)
                        throws SignatureException
Convenience method which calls the method with the same name and one argument after copying the designated bytes into a temporary byte array. Subclasses may override this method for performance reasons.

Parameters:
sigBytes - the array of bytes to use.
offset - the offset to start from in the array of bytes.
length - the number of bytes to use, starting at offset.
Returns:
true if verified, false otherwise.
Throws:
SignatureException - if the engine is not properly initialized.

engineSetParameter

protected abstract void engineSetParameter(String param,
                                           Object value)
                                    throws InvalidParameterException
Deprecated. use the other setParameter.

Sets the specified algorithm parameter to the specified value.

Parameters:
param - the parameter name.
value - the parameter value.
Throws:
InvalidParameterException - if the parameter invalid, the parameter is already set and cannot be changed, a security exception occured, etc.

engineSetParameter

protected void engineSetParameter(AlgorithmParameterSpec params)
                           throws InvalidAlgorithmParameterException
Sets the signature engine with the specified AlgorithmParameterSpec.

This method cannot be abstract for backward compatibility reasons. By default it always throws UnsupportedOperationException unless overridden.

Parameters:
params - the parameters.
Throws:
InvalidParameterException - if the parameter is invalid, the parameter is already set and cannot be changed, a security exception occured, etc.
InvalidAlgorithmParameterException

engineGetParameters

protected AlgorithmParameters engineGetParameters()
The default implementaion of this method always throws a UnsupportedOperationException. It MUST be overridden by concrete implementations to return the appropriate AlgorithmParameters for this signature engine (or null when that engine does not use any parameters.

Returns:
the parameters used with this signature engine, or null if it does not use any parameters.
Throws:
UnsupportedOperationException - always.

engineGetParameter

protected abstract Object engineGetParameter(String param)
                                      throws InvalidParameterException
Deprecated. use the other getParameter

Returns the value for the specified algorithm parameter.

Parameters:
param - the parameter name.
Returns:
the parameter value.
Throws:
InvalidParameterException - if the parameter is invalid.

clone

public Object clone()
             throws CloneNotSupportedException
Returns a clone of this instance.

Overrides:
clone in class Object
Returns:
a clone of this instance.
Throws:
CloneNotSupportedException - if the implementation does not support cloning.
See Also:
Cloneable