java.security

Class SignatureSpi

Known Direct Subclasses:
Signature, SSLRSASignatureImpl

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 abstract void
engineSetParameter(String param, Object value)
Deprecated. use the other setParameter.
protected void
engineSetParameter(AlgorithmParameterSpec params)
Sets the signature engine with the specified AlgorithmParameterSpec.
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

clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

appRandom

protected SecureRandom appRandom
Source of randomness.

Constructor Details

SignatureSpi

public SignatureSpi()
Creates a new instance of SignatureSpi.

Method Details

clone

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.

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.

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.

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

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.

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.

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

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.

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.

SignatureSpi.java --- Signature Service Provider Interface Copyright (C) 1999, 2003, Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.