Class SignatureSpi

protected SecureRandom appRandom

Source of randomness.

public SignatureSpi()

Creates a new instance of SignatureSpi.

public Object clone()
            throws CloneNotSupportedException

Returns a clone of this instance.

Overrides:

clone in interface Object

Returns:

a clone of this instance.

Throws:

CloneNotSupportedException - if the implementation does not support cloning.

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.

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.

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.

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

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.

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.

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.

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.

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

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.

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.

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.

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.

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.