Overview | Package | Class | Tree | Deprecated | Index | Help
| Bouncy Castle Cryptography 1.28
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javax.crypto
Class Cipher

    java.lang.Object
      javax.crypto.Cipher

Direct Known Subclasses:
  NullCipher

public class Cipher
extends java.lang.Object

This class provides the functionality of a cryptographic cipher for encryption and decryption. It forms the core of the Java Cryptographic Extension (JCE) framework.

In order to create a Cipher object, the application calls the Cipher's `getInstance` method, and passes the name of the requested transformation to it. Optionally, the name of a provider may be specified.

A transformation is a string that describes the operation (or set of operations) to be performed on the given input, to produce some output. A transformation always includes the name of a cryptographic algorithm (e.g., DES), and may be followed by a feedback mode and padding scheme.

A transformation is of the form:

- "algorithm/mode/padding" or

- "algorithm"

(in the latter case, provider-specific default values for the mode and padding scheme are used). For example, the following is a valid transformation:

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

When requesting a block cipher in stream cipher mode (e.g., `DES` in `CFB` or `OFB` mode), the user may optionally specify the number of bits to be processed at a time, by appending this number to the mode name as shown in the "DES/CFB8/NoPadding" and "DES/OFB32/PKCS5Padding" transformations. If no such number is specified, a provider-specific default is used. (For example, the "SunJCE" provider uses a default of 64 bits.)

Field Summary
`static int` | `DECRYPT_MODE`
`static int` | `ENCRYPT_MODE`
`static int` | `PRIVATE_KEY`
`static int` | `PUBLIC_KEY`
`static int` | `SECRET_KEY`
`static int` | `UNWRAP_MODE`
`static int` | `WRAP_MODE`

Constructor Summary
`protected` | `Cipher(CipherSpi cipherSpi, java.security.Provider provider, java.lang.String transformation)` Creates a Cipher object.

Method Summary
`byte[]` | `doFinal()` Finishes a multiple-part encryption or decryption operation, depending on how this cipher was initialized.
`byte[]` | `doFinal(byte[] input)` Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
`int` | `doFinal(byte[] output, int outputOffset)` Finishes a multiple-part encryption or decryption operation, depending on how this cipher was initialized.
`byte[]` | `doFinal(byte[] input, int inputOffset, int inputLen)` Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
`int` | `doFinal(byte[] input, int inputOffset, int inputLen, byte[] output)` Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
`int` | `doFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)` Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
`java.lang.String` | `getAlgorithm()` Returns the algorithm name of this `Cipher` object.
`int` | `getBlockSize()` Returns the block size (in bytes).
`ExemptionMechanism` | `getExemptionMechanism()` Returns the exemption mechanism object used with this cipher.
`static Cipher` | `getInstance(java.lang.String transformation)` Generates a `Cipher` object that implements the specified transformation.
`static Cipher` | `getInstance(java.lang.String transformation, java.lang.String provider)` Creates a `Cipher` object that implements the specified transformation, as supplied by the specified provider.
`byte[]` | `getIV()` Returns the initialization vector (IV) in a new buffer.
`int` | `getOutputSize(int inputLen)` Returns the length in bytes that an output buffer would need to be in order to hold the result of the next `update` or `doFinal` operation, given the input length `inputLen` (in bytes).
`java.security.AlgorithmParameters` | `getParameters()` Returns the parameters used with this cipher.
`java.security.Provider` | `getProvider()` Returns the provider of this `Cipher` object.
`void` | `init(int opmode, java.security.cert.Certificate certificate)` Initializes this cipher with the public key from the given certificate.
`void` | `init(int opmode, java.security.cert.Certificate certificate, java.security.SecureRandom random)` Initializes this cipher with the public key from the given certificate and a source of randomness.
`void` | `init(int opmode, java.security.Key key)` Initializes this cipher with a key.
`void` | `init(int opmode, java.security.Key key, java.security.AlgorithmParameters params)` Initializes this cipher with a key and a set of algorithm parameters.
`void` | `init(int opmode, java.security.Key key, java.security.spec.AlgorithmParameterSpec params)` Initializes this cipher with a key and a set of algorithm parameters.
`void` | `init(int opmode, java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random)` Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.
`void` | `init(int opmode, java.security.Key key, java.security.AlgorithmParameters params, java.security.SecureRandom random)` Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.
`void` | `init(int opmode, java.security.Key key, java.security.SecureRandom random)` Initializes this cipher with a key and a source of randomness.
`java.security.Key` | `unwrap(byte[] wrappedKey, java.lang.String wrappedKeyAlgorithm, int wrappedKeyType)` Unwrap a previously wrapped key.
`byte[]` | `update(byte[] input)` Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
`byte[]` | `update(byte[] input, int inputOffset, int inputLen)` Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
`int` | `update(byte[] input, int inputOffset, int inputLen, byte[] output)` Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
`int` | `update(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)` Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
`byte[]` | `wrap(java.security.Key key)` Wrap a key.

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

Field Detail

### ENCRYPT_MODE

    public static final int ENCRYPT_MODE

See Also:
  Constant Field Values

### DECRYPT_MODE

    public static final int DECRYPT_MODE

See Also:
  Constant Field Values

### WRAP_MODE

    public static final int WRAP_MODE

See Also:
  Constant Field Values

### UNWRAP_MODE

    public static final int UNWRAP_MODE

See Also:
  Constant Field Values

### PUBLIC_KEY

    public static final int PUBLIC_KEY

See Also:
  Constant Field Values

### PRIVATE_KEY

    public static final int PRIVATE_KEY

See Also:
  Constant Field Values

### SECRET_KEY

    public static final int SECRET_KEY

See Also:
  Constant Field Values

Constructor Detail

### Cipher

    protected Cipher(CipherSpi cipherSpi,
                     java.security.Provider provider,
                     java.lang.String transformation)

  Creates a Cipher object.

Parameters:
  `cipherSpi` - the delegate
  `provider` - the provider
  `transformation` - the transformation

Method Detail

### getInstance

    public static final Cipher getInstance(java.lang.String transformation)
                                    throws java.security.NoSuchAlgorithmException,
                                           NoSuchPaddingException

  Generates a `Cipher` object that implements the specified transformation.

  If the default provider package supplies an implementation of the requested transformation, an instance of `Cipher` containing that implementation is returned. If the transformation is not available in the default provider package, other provider packages are searched.

  Parameters:
    `transformation` - the name of the transformation, e.g., DES/CBC/PKCS5Padding. See Appendix A in the Java Cryptography Extension API Specification & Reference for information about standard transformation names.
  Returns:
    a cipher that implements the requested transformation
  Throws:
    `java.security.NoSuchAlgorithmException` - if the specified transformation is not available in the default provider package or any of the other provider packages that were searched.
    `NoSuchPaddingException` - if `transformation` contains a padding scheme that is not available.

### getInstance

    public static final Cipher getInstance(java.lang.String transformation,
                                           java.lang.String provider)
                                    throws java.security.NoSuchAlgorithmException,
                                           java.security.NoSuchProviderException,
                                           NoSuchPaddingException

  Creates a `Cipher` object that implements the specified transformation, as supplied by the specified provider.

  Parameters:
    `transformation` - the name of the transformation, e.g., DES/CBC/PKCS5Padding. See Appendix A in the Java Cryptography Extension API Specification & Reference for information about standard transformation names.
    `provider` - the name of the provider
  Returns:
    a cipher that implements the requested transformation
  Throws:
    `java.security.NoSuchAlgorithmException` - if no transformation was specified, or if the specified transformation is not available from the specified provider.
    `java.security.NoSuchProviderException` - if the specified provider has not been configured.
    `NoSuchPaddingException` - if `transformation` contains a padding scheme that is not available.

### getProvider

    public final java.security.Provider getProvider()

  Returns the provider of this `Cipher` object.

  Returns:
    the provider of this `Cipher` object

### getAlgorithm

    public final java.lang.String getAlgorithm()

  Returns the algorithm name of this `Cipher` object.

  This is the same name that was specified in one of the `getInstance` calls that created this `Cipher` object..

  Returns:
    the algorithm name of this `Cipher` object.

### getBlockSize

    public final int getBlockSize()

  Returns the block size (in bytes).

  Returns:
    the block size (in bytes), or 0 if the underlying algorithm is not a block cipher

### getOutputSize

    public final int getOutputSize(int inputLen)
                            throws java.lang.IllegalStateException

  Returns the length in bytes that an output buffer would need to be in order to hold the result of the next `update` or `doFinal` operation, given the input length `inputLen` (in bytes).

  This call takes into account any unprocessed (buffered) data from a previous `update` call, and padding.

  The actual output length of the next `update` or `doFinal` call may be smaller than the length returned by this method.

  Parameters:
    `inputLen` - the input length (in bytes)
  Returns:
    the required output buffer size (in bytes)
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not yet been initialized)

### getIV

    public final byte[] getIV()

  Returns the initialization vector (IV) in a new buffer.

  This is useful in the case where a random IV was created, or in the context of password-based encryption or decryption, where the IV is derived from a user-supplied password.

  Returns:
    the initialization vector in a new buffer, or null if the underlying algorithm does not use an IV, or if the IV has not yet been set.

### getParameters

    public final java.security.AlgorithmParameters getParameters()

  Returns the parameters used with this cipher.

  The returned parameters may be the same that were used to initialize this cipher, or may contain a combination of default and random parameter values used by the underlying cipher implementation if this cipher requires algorithm parameters but was not initialized with any.

  Returns:
    the parameters used with this cipher, or null if this cipher does not use any parameters.

### getExemptionMechanism

    public final ExemptionMechanism getExemptionMechanism()

  Returns the exemption mechanism object used with this cipher.

  Returns:
    the exemption mechanism object used with this cipher, or null if this cipher does not use any exemption mechanism.

### init

    public final void init(int opmode,
                           java.security.Key key)
                    throws java.security.InvalidKeyException

  Initializes this cipher with a key.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters that cannot be derived from the given `key`, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidKeyException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them using the `SecureRandom` implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the key
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or if this cipher is being initialized for decryption and requires algorithm parameters that cannot be determined from the given key, or if the given key has a keysize that exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.Key key,
                           java.security.SecureRandom random)
                    throws java.security.InvalidKeyException

  Initializes this cipher with a key and a source of randomness.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters that cannot be derived from the given `key`, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidKeyException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using engineGetParameters or engineGetIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from `random`.

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the encryption key
    `random` - the source of randomness
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or if this cipher is being initialized for decryption and requires algorithm parameters that cannot be determined from the given key, or if the given key has a keysize that exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.Key key,
                           java.security.spec.AlgorithmParameterSpec params)
                    throws java.security.InvalidKeyException,
                           java.security.InvalidAlgorithmParameterException

  Initializes this cipher with a key and a set of algorithm parameters.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters and `params` is null, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidAlgorithmParameterException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them using the `SecureRandom` implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the encryption key
    `params` - the algorithm parameters
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or its keysize exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files).
    `java.security.InvalidAlgorithmParameterException` - if the given algorithm parameters are inappropriate for this cipher, or this cipher is being initialized for decryption and requires algorithm parameters and `params` is null, or the given algorithm parameters imply a cryptographic strength that would exceed the legal limits (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.Key key,
                           java.security.spec.AlgorithmParameterSpec params,
                           java.security.SecureRandom random)
                    throws java.security.InvalidKeyException,
                           java.security.InvalidAlgorithmParameterException

  Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters and `params` is null, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidAlgorithmParameterException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from `random`.

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the encryption key
    `params` - the algorithm parameters
    `random` - the source of randomness
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or its keysize exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files).
    `java.security.InvalidAlgorithmParameterException` - if the given algorithm parameters are inappropriate for this cipher, or this cipher is being initialized for decryption and requires algorithm parameters and `params` is null, or the given algorithm parameters imply a cryptographic strength that would exceed the legal limits (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.Key key,
                           java.security.AlgorithmParameters params)
                    throws java.security.InvalidKeyException,
                           java.security.InvalidAlgorithmParameterException

  Initializes this cipher with a key and a set of algorithm parameters.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters and `params` is null, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidAlgorithmParameterException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them using the `SecureRandom` implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the encryption key
    `params` - the algorithm parameters
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or its keysize exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files).
    `java.security.InvalidAlgorithmParameterException` - if the given algorithm parameters are inappropriate for this cipher, or this cipher is being initialized for decryption and requires algorithm parameters and `params` is null, or the given algorithm parameters imply a cryptographic strength that would exceed the legal limits (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.Key key,
                           java.security.AlgorithmParameters params,
                           java.security.SecureRandom random)
                    throws java.security.InvalidKeyException,
                           java.security.InvalidAlgorithmParameterException

  Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If this cipher requires any algorithm parameters and `params` is null, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidAlgorithmParameterException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from `random`.

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `key` - the encryption key
    `params` - the algorithm parameters
    `random` - the source of randomness
  Throws:
    `java.security.InvalidKeyException` - if the given key is inappropriate for initializing this cipher, or its keysize exceeds the maximum allowable keysize (as determined from the configured jurisdiction policy files).
    `java.security.InvalidAlgorithmParameterException` - if the given algorithm parameters are inappropriate for this cipher, or this cipher is being initialized for decryption and requires algorithm parameters and `params` is null, or the given algorithm parameters imply a cryptographic strength that would exceed the legal limits (as determined from the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.cert.Certificate certificate)
                    throws java.security.InvalidKeyException

  Initializes this cipher with the public key from the given certificate.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If the certificate is of type X.509 and has a key usage extension field marked as critical, and the value of the key usage extension field implies that the public key in the certificate and its corresponding private key are not supposed to be used for the operation represented by the value of `opmode`, an `InvalidKeyException` is thrown.

  If this cipher requires any algorithm parameters that cannot be derived from the public key in the given certificate, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or ramdom values) if it is being initialized for encryption or key wrapping, and raise an `InvalidKeyException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them using the `SecureRandom` implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `certificate` - the certificate
  Throws:
    `java.security.InvalidKeyException` - if the public key in the given certificate is inappropriate for initializing this cipher, or this cipher is being initialized for decryption or unwrapping keys and requires algorithm parameters that cannot be determined from the public key in the given certificate, or the keysize of the public key in the given certificate has a keysize that exceeds the maximum allowable keysize (as determined by the configured jurisdiction policy files). Note: Jurisdiction files are ignored in this implementation.

### init

    public final void init(int opmode,
                           java.security.cert.Certificate certificate,
                           java.security.SecureRandom random)
                    throws java.security.InvalidKeyException

  Initializes this cipher with the public key from the given certificate and a source of randomness.

  The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of `opmode`.

  If the certificate is of type X.509 and has a key usage extension field marked as critical, and the value of the key usage extension field implies that the public key in the certificate and its corresponding private key are not supposed to be used for the operation represented by the value of `opmode`, an `InvalidKeyException` is thrown.

  If this cipher requires any algorithm parameters that cannot be derived from the public key in the given `certificate`, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an `InvalidKeyException` if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using engineGetParameters or engineGetIV (if the parameter is an IV).

  If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from `random`.

  Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it.

  Parameters:
    `opmode` - the operation mode of this cipher (this is one of the following: `ENCRYPT_MODE`, `DECRYPT_MODE`, `WRAP_MODE` or `UNWRAP_MODE`)
    `certificate` - the certificate
    `random` - the source of randomness
  Throws:
    `java.security.InvalidKeyException` - if the public key in the given certificate is inappropriate for initializing this cipher, or this cipher is being initialized for decryption or unwrapping keys and requires algorithm parameters that cannot be determined from the public key in the given certificate, or the keysize of the public key in the given certificate has a keysize that exceeds the maximum allowable keysize (as determined by the configured jurisdiction policy files).

### update

    public final byte[] update(byte[] input)
                        throws java.lang.IllegalStateException

  Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

  The bytes in the `input` buffer are processed, and the result is stored in a new buffer.

  If `input` has a length of zero, this method returns `null`.

  Parameters:
    `input` - the input buffer
  Returns:
    the new buffer with the result, or null if the underlying cipher is a block cipher and the input data is too short to result in a new block.
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)

### update

    public final byte[] update(byte[] input,
                               int inputOffset,
                               int inputLen)
                        throws java.lang.IllegalStateException

  Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, are processed, and the result is stored in a new buffer.

  If `inputLen` is zero, this method returns `null`.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
  Returns:
    the new buffer with the result, or null if the underlying cipher is a block cipher and the input data is too short to result in a new block.
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)

### update

    public final int update(byte[] input,
                            int inputOffset,
                            int inputLen,
                            byte[] output)
                     throws java.lang.IllegalStateException,
                            ShortBufferException

  Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, are processed, and the result is stored in the `output` buffer.

  If the `output` buffer is too small to hold the result, a `ShortBufferException` is thrown. In this case, repeat this call with a larger output buffer. Use getOutputSize to determine how big the output buffer should be.

  If `inputLen` is zero, this method returns a length of zero.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
    `output` - the buffer for the result
  Returns:
    the number of bytes stored in `output`
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `ShortBufferException` - if the given output buffer is too small to hold the result

### update

    public final int update(byte[] input,
                            int inputOffset,
                            int inputLen,
                            byte[] output,
                            int outputOffset)
                     throws java.lang.IllegalStateException,
                            ShortBufferException

  Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, are processed, and the result is stored in the `output` buffer, starting at `outputOffset` inclusive.

  If the `output` buffer is too small to hold the result, a `ShortBufferException` is thrown. In this case, repeat this call with a larger output buffer. Use getOutputSize to determine how big the output buffer should be.

  If `inputLen` is zero, this method returns a length of zero.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
    `output` - the buffer for the result
    `outputOffset` - the offset in `output` where the result is stored
  Returns:
    the number of bytes stored in `output`
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `ShortBufferException` - if the given output buffer is too small to hold the result

### doFinal

    public final byte[] doFinal()
                         throws java.lang.IllegalStateException,
                                IllegalBlockSizeException,
                                BadPaddingException

  Finishes a multiple-part encryption or decryption operation, depending on how this cipher was initialized.

  Input data that may have been buffered during a previous `update` operation is processed, with padding (if requested) being applied. The result is stored in a new buffer.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Returns:
    the new buffer with the result
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### doFinal

    public final int doFinal(byte[] output,
                             int outputOffset)
                      throws java.lang.IllegalStateException,
                             IllegalBlockSizeException,
                             ShortBufferException,
                             BadPaddingException

  Finishes a multiple-part encryption or decryption operation, depending on how this cipher was initialized.

  Input data that may have been buffered during a previous `update` operation is processed, with padding (if requested) being applied. The result is stored in the `output` buffer, starting at `outputOffset` inclusive.

  If the `output` buffer is too small to hold the result, a `ShortBufferException` is thrown. In this case, repeat this call with a larger output buffer. Use getOutputSize to determine how big the output buffer should be.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Parameters:
    `output` - the buffer for the result
    `outputOffset` - the offset in `output` where the result is stored
  Returns:
    the number of bytes stored in `output`
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `ShortBufferException` - if the given output buffer is too small to hold the result
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### doFinal

    public final byte[] doFinal(byte[] input)
                         throws java.lang.IllegalStateException,
                                IllegalBlockSizeException,
                                BadPaddingException

  Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation. The data is encrypted or decrypted, depending on how this cipher was initialized.

  The bytes in the `input` buffer, and any input bytes that may have been buffered during a previous `update` operation, are processed, with padding (if requested) being applied. The result is stored in a new buffer.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Parameters:
    `input` - the input buffer
  Returns:
    the new buffer with the result
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### doFinal

    public final byte[] doFinal(byte[] input,
                                int inputOffset,
                                int inputLen)
                         throws java.lang.IllegalStateException,
                                IllegalBlockSizeException,
                                BadPaddingException

  Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation. The data is encrypted or decrypted, depending on how this cipher was initialized.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, and any input bytes that may have been buffered during a previous `update` operation, are processed, with padding (if requested) being applied. The result is stored in a new buffer.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
  Returns:
    the new buffer with the result
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### doFinal

    public final int doFinal(byte[] input,
                             int inputOffset,
                             int inputLen,
                             byte[] output)
                      throws java.lang.IllegalStateException,
                             ShortBufferException,
                             IllegalBlockSizeException,
                             BadPaddingException

  Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation. The data is encrypted or decrypted, depending on how this cipher was initialized.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, and any input bytes that may have been buffered during a previous `update` operation, are processed, with padding (if requested) being applied. The result is stored in the `output` buffer.

  If the `output` buffer is too small to hold the result, a `ShortBufferException` is thrown. In this case, repeat this call with a larger output buffer. Use getOutputSize to determine how big the output buffer should be.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
    `output` - the buffer for the result
  Returns:
    the number of bytes stored in `output`
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `ShortBufferException` - if the given output buffer is too small to hold the result
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### doFinal

    public final int doFinal(byte[] input,
                             int inputOffset,
                             int inputLen,
                             byte[] output,
                             int outputOffset)
                      throws java.lang.IllegalStateException,
                             ShortBufferException,
                             IllegalBlockSizeException,
                             BadPaddingException

  Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation. The data is encrypted or decrypted, depending on how this cipher was initialized.

  The first `inputLen` bytes in the `input` buffer, starting at `inputOffset` inclusive, and any input bytes that may have been buffered during a previous `update` operation, are processed, with padding (if requested) being applied. The result is stored in the `output` buffer, starting at `outputOffset` inclusive.

  If the `output` buffer is too small to hold the result, a `ShortBufferException` is thrown. In this case, repeat this call with a larger output buffer. Use getOutputSize to determine how big the output buffer should be.

  A call to this method resets this cipher object to the state it was in when previously initialized via a call to `init`. That is, the object is reset and available to encrypt or decrypt (depending on the operation mode that was specified in the call to `init`) more data.

  Parameters:
    `input` - the input buffer
    `inputOffset` - the offset in `input` where the input starts
    `inputLen` - the input length
    `output` - the buffer for the result
    `outputOffset` - the offset in `output` where the result is stored
  Returns:
    the number of bytes stored in `output`
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized)
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested (only in encryption mode), and the total input length of the data processed by this cipher is not a multiple of block size
    `ShortBufferException` - if the given output buffer is too small to hold the result
    `BadPaddingException` - if this cipher is in decryption mode, and (un)padding has been requested, but the decrypted data is not bounded by the appropriate padding bytes

### wrap

    public final byte[] wrap(java.security.Key key)
                      throws java.lang.IllegalStateException,
                             IllegalBlockSizeException,
                             java.security.InvalidKeyException

  Wrap a key.

  Parameters:
    `key` - the key to be wrapped.
  Returns:
    the wrapped key.
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized).
    `IllegalBlockSizeException` - if this cipher is a block cipher, no padding has been requested, and the length of the encoding of the key to be wrapped is not a multiple of the block size.
    ``
    java.security.InvalidKeyException - - if it is impossible or unsafe to wrap the key with this cipher (e.g., a hardware protected key is being passed to a software-only cipher).
    `java.security.InvalidKeyException`

### unwrap

    public final java.security.Key unwrap(byte[] wrappedKey,
                                          java.lang.String wrappedKeyAlgorithm,
                                          int wrappedKeyType)
                                   throws java.lang.IllegalStateException,
                                          java.security.InvalidKeyException,
                                          java.security.NoSuchAlgorithmException

  Unwrap a previously wrapped key.

  Parameters:
    `wrappedKey` - the key to be unwrapped.
    `wrappedKeyAlgorithm` - the algorithm associated with the wrapped key.
    `wrappedKeyType` - the type of the wrapped key. This must be one of `SECRET_KEY`, `PRIVATE_KEY`, or `PUBLIC_KEY`.
  Returns:
    the unwrapped key.
  Throws:
    `java.lang.IllegalStateException` - if this cipher is in a wrong state (e.g., has not been initialized).
    `java.security.InvalidKeyException` - if `wrappedKey` does not represent a wrapped key, or if the algorithm associated with the wrapped key is different from `wrappedKeyAlgorithm` and/or its key type is different from `wrappedKeyType`.
    `java.security.NoSuchAlgorithmException` - - if no installed providers can create keys for the `wrappedKeyAlgorithm`.

Overview | Package | Class | Tree | Deprecated | Index | Help
| Bouncy Castle Cryptography 1.28
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD