AES加密算法介绍与实现

悠悠 2022-11-05 11:59 157阅读 0赞

# AES简介 #

高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图：   
![加密流程图][SouthEast]  
下面简单介绍下各个部分的作用与意义：

*  明文P
    
    > 没有经过加密的数据。
 *  密钥K
    
    > 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。
 *  AES加密函数
    
    > 设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输入，则加密函数E会输出密文C。
 *  密文C
    
    > 经加密函数处理后的数据
 *  AES解密函数
    
    > 设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输入，则解密函数会输出明文P。

在这里简单介绍下对称加密算法与非对称加密算法的区别。

*  对称加密算法
    
    > 加密和解密用到的密钥是相同的，这种加密方式加密速度非常快，适合经常发送数据的场合。缺点是密钥的传输比较麻烦。
 *  非对称加密算法
    
    > 加密和解密用的密钥是不同的，这种加密方式是用数学上的难解问题构造的，通常加密解密的速度比较慢，适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal。

实际中，一般是通过RSA加密AES的密钥，传输到接收方，接收方解密得到AES密钥，然后发送方和接收方用AES密钥来通信。

本文下面AES原理的介绍参考自《现代密码学教程》，AES的实现在介绍完原理后开始。

# AES的基本结构 #

AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：

轮数在下面介绍，这里实现的是AES-128，也就是密钥的长度为128位，加密轮数为10轮。   
上面说到，AES的加密公式为C = E(K,P)，在加密函数E中，会执行一个轮函数，并且执行10次这个轮函数，这个轮函数的前9次执行的操作是一样的，只有第10次有所不同。也就是说，一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。

AES的处理单位是字节，128位的输入明文分组P和输入密钥K都被分成16个字节，分别记为P = P0 P1 … P15 和 K = K0 K1 … K15。如，明文分组为P = abcdefghijklmnop,其中的字符a对应P0，p对应P15。一般地，明文分组用字节为单位的正方形矩阵描述，称为状态矩阵。在算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如下图所示：   
![state][]

现在假设明文分组P为”abcdefghijklmnop”，则对应上面生成的状态矩阵图如下：   
![state2][]  
上图中，0x61为字符a的十六进制表示。可以看到，明文经过AES加密后，已经面目全非。

类似地，128位密钥也是用字节为单位的矩阵表示，矩阵的每一列被称为1个32位比特字。通过密钥编排函数该密钥矩阵被扩展成一个44个字组成的序列W\[0\],W\[1\], … ,W\[43\],该序列的前4个元素W\[0\],W\[1\],W\[2\],W\[3\]是原始密钥，用于加密运算中的初始密钥加（下面介绍）;后面40个字分为10组，每组4个字（128比特）分别用于10轮加密运算中的轮密钥加，如下图所示：   
![keystate][]  
上图中，设K = “abcdefghijklmnop”，则K0 = a, K15 = p, W\[0\] = K0 K1 K2 K3 = “abcd”。

AES的整体结构如下图所示，其中的W\[0,3\]是指W\[0\]、W\[1\]、W\[2\]和W\[3\]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样，包括4个操作：字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。   
![aes\_struct][aes_struct]  
上图也展示了AES解密过程，解密过程仍为10轮，每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的，因此，解密操作的一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似，最后一轮不执行逆列混合，在第1轮解密之前，要执行1次密钥加操作。

下面分别介绍AES中一轮的4个操作阶段，这4分操作阶段使输入位得到充分的混淆。

# 一、字节代换 #

## 1.字节代换操作 ##

AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒。   
AES的S盒：

状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：   
![byte][]

## 2.字节代换逆操作 ##

逆字节代换也就是查逆S盒来变换，逆S盒如下：

# 二、行移位 #

## 1.行移位操作 ##

行移位是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节，如下图所示：   
![shiftRows][]

## 2.行移位的逆变换 ##

行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如AES-128中，状态矩阵的第0行右移0字节，第1行右移1字节，第2行右移2字节，第3行右移3字节。

# 三、列混合 #

## 1.列混合操作 ##

列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图的公式所示：   
![col][]

状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：   
![col2][]

其中，矩阵元素的乘法和加法都是定义在基于GF(2^8)上的二元运算,并不是通常意义上的乘法和加法。这里涉及到一些信息安全上的数学知识，不过不懂这些知识也行。其实这种二元运算的加法等价于两个字节的异或，乘法则复杂一点。对于一个8位的二进制数来说，使用域上的乘法乘以(00000010)等价于左移1位(低位补0)后，再根据情况同(00011011)进行异或运算，设S1 = (a7 a6 a5 a4 a3 a2 a1 a0)，刚0x02 \* S1如下图所示：   
![col3][]  
也就是说，如果a7为1，则进行异或运算，否则不进行。   
类似地，乘以(00000100)可以拆分成两次乘以(00000010)的运算：   
![col4][]  
乘以(0000 0011)可以拆分成先分别乘以(0000 0001)和(0000 0010)，再将两个乘积异或：   
![col5][]  
因此，我们只需要实现乘以2的函数，其他数值的乘法都可以通过组合来实现。   
下面举个具体的例子,输入的状态矩阵如下：

下面，进行列混合运算：   
以第一列的运算为例：   
![col7][]   
其它列的计算就不列举了，列混合后生成的新状态矩阵如下：

## 2.列混合逆运算 ##

逆向列混合变换可由下图的矩阵乘法定义：   
![col6][]   
可以验证，逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。

# 四、轮密钥加 #

轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作，如下图所示。其中，密钥Ki中每个字W\[4i\],W\[4i+1\],W\[4i+2\],W\[4i+3\]为32位比特字，包含4个字节，他们的生成算法下面在下面介绍。轮密钥加过程可以看成是字逐位异或的结果，也可以看成字节级别或者位级别的操作。也就是说，可以看成S0 S1 S2 S3 组成的32位字与W\[4i\]的异或运算。   
![roundadd][]  
轮密钥加的逆运算同正向的轮密钥加运算完全一致，这是因为异或的逆操作是其自身。轮密钥加非常简单，但却能够影响S数组中的每一位。

# 密钥扩展 #

AES首先将初始密钥输入到一个4\*4的状态矩阵中，如下图所示。   
![keyextends][]  
这个4\*4矩阵的每一列的4个字节组成一个字，矩阵4列的4个字依次命名为W\[0\]、W\[1\]、W\[2\]和W\[3\]，它们构成一个以字为单位的数组W。例如，设密钥K为”abcdefghijklmnop”,则K0 = ‘a’,K1 = ‘b’, K2 = ‘c’,K3 = ‘d’,W\[0\] = “abcd”。   
接着，对W数组扩充40个新列，构成总共44列的扩展密钥数组。新列以如下的递归方式产生：   
1.如果i不是4的倍数，那么第i列由如下等式确定：   
W\[i\]=W\[i-4\]⨁W\[i-1\]   
2.如果i是4的倍数，那么第i列由如下等式确定：   
W\[i\]=W\[i-4\]⨁T(W\[i-1\])   
其中，T是一个有点复杂的函数。   
函数T由3部分组成：字循环、字节代换和轮常量异或，这3部分的作用分别如下。   
a.字循环：将1个字中的4个字节循环左移1个字节。即将输入字\[b0, b1, b2, b3\]变换成\[b1,b2,b3,b0\]。   
b.字节代换：对字循环的结果使用S盒进行字节代换。   
c.轮常量异或：将前两步的结果同轮常量Rcon\[j\]进行异或，其中j表示轮数。   
轮常量Rcon\[j\]是一个字，其值见下表。

下面举个例子：   
设初始的128位密钥为：   
3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD   
那么4个初始值为：   
W\[0\] = 3C A1 0B 21   
W\[1\] = 57 F0 19 16   
W\[2\] = 90 2E 13 80   
W\[3\] = AC C1 07 BD   
下面求扩展的第1轮的子密钥(W\[4\],W\[5\],W\[6\],W\[7\])。   
由于4是4的倍数，所以：   
W\[4\] = W\[0\] ⨁ T(W\[3\])   
T(W\[3\])的计算步骤如下：   
1. 循环地将W\[3\]的元素移位：AC C1 07 BD变成C1 07 BD AC;   
2. 将 C1 07 BD AC 作为S盒的输入，输出为78 C5 7A 91;   
3. 将78 C5 7A 91与第一轮轮常量Rcon\[1\]进行异或运算，将得到79 C5 7A 91，因此，T(W\[3\])=79 C5 7A 91，故   
W\[4\] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 45 64 71 B0   
其余的3个子密钥段的计算如下：   
W\[5\] = W\[1\] ⨁ W\[4\] = 57 F0 19 16 ⨁ 45 64 71 B0 = 12 94 68 A6   
W\[6\] = W\[2\] ⨁ W\[5\] =90 2E 13 80 ⨁ 12 94 68 A6 = 82 BA 7B 26   
W\[7\] = W\[3\] ⨁ W\[6\] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B 7C 9B   
所以，第一轮的密钥为 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B。

# AES解密 #

在文章开始的图中，有AES解密的流程图，可以对应那个流程图来进行解密。下面介绍的是另一种等价的解密模式，流程图如下图所示。这种等价的解密模式使得解密过程各个变换的使用顺序同加密过程的顺序一致，只是用逆变换取代原来的变换。   
![deaes][]

AES原理到这里就结束了，下面主要为AES的实现，对以上原理中的每一个小节进行实现讲解，讲解的时候会插入一些关键代码，完整的代码参见文章最后。文章最后提供两个完整的程序，一个能在linux下面编译运行，一个能在VC6.0下面编译通过。

# AES算法实现 #

## AES加密函数预览 ##

aes加密函数中，首先进行密钥扩展，然后把128位长度的字符串读进一个4\*4的整数数组中，这个数组就是状态矩阵。例如，pArray\[0\]\[0\] = S0,pArray\[1\]\[0\] = S1, pArray\[0\]\[1\] = S4。这个读取过程是通过 convertToIntArray()函数来实现的。每个轮操作的函数都对pArray进行修改，也就是对状态矩阵进行混淆。在执行完10轮加密后，会把pArray转换回字符串，再存入明文p的字符数组中，所以，在加密完后，明文p的字符串中的字符就是加密后的字符了。这个转换过程是通过convertArrayToStr()函数来实现的。

1.  `/**`
2.  `* 参数 p: 明文的字符串数组。`
3.  `* 参数 plen: 明文的长度。`
4.  `* 参数 key: 密钥的字符串数组。`
5.  `*/`
6.  `void aes(char *p, int plen, char *key){`
7.   
8.  `int keylen = strlen(key);`
9.  `if(plen == 0 || plen % 16 != 0) {`
10. `printf("明文字符长度必须为16的倍数！\n");`
11. `exit(0);`
12. `}`
13.  
14. `if(!checkKeyLen(keylen)) {`
15. `printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);`
16. `exit(0);`
17. `}`
18.  
19. `extendKey(key);//扩展密钥`
20. `int pArray[4][4];`
21.  
22. `for(int k = 0; k < plen; k += 16) {`
23. `convertToIntArray(p + k, pArray);`
24.  
25. `addRoundKey(pArray, 0);//一开始的轮密钥加`
26.  
27. `for(int i = 1; i < 10; i++){//前9轮`
28.  
29. `subBytes(pArray);//字节代换`
30.  
31. `shiftRows(pArray);//行移位`
32.  
33. `mixColumns(pArray);//列混合`
34.  
35. `addRoundKey(pArray, i);`
36.  
37. `}`
38.  
39. `//第10轮`
40. `subBytes(pArray);//字节代换`
41.  
42. `shiftRows(pArray);//行移位`
43.  
44. `addRoundKey(pArray, 10);`
45.  
46. `convertArrayToStr(pArray, p + k);`
47. `}`
48. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49

## 1.密钥扩展的实现 ##

在开始加密前，必须先获得第一轮加密用到的密钥，故先实现密钥扩展   
下面是密钥扩展函数的实现，这个函数传入密钥key的字符串表示，然后从字符串中读取W\[0\]到W\[3\],函数getWordFromStr()用于实现此功能。读取后，就开始扩展密钥，当i是4的倍数的时候，就会调用T()函数来进行扩展，因为T函数的行为与加密的轮数有关，故要把加密的轮数 j 作为参数传进去。

1.  `//密钥对应的扩展数组`
2.  `static int w[44];`
3.   
4.  `/**`
5.  `* 扩展密钥，结果是把w[44]中的每个元素初始化`
6.  `*/`
7.  `static void extendKey(char *key) {`
8.  `for(int i = 0; i < 4; i++)`
9.  `w[i] = getWordFromStr(key + i * 4);`
10.  
11. `for(int i = 4, j = 0; i < 44; i++) {`
12. `if( i % 4 == 0) {`
13. `w[i] = w[i - 4] ^ T(w[i - 1], j);`
14. `j++;//下一轮`
15. `}else {`
16. `w[i] = w[i - 4] ^ w[i - 1];`
17. `}`
18. `}`
19.  
20. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21

下面是T()函数的代码实现，T()函数中接收两个参数，参数num为上面传进的W\[i - 1\]，round为加密的轮数。首先用一个numArray储存从32位的W\[i-1\]中取得4个字节。如果W\[i-1\]为0x12ABCDEF,那么numArray\[0\] = 0x12,numArray\[1\] = 0xAB。函数splitIntToArray()用于从32位整数中读取这四个字节，之所以这样做是因为整数数组比较容易操作。然后调用leftLoop4int()函数把numArray数组中的4个元素循环左移1位。然后执行字节代换，通过getNumFromSBox()函数来获取S盒中相应的值来替换numArray中的值。接着通过mergeArrayToInt()函数把字节代换后的numArray合并回32位的整数，在进行轮常量异或后返回。

1.  `/**`
2.  `* 常量轮值表`
3.  `*/`
4.  `static const int Rcon[10] = { 0x01000000, 0x02000000,`
5.  `0x04000000, 0x08000000,`
6.  `0x10000000, 0x20000000,`
7.  `0x40000000, 0x80000000,`
8.  `0x1b000000, 0x36000000 };`
9.  `/**`
10. `* 密钥扩展中的T函数`
11. `*/`
12. `static int T(int num, int round) {`
13. `int numArray[4];`
14. `splitIntToArray(num, numArray);`
15. `leftLoop4int(numArray, 1);//字循环`
16.  
17. `//字节代换`
18. `for(int i = 0; i < 4; i++)`
19. `numArray[i] = getNumFromSBox(numArray[i]);`
20.  
21. `int result = mergeArrayToInt(numArray);`
22. `return result ^ Rcon[round];`
23. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24

## 2. 字节代换的实现 ##

字节代换的代码很简单，就是把状态矩阵中的每个元素传进getNumFromSBox()函数中，然后取得前面8位中的高4位作为行值，低4位作为列值，然后返回S\[row\]\[col\]，这里的S是储存S盒的数组。

1.   
2.  `/**`
3.  `* 根据索引，从S盒中获得元素`
4.  `*/`
5.  `static int getNumFromSBox(int index) {`
6.  `int row = getLeft4Bit(index);`
7.  `int col = getRight4Bit(index);`
8.  `return S[row][col];`
9.  `}`
10.  
11. `/**`
12. `* 字节代换`
13. `*/`
14. `static void subBytes(int array[4][4]){`
15. `for(int i = 0; i < 4; i++)`
16. `for(int j = 0; j < 4; j++)`
17. `array[i][j] = getNumFromSBox(array[i][j]);`
18. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

## 3.行移位的实现 ##

行移位的时候，首先把状态矩阵中第2，3，4行复制出来，然后对它们行进左移相应的位数，然后再复制回去状态矩阵array中。

1.   
2.  `/**`
3.  `* 将数组中的元素循环左移step位`
4.  `*/`
5.  `static void leftLoop4int(int array[4], int step) {`
6.  `int temp[4];`
7.  `for(int i = 0; i < 4; i++)`
8.  `temp[i] = array[i];`
9.   
10. `int index = step % 4 == 0 ? 0 : step % 4;`
11. `for(int i = 0; i < 4; i++){`
12. `array[i] = temp[index];`
13. `index++;`
14. `index = index % 4;`
15. `}`
16. `}`
17.  
18. `/**`
19. `* 行移位`
20. `*/`
21. `static void shiftRows(int array[4][4]) {`
22. `int rowTwo[4], rowThree[4], rowFour[4];`
23. `//复制状态矩阵的第2,3,4行`
24. `for(int i = 0; i < 4; i++) {`
25. `rowTwo[i] = array[1][i];`
26. `rowThree[i] = array[2][i];`
27. `rowFour[i] = array[3][i];`
28. `}`
29. `//循环左移相应的位数`
30. `leftLoop4int(rowTwo, 1);`
31. `leftLoop4int(rowThree, 2);`
32. `leftLoop4int(rowFour, 3);`
33.  
34. `//把左移后的行复制回状态矩阵中`
35. `for(int i = 0; i < 4; i++) {`
36. `array[1][i] = rowTwo[i];`
37. `array[2][i] = rowThree[i];`
38. `array[3][i] = rowFour[i];`
39. `}`
40. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41

## 4.列混合的实现 ##

列混合函数中，先把状态矩阵初始状态复制一份到tempArray中，然后把tempArray与colM矩阵相乘，colM为存放要乘的常数矩阵的数组。其中的GFMul()函数定义了矩阵相乘时的乘法，加法则直接通过异或来实现。GFMul()通过调用乘以各个数对应的函数来实现乘法。例如，S1 \* 2 刚通过调用GFMul2(S1)来实现。S1 \* 3 刚通过GFMul3(S1)来实现。在这里，主要实现GFMul2()函数就行了，其它的都可以通过GFMul2()的组合来实现。举个例子吧，为计算下面这条等式，需要像下面这样调用函数   
![ex][]

s = GFMul3(0xC9) ^ 0x7A ^ 0x63 ^ GFMul2(0xB0)

1.  `/**`
2.  `* 列混合要用到的矩阵`
3.  `*/`
4.  `static const int colM[4][4] = { 2, 3, 1, 1,`
5.  `1, 2, 3, 1,`
6.  `1, 1, 2, 3,`
7.  `3, 1, 1, 2 };`
8.   
9.  `static int GFMul2(int s) {`
10. `int result = s << 1;`
11. `int a7 = result & 0x00000100;`
12.  
13. `if(a7 != 0) {`
14. `result = result & 0x000000ff;`
15. `result = result ^ 0x1b;`
16. `}`
17.  
18. `return result;`
19. `}`
20.  
21. `static int GFMul3(int s) {`
22. `return GFMul2(s) ^ s;`
23. `}`
24.  
25. `/**`
26. `* GF上的二元运算`
27. `*/`
28. `static int GFMul(int n, int s) {`
29. `int result;`
30.  
31. `if(n == 1)`
32. `result = s;`
33. `else if(n == 2)`
34. `result = GFMul2(s);`
35. `else if(n == 3)`
36. `result = GFMul3(s);`
37. `else if(n == 0x9)`
38. `result = GFMul9(s);`
39. `else if(n == 0xb)//11`
40. `result = GFMul11(s);`
41. `else if(n == 0xd)//13`
42. `result = GFMul13(s);`
43. `else if(n == 0xe)//14`
44. `result = GFMul14(s);`
45.  
46. `return result;`
47. `}`
48.  
49. `/**`
50. `* 列混合`
51. `*/`
52. `static void mixColumns(int array[4][4]) {`
53.  
54. `int tempArray[4][4];`
55.  
56. `for(int i = 0; i < 4; i++)`
57. `for(int j = 0; j < 4; j++)`
58. `tempArray[i][j] = array[i][j];`
59.  
60. `for(int i = 0; i < 4; i++)`
61. `for(int j = 0; j < 4; j++){`
62. `array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])`
63. `^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);`
64. `}`
65. `}`

## 5.轮密钥加的实现 ##

轮密钥加的实现很简单，就是根据传入的轮数来把状态矩阵与相应的W\[i\]异或。

1.   
2.  `/**`
3.  `* 轮密钥加`
4.  `*/`
5.  `static void addRoundKey(int array[4][4], int round) {`
6.  `int warray[4];`
7.  `for(int i = 0; i < 4; i++) {`
8.   
9.  `splitIntToArray(w[ round * 4 + i], warray);`
10.  
11. `for(int j = 0; j < 4; j++) {`
12. `array[j][i] = array[j][i] ^ warray[j];`
13. `}`
14. `}`
15. `}`
16.

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17

## AES解密函数 ##

AES的解密函数和加密函数有点不同，可以参考上面的等价解密流程图来理解，解密函数中调用的是各轮操作的逆函数。逆函数在这里就不详细讲解了，可以参考最后的完整代码。

1.  `/**`
2.  `* 参数 c: 密文的字符串数组。`
3.  `* 参数 clen: 密文的长度。`
4.  `* 参数 key: 密钥的字符串数组。`
5.  `*/`
6.  `void deAes(char *c, int clen, char *key) {`
7.   
8.  `int keylen = strlen(key);`
9.  `if(clen == 0 || clen % 16 != 0) {`
10. `printf("密文字符长度必须为16的倍数！现在的长度为%d\n",clen);`
11. `exit(0);`
12. `}`
13.  
14. `if(!checkKeyLen(keylen)) {`
15. `printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);`
16. `exit(0);`
17. `}`
18.  
19. `extendKey(key);//扩展密钥`
20. `int cArray[4][4];`
21. `for(int k = 0; k < clen; k += 16) {`
22. `convertToIntArray(c + k, cArray);`
23.  
24.  
25. `addRoundKey(cArray, 10);`
26.  
27. `int wArray[4][4];`
28. `for(int i = 9; i >= 1; i--) {`
29. `deSubBytes(cArray);`
30.  
31. `deShiftRows(cArray);`
32.  
33. `deMixColumns(cArray);`
34. `getArrayFrom4W(i, wArray);`
35. `deMixColumns(wArray);`
36.  
37. `addRoundTowArray(cArray, wArray);`
38. `}`
39.  
40. `deSubBytes(cArray);`
41.  
42. `deShiftRows(cArray);`
43.  
44. `addRoundKey(cArray, 0);`
45.  
46. `convertArrayToStr(cArray, c + k);`
47.  
48. `}`
49. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50

# 完整的程序代码 #

## Linux版本 ##

### aes.h ###

1.  `#ifndef AES_H`
2.  `#define AES_H`
3.   
4.  `/**`
5.  `* 参数 p: 明文的字符串数组。`
6.  `* 参数 plen: 明文的长度,长度必须为16的倍数。`
7.  `* 参数 key: 密钥的字符串数组。`
8.  `*/`
9.  `void aes(char *p, int plen, char *key);`
10.  
11. `/**`
12. `* 参数 c: 密文的字符串数组。`
13. `* 参数 clen: 密文的长度,长度必须为16的倍数。`
14. `* 参数 key: 密钥的字符串数组。`
15. `*/`
16. `void deAes(char *c, int clen, char *key);`
17.  
18. `#endif`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

### aes.c ###

1.  `#include <stdio.h>`
2.  `#include <stdlib.h>`
3.  `#include <string.h>`
4.  `#include "aes.h"`
5.   
6.  `/**`
7.  `* S盒`
8.  `*/`
9.  `static const int S[16][16] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,`
10. `0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,`
11. `0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,`
12. `0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,`
13. `0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,`
14. `0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,`
15. `0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,`
16. `0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,`
17. `0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,`
18. `0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,`
19. `0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,`
20. `0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,`
21. `0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,`
22. `0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,`
23. `0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,`
24. `0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };`
25.  
26. `/**`
27. `* 逆S盒`
28. `*/`
29. `static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,`
30. `0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,`
31. `0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,`
32. `0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,`
33. `0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,`
34. `0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,`
35. `0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,`
36. `0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,`
37. `0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,`
38. `0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,`
39. `0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,`
40. `0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,`
41. `0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,`
42. `0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,`
43. `0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,`
44. `0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };`
45.  
46. `/**`
47. `* 获取整形数据的低8位的左4个位`
48. `*/`
49. `static int getLeft4Bit(int num) {`
50. `int left = num & 0x000000f0;`
51. `return left >> 4;`
52. `}`
53.  
54. `/**`
55. `* 获取整形数据的低8位的右4个位`
56. `*/`
57. `static int getRight4Bit(int num) {`
58. `return num & 0x0000000f;`
59. `}`
60. `/**`
61. `* 根据索引，从S盒中获得元素`
62. `*/`
63. `static int getNumFromSBox(int index) {`
64. `int row = getLeft4Bit(index);`
65. `int col = getRight4Bit(index);`
66. `return S[row][col];`
67. `}`
68.  
69. `/**`
70. `* 把一个字符转变成整型`
71. `*/`
72. `static int getIntFromChar(char c) {`
73. `int result = (int) c;`
74. `return result & 0x000000ff;`
75. `}`
76.  
77. `/**`
78. `* 把16个字符转变成4X4的数组，`
79. `* 该矩阵中字节的排列顺序为从上到下，`
80. `* 从左到右依次排列。`
81. `*/`
82. `static void convertToIntArray(char *str, int pa[4][4]) {`
83. `int k = 0;`
84. `for(int i = 0; i < 4; i++)`
85. `for(int j = 0; j < 4; j++) {`
86. `pa[j][i] = getIntFromChar(str[k]);`
87. `k++;`
88. `}`
89. `}`
90.  
91. `/**`
92. `* 打印4X4的数组`
93. `*/`
94. `static void printArray(int a[4][4]) {`
95. `for(int i = 0; i < 4; i++){`
96. `for(int j = 0; j < 4; j++)`
97. `printf("a[%d][%d] = 0x%x ", i, j, a[i][j]);`
98. `printf("\n");`
99. `}`
100. `printf("\n");`
101. `}`
102.  
103. `/**`
104. `* 打印字符串的ASSCI，`
105. `* 以十六进制显示。`
106. `*/`
107. `static void printASSCI(char *str, int len) {`
108. `for(int i = 0; i < len; i++)`
109. `printf("0x%x ", getIntFromChar(str[i]));`
110. `printf("\n");`
111. `}`
112.  
113. `/**`
114. `* 把连续的4个字符合并成一个4字节的整型`
115. `*/`
116. `static int getWordFromStr(char *str) {`
117. `int one = getIntFromChar(str[0]);`
118. `one = one << 24;`
119. `int two = getIntFromChar(str[1]);`
120. `two = two << 16;`
121. `int three = getIntFromChar(str[2]);`
122. `three = three << 8;`
123. `int four = getIntFromChar(str[3]);`
124. `return one | two | three | four;`
125. `}`
126.  
127. `/**`
128. `* 把一个4字节的数的第一、二、三、四个字节取出，`
129. `* 入进一个4个元素的整型数组里面。`
130. `*/`
131. `static void splitIntToArray(int num, int array[4]) {`
132. `int one = num >> 24;`
133. `array[0] = one & 0x000000ff;`
134. `int two = num >> 16;`
135. `array[1] = two & 0x000000ff;`
136. `int three = num >> 8;`
137. `array[2] = three & 0x000000ff;`
138. `array[3] = num & 0x000000ff;`
139. `}`
140.  
141. `/**`
142. `* 将数组中的元素循环左移step位`
143. `*/`
144. `static void leftLoop4int(int array[4], int step) {`
145. `int temp[4];`
146. `for(int i = 0; i < 4; i++)`
147. `temp[i] = array[i];`
148.  
149. `int index = step % 4 == 0 ? 0 : step % 4;`
150. `for(int i = 0; i < 4; i++){`
151. `array[i] = temp[index];`
152. `index++;`
153. `index = index % 4;`
154. `}`
155. `}`
156.  
157. `/**`
158. `* 把数组中的第一、二、三和四元素分别作为`
159. `* 4字节整型的第一、二、三和四字节，合并成一个4字节整型`
160. `*/`
161. `static int mergeArrayToInt(int array[4]) {`
162. `int one = array[0] << 24;`
163. `int two = array[1] << 16;`
164. `int three = array[2] << 8;`
165. `int four = array[3];`
166. `return one | two | three | four;`
167. `}`
168.  
169. `/**`
170. `* 常量轮值表`
171. `*/`
172. `static const int Rcon[10] = { 0x01000000, 0x02000000,`
173. `0x04000000, 0x08000000,`
174. `0x10000000, 0x20000000,`
175. `0x40000000, 0x80000000,`
176. `0x1b000000, 0x36000000 };`
177. `/**`
178. `* 密钥扩展中的T函数`
179. `*/`
180. `static int T(int num, int round) {`
181. `int numArray[4];`
182. `splitIntToArray(num, numArray);`
183. `leftLoop4int(numArray, 1);//字循环`
184.  
185. `//字节代换`
186. `for(int i = 0; i < 4; i++)`
187. `numArray[i] = getNumFromSBox(numArray[i]);`
188.  
189. `int result = mergeArrayToInt(numArray);`
190. `return result ^ Rcon[round];`
191. `}`
192.  
193. `//密钥对应的扩展数组`
194. `static int w[44];`
195.  
196. `/**`
197. `* 扩展密钥，结果是把w[44]中的每个元素初始化`
198. `*/`
199. `static void extendKey(char *key) {`
200. `for(int i = 0; i < 4; i++)`
201. `w[i] = getWordFromStr(key + i * 4);`
202.  
203. `for(int i = 4, j = 0; i < 44; i++) {`
204. `if( i % 4 == 0) {`
205. `w[i] = w[i - 4] ^ T(w[i - 1], j);`
206. `j++;//下一轮`
207. `}else {`
208. `w[i] = w[i - 4] ^ w[i - 1];`
209. `}`
210. `}`
211.  
212. `}`
213.  
214. `/**`
215. `* 轮密钥加`
216. `*/`
217. `static void addRoundKey(int array[4][4], int round) {`
218. `int warray[4];`
219. `for(int i = 0; i < 4; i++) {`
220.  
221. `splitIntToArray(w[ round * 4 + i], warray);`
222.  
223. `for(int j = 0; j < 4; j++) {`
224. `array[j][i] = array[j][i] ^ warray[j];`
225. `}`
226. `}`
227. `}`
228.  
229. `/**`
230. `* 字节代换`
231. `*/`
232. `static void subBytes(int array[4][4]){`
233. `for(int i = 0; i < 4; i++)`
234. `for(int j = 0; j < 4; j++)`
235. `array[i][j] = getNumFromSBox(array[i][j]);`
236. `}`
237.  
238. `/**`
239. `* 行移位`
240. `*/`
241. `static void shiftRows(int array[4][4]) {`
242. `int rowTwo[4], rowThree[4], rowFour[4];`
243. `//复制状态矩阵的第2,3,4行`
244. `for(int i = 0; i < 4; i++) {`
245. `rowTwo[i] = array[1][i];`
246. `rowThree[i] = array[2][i];`
247. `rowFour[i] = array[3][i];`
248. `}`
249. `//循环左移相应的位数`
250. `leftLoop4int(rowTwo, 1);`
251. `leftLoop4int(rowThree, 2);`
252. `leftLoop4int(rowFour, 3);`
253.  
254. `//把左移后的行复制回状态矩阵中`
255. `for(int i = 0; i < 4; i++) {`
256. `array[1][i] = rowTwo[i];`
257. `array[2][i] = rowThree[i];`
258. `array[3][i] = rowFour[i];`
259. `}`
260. `}`
261.  
262. `/**`
263. `* 列混合要用到的矩阵`
264. `*/`
265. `static const int colM[4][4] = { 2, 3, 1, 1,`
266. `1, 2, 3, 1,`
267. `1, 1, 2, 3,`
268. `3, 1, 1, 2 };`
269.  
270. `static int GFMul2(int s) {`
271. `int result = s << 1;`
272. `int a7 = result & 0x00000100;`
273.  
274. `if(a7 != 0) {`
275. `result = result & 0x000000ff;`
276. `result = result ^ 0x1b;`
277. `}`
278.  
279. `return result;`
280. `}`
281.  
282. `static int GFMul3(int s) {`
283. `return GFMul2(s) ^ s;`
284. `}`
285.  
286. `static int GFMul4(int s) {`
287. `return GFMul2(GFMul2(s));`
288. `}`
289.  
290. `static int GFMul8(int s) {`
291. `return GFMul2(GFMul4(s));`
292. `}`
293.  
294. `static int GFMul9(int s) {`
295. `return GFMul8(s) ^ s;`
296. `}`
297.  
298. `static int GFMul11(int s) {`
299. `return GFMul9(s) ^ GFMul2(s);`
300. `}`
301.  
302. `static int GFMul12(int s) {`
303. `return GFMul8(s) ^ GFMul4(s);`
304. `}`
305.  
306. `static int GFMul13(int s) {`
307. `return GFMul12(s) ^ s;`
308. `}`
309.  
310. `static int GFMul14(int s) {`
311. `return GFMul12(s) ^ GFMul2(s);`
312. `}`
313.  
314. `/**`
315. `* GF上的二元运算`
316. `*/`
317. `static int GFMul(int n, int s) {`
318. `int result;`
319.  
320. `if(n == 1)`
321. `result = s;`
322. `else if(n == 2)`
323. `result = GFMul2(s);`
324. `else if(n == 3)`
325. `result = GFMul3(s);`
326. `else if(n == 0x9)`
327. `result = GFMul9(s);`
328. `else if(n == 0xb)//11`
329. `result = GFMul11(s);`
330. `else if(n == 0xd)//13`
331. `result = GFMul13(s);`
332. `else if(n == 0xe)//14`
333. `result = GFMul14(s);`
334.  
335. `return result;`
336. `}`
337. `/**`
338. `* 列混合`
339. `*/`
340. `static void mixColumns(int array[4][4]) {`
341.  
342. `int tempArray[4][4];`
343.  
344. `for(int i = 0; i < 4; i++)`
345. `for(int j = 0; j < 4; j++)`
346. `tempArray[i][j] = array[i][j];`
347.  
348. `for(int i = 0; i < 4; i++)`
349. `for(int j = 0; j < 4; j++){`
350. `array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])`
351. `^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);`
352. `}`
353. `}`
354. `/**`
355. `* 把4X4数组转回字符串`
356. `*/`
357. `static void convertArrayToStr(int array[4][4], char *str) {`
358. `for(int i = 0; i < 4; i++)`
359. `for(int j = 0; j < 4; j++)`
360. `*str++ = (char)array[j][i];`
361. `}`
362. `/**`
363. `* 检查密钥长度`
364. `*/`
365. `static int checkKeyLen(int len) {`
366. `if(len == 16)`
367. `return 1;`
368. `else`
369. `return 0;`
370. `}`
371.  
372. `/**`
373. `* 参数 p: 明文的字符串数组。`
374. `* 参数 plen: 明文的长度。`
375. `* 参数 key: 密钥的字符串数组。`
376. `*/`
377. `void aes(char *p, int plen, char *key){`
378.  
379. `int keylen = strlen(key);`
380. `if(plen == 0 || plen % 16 != 0) {`
381. `printf("明文字符长度必须为16的倍数！\n");`
382. `exit(0);`
383. `}`
384.  
385. `if(!checkKeyLen(keylen)) {`
386. `printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);`
387. `exit(0);`
388. `}`
389.  
390. `extendKey(key);//扩展密钥`
391. `int pArray[4][4];`
392.  
393. `for(int k = 0; k < plen; k += 16) {`
394. `convertToIntArray(p + k, pArray);`
395.  
396. `addRoundKey(pArray, 0);//一开始的轮密钥加`
397.  
398. `for(int i = 1; i < 10; i++){//前9轮`
399.  
400. `subBytes(pArray);//字节代换`
401.  
402. `shiftRows(pArray);//行移位`
403.  
404. `mixColumns(pArray);//列混合`
405.  
406. `addRoundKey(pArray, i);`
407.  
408. `}`
409.  
410. `//第10轮`
411. `subBytes(pArray);//字节代换`
412.  
413. `shiftRows(pArray);//行移位`
414.  
415. `addRoundKey(pArray, 10);`
416.  
417. `convertArrayToStr(pArray, p + k);`
418. `}`
419. `}`
420. `/**`
421. `* 根据索引从逆S盒中获取值`
422. `*/`
423. `static int getNumFromS1Box(int index) {`
424. `int row = getLeft4Bit(index);`
425. `int col = getRight4Bit(index);`
426. `return S2[row][col];`
427. `}`
428. `/**`
429. `* 逆字节变换`
430. `*/`
431. `static void deSubBytes(int array[4][4]) {`
432. `for(int i = 0; i < 4; i++)`
433. `for(int j = 0; j < 4; j++)`
434. `array[i][j] = getNumFromS1Box(array[i][j]);`
435. `}`
436. `/**`
437. `* 把4个元素的数组循环右移step位`
438. `*/`
439. `static void rightLoop4int(int array[4], int step) {`
440. `int temp[4];`
441. `for(int i = 0; i < 4; i++)`
442. `temp[i] = array[i];`
443.  
444. `int index = step % 4 == 0 ? 0 : step % 4;`
445. `index = 3 - index;`
446. `for(int i = 3; i >= 0; i--) {`
447. `array[i] = temp[index];`
448. `index--;`
449. `index = index == -1 ? 3 : index;`
450. `}`
451. `}`
452.  
453. `/**`
454. `* 逆行移位`
455. `*/`
456. `static void deShiftRows(int array[4][4]) {`
457. `int rowTwo[4], rowThree[4], rowFour[4];`
458. `for(int i = 0; i < 4; i++) {`
459. `rowTwo[i] = array[1][i];`
460. `rowThree[i] = array[2][i];`
461. `rowFour[i] = array[3][i];`
462. `}`
463.  
464. `rightLoop4int(rowTwo, 1);`
465. `rightLoop4int(rowThree, 2);`
466. `rightLoop4int(rowFour, 3);`
467.  
468. `for(int i = 0; i < 4; i++) {`
469. `array[1][i] = rowTwo[i];`
470. `array[2][i] = rowThree[i];`
471. `array[3][i] = rowFour[i];`
472. `}`
473. `}`
474. `/**`
475. `* 逆列混合用到的矩阵`
476. `*/`
477. `static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9,`
478. `0x9, 0xe, 0xb, 0xd,`
479. `0xd, 0x9, 0xe, 0xb,`
480. `0xb, 0xd, 0x9, 0xe };`
481.  
482. `/**`
483. `* 逆列混合`
484. `*/`
485. `static void deMixColumns(int array[4][4]) {`
486. `int tempArray[4][4];`
487.  
488. `for(int i = 0; i < 4; i++)`
489. `for(int j = 0; j < 4; j++)`
490. `tempArray[i][j] = array[i][j];`
491.  
492. `for(int i = 0; i < 4; i++)`
493. `for(int j = 0; j < 4; j++){`
494. `array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j])`
495. `^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]);`
496. `}`
497. `}`
498. `/**`
499. `* 把两个4X4数组进行异或`
500. `*/`
501. `static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) {`
502. `for(int i = 0; i < 4; i++)`
503. `for(int j = 0; j < 4; j++)`
504. `aArray[i][j] = aArray[i][j] ^ bArray[i][j];`
505. `}`
506. `/**`
507. `* 从4个32位的密钥字中获得4X4数组，`
508. `* 用于进行逆列混合`
509. `*/`
510. `static void getArrayFrom4W(int i, int array[4][4]) {`
511. `int index = i * 4;`
512. `int colOne[4], colTwo[4], colThree[4], colFour[4];`
513. `splitIntToArray(w[index], colOne);`
514. `splitIntToArray(w[index + 1], colTwo);`
515. `splitIntToArray(w[index + 2], colThree);`
516. `splitIntToArray(w[index + 3], colFour);`
517.  
518. `for(int i = 0; i < 4; i++) {`
519. `array[i][0] = colOne[i];`
520. `array[i][1] = colTwo[i];`
521. `array[i][2] = colThree[i];`
522. `array[i][3] = colFour[i];`
523. `}`
524.  
525. `}`
526.  
527. `/**`
528. `* 参数 c: 密文的字符串数组。`
529. `* 参数 clen: 密文的长度。`
530. `* 参数 key: 密钥的字符串数组。`
531. `*/`
532. `void deAes(char *c, int clen, char *key) {`
533.  
534. `int keylen = strlen(key);`
535. `if(clen == 0 || clen % 16 != 0) {`
536. `printf("密文字符长度必须为16的倍数！现在的长度为%d\n",clen);`
537. `exit(0);`
538. `}`
539.  
540. `if(!checkKeyLen(keylen)) {`
541. `printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);`
542. `exit(0);`
543. `}`
544.  
545. `extendKey(key);//扩展密钥`
546. `int cArray[4][4];`
547. `for(int k = 0; k < clen; k += 16) {`
548. `convertToIntArray(c + k, cArray);`
549.  
550.  
551. `addRoundKey(cArray, 10);`
552.  
553. `int wArray[4][4];`
554. `for(int i = 9; i >= 1; i--) {`
555. `deSubBytes(cArray);`
556.  
557. `deShiftRows(cArray);`
558.  
559. `deMixColumns(cArray);`
560. `getArrayFrom4W(i, wArray);`
561. `deMixColumns(wArray);`
562.  
563. `addRoundTowArray(cArray, wArray);`
564. `}`
565.  
566. `deSubBytes(cArray);`
567.  
568. `deShiftRows(cArray);`
569.  
570. `addRoundKey(cArray, 0);`
571.  
572. `convertArrayToStr(cArray, c + k);`
573.  
574. `}`
575. `}`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136
 *  137
 *  138
 *  139
 *  140
 *  141
 *  142
 *  143
 *  144
 *  145
 *  146
 *  147
 *  148
 *  149
 *  150
 *  151
 *  152
 *  153
 *  154
 *  155
 *  156
 *  157
 *  158
 *  159
 *  160
 *  161
 *  162
 *  163
 *  164
 *  165
 *  166
 *  167
 *  168
 *  169
 *  170
 *  171
 *  172
 *  173
 *  174
 *  175
 *  176
 *  177
 *  178
 *  179
 *  180
 *  181
 *  182
 *  183
 *  184
 *  185
 *  186
 *  187
 *  188
 *  189
 *  190
 *  191
 *  192
 *  193
 *  194
 *  195
 *  196
 *  197
 *  198
 *  199
 *  200
 *  201
 *  202
 *  203
 *  204
 *  205
 *  206
 *  207
 *  208
 *  209
 *  210
 *  211
 *  212
 *  213
 *  214
 *  215
 *  216
 *  217
 *  218
 *  219
 *  220
 *  221
 *  222
 *  223
 *  224
 *  225
 *  226
 *  227
 *  228
 *  229
 *  230
 *  231
 *  232
 *  233
 *  234
 *  235
 *  236
 *  237
 *  238
 *  239
 *  240
 *  241
 *  242
 *  243
 *  244
 *  245
 *  246
 *  247
 *  248
 *  249
 *  250
 *  251
 *  252
 *  253
 *  254
 *  255
 *  256
 *  257
 *  258
 *  259
 *  260
 *  261
 *  262
 *  263
 *  264
 *  265
 *  266
 *  267
 *  268
 *  269
 *  270
 *  271
 *  272
 *  273
 *  274
 *  275
 *  276
 *  277
 *  278
 *  279
 *  280
 *  281
 *  282
 *  283
 *  284
 *  285
 *  286
 *  287
 *  288
 *  289
 *  290
 *  291
 *  292
 *  293
 *  294
 *  295
 *  296
 *  297
 *  298
 *  299
 *  300
 *  301
 *  302
 *  303
 *  304
 *  305
 *  306
 *  307
 *  308
 *  309
 *  310
 *  311
 *  312
 *  313
 *  314
 *  315
 *  316
 *  317
 *  318
 *  319
 *  320
 *  321
 *  322
 *  323
 *  324
 *  325
 *  326
 *  327
 *  328
 *  329
 *  330
 *  331
 *  332
 *  333
 *  334
 *  335
 *  336
 *  337
 *  338
 *  339
 *  340
 *  341
 *  342
 *  343
 *  344
 *  345
 *  346
 *  347
 *  348
 *  349
 *  350
 *  351
 *  352
 *  353
 *  354
 *  355
 *  356
 *  357
 *  358
 *  359
 *  360
 *  361
 *  362
 *  363
 *  364
 *  365
 *  366
 *  367
 *  368
 *  369
 *  370
 *  371
 *  372
 *  373
 *  374
 *  375
 *  376
 *  377
 *  378
 *  379
 *  380
 *  381
 *  382
 *  383
 *  384
 *  385
 *  386
 *  387
 *  388
 *  389
 *  390
 *  391
 *  392
 *  393
 *  394
 *  395
 *  396
 *  397
 *  398
 *  399
 *  400
 *  401
 *  402
 *  403
 *  404
 *  405
 *  406
 *  407
 *  408
 *  409
 *  410
 *  411
 *  412
 *  413
 *  414
 *  415
 *  416
 *  417
 *  418
 *  419
 *  420
 *  421
 *  422
 *  423
 *  424
 *  425
 *  426
 *  427
 *  428
 *  429
 *  430
 *  431
 *  432
 *  433
 *  434
 *  435
 *  436
 *  437
 *  438
 *  439
 *  440
 *  441
 *  442
 *  443
 *  444
 *  445
 *  446
 *  447
 *  448
 *  449
 *  450
 *  451
 *  452
 *  453
 *  454
 *  455
 *  456
 *  457
 *  458
 *  459
 *  460
 *  461
 *  462
 *  463
 *  464
 *  465
 *  466
 *  467
 *  468
 *  469
 *  470
 *  471
 *  472
 *  473
 *  474
 *  475
 *  476
 *  477
 *  478
 *  479
 *  480
 *  481
 *  482
 *  483
 *  484
 *  485
 *  486
 *  487
 *  488
 *  489
 *  490
 *  491
 *  492
 *  493
 *  494
 *  495
 *  496
 *  497
 *  498
 *  499
 *  500
 *  501
 *  502
 *  503
 *  504
 *  505
 *  506
 *  507
 *  508
 *  509
 *  510
 *  511
 *  512
 *  513
 *  514
 *  515
 *  516
 *  517
 *  518
 *  519
 *  520
 *  521
 *  522
 *  523
 *  524
 *  525
 *  526
 *  527
 *  528
 *  529
 *  530
 *  531
 *  532
 *  533
 *  534
 *  535
 *  536
 *  537
 *  538
 *  539
 *  540
 *  541
 *  542
 *  543
 *  544
 *  545
 *  546
 *  547
 *  548
 *  549
 *  550
 *  551
 *  552
 *  553
 *  554
 *  555
 *  556
 *  557
 *  558
 *  559
 *  560
 *  561
 *  562
 *  563
 *  564
 *  565
 *  566
 *  567
 *  568
 *  569
 *  570
 *  571
 *  572
 *  573
 *  574
 *  575

### main.c ###

1.  `#include <stdio.h>`
2.  `#include <unistd.h>`
3.  `#include <string.h>`
4.  `#include <stdlib.h>`
5.   
6.  `#include "aes.h"`
7.   
8.  `#define MAXLEN 1024`
9.   
10. `void getString(char *str, int len){`
11.  
12. `int slen = read(0, str, len);`
13. `for(int i = 0; i < slen; i++,str++){`
14. `if(*str == '\n'){`
15. `*str = '\0';`
16. `break;`
17. `}`
18. `}`
19. `}`
20.  
21. `void printASCCI(char *str, int len) {`
22. `int c;`
23. `for(int i = 0; i < len; i++) {`
24. `c = (int)*str++;`
25. `c = c & 0x000000ff;`
26. `printf("0x%x ", c);`
27. `}`
28. `printf("\n");`
29. `}`
30.  
31. `/**`
32. `* 从标准输入中读取用户输入的字符串`
33. `*/`
34. `void readPlainText(char *str, int *len) {`
35. `int plen;`
36. `while(1) {`
37. `getString(str, MAXLEN);`
38. `plen = strlen(str);`
39. `if(plen != 0 && plen % 16 == 0) {`
40. `printf("你输入的明文为：%s\n", str);`
41. `break;`
42. `}else{`
43. `printf("明文字符长度必须为16的倍数,现在的长度为%d\n", plen);`
44. `}`
45. `}`
46. `*len = plen;`
47. `}`
48. `/**`
49. `* 把字符串写进文件`
50. `*/`
51. `void writeStrToFile(char *str, int len, char *fileName) {`
52. `FILE *fp;`
53. `fp = fopen(fileName, "wb");`
54. `for(int i = 0; i < len; i++)`
55. `putc(str[i], fp);`
56. `fclose(fp);`
57. `}`
58.  
59.  
60. `void aesStrToFile(char *key) {`
61.  
62. `char p[MAXLEN];`
63. `int plen;`
64. `printf("请输入你的明文，明文字符长度必须为16的倍数\n");`
65. `readPlainText(p,&plen);`
66. `printf("进行AES加密..................\n");`
67.  
68. `aes(p, plen, key);//AES加密`
69.  
70. `printf("加密完后的明文的ASCCI为：\n");`
71. `printASCCI(p, plen);`
72. `char fileName[64];`
73. `printf("请输入你想要写进的文件名，比如'test.txt':\n");`
74. `if(scanf("%s", fileName) == 1) {`
75. `writeStrToFile(p, plen, fileName);`
76. `printf("已经将密文写进%s中了,可以在运行该程序的当前目录中找到它。\n", fileName);`
77. `}`
78. `}`
79. `/**`
80. `* 从文件中读取字符串`
81. `*/`
82. `int readStrFromFile(char *fileName, char *str) {`
83. `FILE *fp = fopen(fileName, "rb");`
84. `if(fp == NULL) {`
85. `printf("打开文件出错，请确认文件存在当前目录下！\n");`
86. `exit(0);`
87. `}`
88.  
89. `int i;`
90. `for(i = 0; i < MAXLEN && (str[i] = getc(fp)) != EOF; i++);`
91.  
92. `if(i >= MAXLEN) {`
93. `printf("解密文件过大！\n");`
94. `exit(0);`
95. `}`
96.  
97. `str[i] = '\0';`
98. `fclose(fp);`
99. `return i;`
100. `}`
101.  
102.  
103. `void deAesFile(char *key) {`
104. `char fileName[64];`
105. `char c[MAXLEN];//密文字符串`
106. `printf("请输入要解密的文件名，该文件必须和本程序在同一个目录\n");`
107. `if(scanf("%s", fileName) == 1) {`
108. `int clen = readStrFromFile(fileName, c);`
109. `printf("开始解密.........\n");`
110. `deAes(c, clen, key);`
111. `printf("解密后的明文ASCII为：\n");`
112. `printASCCI(c, clen);`
113. `printf("明文为：%s\n", c);`
114. `writeStrToFile(c,clen,fileName);`
115. `printf("现在可以打开%s来查看解密后的密文了！\n",fileName);`
116. `}`
117. `}`
118.  
119. `void aesFile(char *key) {`
120. `char fileName[64];`
121. `char fileP[MAXLEN];`
122.  
123. `printf("请输入要加密的文件名，该文件必须和本程序在同一个目录\n");`
124. `if(scanf("%s", fileName) == 1) {`
125. `readStrFromFile(fileName, fileP);`
126. `int plen = strlen(fileP);`
127. `printf("开始加密.........\n");`
128. `printf("加密前文件中字符的ASCII为：\n");`
129. `printASCCI(fileP, plen);`
130.  
131. `aes(fileP, plen, key);//开始加密`
132.  
133. `printf("加密后的密文ASCII为：\n");`
134. `printASCCI(fileP, plen);`
135. `writeStrToFile(fileP,plen,fileName);`
136. `printf("已经将加密后的密文写进%s中了\n",fileName);`
137. `}`
138. `}`
139.  
140. `int main(int argc, char const *argv[]) {`
141.  
142. `char key[17];`
143. `printf("请输入16个字符的密钥：\n");`
144. `int klen;`
145. `while(1){`
146. `getString(key,17);`
147. `klen = strlen(key);`
148. `if(klen != 16){`
149. `printf("请输入16个字符的密钥,当前密钥的长度为%d\n",klen);`
150. `}else{`
151. `printf("你输入的密钥为：%s\n",key);`
152. `break;`
153. `}`
154. `}`
155.  
156. `printf("输入's'表示要加密输入的字符串,并将加密后的内容写入到文件\n");`
157. `printf("请输入要功能选项并按回车，输入'f'表示要加密文件\n");`
158. `printf("输入'p'表示要解密文件\n");`
159. `char c;`
160. `if(scanf("%s",&c) == 1) {`
161. `if(c == 's')`
162. `aesStrToFile(key);//用AES加密字符串，并将字符串写进文件中`
163. `else if(c == 'p')`
164. `deAesFile(key);//把文件中的密文解密，并写回文件中`
165. `else if(c == 'f')//用AES加密文件`
166. `aesFile(key);`
167. `}`
168. `return 0;`
169. `}`

通过下面的gcc命令来编译运行：

gcc -o aes aes.c main.c

*  1

## VC6.0版本 ##

由于VC6.0的编译器比较坑，要先声明，后使用变量，故要对代码进行相应的修改。

### aes.h ###

1.  `#ifndef MY_AES_H`
2.  `#define MY_AES_H`
3.   
4.  `/**`
5.  `* 参数 p: 明文的字符串数组。`
6.  `* 参数 plen: 明文的长度,长度必须为16的倍数。`
7.  `* 参数 key: 密钥的字符串数组。`
8.  `*/`
9.  `void aes(char *p, int plen, char *key);`
10.  
11. `/**`
12. `* 参数 c: 密文的字符串数组。`
13. `* 参数 clen: 密文的长度,长度必须为16的倍数。`
14. `* 参数 key: 密钥的字符串数组。`
15. `*/`
16. `void deAes(char *c, int clen, char *key);`
17.  
18. `#endif`

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18

### aes.cpp ###

1.  `#include <stdio.h>`
2.  `#include <stdlib.h>`
3.  `#include <string.h>`
4.   
5.  `#include "aes.h"`
6.   
7.  `/**`
8.  `* S盒`
9.  `*/`
10. `static const int S[16][16] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,`
11. `0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,`
12. `0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,`
13. `0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,`
14. `0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,`
15. `0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,`
16. `0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,`
17. `0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,`
18. `0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,`
19. `0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,`
20. `0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,`
21. `0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,`
22. `0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,`
23. `0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,`
24. `0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,`
25. `0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };`
26.  
27. `/**`
28. `* 逆S盒`
29. `*/`
30. `static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,`
31. `0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,`
32. `0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,`
33. `0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,`
34. `0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,`
35. `0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,`
36. `0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,`
37. `0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,`
38. `0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,`
39. `0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,`
40. `0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,`
41. `0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,`
42. `0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,`
43. `0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,`
44. `0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,`
45. `0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };`
46.  
47. `/**`
48. `* 获取整形数据的低8位的左4个位`
49. `*/`
50. `static int getLeft4Bit(int num) {`
51. `int left = num & 0x000000f0;`
52. `return left >> 4;`
53. `}`
54.  
55. `/**`
56. `* 获取整形数据的低8位的右4个位`
57. `*/`
58. `static int getRight4Bit(int num) {`
59. `return num & 0x0000000f;`
60. `}`
61. `/**`
62. `* 根据索引，从S盒中获得元素`
63. `*/`
64. `static int getNumFromSBox(int index) {`
65. `int row = getLeft4Bit(index);`
66. `int col = getRight4Bit(index);`
67. `return S[row][col];`
68. `}`
69.  
70. `/**`
71. `* 把一个字符转变成整型`
72. `*/`
73. `static int getIntFromChar(char c) {`
74. `int result = (int) c;`
75. `return result & 0x000000ff;`
76. `}`
77.  
78. `/**`
79. `* 把16个字符转变成4X4的数组，`
80. `* 该矩阵中字节的排列顺序为从上到下，`
81. `* 从左到右依次排列。`
82. `*/`
83. `static void convertToIntArray(char *str, int pa[4][4]) {`
84. `int k = 0;`
85. `int i,j;`
86. `for(i = 0; i < 4; i++)`
87. `for(j = 0; j < 4; j++) {`
88. `pa[j][i] = getIntFromChar(str[k]);`
89. `k++;`
90. `}`
91. `}`
92.  
93. `/**`
94. `* 打印4X4的数组`
95. `*/`
96. `static void printArray(int a[4][4]) {`
97. `int i,j;`
98. `for(i = 0; i < 4; i++){`
99. `for(j = 0; j < 4; j++)`
100. `printf("a[%d][%d] = 0x%x ", i, j, a[i][j]);`
101. `printf("\n");`
102. `}`
103. `printf("\n");`
104. `}`
105.  
106. `/**`
107. `* 打印字符串的ASSCI，`
108. `* 以十六进制显示。`
109. `*/`
110. `static void printASSCI(char *str, int len) {`
111. `int i;`
112. `for(i = 0; i < len; i++)`
113. `printf("0x%x ", getIntFromChar(str[i]));`
114. `printf("\n");`
115. `}`
116.  
117. `/**`
118. `* 把连续的4个字符合并成一个4字节的整型`
119. `*/`
120. `static int getWordFromStr(char *str) {`
121. `int one, two, three, four;`
122. `one = getIntFromChar(str[0]);`
123. `one = one << 24;`
124. `two = getIntFromChar(str[1]);`
125. `two = two << 16;`
126. `three = getIntFromChar(str[2]);`
127. `three = three << 8;`
128. `four = getIntFromChar(str[3]);`
129. `return one | two | three | four;`
130. `}`
131.  
132. `/**`
133. `* 把一个4字节的数的第一、二、三、四个字节取出，`
134. `* 入进一个4个元素的整型数组里面。`
135. `*/`
136. `static void splitIntToArray(int num, int array[4]) {`
137. `int one, two, three;`
138. `one = num >> 24;`
139. `array[0] = one & 0x000000ff;`
140. `two = num >> 16;`
141. `array[1] = two & 0x000000ff;`
142. `three = num >> 8;`
143. `array[2] = three & 0x000000ff;`
144. `array[3] = num & 0x000000ff;`
145. `}`
146.  
147. `/**`
148. `* 将数组中的元素循环左移step位`
149. `*/`
150. `static void leftLoop4int(int array[4], int step) {`
151. `int temp[4];`
152. `int i;`
153. `int index;`
154. `for(i = 0; i < 4; i++)`
155. `temp[i] = array[i];`
156.  
157. `index = step % 4 == 0 ? 0 : step % 4;`
158. `for(i = 0; i < 4; i++){`
159. `array[i] = temp[index];`
160. `index++;`
161. `index = index % 4;`
162. `}`
163. `}`
164.  
165. `/**`
166. `* 把数组中的第一、二、三和四元素分别作为`
167. `* 4字节整型的第一、二、三和四字节，合并成一个4字节整型`
168. `*/`
169. `static int mergeArrayToInt(int array[4]) {`
170. `int one = array[0] << 24;`
171. `int two = array[1] << 16;`
172. `int three = array[2] << 8;`
173. `int four = array[3];`
174. `return one | two | three | four;`
175. `}`
176.  
177. `/**`
178. `* 常量轮值表`
179. `*/`
180. `static const int Rcon[10] = { 0x01000000, 0x02000000,`
181. `0x04000000, 0x08000000,`
182. `0x10000000, 0x20000000,`
183. `0x40000000, 0x80000000,`
184. `0x1b000000, 0x36000000 };`
185. `/**`
186. `* 密钥扩展中的T函数`
187. `*/`
188. `static int T(int num, int round) {`
189. `int numArray[4];`
190. `int i;`
191. `int result;`
192. `splitIntToArray(num, numArray);`
193. `leftLoop4int(numArray, 1);//字循环`
194.  
195. `//字节代换`
196. `for(i = 0; i < 4; i++)`
197. `numArray[i] = getNumFromSBox(numArray[i]);`
198.  
199. `result = mergeArrayToInt(numArray);`
200. `return result ^ Rcon[round];`
201. `}`
202.  
203. `//密钥对应的扩展数组`
204. `static int w[44];`
205. `/**`
206. `* 打印W数组`
207. `*/`
208. `static void printW() {`
209. `int i, j;`
210. `for(i = 0, j = 1; i < 44; i++,j++){`
211. `printf("w[%d] = 0x%x ", i, w[i]);`
212. `if(j % 4 == 0)`
213. `printf("\n");`
214. `}`
215. `printf("\n");`
216. `}`
217.  
218.  
219. `/**`
220. `* 扩展密钥，结果是把w[44]中的每个元素初始化`
221. `*/`
222. `static void extendKey(char *key) {`
223. `int i,j;`
224. `for(i = 0; i < 4; i++)`
225. `w[i] = getWordFromStr(key + i * 4);`
226.  
227. `for(i = 4, j = 0; i < 44; i++) {`
228. `if( i % 4 == 0) {`
229. `w[i] = w[i - 4] ^ T(w[i - 1], j);`
230. `j++;//下一轮`
231. `}else {`
232. `w[i] = w[i - 4] ^ w[i - 1];`
233. `}`
234. `}`
235.  
236. `}`
237.  
238. `/**`
239. `* 轮密钥加`
240. `*/`
241. `static void addRoundKey(int array[4][4], int round) {`
242. `int warray[4];`
243. `int i,j;`
244. `for(i = 0; i < 4; i++) {`
245.  
246. `splitIntToArray(w[ round * 4 + i], warray);`
247.  
248. `for(j = 0; j < 4; j++) {`
249. `array[j][i] = array[j][i] ^ warray[j];`
250. `}`
251. `}`
252. `}`
253.  
254. `/**`
255. `* 字节代换`
256. `*/`
257. `static void subBytes(int array[4][4]){`
258. `int i,j;`
259. `for(i = 0; i < 4; i++)`
260. `for(j = 0; j < 4; j++)`
261. `array[i][j] = getNumFromSBox(array[i][j]);`
262. `}`
263.  
264. `/**`
265. `* 行移位`
266. `*/`
267. `static void shiftRows(int array[4][4]) {`
268. `int rowTwo[4], rowThree[4], rowFour[4];`
269. `int i;`
270. `for(i = 0; i < 4; i++) {`
271. `rowTwo[i] = array[1][i];`
272. `rowThree[i] = array[2][i];`
273. `rowFour[i] = array[3][i];`
274. `}`
275.  
276. `leftLoop4int(rowTwo, 1);`
277. `leftLoop4int(rowThree, 2);`
278. `leftLoop4int(rowFour, 3);`
279.  
280. `for(i = 0; i < 4; i++) {`
281. `array[1][i] = rowTwo[i];`
282. `array[2][i] = rowThree[i];`
283. `array[3][i] = rowFour[i];`
284. `}`
285. `}`
286.  
287. `/**`
288. `* 列混合要用到的矩阵`
289. `*/`
290. `static const int colM[4][4] = { 2, 3, 1, 1,`
291. `1, 2, 3, 1,`
292. `1, 1, 2, 3,`
293. `3, 1, 1, 2 };`
294.  
295. `static int GFMul2(int s) {`
296. `int result = s << 1;`
297. `int a7 = result & 0x00000100;`
298.  
299. `if(a7 != 0) {`
300. `result = result & 0x000000ff;`
301. `result = result ^ 0x1b;`
302. `}`
303.  
304. `return result;`
305. `}`
306.  
307. `static int GFMul3(int s) {`
308. `return GFMul2(s) ^ s;`
309. `}`
310.  
311. `static int GFMul4(int s) {`
312. `return GFMul2(GFMul2(s));`
313. `}`
314.  
315. `static int GFMul8(int s) {`
316. `return GFMul2(GFMul4(s));`
317. `}`
318.  
319. `static int GFMul9(int s) {`
320. `return GFMul8(s) ^ s;`
321. `}`
322.  
323. `static int GFMul11(int s) {`
324. `return GFMul9(s) ^ GFMul2(s);`
325. `}`
326.  
327. `static int GFMul12(int s) {`
328. `return GFMul8(s) ^ GFMul4(s);`
329. `}`
330.  
331. `static int GFMul13(int s) {`
332. `return GFMul12(s) ^ s;`
333. `}`
334.  
335. `static int GFMul14(int s) {`
336. `return GFMul12(s) ^ GFMul2(s);`
337. `}`
338.  
339. `/**`
340. `* GF上的二元运算`
341. `*/`
342. `static int GFMul(int n, int s) {`
343. `int result;`
344.  
345. `if(n == 1)`
346. `result = s;`
347. `else if(n == 2)`
348. `result = GFMul2(s);`
349. `else if(n == 3)`
350. `result = GFMul3(s);`
351. `else if(n == 0x9)`
352. `result = GFMul9(s);`
353. `else if(n == 0xb)//11`
354. `result = GFMul11(s);`
355. `else if(n == 0xd)//13`
356. `result = GFMul13(s);`
357. `else if(n == 0xe)//14`
358. `result = GFMul14(s);`
359.  
360. `return result;`
361. `}`
362. `/**`
363. `* 列混合`
364. `*/`
365. `static void mixColumns(int array[4][4]) {`
366.  
367. `int tempArray[4][4];`
368. `int i,j;`
369. `for(i = 0; i < 4; i++)`
370. `for(j = 0; j < 4; j++)`
371. `tempArray[i][j] = array[i][j];`
372.  
373. `for(i = 0; i < 4; i++)`
374. `for(j = 0; j < 4; j++){`
375. `array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])`
376. `^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);`
377. `}`
378. `}`
379. `/**`
380. `* 把4X4数组转回字符串`
381. `*/`
382. `static void convertArrayToStr(int array[4][4], char *str) {`
383. `int i,j;`
384. `for(i = 0; i < 4; i++)`
385. `for(j = 0; j < 4; j++)`
386. `*str++ = (char)array[j][i];`
387. `}`
388. `/**`
389. `* 检查密钥长度`
390. `*/`
391. `static int checkKeyLen(int len) {`
392. `if(len == 16)`
393. `return 1;`
394. `else`
395. `return 0;`
396. `}`
397.  
398.  
399. `/**`
400. `* 参数 p: 明文的字符串数组。`
401. `* 参数 plen: 明文的长度。`
402. `* 参数 key: 密钥的字符串数组。`
403. `*/`
404. `void aes(char *p, int plen, char *key){`
405.  
406. `int keylen = strlen(key);`
407. `int pArray[4][4];`
408. `int k,i;`
409.  
410. `if(plen == 0 || plen % 16 != 0) {`
411. `printf("明文字符长度必须为16的倍数！\n");`
412. `exit(0);`
413. `}`
414.  
415. `if(!checkKeyLen(keylen)) {`
416. `printf("密钥字符长度错误！长度必须为16。当前长度为%d\n",keylen);`
417. `exit(0);`
418. `}`
419.  
420. `extendKey(key);//扩展密钥`
421.  
422. `for(k = 0; k < plen; k += 16) {`
423. `convertToIntArray(p + k, pArray);`
424.  
425. `addRoundKey(pArray, 0);//一开始的轮密钥加`
426.  
427. `for(i = 1; i < 10; i++){`
428.  
429. `subBytes(pArray);//字节代换`
430.  
431. `shiftRows(pArray);//行移位`
432.  
433. `mixColumns(pArray);//列混合`
434.  
435. `addRoundKey(pArray, i);`
436.  
437. `}`
438.  
439. `subBytes(pArray);//字节代换`
440.  
441. `shiftRows(pArray);//行移位`
442.  
443. `addRoundKey(pArray, 10);`
444.  
445. `convertArrayToStr(pArray, p + k);`
446. `}`
447. `}`
448. `/**`
449. `* 根据索引从逆S盒中获取值`
450. `*/`
451. `static int getNumFromS1Box(int index) {`
452. `int row = getLeft4Bit(index);`
453. `int col = getRight4Bit(index);`
454. `return S2[row][col];`
455. `}`
456. `/**`
457. `* 逆字节变换`
458. `*/`
459. `static void deSubBytes(int array[4][4]) {`
460. `int i,j;`
461. `for(i = 0; i < 4; i++)`
462. `for(j = 0; j < 4; j++)`
463. `array[i][j] = getNumFromS1Box(array[i][j]);`
464. `}`
465. `/**`
466. `* 把4个元素的数组循环右移step位`
467. `*/`
468. `static void rightLoop4int(int array[4], int step) {`
469. `int temp[4];`
470. `int i;`
471. `int index;`
472. `for(i = 0; i < 4; i++)`
473. `temp[i] = array[i];`
474.  
475. `index = step % 4 == 0 ? 0 : step % 4;`
476. `index = 3 - index;`
477. `for(i = 3; i >= 0; i--) {`
478. `array[i] = temp[index];`
479. `index--;`
480. `index = index == -1 ? 3 : index;`
481. `}`
482. `}`
483.  
484. `/**`
485. `* 逆行移位`
486. `*/`
487. `static void deShiftRows(int array[4][4]) {`
488. `int rowTwo[4], rowThree[4], rowFour[4];`
489. `int i;`
490. `for(i = 0; i < 4; i++) {`
491. `rowTwo[i] = array[1][i];`
492. `rowThree[i] = array[2][i];`
493. `rowFour[i] = array[3][i];`
494. `}`
495.  
496. `rightLoop4int(rowTwo, 1);`
497. `rightLoop4int(rowThree, 2);`
498. `rightLoop4int(rowFour, 3);`
499.  
500. `for(i = 0; i < 4; i++) {`
501. `array[1][i] = rowTwo[i];`
502. `array[2][i] = rowThree[i];`
503. `array[3][i] = rowFour[i];`
504. `}`
505. `}`
506. `/**`
507. `* 逆列混合用到的矩阵`
508. `*/`
509. `static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9,`
510. `0x9, 0xe, 0xb, 0xd,`
511. `0xd, 0x9, 0xe, 0xb,`
512. `0xb, 0xd, 0x9, 0xe };`
513.  
514. `/**`
515. `* 逆列混合`
516. `*/`
517. `static void deMixColumns(int array[4][4]) {`
518. `int tempArray[4][4];`
519. `int i,j;`
520. `for(i = 0; i < 4; i++)`
521. `for(j = 0; j < 4; j++)`
522. `tempArray[i][j] = array[i][j];`
523.  
524. `for(i = 0; i < 4; i++)`
525. `for(j = 0; j < 4; j++){`
526. `array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j])`
527. `^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]);`
528. `}`
529. `}`
530. `/**`
531. `* 把两个4X4数组进行异或`
532. `*/`
533. `static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) {`
534. `int i,j;`
535. `for(i = 0; i < 4; i++)`
536. `for(j = 0; j < 4; j++)`
537. `aArray[i][j] = aArray[i][j] ^ bArray[i][j];`
538. `}`
539. `/**`
540. `* 从4个32位的密钥字中获得4X4数组，`
541. `* 用于进行逆列混合`
542. `*/`
543. `static void getArrayFrom4W(int i, int array[4][4]) {`
544. `int index,j;`
545. `int colOne[4], colTwo[4], colThree[4], colFour[4];`
546. `index = i * 4;`
547. `splitIntToArray(w[index], colOne);`
548. `splitIntToArray(w[index + 1], colTwo);`
549. `splitIntToArray(w[index + 2], colThree);`
550. `splitIntToArray(w[index + 3], colFour);`
551.  
552. `for(j = 0; j < 4; j++) {`
553. `array[j][0] = colOne[j];`
554. `array[j][1] = colTwo[j];`
555. `array[j][2] = colThree[j];`
556. `array[j][3] = colFour[j];`
557. `}`
558.  
559. `}`
560.  
561. `/**`
562. `* 参数 c: 密文的字符串数组。`
563. `* 参数 clen: 密文的长度。`
564. `* 参数 key: 密钥的字符串数组。`
565. `*/`
566. `void deAes(char *c, int clen, char *key) {`
567.  
568. `int cArray[4][4];`
569. `int keylen,k;`
570. `keylen = strlen(key);`
571. `if(clen == 0 || clen % 16 != 0) {`
572. `printf("密文字符长度必须为16的倍数！现在的长度为%d\n",clen);`
573. `exit(0);`
574. `}`
575.  
576. `if(!checkKeyLen(keylen)) {`
577. `printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);`
578. `exit(0);`
579. `}`
580.  
581. `extendKey(key);//扩展密钥`
582.  
583. `for(k = 0; k < clen; k += 16) {`
584. `int i;`
585. `int wArray[4][4];`
586.  
587. `convertToIntArray(c + k, cArray);`
588.  
589.  
590.  
591.  
592.  
593. `addRoundKey(cArray, 10);`
594.  
595. `for(i = 9; i >= 1; i--) {`
596. `deSubBytes(cArray);`
597.  
598. `deShiftRows(cArray);`
599.  
600. `deMixColumns(cArray);`
601. `getArrayFrom4W(i, wArray);`
602. `deMixColumns(wArray);`
603.  
604. `addRoundTowArray(cArray, wArray);`
605. `}`
606.  
607. `deSubBytes(cArray);`
608.  
609. `deShiftRows(cArray);`
610.  
611. `addRoundKey(cArray, 0);`
612.  
613. `convertArrayToStr(cArray, c + k);`
614.  
615. `}`
616.

[SouthEast]: /images/20221023/3d9c699b27e040ecacf364a6f9c3f6b7.png
[state]: /images/20221023/c8fb85ff5d93433795eca4ea7a5eb38e.png
[state2]: /images/20221023/70f8ee40e96143baaa0396d99e178016.png
[keystate]: /images/20221023/b9284614c3a543da893bcbb2f6a9f045.png
[aes_struct]: /images/20221023/c1329311acda40119318560698c74803.png
[byte]: /images/20221023/04bfcfcd845e43d2b43c32957a126a4f.png
[shiftRows]: /images/20221023/9776c978ad9b4ef88f0021d7cfbc45de.png
[col]: /images/20221023/7c9e66ce5a084b1bacbdd567e29b3084.png
[col2]: /images/20221023/54954a7eb6fe4ee38b3e92a65cd18aa5.png
[col3]: /images/20221023/5133fd59851e42bd9de795d54603855c.png
[col4]: /images/20221023/fb1f05d5a6774adfabb35be703afb866.png
[col5]: /images/20221023/4d83e773667e4bd1ac541992c23a8059.png
[col7]: /images/20221023/bd3027cfef014231a67e7e13236b4650.png
[col6]: /images/20221023/eeacccba9f2f4f40814728743c5e9017.png
[roundadd]: /images/20221023/12d44b65c6a046d18d4b8e5c5adc4a69.png
[keyextends]: /images/20221023/325b2159056846f280faa81700ddc0ff.png
[deaes]: /images/20221023/bd278a7c736743b69dfdc228c3b9cc44.png
[ex]: /images/20221023/c635258f89ad48c2b49d0fafe83dce34.png