org.spongycastle.crypto.StreamBlockCipher Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of scprov-jdk15on Show documentation
Show all versions of scprov-jdk15on Show documentation
The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms.
This jar contains JCE provider for the Bouncy Castle Cryptography APIs for JDK 1.5 to JDK 1.7.
package org.spongycastle.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();
}
}