aes.java

thinking in java4 src

			for (int j = 1; j < ROUNDS; j++)
			{
				for (int i = 0; i < 4; i++)
				{
					W[j][i] = inv_mcol(W[j][i]);
				}
			}
		}

		return W;
	}

	private int ROUNDS;
	private int[][] WorkingKey = null;
	private int C0, C1, C2, C3;
	private boolean doEncrypt;

	private static final int BLOCK_SIZE = 16;

	/**
	 * default constructor - 128 bit block size.
	 */
	public AES()
	{
	}

	/**
	 * initialise an AES cipher.
	 * 
	 * @param forEncryption
	 *            whether or not we are for encryption.
	 * @param key
	 *            the key required to set up the cipher.
	 * @exception IllegalArgumentException
	 *                if the params argument is inappropriate.
	 */

	public final void init(boolean forEncryption, byte[] key)
	{
		WorkingKey = generateWorkingKey(key, forEncryption);
		this.doEncrypt = forEncryption;
	}

	public final String getAlgorithmName()
	{
		return "AES";
	}

	public final int getBlockSize()
	{
		return BLOCK_SIZE;
	}

	public final int processBlock(byte[] in, int inOff, byte[] out, int outOff)
	{
		if (WorkingKey == null)
		{
			throw new IllegalStateException("AES engine not initialised");
		}

		if ((inOff + (32 / 2)) > in.length)
		{
			throw new IllegalArgumentException("input buffer too short");
		}

		if ((outOff + (32 / 2)) > out.length)
		{
			throw new IllegalArgumentException("output buffer too short");
		}

		if (doEncrypt)
		{
			unpackBlock(in, inOff);
			encryptBlock(WorkingKey);
			packBlock(out, outOff);
		}
		else
		{
			unpackBlock(in, inOff);
			decryptBlock(WorkingKey);
			packBlock(out, outOff);
		}

		return BLOCK_SIZE;
	}

	public final void reset()
	{
	}

	private final void unpackBlock(byte[] bytes, int off)
	{
		int index = off;

		C0 = (bytes[index++] & 0xff);
		C0 |= (bytes[index++] & 0xff) << 8;
		C0 |= (bytes[index++] & 0xff) << 16;
		C0 |= bytes[index++] << 24;

		C1 = (bytes[index++] & 0xff);
		C1 |= (bytes[index++] & 0xff) << 8;
		C1 |= (bytes[index++] & 0xff) << 16;
		C1 |= bytes[index++] << 24;

		C2 = (bytes[index++] & 0xff);
		C2 |= (bytes[index++] & 0xff) << 8;
		C2 |= (bytes[index++] & 0xff) << 16;
		C2 |= bytes[index++] << 24;

		C3 = (bytes[index++] & 0xff);
		C3 |= (bytes[index++] & 0xff) << 8;
		C3 |= (bytes[index++] & 0xff) << 16;
		C3 |= bytes[index++] << 24;
	}

	private final void packBlock(byte[] bytes, int off)
	{
		int index = off;

		bytes[index++] = (byte) C0;
		bytes[index++] = (byte) (C0 >> 8);
		bytes[index++] = (byte) (C0 >> 16);
		bytes[index++] = (byte) (C0 >> 24);

		bytes[index++] = (byte) C1;
		bytes[index++] = (byte) (C1 >> 8);
		bytes[index++] = (byte) (C1 >> 16);
		bytes[index++] = (byte) (C1 >> 24);

		bytes[index++] = (byte) C2;
		bytes[index++] = (byte) (C2 >> 8);
		bytes[index++] = (byte) (C2 >> 16);
		bytes[index++] = (byte) (C2 >> 24);

		bytes[index++] = (byte) C3;
		bytes[index++] = (byte) (C3 >> 8);
		bytes[index++] = (byte) (C3 >> 16);
		bytes[index++] = (byte) (C3 >> 24);
	}

	private final void encryptBlock(int[][] KW)
	{
		int r, r0, r1, r2, r3;

		C0 ^= KW[0][0];
		C1 ^= KW[0][1];
		C2 ^= KW[0][2];
		C3 ^= KW[0][3];

		for (r = 1; r < ROUNDS - 1;)
		{
			r0 = T0[C0 & 255] ^ T1[(C1 >> 8) & 255] ^ T2[(C2 >> 16) & 255] ^ T3[(C3 >> 24) & 255] ^ KW[r][0];
			r1 = T0[C1 & 255] ^ T1[(C2 >> 8) & 255] ^ T2[(C3 >> 16) & 255] ^ T3[(C0 >> 24) & 255] ^ KW[r][1];
			r2 = T0[C2 & 255] ^ T1[(C3 >> 8) & 255] ^ T2[(C0 >> 16) & 255] ^ T3[(C1 >> 24) & 255] ^ KW[r][2];
			r3 = T0[C3 & 255] ^ T1[(C0 >> 8) & 255] ^ T2[(C1 >> 16) & 255] ^ T3[(C2 >> 24) & 255] ^ KW[r++][3];
			C0 = T0[r0 & 255] ^ T1[(r1 >> 8) & 255] ^ T2[(r2 >> 16) & 255] ^ T3[(r3 >> 24) & 255] ^ KW[r][0];
			C1 = T0[r1 & 255] ^ T1[(r2 >> 8) & 255] ^ T2[(r3 >> 16) & 255] ^ T3[(r0 >> 24) & 255] ^ KW[r][1];
			C2 = T0[r2 & 255] ^ T1[(r3 >> 8) & 255] ^ T2[(r0 >> 16) & 255] ^ T3[(r1 >> 24) & 255] ^ KW[r][2];
			C3 = T0[r3 & 255] ^ T1[(r0 >> 8) & 255] ^ T2[(r1 >> 16) & 255] ^ T3[(r2 >> 24) & 255] ^ KW[r++][3];
		}

		r0 = T0[C0 & 255] ^ T1[(C1 >> 8) & 255] ^ T2[(C2 >> 16) & 255] ^ T3[(C3 >> 24) & 255] ^ KW[r][0];
		r1 = T0[C1 & 255] ^ T1[(C2 >> 8) & 255] ^ T2[(C3 >> 16) & 255] ^ T3[(C0 >> 24) & 255] ^ KW[r][1];
		r2 = T0[C2 & 255] ^ T1[(C3 >> 8) & 255] ^ T2[(C0 >> 16) & 255] ^ T3[(C1 >> 24) & 255] ^ KW[r][2];
		r3 = T0[C3 & 255] ^ T1[(C0 >> 8) & 255] ^ T2[(C1 >> 16) & 255] ^ T3[(C2 >> 24) & 255] ^ KW[r++][3];

		// the final round's table is a simple function of S so we don't use a
		// whole other four tables for it

		C0 = (S[r0 & 255] & 255) ^ ((S[(r1 >> 8) & 255] & 255) << 8) ^ ((S[(r2 >> 16) & 255] & 255) << 16)
				^ (S[(r3 >> 24) & 255] << 24) ^ KW[r][0];
		C1 = (S[r1 & 255] & 255) ^ ((S[(r2 >> 8) & 255] & 255) << 8) ^ ((S[(r3 >> 16) & 255] & 255) << 16)
				^ (S[(r0 >> 24) & 255] << 24) ^ KW[r][1];
		C2 = (S[r2 & 255] & 255) ^ ((S[(r3 >> 8) & 255] & 255) << 8) ^ ((S[(r0 >> 16) & 255] & 255) << 16)
				^ (S[(r1 >> 24) & 255] << 24) ^ KW[r][2];
		C3 = (S[r3 & 255] & 255) ^ ((S[(r0 >> 8) & 255] & 255) << 8) ^ ((S[(r1 >> 16) & 255] & 255) << 16)
				^ (S[(r2 >> 24) & 255] << 24) ^ KW[r][3];

	}

	private final void decryptBlock(int[][] KW)
	{
		int r, r0, r1, r2, r3;

		C0 ^= KW[ROUNDS][0];
		C1 ^= KW[ROUNDS][1];
		C2 ^= KW[ROUNDS][2];
		C3 ^= KW[ROUNDS][3];

		for (r = ROUNDS - 1; r > 1;)
		{
			r0 = Tinv0[C0 & 255] ^ Tinv1[(C3 >> 8) & 255] ^ Tinv2[(C2 >> 16) & 255] ^ Tinv3[(C1 >> 24) & 255]
					^ KW[r][0];
			r1 = Tinv0[C1 & 255] ^ Tinv1[(C0 >> 8) & 255] ^ Tinv2[(C3 >> 16) & 255] ^ Tinv3[(C2 >> 24) & 255]
					^ KW[r][1];
			r2 = Tinv0[C2 & 255] ^ Tinv1[(C1 >> 8) & 255] ^ Tinv2[(C0 >> 16) & 255] ^ Tinv3[(C3 >> 24) & 255]
					^ KW[r][2];
			r3 = Tinv0[C3 & 255] ^ Tinv1[(C2 >> 8) & 255] ^ Tinv2[(C1 >> 16) & 255] ^ Tinv3[(C0 >> 24) & 255]
					^ KW[r--][3];
			C0 = Tinv0[r0 & 255] ^ Tinv1[(r3 >> 8) & 255] ^ Tinv2[(r2 >> 16) & 255] ^ Tinv3[(r1 >> 24) & 255]
					^ KW[r][0];
			C1 = Tinv0[r1 & 255] ^ Tinv1[(r0 >> 8) & 255] ^ Tinv2[(r3 >> 16) & 255] ^ Tinv3[(r2 >> 24) & 255]
					^ KW[r][1];
			C2 = Tinv0[r2 & 255] ^ Tinv1[(r1 >> 8) & 255] ^ Tinv2[(r0 >> 16) & 255] ^ Tinv3[(r3 >> 24) & 255]
					^ KW[r][2];
			C3 = Tinv0[r3 & 255] ^ Tinv1[(r2 >> 8) & 255] ^ Tinv2[(r1 >> 16) & 255] ^ Tinv3[(r0 >> 24) & 255]
					^ KW[r--][3];
		}

		r0 = Tinv0[C0 & 255] ^ Tinv1[(C3 >> 8) & 255] ^ Tinv2[(C2 >> 16) & 255] ^ Tinv3[(C1 >> 24) & 255] ^ KW[r][0];
		r1 = Tinv0[C1 & 255] ^ Tinv1[(C0 >> 8) & 255] ^ Tinv2[(C3 >> 16) & 255] ^ Tinv3[(C2 >> 24) & 255] ^ KW[r][1];
		r2 = Tinv0[C2 & 255] ^ Tinv1[(C1 >> 8) & 255] ^ Tinv2[(C0 >> 16) & 255] ^ Tinv3[(C3 >> 24) & 255] ^ KW[r][2];
		r3 = Tinv0[C3 & 255] ^ Tinv1[(C2 >> 8) & 255] ^ Tinv2[(C1 >> 16) & 255] ^ Tinv3[(C0 >> 24) & 255] ^ KW[r--][3];

		// the final round's table is a simple function of Si so we don't use a
		// whole other four tables for it

		C0 = (Si[r0 & 255] & 255) ^ ((Si[(r3 >> 8) & 255] & 255) << 8) ^ ((Si[(r2 >> 16) & 255] & 255) << 16)
				^ (Si[(r1 >> 24) & 255] << 24) ^ KW[0][0];
		C1 = (Si[r1 & 255] & 255) ^ ((Si[(r0 >> 8) & 255] & 255) << 8) ^ ((Si[(r3 >> 16) & 255] & 255) << 16)
				^ (Si[(r2 >> 24) & 255] << 24) ^ KW[0][1];
		C2 = (Si[r2 & 255] & 255) ^ ((Si[(r1 >> 8) & 255] & 255) << 8) ^ ((Si[(r0 >> 16) & 255] & 255) << 16)
				^ (Si[(r3 >> 24) & 255] << 24) ^ KW[0][2];
		C3 = (Si[r3 & 255] & 255) ^ ((Si[(r2 >> 8) & 255] & 255) << 8) ^ ((Si[(r1 >> 16) & 255] & 255) << 16)
				^ (Si[(r0 >> 24) & 255] << 24) ^ KW[0][3];
	}

	public void transformBlock(byte[] src, int srcoff, byte[] dst, int dstoff)
	{
		processBlock(src, srcoff, dst, dstoff);
	}
}