aesengine.java

进行与数字证书相关开发必须的java源码

            if(KC > 6 && i % KC == 4)
                temp = subWord(temp);
            W[i >> 2][i & 0x3] = W[i - KC >> 2][i - KC & 0x3] ^ temp;
        }

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

            }

        }
        return W;
    }

    public AESEngine()
    {
        WorkingKey = null;
    }

    public void init(boolean forEncryption, CipherParameters params)
    {
        if(params instanceof KeyParameter)
        {
            WorkingKey = generateWorkingKey(((KeyParameter)params).getKey(), forEncryption);
            this.forEncryption = forEncryption;
            return;
        } else
        {
            throw new IllegalArgumentException("invalid parameter passed to AES init - ".concat(String.valueOf(String.valueOf(params.getClass().getName()))));
        }
    }

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

    public int getBlockSize()
    {
        return 16;
    }

    public int processBlock(byte in[], int inOff, byte out[], int outOff)
    {
        if(WorkingKey == null)
            throw new IllegalStateException("AES engine not initialised");
        if(inOff + 16 > in.length)
            throw new DataLengthException("input buffer too short");
        if(outOff + 16 > out.length)
            throw new DataLengthException("output buffer too short");
        if(forEncryption)
        {
            unpackBlock(in, inOff);
            encryptBlock(WorkingKey);
            packBlock(out, outOff);
        } else
        {
            unpackBlock(in, inOff);
            decryptBlock(WorkingKey);
            packBlock(out, outOff);
        }
        return 16;
    }

    public 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[][])
    {
        C0 ^= KW[0][0];
        C1 ^= KW[0][1];
        C2 ^= KW[0][2];
        C3 ^= KW[0][3];
        int r;
        int r0;
        int r1;
        int r2;
        int r3;
        for(r = 1; r < ROUNDS - 1;)
        {
            r0 = T0[C0 & 0xff] ^ shift(T0[C1 >> 8 & 0xff], 24) ^ shift(T0[C2 >> 16 & 0xff], 16) ^ shift(T0[C3 >> 24 & 0xff], 8) ^ KW[r][0];
            r1 = T0[C1 & 0xff] ^ shift(T0[C2 >> 8 & 0xff], 24) ^ shift(T0[C3 >> 16 & 0xff], 16) ^ shift(T0[C0 >> 24 & 0xff], 8) ^ KW[r][1];
            r2 = T0[C2 & 0xff] ^ shift(T0[C3 >> 8 & 0xff], 24) ^ shift(T0[C0 >> 16 & 0xff], 16) ^ shift(T0[C1 >> 24 & 0xff], 8) ^ KW[r][2];
            r3 = T0[C3 & 0xff] ^ shift(T0[C0 >> 8 & 0xff], 24) ^ shift(T0[C1 >> 16 & 0xff], 16) ^ shift(T0[C2 >> 24 & 0xff], 8) ^ KW[r++][3];
            C0 = T0[r0 & 0xff] ^ shift(T0[r1 >> 8 & 0xff], 24) ^ shift(T0[r2 >> 16 & 0xff], 16) ^ shift(T0[r3 >> 24 & 0xff], 8) ^ KW[r][0];
            C1 = T0[r1 & 0xff] ^ shift(T0[r2 >> 8 & 0xff], 24) ^ shift(T0[r3 >> 16 & 0xff], 16) ^ shift(T0[r0 >> 24 & 0xff], 8) ^ KW[r][1];
            C2 = T0[r2 & 0xff] ^ shift(T0[r3 >> 8 & 0xff], 24) ^ shift(T0[r0 >> 16 & 0xff], 16) ^ shift(T0[r1 >> 24 & 0xff], 8) ^ KW[r][2];
            C3 = T0[r3 & 0xff] ^ shift(T0[r0 >> 8 & 0xff], 24) ^ shift(T0[r1 >> 16 & 0xff], 16) ^ shift(T0[r2 >> 24 & 0xff], 8) ^ KW[r++][3];
        }

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

    private final void decryptBlock(int KW[][])
    {
        C0 ^= KW[ROUNDS][0];
        C1 ^= KW[ROUNDS][1];
        C2 ^= KW[ROUNDS][2];
        C3 ^= KW[ROUNDS][3];
        int r;
        int r0;
        int r1;
        int r2;
        int r3;
        for(r = ROUNDS - 1; r > 1;)
        {
            r0 = Tinv0[C0 & 0xff] ^ shift(Tinv0[C3 >> 8 & 0xff], 24) ^ shift(Tinv0[C2 >> 16 & 0xff], 16) ^ shift(Tinv0[C1 >> 24 & 0xff], 8) ^ KW[r][0];
            r1 = Tinv0[C1 & 0xff] ^ shift(Tinv0[C0 >> 8 & 0xff], 24) ^ shift(Tinv0[C3 >> 16 & 0xff], 16) ^ shift(Tinv0[C2 >> 24 & 0xff], 8) ^ KW[r][1];
            r2 = Tinv0[C2 & 0xff] ^ shift(Tinv0[C1 >> 8 & 0xff], 24) ^ shift(Tinv0[C0 >> 16 & 0xff], 16) ^ shift(Tinv0[C3 >> 24 & 0xff], 8) ^ KW[r][2];
            r3 = Tinv0[C3 & 0xff] ^ shift(Tinv0[C2 >> 8 & 0xff], 24) ^ shift(Tinv0[C1 >> 16 & 0xff], 16) ^ shift(Tinv0[C0 >> 24 & 0xff], 8) ^ KW[r--][3];
            C0 = Tinv0[r0 & 0xff] ^ shift(Tinv0[r3 >> 8 & 0xff], 24) ^ shift(Tinv0[r2 >> 16 & 0xff], 16) ^ shift(Tinv0[r1 >> 24 & 0xff], 8) ^ KW[r][0];
            C1 = Tinv0[r1 & 0xff] ^ shift(Tinv0[r0 >> 8 & 0xff], 24) ^ shift(Tinv0[r3 >> 16 & 0xff], 16) ^ shift(Tinv0[r2 >> 24 & 0xff], 8) ^ KW[r][1];
            C2 = Tinv0[r2 & 0xff] ^ shift(Tinv0[r1 >> 8 & 0xff], 24) ^ shift(Tinv0[r0 >> 16 & 0xff], 16) ^ shift(Tinv0[r3 >> 24 & 0xff], 8) ^ KW[r][2];
            C3 = Tinv0[r3 & 0xff] ^ shift(Tinv0[r2 >> 8 & 0xff], 24) ^ shift(Tinv0[r1 >> 16 & 0xff], 16) ^ shift(Tinv0[r0 >> 24 & 0xff], 8) ^ KW[r--][3];
        }

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

    static 
    {
        m1 = 0x80808080;
        m2 = 0x7f7f7f7f;
        m3 = 27;
        BLOCK_SIZE = 16;
    }
}