1 files changed, 29 insertions, 79 deletions

diff --git a/bcprov/src/main/java/org/bouncycastle/crypto/StreamBlockCipher.java b/bcprov/src/main/java/org/bouncycastle/crypto/StreamBlockCipher.java
index 8fdd232..09aadfb 100644
--- a/bcprov/src/main/java/org/bouncycastle/crypto/StreamBlockCipher.java
+++ b/bcprov/src/main/java/org/bouncycastle/crypto/StreamBlockCipher.java
@@ -1,108 +1,58 @@
 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 parent class for block cipher modes that do not require block aligned data to be processed, but can function in
+ * a streaming mode.
  */
-public class StreamBlockCipher
-    implements StreamCipher
+public abstract class StreamBlockCipher
+    implements BlockCipher, StreamCipher
 {
-    private BlockCipher  cipher;
+    private final 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)
+    protected StreamBlockCipher(BlockCipher cipher)
     {
-        if (cipher.getBlockSize() != 1)
-        {
-            throw new IllegalArgumentException("block cipher block size != 1.");
-        }
-
         this.cipher = cipher;
     }
 
     /**
-     * initialise the underlying cipher.
+     * return the underlying block cipher that we are wrapping.
      *
-     * @param forEncryption true if we are setting up for encryption, false otherwise.
-     * @param params the necessary parameters for the underlying cipher to be initialised.
+     * @return the underlying block cipher that we are wrapping.
      */
-    public void init(
-        boolean forEncryption,
-        CipherParameters params)
+    public BlockCipher getUnderlyingCipher()
     {
-        cipher.init(forEncryption, params);
+        return cipher;
     }
 
-    /**
-     * return the name of the algorithm we are wrapping.
-     *
-     * @return the name of the algorithm we are wrapping.
-     */
-    public String getAlgorithmName()
+    public final byte returnByte(byte in)
     {
-        return cipher.getAlgorithmName();
+        return calculateByte(in);
     }
 
-    /**
-     * 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)
+    public int 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()");
+            throw new DataLengthException("output buffer too short");
         }
 
-        for (int i = 0; i != len; i++)
+        if (inOff + len > in.length)
         {
-                cipher.processBlock(in, inOff + i, out, outOff + i);
+            throw new DataLengthException("input buffer too small");
         }
-    }
 
-    /**
-     * 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();
+        int inStart = inOff;
+        int inEnd = inOff + len;
+        int outStart = outOff;
+
+        while (inStart < inEnd)
+        {
+             out[outStart++] = calculateByte(in[inStart++]);
+        }
+
+        return len;
     }
-}
+
+    protected abstract byte calculateByte(byte b);
+}
\ No newline at end of file