| package org.bouncycastle.crypto; |
| |
| /** |
| * 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. |
| * |
| * @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. |
| * |
| * @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. |
| * |
| * @return the name of the algorithm we are wrapping. |
| */ |
| public String getAlgorithmName() |
| { |
| return cipher.getAlgorithmName(); |
| } |
| |
| /** |
| * 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. |
| * |
| * @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). |
| */ |
| public void reset() |
| { |
| cipher.reset(); |
| } |
| } |