AES128算法C语言实现（附每轮执行结果以供调试）_128aes-cmac

关于AES128算法的文章网上已经很多了，之所以要写这篇是因为前两天自己在写代码调试的时候遇到一些问题，底层函数单独调试的时候是好的，但是综合在一起执行10轮操作以后总的结果却是不对的，所以一下子很难定位问题出在哪里，为了帮助遇到相同问题的朋友，特此把我每轮执行的结果都贴出来，给大家一个参考。

首先分享一些AES的技术要点，关于数学理论就不多说了，要彻底理解伽罗瓦域在二进制世界里的工作原理相信没点天赋还真的不行，所以这里我只说结论和如何应用这些结论。

关于AES的乘法（在列混合操作中要用到矩阵乘法），AES里乘法逻辑是：

将某个字节所对应的值乘以2，其结果就是将该值的二进制位左移一位，如果原始值的最高位为1，则还需要将移位后的结果异或00011011；

注意一下，这里为什么只说乘以2，因为站在二进制的观点去看，所有的乘数其实都可以分解成2的不同倍数的相加，比如0x07=0001b+0010b+0100b，其实就是1+2+4，所以7*Y=(1*Y)+(2*Y)+(4*Y)，不难看出每一项都是Y乘以2的不同倍数，,求7*Y只要先求出(1*Y)、(2*Y)、(4*Y)、(8*Y)、(16*Y)、(32*Y)、(64*Y)、(128*Y)，这里每一个数又是前一个数乘以2，然后找到7对应的那几个bit把他们再加起来就行了，注意AES的乘以2不是普通的乘以2，而是左移一位且如果原始值最高位为1还要将结果异或00011011。

贴一下我的代码，这是乘以2的函数

unsigned char TwoMult(unsigned char x)
{
    unsigned char rslt = 0u;
    //伽罗瓦域乘2就是将其左移1位，若原先值的最高位为1则还要异或0x1B
    rslt = (x << 1u) ^ ((x & 0x80u) ? 0x1Bu : 0x00u);
    return rslt;
}

这是求两个数相乘的函数

unsigned char GaloisMult(unsigned char a, unsigned char b)
{
    unsigned char rslt = 0u;
    unsigned char temp[8u];
    unsigned char i;
    
    temp[0] = a; //当b的第0位为1
    temp[1] = TwoMult(a);  //当b的第1位为1，其实就是相当于a*0x02
    temp[2] = TwoMult(temp[1u]);  //当b的第2位为1，其实就是相当于a*0x04=a*0x02*0x02
    temp[3] = TwoMult(temp[2u]);  //当b的第3位为1，其实就是相当于a*0x08=a*0x02*0x02*0x02
    temp[4] = TwoMult(temp[3u]);  //当b的第4位为1，其实就是相当于a*0x10=a*0x02*0x02*0x02*0x02
    temp[5] = TwoMult(temp[4u]);  //当b的第5位为1，其实就是相当于a*0x20=a*0x02*0x02*0x02*0x02*0x02
    temp[6] = TwoMult(temp[5u]);  //当b的第6位为1，其实就是相当于a*0x40=a*0x02*0x02*0x02*0x02*0x02*0x02
    temp[7] = TwoMult(temp[6u]);  //当b的第7位为1，其实就是相当于a*0x80=a*0x02*0x02*0x02*0x02*0x02*0x02*0x02
 
    for (i = 0u; i < 8u; i++)
    {
        unsigned char z;
        z = (b & (0x01u << i)) ? temp[i] : 0x00u;  //只要b的某一位为1则把对应的temp[i]取出来循环做异或
        rslt ^= z;
    }
    return rslt;
}

说完乘法，接着说一下数据排布规则，AES里对于顺序输入的数据都是按照从上到下，从左到右的顺序排布到一个[4][4]的矩阵中

比如输入P0，P1，P2，P3，P4，P5，P6，P7，P8，P9，P10，P11，P12，P13，P14，P15

则矩阵应该这样

包括在做秘钥扩展的时候，对于秘钥key一共16字节，也应按照上述规则排布，说道秘钥扩展顺便也说一下我遇到的坑，下图是网上找来的，要注意在g函数里做左移的时候，B0是MSB，举例来说，w3=k12 | k13 | k14 | k15，其中要把k12作为MSB然后执行左移，如果把k15当做MSB左移结果就正好方向反掉了（错：w3=k15 | k14 | k13 | k12） 

 

 

秘钥扩展是一个比较复杂的函数，找了一下网上说的比较清楚的一端描述

密钥扩展过程说明：

　　　　1)  将种子密钥按图(a)的格式排列，其中k0、k1、……、k15依次表示种子密钥的一个字节；排列后用4个32比特的字表示，分别记为w[0]、w[1]、w[2]、w[3]；

　　　　2)  按照如下方式，依次求解w[j]，其中j是整数并且属于[4,43]；

　　　　3)  若j%4=0,则w[j]=w[j-4]⊕g(w[j-1]),否则w[j]=w[j-4]⊕w[j-1]；

　　函数g的流程说明：

　　　　a)  将w循环左移8比特；

　　　　b)  分别对每个字节做S盒置换；

　　　　c)  与32比特的常量（RC[j/4],0,0,0）进行异或，RC是一个一维数组，其值如下。（RC的值只需要有10个，而此处用了11个，实际上RC[0]在运算中没有用到，增加RC[0]是为了便于程序中用数组表示。由于j的最小取值是4，j/4的最小取值则是1，因此不会产生错误。）

RC = {0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36}

 下面是我的代码

unsigned char RC[11u] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36, };
 
unsigned int WGen(unsigned int input, unsigned char round) {
    unsigned char in[4u];
    unsigned char temp[4u];
    unsigned int int_temp;
    unsigned char i = 0;
 
    in[0u] = input & 0x000000FF;         //B3 LSB
    in[1u] = (input & 0x0000FF00)>>8u;   //B2
    in[2u] = (input & 0x00FF0000)>>16u;  //B1
    in[3u] = (input & 0xFF000000)>>24u;  //B0 MSB
    for (i = 0u; i < 4u; i++)
    {
        temp[i] = in[(i + 3u) % 4u]; //左移是将MSB往左移
    }
 
    for (i = 0u; i < 4u; i++)
    {
        temp[i] = Sout(temp[i]);
    }
 
    temp[3] ^= RC[round];
 
    int_temp = temp[0u] | ((unsigned int)temp[1u]) << 8u | ((unsigned int)temp[2u]) << 16u | ((unsigned int)temp[3u]) << 24u;
 
    return int_temp;
};
 
unsigned int WKey[44u];  //44*4=176字节
void KeyExp(const unsigned char(*key)[16u]){
    unsigned char i;
 
    //以B0/B1/B2/B3为例，MSB取B0，LSB取B3，以此类推
    WKey[0u] = ((unsigned int)(*key)[0u]) << 24u | ((unsigned int)(*key)[1u]) << 16u | ((unsigned int)(*key)[2u]) << 8u | (*key)[3u];
    WKey[1u] = ((unsigned int)(*key)[4u]) << 24u | ((unsigned int)(*key)[5u]) << 16u | ((unsigned int)(*key)[6u]) << 8u | (*key)[7u];
    WKey[2u] = ((unsigned int)(*key)[8u]) << 24u | ((unsigned int)(*key)[9u]) << 16u | ((unsigned int)(*key)[10u]) << 8u | (*key)[11u];
    WKey[3u] = ((unsigned int)(*key)[12u]) << 24u | ((unsigned int)(*key)[13u]) << 16u | ((unsigned int)(*key)[14u]) << 8u | (*key)[15u];
 
    for (i = 4u; i <= 43u; i++)
    {
        if ((i % 4u) == 0u)
        {
            WKey[i] = WKey[i - 4u] ^ WGen(WKey[i - 1u], (i/4u));  //i/4就是round，[1, 10]
        }
        else
        {
            WKey[i] = WKey[i - 4u] ^ WKey[i - 1u];
        }
    }
 
};
//先运行fpKeyExp，秘钥扩展后存入WKey[44u]，然后每次秘钥轮加的时候运行GetRoundKey从WKey[44u]里抽取需要的4个组成一个数组与State进行异或
unsigned int RndKey[4u];
void GetRoundKey(unsigned char rnd_key_idx) {
    RndKey[0u] = WKey[rnd_key_idx * 4u];
    RndKey[1u] = WKey[rnd_key_idx * 4u +1u];
    RndKey[2u] = WKey[rnd_key_idx * 4u +2u];
    RndKey[3u] = WKey[rnd_key_idx * 4u +3u];
}
 
//以RndKey[4u]为基础生成ByteRndKey[4u][4u]，和State里的每个字节异或，先调用GetByteRndKey，然后就可以使用ByteRndKey[4u][4u]
unsigned char ByteRndKey[4u][4u];
void GetByteRndKey(unsigned char rnd_key_idx) {
    unsigned char i;
 
    GetRoundKey(rnd_key_idx);
    //从int[4]转char[4][4]时要注意空间位置
    for (i = 0u; i < 4u; i++)
    {
        ByteRndKey[i][0u] = (RndKey[0u] >> ((3u - i) * 8u)) & (unsigned int)0xFF;
    }
    for (i = 0u; i < 4u; i++)
    {
        ByteRndKey[i][1u] = (RndKey[1u] >> ((3u - i) * 8u)) & (unsigned int)0xFF;
    }
    for (i = 0u; i < 4u; i++)
    {
        ByteRndKey[i][2u] = (RndKey[2u] >> ((3u - i) * 8u)) & (unsigned int)0xFF;
    }
    for (i = 0u; i < 4u; i++)
    {
        ByteRndKey[i][3u] = (RndKey[3u] >> ((3u - i) * 8u)) & (unsigned int)0xFF;
    }
 
 
}

说明一下，使用的时候先调用KeyExp吧所有的扩展秘钥都求出来，然后调用GetByteRndKey求出一个[4][4]的矩阵与当前state异或，下面是几个key对应的扩展结果，如果你的程序执行结果和这个一样那就对了，如果不一样那说明你的程序哪里还有问题，另外秘钥扩展程序里用到了S和替换，所以如果你的秘钥扩展结果正确那说明你的S盒替换函数也是正确的。

下面贴几个扩展秘钥的执行结果

对于key={ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xA, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,}

对于key={0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xA, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,}

对于key={ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,}

说完秘钥扩展，接着先贴一下结论，对于

Key={ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xA, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,}

明文Plain={ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xA, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,}

的加密结果为

Cypher=

如果你的结果和这个一致那就不用往下看了，如果不对，下面贴出每一轮操作的结果以供对比。

第0轮轮钥密加后state[4][4]结果如下

 

第1轮【字节替换】执行完state[4][4]结果为

第1轮【行位移】执行完state[4][4]结果为

第1轮【列混合】执行完state[4][4]结果为

第1轮【轮密钥加】执行完state[4][4]结果为

第2轮【字节替换】执行完state[4][4]结果为

第2轮【行位移】执行完state[4][4]结果为

第2轮【列混合】执行完state[4][4]结果为

第2轮【轮密钥加】执行完state[4][4]结果为

第3轮【字节替换】执行完state[4][4]结果为

第3轮【行位移】执行完state[4][4]结果为

第3轮【列混合】执行完state[4][4]结果为

第3轮【轮密钥加】执行完state[4][4]结果为

第4轮【字节替换】执行完state[4][4]结果为

第4轮【行位移】执行完state[4][4]结果为

第4轮【列混合】执行完state[4][4]结果为

第4轮【轮密钥加】执行完state[4][4]结果为

第5轮【字节替换】执行完state[4][4]结果为

第5轮【行位移】执行完state[4][4]结果为

第5轮【列混合】执行完state[4][4]结果为

第5轮【轮密钥加】执行完state[4][4]结果为

第6轮【字节替换】执行完state[4][4]结果为

第6轮【行位移】执行完state[4][4]结果为

第6轮【列混合】执行完state[4][4]结果为

第6轮【轮密钥加】执行完state[4][4]结果为

第7轮【字节替换】执行完state[4][4]结果为

第7轮【行位移】执行完state[4][4]结果为

第7轮【列混合】执行完state[4][4]结果为

第7轮【轮密钥加】执行完state[4][4]结果为

第8轮【字节替换】执行完state[4][4]结果为

第8轮【行位移】执行完state[4][4]结果为

第8轮【列混合】执行完state[4][4]结果为

第8轮【轮密钥加】执行完state[4][4]结果为

 

第9轮【字节替换】执行完state[4][4]结果为

第9轮【行位移】执行完state[4][4]结果为

第9轮【列混合】执行完state[4][4]结果为

第9轮【轮密钥加】执行完state[4][4]结果为 

 

 

第10轮【字节替换】执行完state[4][4]结果为

第10轮【行位移】执行完state[4][4]结果为

第10轮【轮密钥加】执行完state[4][4]结果为

 最后排布到一个数组中就是密文Cypher[16]

其实不用10轮全看，基本上前4轮结论都对那基本就没问题了，最后贴一张全流程图以供参考