For the latest news and information visit The GNU Crypto project

## gnu.crypto.assembly
Class Cascade

    java.lang.Object
      |
      +--gnu.crypto.assembly.Cascade

public class Cascade
extends java.lang.Object

A Cascade Cipher is the concatenation of two or more block ciphers each with independent keys. Plaintext is input to the first stage; the output of stage `i` is input to stage `i + 1`; and the output of the last stage is the Cascade's ciphertext output.

In the simplest case, all stages in a `Cascade` have k-bit keys, and the stage inputs and outputs are all n-bit quantities. The stage ciphers may differ (general cascade of ciphers), or all be identical (cascade of identical ciphers).

The term "block ciphers" used above refers to implementations of `IMode`, including the `ECB` mode which basically exposes a symmetric-key block cipher algorithm as a Mode of Operations.

References:

1. [HAC]: Handbook of Applied Cryptography.
   CRC Press, Inc. ISBN 0-8493-8523-7, 1997
   Menezes, A., van Oorschot, P. and S. Vanstone.

Field Summary
`protected int` `blockSize` The curently set block-size for this instance.
`static java.lang.String` `DIRECTION`
`protected java.util.LinkedList` `stageKeys` The ordered list of Stage UIDs to their attribute maps.
`protected java.util.HashMap` `stages` The map of Stages chained in this cascade.
`protected Direction` `wired` The current operational direction of this instance.

Constructor Summary
`Cascade()`

Method Summary
`java.lang.Object` `append(Stage stage)` Adds to the end of the current chain, a designated `Stage`.
`java.util.Set` `blockSizes()` Returns the `Set` of supported block sizes for this `Cascade` that are common to all of its chained stages.
`int` `currentBlockSize()` Returns the currently set block size for the chain.
`void` `init(java.util.Map attributes)` Initialises the chain for operation with specific characteristics.
`java.lang.Object` `insert(int index, Stage stage)` Inserts a `Stage` into the current chain, at the specified index (zero-based) position.
`java.lang.Object` `prepend(Stage stage)` Adds to the begining of the current chain, a designated `Stage`.
`void` `reset()` Resets the chain for re-initialisation and use with other characteristics.
`boolean` `selfTest()` Conducts a simple correctness test that consists of basic symmetric encryption / decryption test(s) for all supported block and key sizes of underlying block cipher(s) wrapped by Mode leafs.
`int` `size()` Returns the current number of stages in this chain.
`java.util.Iterator` `stages()` Returns an `Iterator` over the stages contained in this instance.
`void` `update(byte[] in, int inOffset, byte[] out, int outOffset)` Processes exactly one block of plaintext (if initialised in the `Direction.FORWARD` state) or ciphertext (if initialised in the `Direction.REVERSED` state).

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

Field Detail

### DIRECTION

    public static final java.lang.String DIRECTION

See Also:
  Constant Field Values

### stages

    protected java.util.HashMap stages

  The map of Stages chained in this cascade.

### stageKeys

    protected java.util.LinkedList stageKeys

  The ordered list of Stage UIDs to their attribute maps.

### wired

    protected Direction wired

  The current operational direction of this instance.

### blockSize

    protected int blockSize

  The curently set block-size for this instance.

Constructor Detail

### Cascade

    public Cascade()

Method Detail

### append

    public java.lang.Object append(Stage stage)
                            throws java.lang.IllegalArgumentException

  Adds to the end of the current chain, a designated `Stage`.

  Parameters:
    `stage` - the `Stage` to append to the chain.
  Returns:
    a unique identifier for this stage, within this cascade.
  Throws:
    `java.lang.IllegalStateException` - if the instance is already initialised.
    `java.lang.IllegalArgumentException` - if the designated stage is already in the chain, or it has incompatible characteristics with the current elements already in the chain.

### prepend

    public java.lang.Object prepend(Stage stage)
                             throws java.lang.IllegalArgumentException

  Adds to the begining of the current chain, a designated `Stage`.

  Parameters:
    `stage` - the `Stage` to prepend to the chain.
  Returns:
    a unique identifier for this stage, within this cascade.
  Throws:
    `java.lang.IllegalStateException` - if the instance is already initialised.
    `java.lang.IllegalArgumentException` - if the designated stage is already in the chain, or it has incompatible characteristics with the current elements already in the chain.

### insert

    public java.lang.Object insert(int index,
                                   Stage stage)
                            throws java.lang.IllegalArgumentException,
                                   java.lang.IndexOutOfBoundsException

  Inserts a `Stage` into the current chain, at the specified index (zero-based) position.

  Parameters:
    `stage` - the `Stage` to insert into the chain.
  Returns:
    a unique identifier for this stage, within this cascade.
  Throws:
    `java.lang.IllegalArgumentException` - if the designated stage is already in the chain, or it has incompatible characteristics with the current elements already in the chain.
    `java.lang.IllegalStateException` - if the instance is already initialised.
    `java.lang.IndexOutOfBoundsException` - if `index` is less than `0` or greater than the current size of this cascade.

### size

    public int size()

  Returns the current number of stages in this chain.

  Returns:
    the current count of stages in this chain.

### stages

    public java.util.Iterator stages()

  Returns an `Iterator` over the stages contained in this instance. Each element of this iterator is a concrete implementation of a `Stage`.

  Returns:
    an `Iterator` over the stages contained in this instance. Each element of the returned iterator is a concrete instance of a `Stage`.

### blockSizes

    public java.util.Set blockSizes()

  Returns the `Set` of supported block sizes for this `Cascade` that are common to all of its chained stages. Each element in the returned `Set` is an instance of `Integer`.

  Returns:
    a `Set` of supported block sizes common to all the stages of the chain.

### init

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

  Initialises the chain for operation with specific characteristics.

  Parameters:
    `attributes` - a set of name-value pairs that describes the desired future behaviour of this instance.
  Throws:
    `java.lang.IllegalStateException` - if the chain, or any of its stages, is already initialised.
    `java.security.InvalidKeyException` - if the intialisation data provided with the stage is incorrect or causes an invalid key to be generated.
  See Also:
    `Direction.FORWARD`, `Direction.REVERSED`

### currentBlockSize

    public int currentBlockSize()

  Returns the currently set block size for the chain.

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

### reset

    public void reset()

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

### update

    public void update(byte[] in,
                       int inOffset,
                       byte[] out,
                       int outOffset)

  Processes exactly one block of plaintext (if initialised in the `Direction.FORWARD` state) or ciphertext (if initialised in the `Direction.REVERSED` state).

  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()

  Conducts a simple correctness test that consists of basic symmetric encryption / decryption test(s) for all supported block and key sizes of underlying block cipher(s) wrapped by Mode leafs. The test also includes one (1) variable key Known Answer Test (KAT) for each block cipher.

  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.