- java.lang.Object
-
- java.security.SignedObject
-
- All Implemented Interfaces:
- Serializable
public final class SignedObject extends Object implements Serializable
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 whatSignature
engine is being used, as its own implementation of theverify
method is invoked to verify a signature. In other words, a maliciousSignature
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-256. The algorithm is specified using the same convention as that for signatures. The DSA algorithm using the SHA-256 message digest algorithm can be specified, for example, as "SHA256withDSA". In the case of RSA the signing algorithm could be specified as, for example, "SHA256withRSA". 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:
- It can be used internally to any Java runtime as an unforgeable authorization token -- one that can be passed around without the fear that the token can be maliciously modified without being detected.
- It can be used to sign and serialize data/object for storage outside the Java runtime (e.g., storing critical access control data on disk).
- Nested SignedObjects can be used to construct a logical sequence of signatures, resembling a chain of authorization and delegation.
- See Also:
Signature
, Serialized Form
-
-
Constructor Summary
Constructors Constructor and Description SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)
Constructs a SignedObject from any Serializable object.
-
Method Summary
Methods Modifier and Type Method and Description 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.
-
-
-
Constructor Detail
-
SignedObject
public SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine) throws IOException, InvalidKeyException, SignatureException
Constructs a SignedObject from any Serializable object. The given object is signed with the given signing key, using the designated signature engine.- Parameters:
object
- the object to be signed.signingKey
- the private key for signing.signingEngine
- the signature signing engine.- Throws:
IOException
- if an error occurs during serializationInvalidKeyException
- if the key is invalid.SignatureException
- if signing fails.
-
-
Method Detail
-
getObject
public Object getObject() throws IOException, ClassNotFoundException
Retrieves the encapsulated object. The encapsulated object is de-serialized before it is returned.- Returns:
- the encapsulated object.
- Throws:
IOException
- if an error occurs during de-serializationClassNotFoundException
- if an error occurs during de-serialization
-
getSignature
public byte[] getSignature()
Retrieves the signature on the signed object, in the form of a byte array.- Returns:
- the signature. Returns a new array each time this method is called.
-
getAlgorithm
public String getAlgorithm()
Retrieves the name of the signature algorithm.- Returns:
- the signature algorithm name.
-
verify
public boolean verify(PublicKey verificationKey, Signature verificationEngine) throws InvalidKeyException, SignatureException
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
- the public key for verification.verificationEngine
- the signature verification engine.- Returns:
- true if the signature is valid, false otherwise
- Throws:
SignatureException
- if signature verification failed.InvalidKeyException
- if the verification key is invalid.
-
-
Traduction non disponible
Les API Java ne sont pas encore traduites en français sur l'infobrol. Seule la version anglaise est disponible pour l'instant.
Version en cache
21/11/2024 21:52:01 Cette version de la page est en cache (à la date du 21/11/2024 21:52:01) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.Document créé le 30/08/2006, dernière modification le 04/03/2020
Source du document imprimé : https://www.gaudry.be/java-api-rf-java/security/signedobject.html
L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.
Références
Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.