cast5engine.java

kmlnjlkj nlkjlkjkljl okopokipoipo oipipipo i

        z47 = IntsTo32bits(z, 0x4);
        z8B = IntsTo32bits(z, 0x8);
        zCF = IntsTo32bits(z, 0xC);
        x03 = z8B ^S5[z[0x5]] ^S6[z[0x7]] ^S7[z[0x4]] ^S8[z[0x6]] ^S7[z[0x0]];
        Bits32ToInts(x03, x, 0x0);
        x47 = z03 ^S5[x[0x0]] ^S6[x[0x2]] ^S7[x[0x1]] ^S8[x[0x3]] ^S8[z[0x2]];
        Bits32ToInts(x47, x, 0x4);
        x8B = z47 ^S5[x[0x7]] ^S6[x[0x6]] ^S7[x[0x5]] ^S8[x[0x4]] ^S5[z[0x1]];
        Bits32ToInts(x8B, x, 0x8);
        xCF = zCF ^S5[x[0xA]] ^S6[x[0x9]] ^S7[x[0xB]] ^S8[x[0x8]] ^S6[z[0x3]];
        Bits32ToInts(xCF, x, 0xC);
        _Kr[13]=(S5[x[0x8]]^S6[x[0x9]]^S7[x[0x7]]^S8[x[0x6]]^S5[x[0x3]])&0x1f;
        _Kr[14]=(S5[x[0xA]]^S6[x[0xB]]^S7[x[0x5]]^S8[x[0x4]]^S6[x[0x7]])&0x1f;
        _Kr[15]=(S5[x[0xC]]^S6[x[0xD]]^S7[x[0x3]]^S8[x[0x2]]^S7[x[0x8]])&0x1f;
        _Kr[16]=(S5[x[0xE]]^S6[x[0xF]]^S7[x[0x1]]^S8[x[0x0]]^S8[x[0xD]])&0x1f;
    }

    /**
     * Encrypt the given input starting at the given offset and place
     * the result in the provided buffer starting at the given offset.
     *
     * @param src        The plaintext buffer
     * @param srcIndex    An offset into src
     * @param dst        The ciphertext buffer
     * @param dstIndex    An offset into dst
     */
    protected int encryptBlock(
        byte[] src, 
        int srcIndex,
        byte[] dst,
        int dstIndex)
    {

        int  result[] = new int[2];

        // process the input block 
        // batch the units up into a 32 bit chunk and go for it
        // the array is in bytes, the increment is 8x8 bits = 64

        int L0 = BytesTo32bits(src, srcIndex);
        int R0 = BytesTo32bits(src, srcIndex + 4);

        CAST_Encipher(L0, R0, result);

        // now stuff them into the destination block
        Bits32ToBytes(result[0], dst, dstIndex);
        Bits32ToBytes(result[1], dst, dstIndex + 4);

        return BLOCK_SIZE;
    }

    /**
     * Decrypt the given input starting at the given offset and place
     * the result in the provided buffer starting at the given offset.
     *
     * @param src        The plaintext buffer
     * @param srcIndex    An offset into src
     * @param dst        The ciphertext buffer
     * @param dstIndex    An offset into dst
     */
    protected int decryptBlock(
        byte[] src, 
        int srcIndex,
        byte[] dst,
        int dstIndex)
    {
        int  result[] = new int[2];

        // process the input block
        // batch the units up into a 32 bit chunk and go for it
        // the array is in bytes, the increment is 8x8 bits = 64
        int L16 = BytesTo32bits(src, srcIndex);
        int R16 = BytesTo32bits(src, srcIndex+4);

        CAST_Decipher(L16, R16, result);

        // now stuff them into the destination block
        Bits32ToBytes(result[0], dst, dstIndex);
        Bits32ToBytes(result[1], dst, dstIndex+4);

        return BLOCK_SIZE;
    }

    /**
     * The first of the three processing functions for the
     * encryption and decryption.
     *
     * @param D            the input to be processed
     * @param Kmi        the mask to be used from Km[n]
     * @param Kri        the rotation value to be used
     *
     */
    protected final int F1(int D, int Kmi, int Kri)
    {
        int I = Kmi + D;
        I = I << Kri | I >>> (32-Kri);
        return ((S1[(I>>>24)&0xff]^S2[(I>>>16)&0xff])-S3[(I>>> 8)&0xff])+
                 S4[I & 0xff];
    }

    /**
     * The second of the three processing functions for the
     * encryption and decryption.
     *
     * @param D            the input to be processed
     * @param Kmi        the mask to be used from Km[n]
     * @param Kri        the rotation value to be used
     *
     */
    protected final int F2(int D, int Kmi, int Kri)
    {
        int I = Kmi ^ D;
        I = I << Kri | I >>> (32-Kri);
        return ((S1[(I>>>24)&0xff]-S2[(I>>>16)&0xff])+S3[(I>>> 8)&0xff])^
                 S4[I & 0xff];
    }

    /**
     * The third of the three processing functions for the
     * encryption and decryption.
     *
     * @param D            the input to be processed
     * @param Kmi        the mask to be used from Km[n]
     * @param Kri        the rotation value to be used
     *
     */
    protected final int F3(int D, int Kmi, int Kri)
    {
        int I = Kmi - D;
        I = I << Kri | I >>> (32-Kri);
        return ((S1[(I>>>24)&0xff]+S2[(I>>>16)&0xff])^S3[(I>>> 8)&0xff])-
                 S4[I & 0xff];
    }

    /**
     * Does the 16 rounds to encrypt the block.
     * 
     * @param L0    the LH-32bits of the plaintext block
     * @param R0    the RH-32bits of the plaintext block
     */
    protected final void CAST_Encipher(int L0, int R0, int result[])
    {
        int Lp = L0;        // the previous value, equiv to L[i-1]
        int Rp = R0;        // equivalent to R[i-1]

        /* 
         * numbering consistent with paper to make
         * checking and validating easier
         */
        int Li = L0, Ri = R0;

        for (int i = 1; i<=_rounds ; i++)
        {
            Lp = Li;
            Rp = Ri;

            Li = Rp;
            switch (i)
            {
                case  1:
                case  4:
                case  7:
                case 10:
                case 13:
                case 16:
                    Ri = Lp ^ F1(Rp, _Km[i], _Kr[i]);
                    break;
                case  2:
                case  5:
                case  8:
                case 11:
                case 14:
                    Ri = Lp ^ F2(Rp, _Km[i], _Kr[i]);
                    break;
                case  3:
                case  6:
                case  9:
                case 12:
                case 15:
                    Ri = Lp ^ F3(Rp, _Km[i], _Kr[i]);
                    break;
            }
        }

        result[0] = Ri;
        result[1] = Li;

        return;
    }

    protected final void CAST_Decipher(int L16, int R16, int result[])
    {
        int Lp = L16;        // the previous value, equiv to L[i-1]
        int Rp = R16;        // equivalent to R[i-1]

        /* 
         * numbering consistent with paper to make
         * checking and validating easier
         */
        int Li = L16, Ri = R16;

        for (int i = _rounds; i > 0; i--)
        {
            Lp = Li;
            Rp = Ri;

            Li = Rp;
            switch (i)
            {
                case  1:
                case  4:
                case  7:
                case 10:
                case 13:
                case 16:
                    Ri = Lp ^ F1(Rp, _Km[i], _Kr[i]);
                    break;
                case  2:
                case  5:
                case  8:
                case 11:
                case 14:
                    Ri = Lp ^ F2(Rp, _Km[i], _Kr[i]);
                    break;
                case  3:
                case  6:
                case  9:
                case 12:
                case 15:
                    Ri = Lp ^ F3(Rp, _Km[i], _Kr[i]);
                    break;
            }
        }

        result[0] = Ri;
        result[1] = Li;

        return;
    }

    protected final void Bits32ToInts(int in,  int[] b, int offset)
    {
        b[offset + 3] = (in & 0xff);
        b[offset + 2] = ((in >>> 8) & 0xff);
        b[offset + 1] = ((in >>> 16) & 0xff);
        b[offset]     = ((in >>> 24) & 0xff);
    }

    protected final int IntsTo32bits(int[] b, int i)
    {
        int rv = 0;

        rv = ((b[i]   & 0xff) << 24) | 
             ((b[i+1] & 0xff) << 16) |
             ((b[i+2] & 0xff) << 8) |
             ((b[i+3] & 0xff));

        return rv;
    }

    protected final 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);
    }

    protected final 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));
    }
}