public abstract class SignatureSpi extends Object
SignatureSpi
is the Service Provider Interface (SPI)
definition for Signature
.Signature
Modifier and Type | Field and Description |
---|---|
protected SecureRandom |
appRandom
Implementation specific source of randomness.
|
Constructor and Description |
---|
SignatureSpi() |
Modifier and Type | Method and Description |
---|---|
Object |
clone()
Creates and returns a copy of this
Object . |
protected abstract Object |
engineGetParameter(String param)
Deprecated.
There is no generally accepted parameter naming convention.
|
protected AlgorithmParameters |
engineGetParameters()
Returns the
AlgorithmParameters of this SignatureSpi
instance. |
protected abstract void |
engineInitSign(PrivateKey privateKey)
Initializes this
SignatureSpi instance for signing, using the
private key of the identity whose signature is going to be generated. |
protected void |
engineInitSign(PrivateKey privateKey,
SecureRandom random)
Initializes this
SignatureSpi instance for signing, using the
private key of the identity whose signature is going to be generated and
the specified source of randomness. |
protected abstract void |
engineInitVerify(PublicKey publicKey)
Initializes this
SignatureSpi instance for signature
verification, using the public key of the identity whose signature is
going to be verified. |
protected void |
engineSetParameter(AlgorithmParameterSpec params)
Sets the specified
AlgorithmParameterSpec . |
protected abstract void |
engineSetParameter(String param,
Object value)
Deprecated.
|
protected abstract byte[] |
engineSign()
Generates and returns the signature of all updated data.
|
protected int |
engineSign(byte[] outbuf,
int offset,
int len)
Generates and stores the signature of all updated data in the provided
byte[] at the specified position with the specified length. |
protected abstract void |
engineUpdate(byte b)
Updates the data to be verified or to be signed, using the specified
byte . |
protected abstract void |
engineUpdate(byte[] b,
int off,
int len)
Updates the data to be verified or to be signed, using the given
byte[] , starting form the specified index for the specified length. |
protected void |
engineUpdate(ByteBuffer input)
Updates the data to be verified or to be signed, using the specified
ByteBuffer . |
protected abstract boolean |
engineVerify(byte[] sigBytes)
Indicates whether the given
sigBytes can be verified using the
public key or a certificate of the signer. |
protected boolean |
engineVerify(byte[] sigBytes,
int offset,
int length)
Indicates whether the given
sigBytes starting at index offset with length bytes can be verified using the public key or
a certificate of the signer. |
protected SecureRandom appRandom
protected abstract void engineInitVerify(PublicKey publicKey) throws InvalidKeyException
SignatureSpi
instance for signature
verification, using the public key of the identity whose signature is
going to be verified.publicKey
- the public key.InvalidKeyException
- if publicKey
is not valid.protected abstract void engineInitSign(PrivateKey privateKey) throws InvalidKeyException
SignatureSpi
instance for signing, using the
private key of the identity whose signature is going to be generated.privateKey
- the private key.InvalidKeyException
- if privateKey
is not valid.protected void engineInitSign(PrivateKey privateKey, SecureRandom random) throws InvalidKeyException
SignatureSpi
instance for signing, using the
private key of the identity whose signature is going to be generated and
the specified source of randomness.privateKey
- the private key.random
- the SecureRandom
to use.InvalidKeyException
- if privateKey
is not valid.protected abstract void engineUpdate(byte b) throws SignatureException
byte
.b
- the byte to update with.SignatureException
- if this SignatureSpi
instance is not initialized
properly.protected abstract void engineUpdate(byte[] b, int off, int len) throws SignatureException
byte[]
, starting form the specified index for the specified length.b
- the byte array to update with.off
- the start index in b
of the data.len
- the number of bytes to use.SignatureException
- if this SignatureSpi
instance is not initialized
properly.protected void engineUpdate(ByteBuffer input)
ByteBuffer
.input
- the ByteBuffer
to update with.RuntimeException
- since SignatureException
is not specified for this
method it throws a RuntimeException
if underlying
engineUpdate(byte[], int, int)
throws SignatureException
.protected abstract byte[] engineSign() throws SignatureException
This SignatureSpi
instance is reset to the state of its last
initialization for signing and thus can be used for another signature
from the same identity.
SignatureException
- if this SignatureSpi
instance is not initialized
properly.protected int engineSign(byte[] outbuf, int offset, int len) throws SignatureException
byte[]
at the specified position with the specified length.
This SignatureSpi
instance is reset to the state of its last
initialization for signing and thus can be used for another signature
from the same identity.
outbuf
- the buffer to store the signature.offset
- the index of the first byte in outbuf
to store.len
- the number of bytes allocated for the signature.outbuf
.SignatureException
- if this SignatureSpi
instance is not initialized
properly.IllegalArgumentException
- if offset
or len
are not valid in respect to
outbuf
.protected abstract boolean engineVerify(byte[] sigBytes) throws SignatureException
sigBytes
can be verified using the
public key or a certificate of the signer.
This SignatureSpi
instance is reset to the state of its last
initialization for verifying and thus can be used to verify another
signature of the same signer.
sigBytes
- the signature to verify.true
if the signature was verified, false
otherwise.SignatureException
- if this SignatureSpi
instance is not initialized
properly.protected boolean engineVerify(byte[] sigBytes, int offset, int length) throws SignatureException
sigBytes
starting at index offset
with length
bytes can be verified using the public key or
a certificate of the signer.
This SignatureSpi
instance is reset to the state of its last
initialization for verifying and thus can be used to verify another
signature of the same signer.
sigBytes
- the byte[]
containing the signature to verify.offset
- the start index in sigBytes
of the signaturelength
- the number of bytes allocated for the signature.true
if the signature was verified, false
otherwise.SignatureException
- if this SignatureSpi
instance is not initialized
properly.IllegalArgumentException
- if offset
or length
are not valid in respect
to sigBytes
.@Deprecated protected abstract void engineSetParameter(String param, Object value) throws InvalidParameterException
engineSetParameter(AlgorithmParameterSpec)
param
- the name of the parameter.value
- the parameter value.InvalidParameterException
- if the parameter is invalid, already set or is not allowed to
be changed.protected void engineSetParameter(AlgorithmParameterSpec params) throws InvalidAlgorithmParameterException
AlgorithmParameterSpec
.params
- the parameter to set.InvalidAlgorithmParameterException
- if the parameter is invalid, already set or is not allowed to
be changed.protected AlgorithmParameters engineGetParameters()
AlgorithmParameters
of this SignatureSpi
instance.AlgorithmParameters
of this SignatureSpi
instance, maybe null
.@Deprecated protected abstract Object engineGetParameter(String param) throws InvalidParameterException
param
- the name of the requested parameter value.null
.InvalidParameterException
- if param
is not a valid parameter for this SignatureSpi
or an other error occurs.public Object clone() throws CloneNotSupportedException
Object
Object
. The default
implementation returns a so-called "shallow" copy: It creates a new
instance of the same class and then copies the field values (including
object references) from this instance to the new instance. A "deep" copy,
in contrast, would also recursively clone nested objects. A subclass that
needs to implement this kind of cloning should call super.clone()
to create the new instance and then create deep copies of the nested,
mutable objects.clone
in class Object
CloneNotSupportedException
- if this object's class does not implement the Cloneable
interface.