javax.crypto
public class: SealedObject [javadoc |
source]
java.lang.Object
javax.crypto.SealedObject
All Implemented Interfaces:
java$io$Serializable
This class enables a programmer to create an object and protect its
confidentiality with a cryptographic algorithm.
Given any Serializable object, one can create a SealedObject
that encapsulates the original object, in serialized
format (i.e., a "deep copy"), and seals (encrypts) its serialized contents,
using a cryptographic algorithm such as DES, to protect its
confidentiality. The encrypted content can later be decrypted (with
the corresponding algorithm using the correct decryption key) and
de-serialized, yielding the original object.
Note that the Cipher object must be fully initialized with the
correct algorithm, key, padding scheme, etc., before being applied
to a SealedObject.
The original object that was sealed can be recovered in two different
ways:
- by using the getObject
method that takes a
Cipher object.
This method requires a fully initialized Cipher object,
initialized with the
exact same algorithm, key, padding scheme, etc., that were used to seal the
object.
This approach has the advantage that the party who unseals the
sealed object does not require knowledge of the decryption key. For example,
after one party has initialized the cipher object with the required
decryption key, it could hand over the cipher object to
another party who then unseals the sealed object.
- by using one of the
getObject methods
that take a
Key object.
In this approach, the getObject method creates a cipher
object for the appropriate decryption algorithm and initializes it with the
given decryption key and the algorithm parameters (if any) that were stored
in the sealed object.
This approach has the advantage that the party who
unseals the object does not need to keep track of the parameters (e.g., an
IV) that were used to seal the object.
Also see:
- Cipher
- author:
Li - Gong
- author:
Jan - Luehe
- since:
1.4 -
| Field Summary |
|---|
| static final long | serialVersionUID | |
| protected byte[] | encodedParams | The cryptographic parameters used by the sealing Cipher,
encoded in the default format.
That is, cipher.getParameters().getEncoded(). |
| Constructor: |
|---|
 protected SealedObject(SealedObject so) {
this.encryptedContent = (byte[]) so.encryptedContent.clone();
this.sealAlg = so.sealAlg;
this.paramsAlg = so.paramsAlg;
if (so.encodedParams != null) {
this.encodedParams = (byte[]) so.encodedParams.clone();
} else {
this.encodedParams = null;
}
}
Constructs a SealedObject object from the passed-in SealedObject. Parameters:
so - a SealedObject object
NullPointerException - if the given sealed object is null.
- exception:
NullPointerException - if the given sealed object is null.
|
public SealedObject(Serializable object,
Cipher c) throws IOException, IllegalBlockSizeException {
/*
* Serialize the object
*/
// creating a stream pipe-line, from a to b
ByteArrayOutputStream b = new ByteArrayOutputStream();
ObjectOutput a = new ObjectOutputStream(b);
byte[] content;
try {
// write and flush the object content to byte array
a.writeObject(object);
a.flush();
content = b.toByteArray();
} finally {
a.close();
}
/*
* Seal the object
*/
try {
this.encryptedContent = c.doFinal(content);
}
catch (BadPaddingException ex) {
// if sealing is encryption only
// Should never happen??
}
// Save the parameters
if (c.getParameters() != null) {
this.encodedParams = c.getParameters().getEncoded();
this.paramsAlg = c.getParameters().getAlgorithm();
}
// Save the encryption algorithm
this.sealAlg = c.getAlgorithm();
} Constructs a SealedObject from any Serializable object.
The given object is serialized, and its serialized contents are
encrypted using the given Cipher, which must be fully initialized.
Any algorithm parameters that may be used in the encryption
operation are stored inside of the new SealedObject. Parameters:
object - the object to be sealed; can be null.
c - the cipher used to seal the object.
NullPointerException - if the given cipher is null.
IOException - if an error occurs during serialization
IllegalBlockSizeException - if the given cipher is a block
cipher, no padding has been requested, and the total input length
(i.e., the length of the serialized object contents) is not a multiple
of the cipher's block size
- exception:
NullPointerException - if the given cipher is null.
- exception:
IOException - if an error occurs during serialization
- exception:
IllegalBlockSizeException - if the given cipher is a block
cipher, no padding has been requested, and the total input length
(i.e., the length of the serialized object contents) is not a multiple
of the cipher's block size
|
| Methods from java.lang.Object: |
|---|
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Method from javax.crypto.SealedObject Detail: |
|---|
public final String getAlgorithm() {
return this.sealAlg;
} Returns the algorithm that was used to seal this object. |
public final Object getObject(Key key) throws IOException, ClassNotFoundException, NoSuchAlgorithmException, InvalidKeyException {
if (key == null) {
throw new NullPointerException("key is null");
}
try {
return unseal(key, null);
} catch (NoSuchProviderException nspe) {
// we've already caught NoSuchProviderException's and converted
// them into NoSuchAlgorithmException's with details about
// the failing algorithm
throw new NoSuchAlgorithmException("algorithm not found");
} catch (IllegalBlockSizeException ibse) {
throw new InvalidKeyException(ibse.getMessage());
} catch (BadPaddingException bpe) {
throw new InvalidKeyException(bpe.getMessage());
}
} Retrieves the original (encapsulated) object.
This method creates a cipher for the algorithm that had been used in
the sealing operation.
If the default provider package provides an implementation of that
algorithm, an instance of Cipher containing that implementation is used.
If the algorithm is not available in the default package, other
packages are searched.
The Cipher object is initialized for decryption, using the given
key and the parameters (if any) that had been used in the
sealing operation.
The encapsulated object is unsealed and de-serialized, before it is
returned. |
public final Object getObject(Cipher c) throws IOException, ClassNotFoundException, IllegalBlockSizeException, BadPaddingException {
/*
* Unseal the object
*/
byte[] content = c.doFinal(this.encryptedContent);
/*
* De-serialize it
*/
// creating a stream pipe-line, from b to a
ByteArrayInputStream b = new ByteArrayInputStream(content);
ObjectInput a = new extObjectInputStream(b);
try {
Object obj = a.readObject();
return obj;
} finally {
a.close();
}
} Retrieves the original (encapsulated) object.
The encapsulated object is unsealed (using the given Cipher,
assuming that the Cipher is already properly initialized) and
de-serialized, before it is returned. |
public final Object getObject(Key key,
String provider) throws IOException, ClassNotFoundException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException {
if (key == null) {
throw new NullPointerException("key is null");
}
if (provider == null || provider.length() == 0) {
throw new IllegalArgumentException("missing provider");
}
try {
return unseal(key, provider);
} catch (IllegalBlockSizeException ibse) {
throw new InvalidKeyException(ibse.getMessage());
} catch (BadPaddingException bpe) {
throw new InvalidKeyException(bpe.getMessage());
}
} Retrieves the original (encapsulated) object.
This method creates a cipher for the algorithm that had been used in
the sealing operation, using an implementation of that algorithm from
the given provider.
The Cipher object is initialized for decryption, using the given
key and the parameters (if any) that had been used in the
sealing operation.
The encapsulated object is unsealed and de-serialized, before it is
returned. |