[question] Rsa

//====================================
// Useful constants
//====================================
private static final int ROUNDS = 16;
private static final int BLOCK_SIZE = 8; // bytes = 64 bits
private static final int SBOX_SK = 256;
private static final int P_SZ = ROUNDS + 2;

public String getAlgorithmName()
{
return "Blowfish";
}

public static final int processBlock(byte[] in, int inOff, byte[] out, int outOff, boolean encrypting, byte[] key) throws IOException
{
if (key == null)
throw new IllegalStateException("Blowfish not initialised");
if ((inOff + BLOCK_SIZE) > in.length)
throw new IOException("input buffer too short");
if ((outOff + BLOCK_SIZE) > out.length)
throw new IOException("output buffer too short");
if (encrypting)
encryptBlock(in, inOff, out, outOff, key);
else
decryptBlock(in, inOff, out, outOff, key);
return BLOCK_SIZE;
}

public void reset()
{
}

public static int getBlockSize()
{
return BLOCK_SIZE;
}

//==================================
// Private Implementation
//==================================
private static int F(int x, int[] S0, int[] S1, int[] S2, int[] S3)
{
return (((S0[(x >>> 24)] + S1[(x >>> 16) & 0xff]) ^ S2[(x >>> 8) & 0xff]) + S3[x & 0xff]);
}

/**
* apply the encryption cycle to each value pair in the table.
*/
private static void processTable(int xl, int xr, int[] table, int[] S0, int[] S1, int[] S2, int[] S3, int[] P)
{
int size = table.length;
for (int s = 0; s < size; s += 2)
{
xl ^= P[0];
for (int i = 1; i < ROUNDS; i += 2)
{
xr ^= F(xl, S0, S1, S2, S3) ^ P[i];
xl ^= F(xr, S0, S1, S2, S3) ^ P[i + 1];
}
xr ^= P[ROUNDS + 1];
table[s] = xr;
table[s + 1] = xl;
xr = xl; // end of cycle swap
xl = table[s];
}
}

private static void setKey(byte[] key, int[] S0, int[] S1, int[] S2, int[] S3, int[] P)
{
/*
* - comments are from _Applied Crypto_, Schneier, p338 please be
* careful comparing the two, AC numbers the arrays from 1, the
* enclosed code from 0.
*
* (1) Initialise the S-boxes and the P-array, with a fixed string This
* string contains the hexadecimal digits of pi (3.141...)
*/
System.arraycopy(KS0, 0, S0, 0, SBOX_SK);
System.arraycopy(KS1, 0, S1, 0, SBOX_SK);
System.arraycopy(KS2, 0, S2, 0, SBOX_SK);
System.arraycopy(KS3, 0, S3, 0, SBOX_SK);
System.arraycopy(KP, 0, P, 0, P_SZ);
/*
* (2) Now, XOR P[0] with the first 32 bits of the key, XOR P[1] with
* the second 32-bits of the key, and so on for all bits of the key (up
* to P[17]). Repeatedly cycle through the key bits until the entire
* P-array has been XOR-ed with the key bits
*/
int keyLength = key.length;
int keyIndex = 0;
for (int i = 0; i < P_SZ; i++)
{
// get the 32 bits of the key, in 4 * 8 bit chunks
int data = 0x0000000;
for (int j = 0; j < 4; j++)
{
// create a 32 bit block
data = (data << 8) | (key[keyIndex++] & 0xff);
// wrap when we get to the end of the key
if (keyIndex >= keyLength)
keyIndex = 0;
}
// XOR the newly created 32 bit chunk onto the P-array
P[i] ^= data;
}
/*
* (3) Encrypt the all-zero string with the Blowfish algorithm, using
* the subkeys described in (1) and (2)
*
* (4) Replace P1 and P2 with the output of step (3)
*
* (5) Encrypt the output of step(3) using the Blowfish algorithm, with
* the modified subkeys.
*
* (6) Replace P3 and P4 with the output of step (5)
*
* (7) Continue the process, replacing all elements of the P-array and
* then all four S-boxes in order, with the output of the continuously
* changing Blowfish algorithm
*/
processTable(0, 0, P, S0, S1, S2, S3, P);
processTable(P[P_SZ - 2], P[P_SZ - 1], S0, S0, S1, S2, S3, P);
processTable(S0[SBOX_SK - 2], S0[SBOX_SK - 1], S1, S0, S1, S2, S3, P);
processTable(S1[SBOX_SK - 2], S1[SBOX_SK - 1], S2, S0, S1, S2, S3, P);
processTable(S2[SBOX_SK - 2], S2[SBOX_SK - 1], S3, S0, S1, S2, S3, P);
}

/**
* Encrypt the given input starting at the given offset and place the
* result in the provided buffer starting at the given offset. The input
* will be an exact multiple of our blocksize.
*/
private static void encryptBlock(byte[] src, int srcIndex, byte[] dst, int dstIndex, byte[] key)
{
int[] S0, S1, S2, S3, P;
S0 = new int[SBOX_SK];
S1 = new int[SBOX_SK];
S2 = new int[SBOX_SK];
S3 = new int[SBOX_SK];
P = new int[P_SZ];
setKey(key, S0, S1, S2, S3, P);
int xl = BytesTo32bits(src, srcIndex);
int xr = BytesTo32bits(src, srcIndex + 4);
xl ^= P[0];
for (int i = 1; i < ROUNDS; i += 2)
{
xr ^= F(xl, S0, S1, S2, S3) ^ P[i];
xl ^= F(xr, S0, S1, S2, S3) ^ P[i + 1];
}
xr ^= P[ROUNDS + 1];
Bits32ToBytes(xr, dst, dstIndex);
Bits32ToBytes(xl, dst, dstIndex + 4);
}

/**
* Decrypt the given input starting at the given offset and place the
* result in the provided buffer starting at the given offset. The input
* will be an exact multiple of our blocksize.
*/
private static void decryptBlock(byte[] src, int srcIndex, byte[] dst, int dstIndex, byte[] key)
{
int[] S0, S1, S2, S3, P;
S0 = new int[SBOX_SK];
S1 = new int[SBOX_SK];
S2 = new int[SBOX_SK];
S3 = new int[SBOX_SK];
P = new int[P_SZ];
setKey(key, S0, S1, S2, S3, P);
int xl = BytesTo32bits(src, srcIndex);
int xr = BytesTo32bits(src, srcIndex + 4);
xl ^= P[ROUNDS + 1];
for (int i = ROUNDS; i > 0; i -= 2)
{
xr ^= F(xl, S0, S1, S2, S3) ^ P[i];
xl ^= F(xr, S0, S1, S2, S3) ^ P[i - 1];
}
xr ^= P[0];
Bits32ToBytes(xr, dst, dstIndex);
Bits32ToBytes(xl, dst, dstIndex + 4);
}

private static int BytesTo32bits(byte[] b, int i)
{
return ((b[i + 3] & 0xff) << 24) | ((b[i + 2] & 0xff) << 16) | ((b[i + 1] & 0xff) << 8) | ((b[i] & 0xff));
}

private static void Bits32ToBytes(int in, byte[] b, int offset)
{
b[offset] = (byte) in;
b[offset + 1] = (byte) (in >> 8);
b[offset + 2] = (byte) (in >> 16);
b[offset + 3] = (byte) (in >> 24);
}