package org.bouncycastle.crypto.modes; import org.bouncycastle.crypto.BlockCipher; import org.bouncycastle.crypto.CipherParameters; import org.bouncycastle.crypto.DataLengthException; import org.bouncycastle.crypto.params.ParametersWithIV; /** * Implements OpenPGP's rather strange version of Cipher-FeedBack (CFB) mode on top of a simple cipher. For further info see <a href="http://www.ietf.org/rfc/rfc2440.html">RFC 2440</a>. */ public class PGPCFBBlockCipher implements BlockCipher { private byte[] IV; private byte[] FR; private byte[] FRE; private byte[] tmp; private BlockCipher cipher; private int count; private int blockSize; private boolean forEncryption; private boolean inlineIv; // if false we don't need to prepend an IV /** * Basic constructor. * * @param cipher the block cipher to be used as the basis of the * feedback mode. * @param inlineIv if true this is for PGP CFB with a prepended iv. */ public PGPCFBBlockCipher( BlockCipher cipher, boolean inlineIv) { this.cipher = cipher; this.inlineIv = inlineIv; this.blockSize = cipher.getBlockSize(); this.IV = new byte[blockSize]; this.FR = new byte[blockSize]; this.FRE = new byte[blockSize]; this.tmp = new byte[blockSize]; } /** * return the underlying block cipher that we are wrapping. * * @return the underlying block cipher that we are wrapping. */ public BlockCipher getUnderlyingCipher() { return cipher; } /** * return the algorithm name and mode. * * @return the name of the underlying algorithm followed by "/PGPCFB" * and the block size in bits. */ public String getAlgorithmName() { if (inlineIv) { return cipher.getAlgorithmName() + "/PGPCFBwithIV"; } else { return cipher.getAlgorithmName() + "/PGPCFB"; } } /** * return the block size we are operating at. * * @return the block size we are operating at (in bytes). */ public int getBlockSize() { return cipher.getBlockSize(); } /** * Process one block of input from the array in and write it to * the out array. * * @param in the array containing the input data. * @param inOff offset into the in array the data starts at. * @param out the array the output data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ public int processBlock( byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException { if (inlineIv) { return (forEncryption) ? encryptBlockWithIV(in, inOff, out, outOff) : decryptBlockWithIV(in, inOff, out, outOff); } else { return (forEncryption) ? encryptBlock(in, inOff, out, outOff) : decryptBlock(in, inOff, out, outOff); } } /** * reset the chaining vector back to the IV and reset the underlying * cipher. */ public void reset() { count = 0; for (int i = 0; i != FR.length; i++) { if (inlineIv) FR[i] = 0; else FR[i] = IV[i]; // if simple mode, key is IV (even if this is zero) } cipher.reset(); } /** * Initialise the cipher and, possibly, the initialisation vector (IV). * If an IV isn't passed as part of the parameter, the IV will be all zeros. * An IV which is too short is handled in FIPS compliant fashion. * * @param forEncryption if true the cipher is initialised for * encryption, if false for decryption. * @param param the key and other data required by the cipher. * @exception IllegalArgumentException if the params argument is * inappropriate. */ public void init( boolean forEncryption, CipherParameters params) throws IllegalArgumentException { this.forEncryption = forEncryption; if (params instanceof ParametersWithIV) { ParametersWithIV ivParam = (ParametersWithIV)params; byte[] iv = ivParam.getIV(); if (iv.length < IV.length) { // prepend the supplied IV with zeros (per FIPS PUB 81) System.arraycopy(iv, 0, IV, IV.length - iv.length, iv.length); for (int i = 0; i < IV.length - iv.length; i++) { IV[i] = 0; } } else { System.arraycopy(iv, 0, IV, 0, IV.length); } reset(); cipher.init(true, ivParam.getParameters()); } else { reset(); cipher.init(true, params); } } /** * Encrypt one byte of data according to CFB mode. * @param data the byte to encrypt * @param where am i in the current block, determines when to resync the block * @returns the encrypted byte */ private byte encryptByte(byte data, int blockOff) { return (byte)(FRE[blockOff] ^ data); } /** * Do the appropriate processing for CFB IV mode encryption. * * @param in the array containing the data to be encrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ private int encryptBlockWithIV( byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException { if ((inOff + blockSize) > in.length) { throw new DataLengthException("input buffer too short"); } if ((outOff + blockSize) > out.length) { throw new DataLengthException("output buffer too short"); } if (count == 0) { cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize; n++) { out[outOff + n] = encryptByte(IV[n], n); } System.arraycopy(out, outOff, FR, 0, blockSize); cipher.processBlock(FR, 0, FRE, 0); out[outOff + blockSize] = encryptByte(IV[blockSize - 2], 0); out[outOff + blockSize + 1] = encryptByte(IV[blockSize - 1], 1); System.arraycopy(out, outOff + 2, FR, 0, blockSize); cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize; n++) { out[outOff + blockSize + 2 + n] = encryptByte(in[inOff + n], n); } System.arraycopy(out, outOff + blockSize + 2, FR, 0, blockSize); count += 2 * blockSize + 2; return 2 * blockSize + 2; } else if (count >= blockSize + 2) { cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize; n++) { out[outOff + n] = encryptByte(in[inOff + n], n); } System.arraycopy(out, outOff, FR, 0, blockSize); } return blockSize; } /** * Do the appropriate processing for CFB IV mode decryption. * * @param in the array containing the data to be decrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ private int decryptBlockWithIV( byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException { if ((inOff + blockSize) > in.length) { throw new DataLengthException("input buffer too short"); } if ((outOff + blockSize) > out.length) { throw new DataLengthException("output buffer too short"); } if (count == 0) { for (int n = 0; n < blockSize; n++) { FR[n] = in[inOff + n]; } cipher.processBlock(FR, 0, FRE, 0); count += blockSize; return 0; } else if (count == blockSize) { // copy in buffer so that this mode works if in and out are the same System.arraycopy(in, inOff, tmp, 0, blockSize); System.arraycopy(FR, 2, FR, 0, blockSize - 2); FR[blockSize - 2] = tmp[0]; FR[blockSize - 1] = tmp[1]; cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize - 2; n++) { out[outOff + n] = encryptByte(tmp[n + 2], n); } System.arraycopy(tmp, 2, FR, 0, blockSize - 2); count += 2; return blockSize - 2; } else if (count >= blockSize + 2) { // copy in buffer so that this mode works if in and out are the same System.arraycopy(in, inOff, tmp, 0, blockSize); out[outOff + 0] = encryptByte(tmp[0], blockSize - 2); out[outOff + 1] = encryptByte(tmp[1], blockSize - 1); System.arraycopy(tmp, 0, FR, blockSize - 2, 2); cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize - 2; n++) { out[outOff + n + 2] = encryptByte(tmp[n + 2], n); } System.arraycopy(tmp, 2, FR, 0, blockSize - 2); } return blockSize; } /** * Do the appropriate processing for CFB mode encryption. * * @param in the array containing the data to be encrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ private int encryptBlock( byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException { if ((inOff + blockSize) > in.length) { throw new DataLengthException("input buffer too short"); } if ((outOff + blockSize) > out.length) { throw new DataLengthException("output buffer too short"); } cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize; n++) out[outOff + n] = encryptByte(in[inOff + n], n); for (int n = 0; n < blockSize; n++) FR[n] = out[outOff + n]; return blockSize; } /** * Do the appropriate processing for CFB mode decryption. * * @param in the array containing the data to be decrypted. * @param inOff offset into the in array the data starts at. * @param out the array the encrypted data will be copied into. * @param outOff the offset into the out array the output will start at. * @exception DataLengthException if there isn't enough data in in, or * space in out. * @exception IllegalStateException if the cipher isn't initialised. * @return the number of bytes processed and produced. */ private int decryptBlock( byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException { if ((inOff + blockSize) > in.length) { throw new DataLengthException("input buffer too short"); } if ((outOff + blockSize) > out.length) { throw new DataLengthException("output buffer too short"); } cipher.processBlock(FR, 0, FRE, 0); for (int n = 0; n < blockSize; n++) out[outOff + n] = encryptByte(in[inOff + n], n); for (int n = 0; n < blockSize; n++) FR[n] = in[inOff + n]; return blockSize; } }