org.bouncycastle.crypto.modes

## Class NISTCTSBlockCipher

- java.lang.Object
- - org.bouncycastle.crypto.BufferedBlockCipher
  - - org.bouncycastle.crypto.DefaultBufferedBlockCipher
    - - org.bouncycastle.crypto.modes.NISTCTSBlockCipher

-     public class NISTCTSBlockCipher
      extends DefaultBufferedBlockCipher

  A Cipher Text Stealing (CTS) mode cipher. CTS allows block ciphers to be used to produce cipher text which is the same length as the plain text.

  This class implements the NIST version as documented in "Addendum to NIST SP 800-38A, Recommendation for Block Cipher Modes of Operation: Three Variants of Ciphertext Stealing for CBC Mode"

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `CS1`
    `static int` | `CS2`
    `static int` | `CS3`

    - ### Fields inherited from class org.bouncycastle.crypto.DefaultBufferedBlockCipher

      `buf, bufOff, cipher, forEncryption, mbCipher, partialBlockOkay, pgpCFB`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `NISTCTSBlockCipher(int type, BlockCipher cipher)` Create a buffered block cipher that uses NIST Cipher Text Stealing

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `doFinal(byte[] out, int outOff)` Process the last block in the buffer.
    `int` | `getOutputSize(int len)` return the size of the output buffer required for an update plus a doFinal with an input of len bytes.
    `int` | `getUpdateOutputSize(int len)` return the size of the output buffer required for an update an input of len bytes.
    `int` | `processByte(byte in, byte[] out, int outOff)` process a single byte, producing an output block if necessary.
    `int` | `processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)` process an array of bytes, producing output if necessary.

    - ### Methods inherited from class org.bouncycastle.crypto.DefaultBufferedBlockCipher

      `getBlockSize, getUnderlyingCipher, init, reset`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### CS1

          public static final int CS1

      See Also:
        Constant Field Values

    - #### CS2

          public static final int CS2

      See Also:
        Constant Field Values

    - #### CS3

          public static final int CS3

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### NISTCTSBlockCipher

          public NISTCTSBlockCipher(int type,
                                    BlockCipher cipher)

      Create a buffered block cipher that uses NIST Cipher Text Stealing
      Parameters:
        `type` - type of CTS mode (CS1, CS2, or CS3)
        `cipher` - the underlying block cipher used to create the CBC block cipher this cipher uses..

  - ### Method Detail

    - #### getUpdateOutputSize

          public int getUpdateOutputSize(int len)

      return the size of the output buffer required for an update an input of len bytes.
      Overrides:
        `getUpdateOutputSize` in class `DefaultBufferedBlockCipher`
      Parameters:
        `len` - the length of the input.
      Returns:
        the space required to accommodate a call to update with len bytes of input.

    - #### getOutputSize

          public int getOutputSize(int len)

      return the size of the output buffer required for an update plus a doFinal with an input of len bytes.
      Overrides:
        `getOutputSize` in class `DefaultBufferedBlockCipher`
      Parameters:
        `len` - the length of the input.
      Returns:
        the space required to accommodate a call to update and doFinal with len bytes of input.

    - #### processByte

          public int processByte(byte in,
                                 byte[] out,
                                 int outOff)
                          throws DataLengthException,
                                 java.lang.IllegalStateException

      process a single byte, producing an output block if necessary.
      Overrides:
        `processByte` in class `DefaultBufferedBlockCipher`
      Parameters:
        `in` - the input byte.
        `out` - the space for any output that might be produced.
        `outOff` - the offset from which the output will be copied.
      Returns:
        the number of output bytes copied to out.
      Throws:
        `DataLengthException` - if there isn't enough space in out.
        `java.lang.IllegalStateException` - if the cipher isn't initialised.

    - #### processBytes

          public int processBytes(byte[] in,
                                  int inOff,
                                  int len,
                                  byte[] out,
                                  int outOff)
                           throws DataLengthException,
                                  java.lang.IllegalStateException

      process an array of bytes, producing output if necessary.
      Overrides:
        `processBytes` in class `DefaultBufferedBlockCipher`
      Parameters:
        `in` - the input byte array.
        `inOff` - the offset at which the input data starts.
        `len` - the number of bytes to be copied out of the input array.
        `out` - the space for any output that might be produced.
        `outOff` - the offset from which the output will be copied.
      Returns:
        the number of output bytes copied to out.
      Throws:
        `DataLengthException` - if there isn't enough space in out.
        `java.lang.IllegalStateException` - if the cipher isn't initialised.

    - #### doFinal

          public int doFinal(byte[] out,
                             int outOff)
                      throws DataLengthException,
                             java.lang.IllegalStateException,
                             InvalidCipherTextException

      Process the last block in the buffer.
      Overrides:
        `doFinal` in class `DefaultBufferedBlockCipher`
      Parameters:
        `out` - the array the block currently being held is copied into.
        `outOff` - the offset at which the copying starts.
      Returns:
        the number of output bytes copied to out.
      Throws:
        `DataLengthException` - if there is insufficient space in out for the output.
        `java.lang.IllegalStateException` - if the underlying cipher is not initialised.
        `InvalidCipherTextException` - if cipher text decrypts wrongly (in case the exception will never get thrown).