AES算法的核心代码VC++（源文件2）

最新推荐文章于 2024-03-09 11:38:26 发布

wmnmtm

最新推荐文章于 2024-03-09 11:38:26 发布

阅读量230

点赞数

本文链接：https://blog.csdn.net/wmnmtm/article/details/82922048

版权

void rijndael::set_key(const u1byte in_key[], const u4byte key_len)
{ u4byte i, t, u, v, w;

if(!tab_gen)

gen_tabs();

k_len = (key_len + 31) / 32;

    e_key[0] = u4byte_in(in_key     );
e_key[1] = u4byte_in(in_key +  4);
    e_key[2] = u4byte_in(in_key +  8);
e_key[3] = u4byte_in(in_key + 12);

    switch(k_len)
    {
        case 4: t = e_key[3];
                for(i = 0; i < 10; ++i)
                    loop4(i);
                break;

        case 6: e_key[4] = u4byte_in(in_key + 16); t = e_key[5] = u4byte_in(in_key + 20);
                for(i = 0; i < 8; ++i)
                    loop6(i);
                break;

        case 8: e_key[4] = u4byte_in(in_key + 16); e_key[5] = u4byte_in(in_key + 20);
                e_key[6] = u4byte_in(in_key + 24); t = e_key[7] = u4byte_in(in_key + 28);
                for(i = 0; i < 7; ++i)
                    loop8(i);
                break;
    }

d_key[0] = e_key[0]; d_key[1] = e_key[1];
d_key[2] = e_key[2]; d_key[3] = e_key[3];

    for(i = 4; i < 4 * k_len + 24; ++i)
    {
        imix_col(d_key[i], e_key[i]);
    }

return;
}

// encrypt a block of text

#define f_nround(bo, bi, k) \
    f_rn(bo, bi, 0, k);     \
    f_rn(bo, bi, 1, k);     \
    f_rn(bo, bi, 2, k);     \
    f_rn(bo, bi, 3, k);     \
    k += 4

#define f_lround(bo, bi, k) \
    f_rl(bo, bi, 0, k);     \
    f_rl(bo, bi, 1, k);     \
    f_rl(bo, bi, 2, k);     \
    f_rl(bo, bi, 3, k)

void rijndael::encrypt(const u1byte in_blk[16], u1byte out_blk[16])
{ u4byte b0[4], b1[4], *kp;

b0[0] = u4byte_in(in_blk ) ^ e_key[0]; b0[1] = u4byte_in(in_blk + 4) ^ e_key[1];
b0[2] = u4byte_in(in_blk + 8) ^ e_key[2]; b0[3] = u4byte_in(in_blk + 12) ^ e_key[3];

kp = e_key + 4;

    if(k_len > 6)
    {
        f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    }

    if(k_len > 4)
    {
        f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    }

    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_lround(b0, b1, kp);

u4byte_out(out_blk, b0[0]); u4byte_out(out_blk + 4, b0[1]);
u4byte_out(out_blk + 8, b0[2]); u4byte_out(out_blk + 12, b0[3]);
}

// decrypt a block of text

#define i_nround(bo, bi, k) \
    i_rn(bo, bi, 0, k);     \
    i_rn(bo, bi, 1, k);     \
    i_rn(bo, bi, 2, k);     \
    i_rn(bo, bi, 3, k);     \
    k -= 4

#define i_lround(bo, bi, k) \
    i_rl(bo, bi, 0, k);     \
    i_rl(bo, bi, 1, k);     \
    i_rl(bo, bi, 2, k);     \
    i_rl(bo, bi, 3, k)

void rijndael::decrypt(const u1byte in_blk[16], u1byte out_blk[16])
{ u4byte b0[4], b1[4], *kp;

    b0[0] = u4byte_in(in_blk     ) ^ e_key[4 * k_len + 24];
b0[1] = u4byte_in(in_blk +  4) ^ e_key[4 * k_len + 25];
    b0[2] = u4byte_in(in_blk +  8) ^ e_key[4 * k_len + 26];
b0[3] = u4byte_in(in_blk + 12) ^ e_key[4 * k_len + 27];

kp = d_key + 4 * (k_len + 5);

    if(k_len > 6)
    {
        i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    }

    if(k_len > 4)
    {
        i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    }

    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_lround(b0, b1, kp);

u4byte_out(out_blk, b0[0]); u4byte_out(out_blk + 4, b0[1]);
u4byte_out(out_blk + 8, b0[2]); u4byte_out(out_blk + 12, b0[3]);
}