FileDocCategorySizeDatePackage
SealedObject.javaAPI DocAndroid 1.5 API12367Wed May 06 22:41:02 BST 2009javax.crypto

SealedObject

public class SealedObject extends Object implements Serializable
A {@code SealedObject} is a wrapper around a {@code serializable} object instance and encrypts it using a cryptographic cipher.

Since a {@code SealedObject} instance is a serializable object itself it can either be stored or transmitted over an insecure channel.

The wrapped object can later be decrypted (unsealed) using the corresponding key and then be deserialized to retrieve the original object.The sealed object itself keeps track of the cipher and corresponding parameters.
since
Android 1.0

Fields Summary
private static final long
serialVersionUID
protected byte[]
encodedParams
The {@link AlgorithmParameters} in encoded format.
private byte[]
encryptedContent
private String
sealAlg
private String
paramsAlg
Constructors Summary
public SealedObject(Serializable object, Cipher c)
Creates a new {@code SealedObject} instance wrapping the specified object and sealing it using the specified cipher.

The cipher must be fully initialized.

param
object the object to seal, can be {@code null}.
param
c the cipher to encrypt the object.
throws
IOException if the serialization fails.
throws
IllegalBlockSizeException if the specified cipher is a block cipher and the length of the serialized data is not a multiple of the ciphers block size.
throws
NullPointerException if the cipher is {@code null}.
since
Android 1.0

        if (c == null) {
            throw new NullPointerException(Messages.getString("crypto.13")); //$NON-NLS-1$
        }
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(object);
            oos.flush();
            AlgorithmParameters ap = c.getParameters();
            this.encodedParams = (ap == null) ? null : ap.getEncoded();
            this.paramsAlg = (ap == null) ? null : ap.getAlgorithm();
            this.sealAlg = c.getAlgorithm();
            this.encryptedContent = c.doFinal(bos.toByteArray());
        } catch (BadPaddingException e) {
            // should be never thrown because the cipher
            // should be initialized for encryption
            throw new IOException(e.toString());
        }
protected SealedObject(SealedObject so)
Creates a new {@code SealedObject} instance by copying the data from the specified object.

param
so the object to copy.
since
Android 1.0

        if (so == null) {
            throw new NullPointerException(Messages.getString("crypto.14")); //$NON-NLS-1$
        }
        this.encryptedContent = so.encryptedContent;
        this.encodedParams = so.encodedParams;
        this.sealAlg = so.sealAlg;
        this.paramsAlg = so.paramsAlg;
Methods Summary
public final java.lang.StringgetAlgorithm()
Returns the algorithm this object was sealed with.

return
the algorithm this object was sealed with.
since
Android 1.0

        return sealAlg;
public final java.lang.ObjectgetObject(java.security.Key key)
Returns the wrapped object, decrypting it using the specified key.

param
key the key to decrypt the data with.
return
the encapsulated object.
throws
IOException if deserialization fails.
throws
ClassNotFoundException if deserialization fails.
throws
NoSuchAlgorithmException if the algorithm to decrypt the data is not available.
throws
InvalidKeyException if the specified key cannot be used to decrypt the data.
since
Android 1.0

        // BEGIN android-added
        if (key == null) {
            throw new InvalidKeyException(
                    Messages.getString("crypto.05"));
        }
        // END android-added
        try {
            Cipher cipher = Cipher.getInstance(sealAlg);
            if ((paramsAlg != null) && (paramsAlg.length() != 0)) {
                AlgorithmParameters params =
                    AlgorithmParameters.getInstance(paramsAlg);
                params.init(encodedParams);
                cipher.init(Cipher.DECRYPT_MODE, key, params);
            } else {
                cipher.init(Cipher.DECRYPT_MODE, key);
            }
            byte[] serialized = cipher.doFinal(encryptedContent);
            ObjectInputStream ois =
                    new ObjectInputStream(
                            new ByteArrayInputStream(serialized));
            return ois.readObject();
        } catch (NoSuchPaddingException e)  {
            // should not be thrown because cipher text was made
            // with existing padding
            throw new NoSuchAlgorithmException(e.toString());
        } catch (InvalidAlgorithmParameterException e) {
            // should not be thrown because cipher text was made
            // with correct algorithm parameters
            throw new NoSuchAlgorithmException(e.toString());
        } catch (IllegalBlockSizeException e) {
            // should not be thrown because the cipher text
            // was correctly made
            throw new NoSuchAlgorithmException(e.toString());
        } catch (BadPaddingException e) {
            // should not be thrown because the cipher text
            // was correctly made
            throw new NoSuchAlgorithmException(e.toString());
        } catch (IllegalStateException  e) {
            // should never be thrown because cipher is initialized
            throw new NoSuchAlgorithmException(e.toString());
        }
public final java.lang.ObjectgetObject(javax.crypto.Cipher c)
Returns the wrapped object, decrypting it using the specified cipher.

param
c the cipher to decrypt the data.
return
the encapsulated object.
throws
IOException if deserialization fails.
throws
ClassNotFoundException if deserialization fails.
throws
IllegalBlockSizeException if the specified cipher is a block cipher and the length of the serialized data is not a multiple of the ciphers block size.
throws
BadPaddingException if the padding of the data does not match the padding scheme.
since
Android 1.0

        if (c == null) {
            throw new NullPointerException(Messages.getString("crypto.13")); //$NON-NLS-1$
        }
        byte[] serialized = c.doFinal(encryptedContent);
        ObjectInputStream ois =
                new ObjectInputStream(
                        new ByteArrayInputStream(serialized));
        return ois.readObject();
public final java.lang.ObjectgetObject(java.security.Key key, java.lang.String provider)
Returns the wrapped object, decrypting it using the specified key. The specified provider is used to retrieve the cipher algorithm.

param
key the key to decrypt the data.
param
provider the name of the provider that provides the cipher algorithm.
return
the encapsulated object.
throws
IOException if deserialization fails.
throws
ClassNotFoundException if deserialization fails.
throws
NoSuchAlgorithmException if the algorithm used to decrypt the data is not available.
throws
NoSuchProviderException if the specified provider is not available.
throws
InvalidKeyException if the specified key cannot be used to decrypt the data.
since
Android 1.0

        if ((provider == null) || (provider.length() == 0)) {
            throw new IllegalArgumentException(
                    Messages.getString("crypto.15")); //$NON-NLS-1$
        }
        try {
            Cipher cipher = Cipher.getInstance(sealAlg, provider);
            if ((paramsAlg != null) && (paramsAlg.length() != 0)) {
                AlgorithmParameters params =
                    AlgorithmParameters.getInstance(paramsAlg);
                params.init(encodedParams);
                cipher.init(Cipher.DECRYPT_MODE, key, params);
            } else {
                cipher.init(Cipher.DECRYPT_MODE, key);
            }
            byte[] serialized = cipher.doFinal(encryptedContent);
            ObjectInputStream ois =
                    new ObjectInputStream(
                            new ByteArrayInputStream(serialized));
            return ois.readObject();
        } catch (NoSuchPaddingException e)  {
            // should not be thrown because cipher text was made
            // with existing padding
            throw new NoSuchAlgorithmException(e.toString());
        } catch (InvalidAlgorithmParameterException e) {
            // should not be thrown because cipher text was made
            // with correct algorithm parameters
            throw new NoSuchAlgorithmException(e.toString());
        } catch (IllegalBlockSizeException e) {
            // should not be thrown because the cipher text
            // was correctly made
            throw new NoSuchAlgorithmException(e.toString());
        } catch (BadPaddingException e) {
            // should not be thrown because the cipher text
            // was correctly made
            throw new NoSuchAlgorithmException(e.toString());
        } catch (IllegalStateException  e) {
            // should never be thrown because cipher is initialized
            throw new NoSuchAlgorithmException(e.toString());
        }
private voidreadObject(java.io.ObjectInputStream s)


       
                   
        encodedParams = (byte []) s.readUnshared();
        encryptedContent = (byte []) s.readUnshared();
        sealAlg = (String) s.readUnshared();
        paramsAlg = (String) s.readUnshared();