Overview Package Class Use Source Tree Index Deprecated About
Prev Class | Next ClassFrames | No Frames
Summary: Nested | Field | Method | ConstrDetail: Nested | Field | Method | Constr

javax.crypto

Class Cipher

Known Direct Subclasses:
NullCipher
public class Cipher
extends Object
This class implements a cryptographic cipher for transforming data.

Ciphers cannot be instantiated directly; rather one of the getInstance must be used to instantiate a given transformation, optionally with a specific provider.

A transformation is of the form:

where algorithm is the base name of a cryptographic cipher (such as "AES"), mode is the abbreviated name of a block cipher mode (such as "CBC" for cipher block chaining mode), and padding is the name of a padding scheme (such as "PKCS5Padding"). If only the algorithm name is supplied, then the provider-specific default mode and padding will be used.

An example transformation is:

Cipher c = Cipher.getInstance("AES/CBC/PKCS5Padding");

Finally, when requesting a block cipher in stream cipher mode (such as AES in OFB or CFB mode) the number of bits to be processed at a time may be specified by appending it to the name of the mode; e.g. "AES/OFB8/NoPadding". If no such number is specified a provider-specific default value is used.

See Also:
java.security.KeyGenerator, SecretKey

Field Summary

static int
DECRYPT_MODE
The decryption operation mode.
static int
ENCRYPT_MODE
The encryption operation mode.
static int
PRIVATE_KEY
Constant for when the key to be unwrapped is a private key.
static int
PUBLIC_KEY
Constant for when the key to be unwrapped is a public key.
static int
SECRET_KEY
Constant for when the key to be unwrapped is a secret key.
static int
UNWRAP_MODE
The key unwrapping operation mode.
static int
WRAP_MODE
The key wrapping operation mode.

Constructor Summary

Cipher(CipherSpi cipherSpi, Provider provider, String transformation)
Create a cipher.

Method Summary

byte[]
doFinal()
Finishes a multi-part transformation, and returns the final transformed bytes.
byte[]
doFinal(byte[] input)
Finishes a multi-part transformation or does an entire transformation on the input, and returns the transformed bytes.
int
doFinal(byte[] output, int outputOffset)
Finishes a multi-part transformation and stores the transformed bytes into the given array.
byte[]
doFinal(byte[] input, int inputOffset, int inputLength)
Finishes a multi-part transformation or does an entire transformation on the input, and returns the transformed bytes.
int
doFinal(byte[] input, int inputOffset, int inputLength, byte[] output)
int
doFinal(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset)
Finishes a multi-part transformation or transforms a portion of a byte array, and stores the result in the given byte array.
int
doFinal(ByteBuffer input, ByteBuffer output)
Finishes a multi-part transformation with, or completely transforms, a byte buffer, and stores the result into the output buffer.
String
getAlgorithm()
Get the name that this cipher instance was created with; this is equivalent to the "transformation" argument given to any of the getInstance() methods.
int
getBlockSize()
Return the size of blocks, in bytes, that this cipher processes.
ExemptionMechanism
getExemptionMechanism()
Return the currently-operating ExemptionMechanism.
byte[]
getIV()
Return the initialization vector that this instance was initialized with.
static Cipher
getInstance(String transformation)
Creates a new cipher instance for the given transformation.
static Cipher
getInstance(String transformation, String provider)
Creates a new cipher instance for the given transformation and the named provider.
static Cipher
getInstance(String transformation, Provider provider)
Creates a new cipher instance for a given transformation from a given provider.
int
getOutputSize(int inputLength)
Returns the size an output buffer needs to be if this cipher is updated with a number of bytes.
AlgorithmParameters
getParameters()
Return the AlgorithmParameters that this instance was initialized with.
Provider
getProvider()
Return this cipher's provider.
void
init(int opmode, Key key)
Initialize this cipher with the supplied key.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Key key, AlgorithmParameters params)
Initialize this cipher with the supplied key and parameters.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) then the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
Initialize this cipher with the supplied key, parameters, and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Key key, SecureRandom random)
Initialize this cipher with the supplied key and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Key key, AlgorithmParameterSpec params)
Initialize this cipher with the supplied key and parameters.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) then the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random)
Initialize this cipher with the supplied key, parameters, and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Certificate certificate)
Initialize this cipher with the public key from the given certificate.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

As per the Java 1.4 specification, if cert is an instance of an X509Certificate and its key usage extension field is incompatible with opmode then an InvalidKeyException is thrown.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

void
init(int opmode, Certificate certificate, SecureRandom random)
Initialize this cipher with the public key from the given certificate and the specified source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

As per the Java 1.4 specification, if cert is an instance of an X509Certificate and its key usage extension field is incompatible with opmode then an InvalidKeyException is thrown.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Key
unwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType)
Unwrap a previously-wrapped key.
byte[]
update(byte[] input)
Continue a multi-part transformation on an entire byte array, returning the transformed bytes.
byte[]
update(byte[] input, int inputOffset, int inputLength)
Continue a multi-part transformation on part of a byte array, returning the transformed bytes.
int
update(byte[] input, int inputOffset, int inputLength, byte[] output)
Continue a multi-part transformation on part of a byte array, placing the transformed bytes into the given array.
int
update(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset)
Continue a multi-part transformation on part of a byte array, placing the transformed bytes into the given array.
int
update(ByteBuffer input, ByteBuffer output)
Continue a multi-part transformation on a byte buffer, storing the transformed bytes into another buffer.
byte[]
wrap(Key key)
Wrap a key.

Methods inherited from class java.lang.Object

clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

DECRYPT_MODE

public static final int DECRYPT_MODE
The decryption operation mode.
Field Value:
2

ENCRYPT_MODE

public static final int ENCRYPT_MODE
The encryption operation mode.
Field Value:
1

PRIVATE_KEY

public static final int PRIVATE_KEY
Constant for when the key to be unwrapped is a private key.
Field Value:
2

PUBLIC_KEY

public static final int PUBLIC_KEY
Constant for when the key to be unwrapped is a public key.
Field Value:
1

SECRET_KEY

public static final int SECRET_KEY
Constant for when the key to be unwrapped is a secret key.
Field Value:
3

UNWRAP_MODE

public static final int UNWRAP_MODE
The key unwrapping operation mode.
Field Value:
4

WRAP_MODE

public static final int WRAP_MODE
The key wrapping operation mode.
Field Value:
3

Constructor Details

Cipher

protected Cipher(CipherSpi cipherSpi,
                 Provider provider,
                 String transformation)
Create a cipher.
Parameters:
cipherSpi - The underlying implementation of the cipher.
provider - The provider of this cipher implementation.
transformation - The transformation this cipher performs.

Method Details

doFinal

public final byte[] doFinal()
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException
Finishes a multi-part transformation, and returns the final transformed bytes.
Returns:
The final transformed bytes.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.
IllegalBlockSizeException - If this instance has no padding and the input is not a multiple of this cipher's block size.
BadPaddingException - If this instance is decrypting and the padding bytes do not match this instance's padding scheme.

doFinal

public final byte[] doFinal(byte[] input)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException
Finishes a multi-part transformation or does an entire transformation on the input, and returns the transformed bytes.
Parameters:
input - The final input bytes.
Returns:
The final transformed bytes.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.
IllegalBlockSizeException - If this instance has no padding and the input is not a multiple of this cipher's block size.
BadPaddingException - If this instance is decrypting and the padding bytes do not match this instance's padding scheme.

doFinal

public final int doFinal(byte[] output,
                         int outputOffset)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException,
                   ShortBufferException
Finishes a multi-part transformation and stores the transformed bytes into the given array.
Parameters:
output - The destination for the transformed bytes.
outputOffset - The offset in output to start storing bytes.
Returns:
The number of bytes placed into the output array.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.
IllegalBlockSizeException - If this instance has no padding and the input is not a multiple of this cipher's block size.
BadPaddingException - If this instance is decrypting and the padding bytes do not match this instance's padding scheme.
ShortBufferException - If the output array is not large enough to hold the transformed bytes.

doFinal

public final byte[] doFinal(byte[] input,
                            int inputOffset,
                            int inputLength)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException
Finishes a multi-part transformation or does an entire transformation on the input, and returns the transformed bytes.
Parameters:
input - The final input bytes.
inputOffset - The index in the input bytes to start.
inputLength - The number of bytes to read from the input.
Returns:
The final transformed bytes.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.
IllegalBlockSizeException - If this instance has no padding and the input is not a multiple of this cipher's block size.
BadPaddingException - If this instance is decrypting and the padding bytes do not match this instance's padding scheme.

doFinal

public final int doFinal(byte[] input,
                         int inputOffset,
                         int inputLength,
                         byte[] output)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException,
                   ShortBufferException

doFinal

public final int doFinal(byte[] input,
                         int inputOffset,
                         int inputLength,
                         byte[] output,
                         int outputOffset)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   BadPaddingException,
                   ShortBufferException
Finishes a multi-part transformation or transforms a portion of a byte array, and stores the result in the given byte array.
Parameters:
input - The input bytes.
inputOffset - The index in input to start.
inputLength - The number of bytes to transform.
output - The output buffer.
outputOffset - The index in output to start.
Returns:
The number of bytes placed into the output array.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.
IllegalBlockSizeException - If this instance has no padding and the input is not a multiple of this cipher's block size.
BadPaddingException - If this instance is decrypting and the padding bytes do not match this instance's padding scheme.
ShortBufferException - If the output array is not large enough to hold the transformed bytes.

doFinal

public final int doFinal(ByteBuffer input,
                         ByteBuffer output)
            throws ReadOnlyBufferException,
                   ShortBufferException,
                   BadPaddingException,
                   IllegalBlockSizeException
Finishes a multi-part transformation with, or completely transforms, a byte buffer, and stores the result into the output buffer.
Parameters:
input - The input buffer.
output - The output buffer.
Returns:
The number of bytes stored into the output buffer.
Throws:
IllegalArgumentException - If the input and output buffers are the same object.
IllegalStateException - If this cipher was not initialized for encryption or decryption.
ReadOnlyBufferException - If the output buffer is not writable.
IllegalBlockSizeException - If this cipher requires a total input that is a multiple of its block size to complete this transformation.
ShortBufferException - If the output buffer is not large enough to hold the transformed bytes.
BadPaddingException - If the cipher is a block cipher with a padding scheme, and the decrypted bytes do not end with a valid padding.
Since:
1.5

getAlgorithm

public final String getAlgorithm()
Get the name that this cipher instance was created with; this is equivalent to the "transformation" argument given to any of the getInstance() methods.
Returns:
The cipher name.

getBlockSize

public final int getBlockSize()
Return the size of blocks, in bytes, that this cipher processes.
Returns:
The block size.

getExemptionMechanism

public final ExemptionMechanism getExemptionMechanism()
Return the currently-operating ExemptionMechanism.
Returns:
null, currently.

getIV

public final byte[] getIV()
Return the initialization vector that this instance was initialized with.
Returns:
The IV.

getInstance

public static final Cipher getInstance(String transformation)
            throws NoSuchAlgorithmException,
                   NoSuchPaddingException
Creates a new cipher instance for the given transformation.

The installed providers are tried in order for an implementation, and the first appropriate instance is returned. If no installed provider can provide the implementation, an appropriate exception is thrown.

Parameters:
transformation - The transformation to create.
Returns:
An appropriate cipher for this transformation.
Throws:
NoSuchAlgorithmException - If no installed provider can supply the appropriate cipher or mode.
NoSuchPaddingException - If no installed provider can supply the appropriate padding.

getInstance

public static final Cipher getInstance(String transformation,
                                       String provider)
            throws NoSuchAlgorithmException,
                   NoSuchProviderException,
                   NoSuchPaddingException
Creates a new cipher instance for the given transformation and the named provider.
Parameters:
transformation - The transformation to create.
provider - The name of the provider to use.
Returns:
An appropriate cipher for this transformation.
Throws:
NoSuchAlgorithmException - If the provider cannot supply the appropriate cipher or mode.
NoSuchProviderException - If the named provider is not installed.
NoSuchPaddingException - If the provider cannot supply the appropriate padding.
IllegalArgumentException - if either transformation or provider is null.

getInstance

public static final Cipher getInstance(String transformation,
                                       Provider provider)
            throws NoSuchAlgorithmException,
                   NoSuchPaddingException
Creates a new cipher instance for a given transformation from a given provider.
Parameters:
transformation - The transformation to create.
provider - The provider to use.
Returns:
An appropriate cipher for this transformation.
Throws:
NoSuchAlgorithmException - If the given provider cannot supply the appropriate cipher or mode.
NoSuchPaddingException - If the given provider cannot supply the appropriate padding scheme.

getOutputSize

public final int getOutputSize(int inputLength)
            throws IllegalStateException
Returns the size an output buffer needs to be if this cipher is updated with a number of bytes.
Parameters:
inputLength - The input length.
Returns:
The output length given this input length.
Throws:
IllegalStateException - If this instance has not been initialized, or if a doFinal call has already been made.

getParameters

public final AlgorithmParameters getParameters()
Return the AlgorithmParameters that this instance was initialized with.
Returns:
The parameters.

getProvider

public final Provider getProvider()
Return this cipher's provider.
Returns:
The provider.

init

public final void init(int opmode,
                       Key key)
            throws InvalidKeyException
Initialize this cipher with the supplied key.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.

init

public final void init(int opmode,
                       Key key,
                       AlgorithmParameters params)
            throws InvalidKeyException,
                   InvalidAlgorithmParameterException
Initialize this cipher with the supplied key and parameters.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) then the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
params - The algorithm parameters to initialize this instance with.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.
InvalidAlgorithmParameterException - If the supplied parameters are inappropriate for this cipher.

init

public final void init(int opmode,
                       Key key,
                       AlgorithmParameters params,
                       SecureRandom random)
            throws InvalidKeyException,
                   InvalidAlgorithmParameterException
Initialize this cipher with the supplied key, parameters, and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
params - The algorithm parameters to initialize this instance with.
random - The source of randomness to use.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.
InvalidAlgorithmParameterException - If the supplied parameters are inappropriate for this cipher.

init

public final void init(int opmode,
                       Key key,
                       SecureRandom random)
            throws InvalidKeyException
Initialize this cipher with the supplied key and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
random - The source of randomness to use.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.

init

public final void init(int opmode,
                       Key key,
                       AlgorithmParameterSpec params)
            throws InvalidKeyException,
                   InvalidAlgorithmParameterException
Initialize this cipher with the supplied key and parameters.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

If this cipher requires any random bytes (for example for an initilization vector) then the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
params - The algorithm parameters to initialize this instance with.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.
InvalidAlgorithmParameterException - If the supplied parameters are inappropriate for this cipher.

init

public final void init(int opmode,
                       Key key,
                       AlgorithmParameterSpec params,
                       SecureRandom random)
            throws InvalidKeyException,
                   InvalidAlgorithmParameterException
Initialize this cipher with the supplied key, parameters, and source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
key - The key.
params - The algorithm parameters to initialize this instance with.
random - The source of randomness to use.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the given key.
InvalidAlgorithmParameterException - If the supplied parameters are inappropriate for this cipher.

init

public final void init(int opmode,
                       Certificate certificate)
            throws InvalidKeyException
Initialize this cipher with the public key from the given certificate.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

As per the Java 1.4 specification, if cert is an instance of an X509Certificate and its key usage extension field is incompatible with opmode then an InvalidKeyException is thrown.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
certificate - The certificate.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the certificate's public key, or if the public key cannot be used as described above.

init

public final void init(int opmode,
                       Certificate certificate,
                       SecureRandom random)
            throws InvalidKeyException
Initialize this cipher with the public key from the given certificate and the specified source of randomness.

The cipher will be initialized for encryption, decryption, key wrapping, or key unwrapping, depending upon whether the opmode argument is ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, or UNWRAP_MODE, respectively.

As per the Java 1.4 specification, if cert is an instance of an X509Certificate and its key usage extension field is incompatible with opmode then an InvalidKeyException is thrown.

If this cipher requires any random bytes (for example for an initilization vector) than the SecureRandom with the highest priority is used as the source of these bytes.

A call to any of the init methods overrides the state of the instance, and is equivalent to creating a new instance and calling its init method.

Parameters:
opmode - The operation mode to use.
certificate - The certificate.
random - The source of randomness.
Throws:
InvalidKeyException - If the underlying cipher instance rejects the certificate's public key, or if the public key cannot be used as described above.

unwrap

public final Key unwrap(byte[] wrappedKey,
                        String wrappedKeyAlgorithm,
                        int wrappedKeyType)
            throws IllegalStateException,
                   InvalidKeyException,
                   NoSuchAlgorithmException
Unwrap a previously-wrapped key.
Parameters:
wrappedKey - The wrapped key.
wrappedKeyAlgorithm - The algorithm with which the key was wrapped.
wrappedKeyType - The type of key (public, private, or secret) that this wrapped key respresents.
Returns:
The unwrapped key.
Throws:
IllegalStateException - If this instance has not be initialized for unwrapping.
InvalidKeyException - If wrappedKey is not a wrapped key, if the algorithm cannot unwrap this key, or if the unwrapped key's type differs from the specified type.
NoSuchAlgorithmException - If wrappedKeyAlgorithm is not a valid algorithm name.

update

public final byte[] update(byte[] input)
            throws IllegalStateException
Continue a multi-part transformation on an entire byte array, returning the transformed bytes.
Parameters:
input - The input bytes.
Returns:
The transformed bytes.
Throws:
IllegalStateException - If this cipher was not initialized for encryption or decryption.

update

public final byte[] update(byte[] input,
                           int inputOffset,
                           int inputLength)
            throws IllegalStateException
Continue a multi-part transformation on part of a byte array, returning the transformed bytes.
Parameters:
input - The input bytes.
inputOffset - The index in the input to start.
inputLength - The number of bytes to transform.
Returns:
The transformed bytes.
Throws:
IllegalStateException - If this cipher was not initialized for encryption or decryption.

update

public final int update(byte[] input,
                        int inputOffset,
                        int inputLength,
                        byte[] output)
            throws IllegalStateException,
                   ShortBufferException
Continue a multi-part transformation on part of a byte array, placing the transformed bytes into the given array.
Parameters:
input - The input bytes.
inputOffset - The index in the input to start.
inputLength - The number of bytes to transform.
output - The output byte array.
Returns:
The number of transformed bytes.
Throws:
IllegalStateException - If this cipher was not initialized for encryption or decryption.

update

public final int update(byte[] input,
                        int inputOffset,
                        int inputLength,
                        byte[] output,
                        int outputOffset)
            throws IllegalStateException,
                   ShortBufferException
Continue a multi-part transformation on part of a byte array, placing the transformed bytes into the given array.
Parameters:
input - The input bytes.
inputOffset - The index in the input to start.
inputLength - The number of bytes to transform.
output - The output byte array.
outputOffset - The index in the output array to start.
Returns:
The number of transformed bytes.
Throws:
IllegalStateException - If this cipher was not initialized for encryption or decryption.

update

public final int update(ByteBuffer input,
                        ByteBuffer output)
            throws ReadOnlyBufferException,
                   ShortBufferException
Continue a multi-part transformation on a byte buffer, storing the transformed bytes into another buffer.
Parameters:
input - The input buffer.
output - The output buffer.
Returns:
The number of bytes stored in output.
Throws:
IllegalArgumentException - If the two buffers are the same object.
IllegalStateException - If this cipher was not initialized for encrypting or decrypting.
ReadOnlyBufferException - If the output buffer is not writable.
ShortBufferException - If the output buffer does not have enough available space for the transformed bytes.
Since:
1.5

wrap

public final byte[] wrap(Key key)
            throws IllegalStateException,
                   IllegalBlockSizeException,
                   InvalidKeyException
Wrap a key.
Parameters:
key - The key to wrap.
Returns:
The wrapped key.
Throws:
IllegalStateException - If this instance was not initialized for key wrapping.
IllegalBlockSizeException - If this instance has no padding and the key is not a multiple of the block size.
InvalidKeyException - If this instance cannot wrap this key.
Cipher.java -- Interface to a cryptographic cipher. Copyright (C) 2004, 2006 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.

Overview Package Class Use Source Tree Index Deprecated About