Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javax.crypto
Class SealedObject

    java.lang.Object
      |
      +--javax.crypto.SealedObject

public class SealedObject
extends Object
implements 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.

See Also:
  `Cipher`, Serialized Form

Constructor Summary
`SealedObject(Serializable object, Cipher c)` Constructs a SealedObject from any Serializable object.

Method Summary
`String` | `getAlgorithm()` Returns the algorithm that was used to seal this object.
`Object` | `getObject(Cipher c)` Retrieves the original (encapsulated) object.
`Object` | `getObject(Key key)`
`Object` | `getObject(Key key, String provider)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### SealedObject

    public SealedObject(Serializable object,
                        Cipher c)
                 throws IOException,
                        IllegalBlockSizeException,
                        BadPaddingException

  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.
    `c` - the cipher used to seal the object
  Throws:
    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 is not a multiple of the cipher's block size

Method Detail

### getAlgorithm

    public final String getAlgorithm()

  Returns the algorithm that was used to seal this object.
  Returns:
    the algorithm that was used to seal this object.

### getObject

    public final Object getObject(Cipher c)
                           throws IOException,
                                  ClassNotFoundException,
                                  IllegalBlockSizeException,
                                  BadPaddingException

  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.

  Parameters:
    `c` - the cipher used to unseal the object
  Returns:
    the original object.
  Throws:
    IOException - if an error occurs during de-serialization
    ClassNotFoundException - if an error occurs during de-serialization
    IllegalBlockSizeException - if the given cipher is a block cipher, no padding has been requested, and the total input length is not a multiple of the cipher's block size
    BadPaddingException - if the given cipher has been initialized for decryption, and padding has been specified, but the input data does not have proper expected padding bytes

### getObject

    public final Object getObject(Key key)
                           throws IOException,
                                  ClassNotFoundException,
                                  NoSuchAlgorithmException,
                                  InvalidKeyException

### getObject

    public final Object getObject(Key key,
                                  String provider)
                           throws IOException,
                                  ClassNotFoundException,
                                  NoSuchAlgorithmException,
                                  NoSuchProviderException,
                                  InvalidKeyException

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD