FileDocCategorySizeDatePackage
CTSBlockCipher.javaAPI DocAzureus 3.0.3.47623Tue Jun 08 05:12:58 BST 2004org.bouncycastle.crypto.modes

CTSBlockCipher

public class CTSBlockCipher extends org.bouncycastle.crypto.BufferedBlockCipher
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.

Fields Summary
private int
blockSize
Constructors Summary
public CTSBlockCipher(org.bouncycastle.crypto.BlockCipher cipher)
Create a buffered block cipher that uses Cipher Text Stealing

param
cipher the underlying block cipher this buffering object wraps.

        if ((cipher instanceof OFBBlockCipher) || (cipher instanceof CFBBlockCipher))
        {
            throw new IllegalArgumentException("CTSBlockCipher can only accept ECB, or CBC ciphers");
        }

        this.cipher = cipher;

        blockSize = cipher.getBlockSize();

        buf = new byte[blockSize * 2];
        bufOff = 0;
Methods Summary
public intdoFinal(byte[] out, int outOff)
Process the last block in the buffer.

param
out the array the block currently being held is copied into.
param
outOff the offset at which the copying starts.
return
the number of output bytes copied to out.
exception
DataLengthException if there is insufficient space in out for the output.
exception
IllegalStateException if the underlying cipher is not initialised.
exception
InvalidCipherTextException if cipher text decrypts wrongly (in case the exception will never get thrown).

        if (bufOff + outOff > out.length)
        {
            throw new DataLengthException("output buffer to small in doFinal");
        }

        int     blockSize = cipher.getBlockSize();
        int     len = bufOff - blockSize;
        byte[]  block = new byte[blockSize];

        if (forEncryption)
        {
            cipher.processBlock(buf, 0, block, 0);

            for (int i = bufOff; i != buf.length; i++)
            {
                buf[i] = block[i - blockSize];
            }

            for (int i = blockSize; i != bufOff; i++)
            {
                buf[i] ^= block[i - blockSize];
            }

            if (cipher instanceof CBCBlockCipher)
            {
                BlockCipher c = ((CBCBlockCipher)cipher).getUnderlyingCipher();

                c.processBlock(buf, blockSize, out, outOff);
            }
            else
            {
                cipher.processBlock(buf, blockSize, out, outOff);
            }

            System.arraycopy(block, 0, out, outOff + blockSize, len);
        }
        else
        {
            byte[]  lastBlock = new byte[blockSize];

            if (cipher instanceof CBCBlockCipher)
            {
                BlockCipher c = ((CBCBlockCipher)cipher).getUnderlyingCipher();

                c.processBlock(buf, 0, block, 0);
            }
            else
            {
                cipher.processBlock(buf, 0, block, 0);
            }

            for (int i = blockSize; i != bufOff; i++)
            {
                lastBlock[i - blockSize] = (byte)(block[i - blockSize] ^ buf[i]);
            }

            System.arraycopy(buf, blockSize, block, 0, len);

            cipher.processBlock(block, 0, out, outOff);
            System.arraycopy(lastBlock, 0, out, outOff + blockSize, len);
        }

        int offset = bufOff;

        reset();

		return offset;
public intgetOutputSize(int len)
return the size of the output buffer required for an update plus a doFinal with an input of len bytes.

param
len the length of the input.
return
the space required to accommodate a call to update and doFinal with len bytes of input.

        return len + bufOff;
public intgetUpdateOutputSize(int len)
return the size of the output buffer required for an update an input of len bytes.

param
len the length of the input.
return
the space required to accommodate a call to update with len bytes of input.

        int total       = len + bufOff;
        int leftOver    = total % buf.length;

        if (leftOver == 0)
        {
            return total - buf.length;
        }

        return total - leftOver;
public intprocessByte(byte in, byte[] out, int outOff)
process a single byte, producing an output block if neccessary.

param
in the input byte.
param
out the space for any output that might be produced.
param
outOff the offset from which the output will be copied.
return
the number of output bytes copied to out.
exception
DataLengthException if there isn't enough space in out.
exception
IllegalStateException if the cipher isn't initialised.

        int         resultLen = 0;

        if (bufOff == buf.length)
        {
            resultLen = cipher.processBlock(buf, 0, out, outOff);
            System.arraycopy(buf, blockSize, buf, 0, blockSize);

            bufOff = blockSize;
        }

        buf[bufOff++] = in;

        return resultLen;
public intprocessBytes(byte[] in, int inOff, int len, byte[] out, int outOff)
process an array of bytes, producing output if necessary.

param
in the input byte array.
param
inOff the offset at which the input data starts.
param
len the number of bytes to be copied out of the input array.
param
out the space for any output that might be produced.
param
outOff the offset from which the output will be copied.
return
the number of output bytes copied to out.
exception
DataLengthException if there isn't enough space in out.
exception
IllegalStateException if the cipher isn't initialised.

        if (len < 0)
        {
            throw new IllegalArgumentException("Can't have a negative input length!");
        }

        int blockSize   = getBlockSize();
        int length      = getUpdateOutputSize(len);
        
        if (length > 0)
        {
            if ((outOff + length) > out.length)
            {
                throw new DataLengthException("output buffer too short");
            }
        }

		int resultLen = 0;
        int gapLen = buf.length - bufOff;

        if (len > gapLen)
        {
            System.arraycopy(in, inOff, buf, bufOff, gapLen);

            resultLen += cipher.processBlock(buf, 0, out, outOff);
            System.arraycopy(buf, blockSize, buf, 0, blockSize);

            bufOff = blockSize;

            len -= gapLen;
            inOff += gapLen;

            while (len > blockSize)
            {
                System.arraycopy(in, inOff, buf, bufOff, blockSize);
                resultLen += cipher.processBlock(buf, 0, out, outOff + resultLen);
                System.arraycopy(buf, blockSize, buf, 0, blockSize);

                len -= blockSize;
                inOff += blockSize;
            }
        }

        System.arraycopy(in, inOff, buf, bufOff, len);

        bufOff += len;

        return resultLen;