blowfishengine.java

kmlnjlkj nlkjlkjkljl okopokipoipo oipipipo i

                0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
                0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6
            };

    //====================================
    // 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;

    private final int[] S0, S1, S2, S3;     // the s-boxes
    private final int[] P;                  // the p-array

    private boolean encrypting = false;

    private byte[] workingKey = null;

    public BlowfishEngine()
    {
        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];
    }

    /**
     * initialise a Blowfish cipher.
     *
     * @param encrypting whether or not we are for encryption.
     * @param params the parameters required to set up the cipher.
     * @exception IllegalArgumentException if the params argument is
     * inappropriate.
     */
    public void init(
        boolean             encrypting,
        CipherParameters    params)
    {
        if (params instanceof KeyParameter)
        {
            this.encrypting = encrypting;
            this.workingKey = ((KeyParameter)params).getKey();
            setKey(this.workingKey);

            return;
        }

        throw new IllegalArgumentException("invalid parameter passed to Blowfish init - " + params.getClass().getName());
    }

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

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

        if ((inOff + BLOCK_SIZE) > in.length)
        {
            throw new DataLengthException("input buffer too short");
        }

        if ((outOff + BLOCK_SIZE) > out.length)
        {
            throw new DataLengthException("output buffer too short");
        }

        if (encrypting)
        {
            encryptBlock(in, inOff, out, outOff);
        }
        else
        {    
            decryptBlock(in, inOff, out, outOff);
        }

        return BLOCK_SIZE;
    }

    public void reset()
    {
    }

    public int getBlockSize()
    {
        return BLOCK_SIZE;
    }

    //==================================
    // Private Implementation
    //==================================

    private int F(int x)
    {
        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 void processTable(
        int     xl,
        int     xr,
        int[]   table)
    {
        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) ^ P[i];
                xl ^= F(xr) ^ P[i + 1];
            }

            xr ^= P[ROUNDS + 1];

            table[s] = xr;
            table[s + 1] = xl;

            xr = xl;            // end of cycle swap
            xl = table[s];
        }
    }

    private void setKey(byte[] key)
    {
        /*
         * - 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);
        processTable(P[P_SZ - 2], P[P_SZ - 1], S0);
        processTable(S0[SBOX_SK - 2], S0[SBOX_SK - 1], S1);
        processTable(S1[SBOX_SK - 2], S1[SBOX_SK - 1], S2);
        processTable(S2[SBOX_SK - 2], S2[SBOX_SK - 1], S3);
    }

    /**
     * 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 void encryptBlock(
        byte[]  src,
        int     srcIndex,
        byte[]  dst,
        int     dstIndex)
    {
        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) ^ P[i];
            xl ^= F(xr) ^ 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 void decryptBlock(
        byte[] src, 
        int srcIndex,
        byte[] dst,
        int dstIndex)
    {
        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) ^ P[i];
            xl ^= F(xr) ^ P[i - 1];
        }

        xr ^= P[0];

        Bits32ToBytes(xr, dst, dstIndex);
        Bits32ToBytes(xl, dst, dstIndex+4);
    }

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

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