package org.bouncycastle.crypto;

a wrapper for block ciphers with a single byte block size, so that they
can be treated like stream ciphers.
/**
 * a wrapper for block ciphers with a single byte block size, so that they
 * can be treated like stream ciphers.
 */
public class StreamBlockCipher
    implements StreamCipher
{
    private BlockCipher  cipher;

    private byte[]  oneByte = new byte[1];

    
basic constructor.
Params:
cipher – the block cipher to be wrapped.
Throws:
IllegalArgumentException – if the cipher has a block size other than
one./**
     * basic constructor.
     *
     * @param cipher the block cipher to be wrapped.
     * @exception IllegalArgumentException if the cipher has a block size other than
     * one.
     */
    public StreamBlockCipher(
        BlockCipher cipher)
    {
        if (cipher.getBlockSize() != 1)
        {
            throw new IllegalArgumentException("block cipher block size != 1.");
        }

        this.cipher = cipher;
    }

    
initialise the underlying cipher.
Params:
forEncryption – true if we are setting up for encryption, false otherwise.
params – the necessary parameters for the underlying cipher to be initialised./**
     * initialise the underlying cipher.
     *
     * @param forEncryption true if we are setting up for encryption, false otherwise.
     * @param params the necessary parameters for the underlying cipher to be initialised.
     */
    public void init(
        boolean forEncryption,
        CipherParameters params)
    {
        cipher.init(forEncryption, params);
    }

    
return the name of the algorithm we are wrapping.
Returns:
the name of the algorithm we are wrapping./**
     * return the name of the algorithm we are wrapping.
     *
     * @return the name of the algorithm we are wrapping.
     */
    public String getAlgorithmName()
    {
        return cipher.getAlgorithmName();
    }

    
encrypt/decrypt a single byte returning the result.
Params:
in – the byte to be processed.
Returns:
the result of processing the input byte./**
     * encrypt/decrypt a single byte returning the result.
     *
     * @param in the byte to be processed.
     * @return the result of processing the input byte.
     */
    public byte returnByte(
        byte    in)
    {
        oneByte[0] = in;

        cipher.processBlock(oneByte, 0, oneByte, 0);

        return oneByte[0];
    }

    
process a block of bytes from in putting the result into out.
Params:
in – the input byte array.
inOff – the offset into the in array where the data to be processed starts.
len – the number of bytes to be processed.
out – the output buffer the processed bytes go into.
outOff – the offset into the output byte array the processed data stars at.
Throws:
DataLengthException – if the output buffer is too small./**
     * process a block of bytes from in putting the result into out.
     * 
     * @param in the input byte array.
     * @param inOff the offset into the in array where the data to be processed starts.
     * @param len the number of bytes to be processed.
     * @param out the output buffer the processed bytes go into.   
     * @param outOff the offset into the output byte array the processed data stars at.
     * @exception DataLengthException if the output buffer is too small.
     */
    public void processBytes(
        byte[]  in,
        int     inOff,
        int     len,
        byte[]  out,
        int     outOff)
        throws DataLengthException
    {
        if (outOff + len > out.length)
        {
            throw new DataLengthException("output buffer too small in processBytes()");
        }

        for (int i = 0; i != len; i++)
        {
                cipher.processBlock(in, inOff + i, out, outOff + i);
        }
    }

    
reset the underlying cipher. This leaves it in the same state
it was at after the last init (if there was one).
/**
     * reset the underlying cipher. This leaves it in the same state
     * it was at after the last init (if there was one).
     */
    public void reset()
    {
        cipher.reset();
    }
}