Skip to content

Most visited

Recently visited

navigation
Added in API level 1

SignedObject

public final class SignedObject
extends Object implements Serializable

java.lang.Object
   ↳ java.security.SignedObject


SignedObject is a class for the purpose of creating authentic runtime objects whose integrity cannot be compromised without being detected.

More specifically, a SignedObject contains another Serializable object, the (to-be-)signed object and its signature.

The signed object is a "deep copy" (in serialized form) of an original object. Once the copy is made, further manipulation of the original object has no side effect on the copy.

The underlying signing algorithm is designated by the Signature object passed to the constructor and the verify method. A typical usage for signing is the following:

 Signature signingEngine = Signature.getInstance(algorithm,
                                                 provider);
 SignedObject so = new SignedObject(myobject, signingKey,
                                    signingEngine);
 

A typical usage for verification is the following (having received SignedObject so):

 Signature verificationEngine =
     Signature.getInstance(algorithm, provider);
 if (so.verify(publickey, verificationEngine))
     try {
         Object myobj = so.getObject();
     } catch (java.lang.ClassNotFoundException e) {};
 

Several points are worth noting. First, there is no need to initialize the signing or verification engine, as it will be re-initialized inside the constructor and the verify method. Secondly, for verification to succeed, the specified public key must be the public key corresponding to the private key used to generate the SignedObject.

More importantly, for flexibility reasons, the constructor and verify method allow for customized signature engines, which can implement signature algorithms that are not installed formally as part of a crypto provider. However, it is crucial that the programmer writing the verifier code be aware what Signature engine is being used, as its own implementation of the verify method is invoked to verify a signature. In other words, a malicious Signature may choose to always return true on verification in an attempt to bypass a security check.

The signature algorithm can be, among others, the NIST standard DSA, using DSA and SHA-1. The algorithm is specified using the same convention as that for signatures. The DSA algorithm using the SHA-1 message digest algorithm can be specified, for example, as "SHA/DSA" or "SHA-1/DSA" (they are equivalent). In the case of RSA, there are multiple choices for the message digest algorithm, so the signing algorithm could be specified as, for example, "MD2/RSA", "MD5/RSA" or "SHA-1/RSA". The algorithm name must be specified, as there is no default.

The name of the Cryptography Package Provider is designated also by the Signature parameter to the constructor and the verify method. If the provider is not specified, the default provider is used. Each installation can be configured to use a particular provider as default.

Potential applications of SignedObject include:

See also:

Summary

Public constructors

SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)

Constructs a SignedObject from any Serializable object.

Public methods

String getAlgorithm()

Retrieves the name of the signature algorithm.

Object getObject()

Retrieves the encapsulated object.

byte[] getSignature()

Retrieves the signature on the signed object, in the form of a byte array.

boolean verify(PublicKey verificationKey, Signature verificationEngine)

Verifies that the signature in this SignedObject is the valid signature for the object stored inside, with the given verification key, using the designated verification engine.

Inherited methods

From class java.lang.Object

Public constructors

SignedObject

Added in API level 1
SignedObject (Serializable object, 
                PrivateKey signingKey, 
                Signature signingEngine)

Constructs a SignedObject from any Serializable object. The given object is signed with the given signing key, using the designated signature engine.

Parameters
object Serializable: the object to be signed.
signingKey PrivateKey: the private key for signing.
signingEngine Signature: the signature signing engine.
Throws
IOException if an error occurs during serialization
InvalidKeyException if the key is invalid.
SignatureException if signing fails.

Public methods

getAlgorithm

Added in API level 1
String getAlgorithm ()

Retrieves the name of the signature algorithm.

Returns
String the signature algorithm name.

getObject

Added in API level 1
Object getObject ()

Retrieves the encapsulated object. The encapsulated object is de-serialized before it is returned.

Returns
Object the encapsulated object.
Throws
IOException if an error occurs during de-serialization
ClassNotFoundException if an error occurs during de-serialization

getSignature

Added in API level 1
byte[] getSignature ()

Retrieves the signature on the signed object, in the form of a byte array.

Returns
byte[] the signature. Returns a new array each time this method is called.

verify

Added in API level 1
boolean verify (PublicKey verificationKey, 
                Signature verificationEngine)

Verifies that the signature in this SignedObject is the valid signature for the object stored inside, with the given verification key, using the designated verification engine.

Parameters
verificationKey PublicKey: the public key for verification.
verificationEngine Signature: the signature verification engine.
Returns
boolean true if the signature is valid, false otherwise
Throws
SignatureException if signature verification failed.
InvalidKeyException if the verification key is invalid.
This site uses cookies to store your preferences for site-specific language and display options.

Hooray!

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.