init() methods, a Mode instance would operate with
* the same block size as its underlying block cipher. As mentioned earlier,
* the block size of the underlying block cipher itself is specified in one of
* the method(s) available in the factory class.
*
* @return the default value, in bytes, of the mode's block size.
* @see ModeFactory
*/
public int defaultBlockSize()
{
return cipherBlockSize;
}
/**
* Returns the default value, in bytes, of the underlying block cipher key
* size.
*
* @return the default value, in bytes, of the underlying cipher's key size.
*/
public int defaultKeySize()
{
return cipher.defaultKeySize();
}
/**
* Returns an {@link Iterator} over the supported block sizes. Each element
* returned by this object is an {@link Integer}.
* * The default behaviour is to return an iterator with just one value, which * is that currently configured for the underlying block cipher. Concrete * implementations may override this behaviour to signal their ability to * support other values. * * @return an {@link Iterator} over the supported block sizes. */ public Iterator blockSizes() { ArrayList al = new ArrayList(); al.add(Integer.valueOf(cipherBlockSize)); return Collections.unmodifiableList(al).iterator(); } /** * Returns an {@link Iterator} over the supported underlying block cipher key * sizes. Each element returned by this object is an instance of * {@link Integer}. * * @return an {@link Iterator} over the supported key sizes. */ public Iterator keySizes() { return cipher.keySizes(); } public void init(Map attributes) throws InvalidKeyException, IllegalStateException { synchronized (lock) { if (state != -1) throw new IllegalStateException(); Integer want = (Integer) attributes.get(STATE); if (want != null) { switch (want.intValue()) { case ENCRYPTION: state = ENCRYPTION; break; case DECRYPTION: state = DECRYPTION; break; default: throw new IllegalArgumentException(); } } Integer bs = (Integer) attributes.get(MODE_BLOCK_SIZE); modeBlockSize = (bs == null ? cipherBlockSize : bs.intValue()); byte[] iv = (byte[]) attributes.get(IV); if (iv != null) this.iv = (byte[]) iv.clone(); else this.iv = new byte[modeBlockSize]; cipher.init(attributes); setup(); } } public int currentBlockSize() { if (state == -1) throw new IllegalStateException(); return modeBlockSize; } public void reset() { synchronized (lock) { state = -1; iv = null; cipher.reset(); teardown(); } } public boolean selfTest() { int ks; Iterator bit; for (Iterator kit = keySizes(); kit.hasNext();) { ks = ((Integer) kit.next()).intValue(); for (bit = blockSizes(); bit.hasNext();) if (! testSymmetry(ks, ((Integer) bit.next()).intValue())) return false; } return true; } public abstract Object clone(); /** The initialisation phase of the concrete mode implementation. */ public abstract void setup(); /** The termination phase of the concrete mode implementation. */ public abstract void teardown(); public abstract void encryptBlock(byte[] in, int i, byte[] out, int o); public abstract void decryptBlock(byte[] in, int i, byte[] out, int o); private boolean testSymmetry(int ks, int bs) { try { IMode mode = (IMode) this.clone(); byte[] iv = new byte[cipherBlockSize]; // all zeroes byte[] k = new byte[ks]; int i; for (i = 0; i < ks; i++) k[i] = (byte) i; int blockCount = 5; int limit = blockCount * bs; byte[] pt = new byte[limit]; for (i = 0; i < limit; i++) pt[i] = (byte) i; byte[] ct = new byte[limit]; byte[] cpt = new byte[limit]; Map map = new HashMap(); map.put(KEY_MATERIAL, k); map.put(CIPHER_BLOCK_SIZE, Integer.valueOf(cipherBlockSize)); map.put(STATE, Integer.valueOf(ENCRYPTION)); map.put(IV, iv); map.put(MODE_BLOCK_SIZE, Integer.valueOf(bs)); mode.reset(); mode.init(map); for (i = 0; i < blockCount; i++) mode.update(pt, i * bs, ct, i * bs); mode.reset(); map.put(STATE, Integer.valueOf(DECRYPTION)); mode.init(map); for (i = 0; i < blockCount; i++) mode.update(ct, i * bs, cpt, i * bs); return Arrays.equals(pt, cpt); } catch (Exception x) { x.printStackTrace(System.err); return false; } } }