For the latest news and information visit The GNU Crypto project

## gnu.crypto.cipher
Interface IBlockCipher

All Superinterfaces:
  java.lang.Cloneable

All Known Subinterfaces:
  IMode

All Known Implementing Classes:
  BaseCipher, BaseMode

public interface IBlockCipher
extends java.lang.Cloneable

The basic visible methods of any symmetric key block cipher.

A symmetric key block cipher is a function that maps n-bit plaintext blocks to n-bit ciphertext blocks; n being the cipher's block size. This encryption function is parameterised by a k-bit key, and is invertible. Its inverse is the decryption function.

Possible initialisation values for an instance of this type are:

- The block size in which to operate this block cipher instance. This value is optional, if unspecified, the block cipher's default block size shall be used.
- The byte array containing the user supplied key material to use for generating the cipher's session key(s). This value is mandatory and should be included in the initialisation parameters. If it isn't, an `IllegalStateException` will be thrown if any method, other than `reset()` is invoked on the instance. Furthermore, the size of this key material shall be taken as an indication on the key size in which to operate this instance.

IMPLEMENTATION NOTE: Although all the concrete classes in this package implement the `Cloneable` interface, it is important to note here that such an operation DOES NOT clone any session key material that may have been used in initialising the source cipher (the instance to be cloned). Instead a clone of an already initialised cipher is another instance that operates with the same block size but without any knowledge of neither key material nor key size.

Field Summary
`static java.lang.String` `CIPHER_BLOCK_SIZE` Property name of the block size in which to operate a block cipher.
`static java.lang.String` `KEY_MATERIAL` Property name of the user-supplied key material.

Method Summary
`java.util.Iterator` `blockSizes()` Returns an `Iterator` over the supported block sizes.
`java.lang.Object` `clone()` Returns a clone of this instance.
`int` `currentBlockSize()` Returns the currently set block size for this instance.
`void` `decryptBlock(byte[] in, int inOffset, byte[] out, int outOffset)` Decrypts exactly one block of ciphertext.
`int` `defaultBlockSize()` Returns the default value, in bytes, of the algorithm's block size.
`int` `defaultKeySize()` Returns the default value, in bytes, of the algorithm's key size.
`void` `encryptBlock(byte[] in, int inOffset, byte[] out, int outOffset)` Encrypts exactly one block of plaintext.
`void` `init(java.util.Map attributes)` Initialises the algorithm with designated attributes.
`java.util.Iterator` `keySizes()` Returns an `Iterator` over the supported key sizes.
`java.lang.String` `name()` Returns the canonical name of this instance.
`void` `reset()` Resets the algorithm instance for re-initialisation and use with other characteristics.
`boolean` `selfTest()` A correctness test that consists of basic symmetric encryption / decryption test(s) for all supported block and key sizes, as well as one (1) variable key Known Answer Test (KAT).

Field Detail

### CIPHER_BLOCK_SIZE

    public static final java.lang.String CIPHER_BLOCK_SIZE

  Property name of the block size in which to operate a block cipher. The value associated with this property name is taken to be an `Integer`.

  See Also:
    Constant Field Values

### KEY_MATERIAL

    public static final java.lang.String KEY_MATERIAL

  Property name of the user-supplied key material. The value associated to this property name is taken to be a byte array.

  See Also:
    Constant Field Values

Method Detail

### name

    public java.lang.String name()

  Returns the canonical name of this instance.

  Returns:
    the canonical name of this instance.

### defaultBlockSize

    public int defaultBlockSize()

  Returns the default value, in bytes, of the algorithm's block size.

  Returns:
    the default value, in bytes, of the algorithm's block size.

### defaultKeySize

    public int defaultKeySize()

  Returns the default value, in bytes, of the algorithm's key size.

  Returns:
    the default value, in bytes, of the algorithm's key size.

### blockSizes

    public java.util.Iterator blockSizes()

  Returns an `Iterator` over the supported block sizes. Each element returned by this object is an `Integer`.

  Returns:
    an `Iterator` over the supported block sizes.

### keySizes

    public java.util.Iterator keySizes()

  Returns an `Iterator` over the supported key sizes. Each element returned by this object is an `Integer`.

  Returns:
    an `Iterator` over the supported key sizes.

### clone

    public java.lang.Object clone()

  Returns a clone of this instance.

  Returns:
    a clone copy of this instance.

### init

    public void init(java.util.Map attributes)
              throws java.security.InvalidKeyException,
                     java.lang.IllegalStateException

  Initialises the algorithm with designated attributes. Permissible names and values are described in the class documentation above.

  Parameters:
    `attributes` - a set of name-value pairs that describes the desired future behaviour of this instance.
  Throws:
    `java.security.InvalidKeyException` - if the key data is invalid.
    `java.lang.IllegalStateException` - if the instance is already initialised.
  See Also:
    `KEY_MATERIAL`, `CIPHER_BLOCK_SIZE`

### currentBlockSize

    public int currentBlockSize()
                         throws java.lang.IllegalStateException

  Returns the currently set block size for this instance.

  Returns:
    the current block size for this instance.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.

### reset

    public void reset()

  Resets the algorithm instance for re-initialisation and use with other characteristics. This method always succeeds.

### encryptBlock

    public void encryptBlock(byte[] in,
                             int inOffset,
                             byte[] out,
                             int outOffset)
                      throws java.lang.IllegalStateException

  Encrypts exactly one block of plaintext.

  Parameters:
    `in` - the plaintext.
    `inOffset` - index of `in` from which to start considering data.
    `out` - the ciphertext.
    `outOffset` - index of `out` from which to store result.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.

### decryptBlock

    public void decryptBlock(byte[] in,
                             int inOffset,
                             byte[] out,
                             int outOffset)
                      throws java.lang.IllegalStateException

  Decrypts exactly one block of ciphertext.

  Parameters:
    `in` - the plaintext.
    `inOffset` - index of `in` from which to start considering data.
    `out` - the ciphertext.
    `outOffset` - index of `out` from which to store result.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.

### selfTest

    public boolean selfTest()

  A correctness test that consists of basic symmetric encryption / decryption test(s) for all supported block and key sizes, as well as one (1) variable key Known Answer Test (KAT).

  Returns:
    `true` if the implementation passes simple correctness tests. Returns `false` otherwise.

For the latest news and information visit The GNU Crypto project

Copyright © 2001, 2002, 2003, 2004 Free Software Foundation, Inc.