AES加密算法的詳細介紹與實現

AES簡介

高級加密標準(AES,Advanced Encryption Standard)爲最常見的對稱加密算法(微信小程序加密傳輸就是用這個加密算法的)。對稱加密算法也就是加密和解密用相同的密鑰，具體的加密流程如下圖：

下面簡單介紹下各個部分的作用與意義：

• 明文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	密鑰長度（32位比特字)	分組長度(32位比特字)	加密輪數
AES-128	4	4	10
AES-192	6	4	12
AES-256	8	4	14

輪數在下面介紹，這裏實現的是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。一般地，明文分組用字節爲單位的正方形矩陣描述，稱爲狀態矩陣。在算法的每一輪中，狀態矩陣的內容不斷髮生變化，最後的結果作爲密文輸出。該矩陣中字節的排列順序爲從上到下、從左至右依次排列，如下圖所示：

現在假設明文分組P爲”abcdefghijklmnop”，則對應上面生成的狀態矩陣圖如下：

上圖中，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輪加密運算中的輪密鑰加，如下圖所示：

上圖中，設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解密過程，解密過程仍爲10輪，每一輪的操作是加密操作的逆操作。由於AES的4個輪操作都是可逆的，因此，解密操作的一輪就是順序執行逆行移位、逆字節代換、輪密鑰加和逆列混合。同加密操作類似，最後一輪不執行逆列混合，在第1輪解密之前，要執行1次密鑰加操作。

下面分別介紹AES中一輪的4個操作階段，這4分操作階段使輸入位得到充分的混淆。

一、字節代換

1.字節代換操作

AES的字節代換其實就是一個簡單的查表操作。AES定義了一個S盒和一個逆S盒。
AES的S盒：

行/列	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0x63	0x7c	0x77	0x7b	0xf2	0x6b	0x6f	0xc5	0x30	0x01	0x67	0x2b	0xfe	0xd7	0xab	0x76
1	0xca	0x82	0xc9	0x7d	0xfa	0x59	0x47	0xf0	0xad	0xd4	0xa2	0xaf	0x9c	0xa4	0x72	0xc0
2	0xb7	0xfd	0x93	0x26	0x36	0x3f	0xf7	0xcc	0x34	0xa5	0xe5	0xf1	0x71	0xd8	0x31	0x15
3	0x04	0xc7	0x23	0xc3	0x18	0x96	0x05	0x9a	0x07	0x12	0x80	0xe2	0xeb	0x27	0xb2	0x75
4	0x09	0x83	0x2c	0x1a	0x1b	0x6e	0x5a	0xa0	0x52	0x3b	0xd6	0xb3	0x29	0xe3	0x2f	0x84
5	0x53	0xd1	0x00	0xed	0x20	0xfc	0xb1	0x5b	0x6a	0xcb	0xbe	0x39	0x4a	0x4c	0x58	0xcf
6	0xd0	0xef	0xaa	0xfb	0x43	0x4d	0x33	0x85	0x45	0xf9	0x02	0x7f	0x50	0x3c	0x9f	0xa8
7	0x51	0xa3	0x40	0x8f	0x92	0x9d	0x38	0xf5	0xbc	0xb6	0xda	0x21	0x10	0xff	0xf3	0xd2
8	0xcd	0x0c	0x13	0xec	0x5f	0x97	0x44	0x17	0xc4	0xa7	0x7e	0x3d	0x64	0x5d	0x19	0x73
9	0x60	0x81	0x4f	0xdc	0x22	0x2a	0x90	0x88	0x46	0xee	0xb8	0x14	0xde	0x5e	0x0b	0xdb
A	0xe0	0x32	0x3a	0x0a	0x49	0x06	0x24	0x5c	0xc2	0xd3	0xac	0x62	0x91	0x95	0xe4	0x79
B	0xe7	0xc8	0x37	0x6d	0x8d	0xd5	0x4e	0xa9	0x6c	0x56	0xf4	0xea	0x65	0x7a	0xae	0x08
C	0xba	0x78	0x25	0x2e	0x1c	0xa6	0xb4	0xc6	0xe8	0xdd	0x74	0x1f	0x4b	0xbd	0x8b	0x8a
D	0x70	0x3e	0xb5	0x66	0x48	0x03	0xf6	0x0e	0x61	0x35	0x57	0xb9	0x86	0xc1	0x1d	0x9e
E	0xe1	0xf8	0x98	0x11	0x69	0xd9	0x8e	0x94	0x9b	0x1e	0x87	0xe9	0xce	0x55	0x28	0xdf
F	0x8c	0xa1	0x89	0x0d	0xbf	0xe6	0x42	0x68	0x41	0x99	0x2d	0x0f	0xb0	0x54	0xbb	0x16

狀態矩陣中的元素按照下面的方式映射爲一個新的字節：把該字節的高4位作爲行值，低4位作爲列值，取出S盒或者逆S盒中對應的行的元素作爲輸出。例如，加密時，輸出的字節S1爲0x12,則查S盒的第0x01行和0x02列，得到值0xc9,然後替換S1原有的0x12爲0xc9。狀態矩陣經字節代換後的圖如下：
(第二個字符0xAB查表後應該是轉換成0x62的，感謝細心的朋友指出，有空再重新畫圖更正了)

2.字節代換逆操作

逆字節代換也就是查逆S盒來變換，逆S盒如下：

行/列	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0	0x52	0x09	0x6a	0xd5	0x30	0x36	0xa5	0x38	0xbf	0x40	0xa3	0x9e	0x81	0xf3	0xd7	0xfb
1	0x7c	0xe3	0x39	0x82	0x9b	0x2f	0xff	0x87	0x34	0x8e	0x43	0x44	0xc4	0xde	0xe9	0xcb
2	0x54	0x7b	0x94	0x32	0xa6	0xc2	0x23	0x3d	0xee	0x4c	0x95	0x0b	0x42	0xfa	0xc3	0x4e
3	0x08	0x2e	0xa1	0x66	0x28	0xd9	0x24	0xb2	0x76	0x5b	0xa2	0x49	0x6d	0x8b	0xd1	0x25
4	0x72	0xf8	0xf6	0x64	0x86	0x68	0x98	0x16	0xd4	0xa4	0x5c	0xcc	0x5d	0x65	0xb6	0x92
5	0x6c	0x70	0x48	0x50	0xfd	0xed	0xb9	0xda	0x5e	0x15	0x46	0x57	0xa7	0x8d	0x9d	0x84
6	0x90	0xd8	0xab	0x00	0x8c	0xbc	0xd3	0x0a	0xf7	0xe4	0x58	0x05	0xb8	0xb3	0x45	0x06
7	0xd0	0x2c	0x1e	0x8f	0xca	0x3f	0x0f	0x02	0xc1	0xaf	0xbd	0x03	0x01	0x13	0x8a	0x6b
8	0x3a	0x91	0x11	0x41	0x4f	0x67	0xdc	0xea	0x97	0xf2	0xcf	0xce	0xf0	0xb4	0xe6	0x73
9	0x96	0xac	0x74	0x22	0xe7	0xad	0x35	0x85	0xe2	0xf9	0x37	0xe8	0x1c	0x75	0xdf	0x6e
A	0x47	0xf1	0x1a	0x71	0x1d	0x29	0xc5	0x89	0x6f	0xb7	0x62	0x0e	0xaa	0x18	0xbe	0x1b
B	0xfc	0x56	0x3e	0x4b	0xc6	0xd2	0x79	0x20	0x9a	0xdb	0xc0	0xfe	0x78	0xcd	0x5a	0xf4
C	0x1f	0xdd	0xa8	0x33	0x88	0x07	0xc7	0x31	0xb1	0x12	0x10	0x59	0x27	0x80	0xec	0x5f
D	0x60	0x51	0x7f	0xa9	0x19	0xb5	0x4a	0x0d	0x2d	0xe5	0x7a	0x9f	0x93	0xc9	0x9c	0xef
E	0xa0	0xe0	0x3b	0x4d	0xae	0x2a	0xf5	0xb0	0xc8	0xeb	0xbb	0x3c	0x83	0x53	0x99	0x61
F	0x17	0x2b	0x04	0x7e	0xba	0x77	0xd6	0x26	0xe1	0x69	0x14	0x63	0x55	0x21	0x0c	0x7d

二、行移位

1.行移位操作

行移位是一個簡單的左循環移位操作。當密鑰長度爲128比特時，狀態矩陣的第0行左移0字節，第1行左移1字節，第2行左移2字節，第3行左移3字節，如下圖所示：

2.行移位的逆變換

行移位的逆變換是將狀態矩陣中的每一行執行相反的移位操作，例如AES-128中，狀態矩陣的第0行右移0字節，第1行右移1字節，第2行右移2字節，第3行右移3字節。

三、列混合

1.列混合操作

列混合變換是通過矩陣相乘來實現的，經行移位後的狀態矩陣與固定的矩陣相乘，得到混淆後的狀態矩陣，如下圖的公式所示：

狀態矩陣中的第j列(0 ≤j≤3)的列混合可以表示爲下圖所示：

其中，矩陣元素的乘法和加法都是定義在基於GF(2^8)上的二元運算,並不是通常意義上的乘法和加法。這裏涉及到一些信息安全上的數學知識，不過不懂這些知識也行。其實這種二元運算的加法等價於兩個字節的異或，乘法則複雜一點。對於一個8位的二進制數來說，使用域上的乘法乘以(00000010)等價於左移1位(低位補0)後，再根據情況同(00011011)進行異或運算，設S1 = (a7 a6 a5 a4 a3 a2 a1 a0)，剛0x02 * S1如下圖所示：

也就是說，如果a7爲1，則進行異或運算，否則不進行。
類似地，乘以(00000100)可以拆分成兩次乘以(00000010)的運算：

乘以(0000 0011)可以拆分成先分別乘以(0000 0001)和(0000 0010)，再將兩個乘積異或：

因此，我們只需要實現乘以2的函數，其他數值的乘法都可以通過組合來實現。
下面舉個具體的例子,輸入的狀態矩陣如下：

C9	E5	FD	2B
7A	F2	78	6E
63	9C	26	67
B0	A7	82	E5

下面，進行列混合運算：
以第一列的運算爲例：

其它列的計算就不列舉了，列混合後生成的新狀態矩陣如下：

D4	E7	CD	66
28	02	E5	BB
BE	C6	D6	BF
22	0F	DF	A5

2.列混合逆運算

逆向列混合變換可由下圖的矩陣乘法定義：

可以驗證，逆變換矩陣同正變換矩陣的乘積恰好爲單位矩陣。

四、輪密鑰加

輪密鑰加是將128位輪密鑰Ki同狀態矩陣中的數據進行逐位異或操作，如下圖所示。其中，密鑰Ki中每個字W[4i],W[4i+1],W[4i+2],W[4i+3]爲32位比特字，包含4個字節，他們的生成算法下面在下面介紹。輪密鑰加過程可以看成是字逐位異或的結果，也可以看成字節級別或者位級別的操作。也就是說，可以看成S0 S1 S2 S3 組成的32位字與W[4i]的異或運算。

輪密鑰加的逆運算同正向的輪密鑰加運算完全一致，這是因爲異或的逆操作是其自身。輪密鑰加非常簡單，但卻能夠影響S數組中的每一位。

密鑰擴展

AES首先將初始密鑰輸入到一個4*4的狀態矩陣中，如下圖所示。

這個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]是一個字，其值見下表。

j	1	2	3	4	5
Rcon[j]	01 00 00 00	02 00 00 00	04 00 00 00	08 00 00 00	10 00 00 00
j	6	7	8	9	10
Rcon[j]	20 00 00 00	40 00 00 00	80 00 00 00	1B 00 00 00	36 00 00 00

下面舉個例子：
設初始的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解密的流程圖，可以對應那個流程圖來進行解密。下面介紹的是另一種等價的解密模式，流程圖如下圖所示。這種等價的解密模式使得解密過程各個變換的使用順序同加密過程的順序一致，只是用逆變換取代原來的變換。

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()函數來實現的。

/**
 * 參數 p: 明文的字符串數組。
 * 參數 plen: 明文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void aes(char *p, int plen, char *key){

    int keylen = strlen(key);
    if(plen == 0 || plen % 16 != 0) {
        printf("明文字符長度必須爲16的倍數！\n");
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16、24和32。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰
    int pArray[4][4];

    for(int k = 0; k < plen; k += 16) {
        convertToIntArray(p + k, pArray);

        addRoundKey(pArray, 0);//一開始的輪密鑰加

        for(int i = 1; i < 10; i++){//前9輪

            subBytes(pArray);//字節代換

            shiftRows(pArray);//行移位

            mixColumns(pArray);//列混合

            addRoundKey(pArray, i);

        }

        //第10輪
        subBytes(pArray);//字節代換

        shiftRows(pArray);//行移位

        addRoundKey(pArray, 10);

        convertArrayToStr(pArray, p + k);
    }
}

1.密鑰擴展的實現

在開始加密前，必須先獲得第一輪加密用到的密鑰，故先實現密鑰擴展
下面是密鑰擴展函數的實現，這個函數傳入密鑰key的字符串表示，然後從字符串中讀取W[0]到W[3],函數getWordFromStr()用於實現此功能。讀取後，就開始擴展密鑰，當i是4的倍數的時候，就會調用T()函數來進行擴展，因爲T函數的行爲與加密的輪數有關，故要把加密的輪數 j 作爲參數傳進去。

//密鑰對應的擴展數組
static int w[44];

/**
 * 擴展密鑰，結果是把w[44]中的每個元素初始化
 */
static void extendKey(char *key) {
    for(int i = 0; i < 4; i++)
        w[i] = getWordFromStr(key + i * 4); 

    for(int i = 4, j = 0; i < 44; i++) {
        if( i % 4 == 0) {
            w[i] = w[i - 4] ^ T(w[i - 1], j); 
            j++;//下一輪
        }else {
            w[i] = w[i - 4] ^ w[i - 1]; 
        }
    }   

}

下面是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位的整數，在進行輪常量異或後返回。

/**
 * 常量輪值表
 */
static const int Rcon[10] = { 0x01000000, 0x02000000,
    0x04000000, 0x08000000,
    0x10000000, 0x20000000,
    0x40000000, 0x80000000,
    0x1b000000, 0x36000000 };
/**
 * 密鑰擴展中的T函數
 */
static int T(int num, int round) {
    int numArray[4];
    splitIntToArray(num, numArray);
    leftLoop4int(numArray, 1);//字循環

    //字節代換
    for(int i = 0; i < 4; i++)
        numArray[i] = getNumFromSBox(numArray[i]);

    int result = mergeArrayToInt(numArray);
    return result ^ Rcon[round];
}

2. 字節代換的實現

字節代換的代碼很簡單，就是把狀態矩陣中的每個元素傳進getNumFromSBox()函數中，然後取得前面8位中的高4位作爲行值，低4位作爲列值，然後返回S[row][col]，這裏的S是儲存S盒的數組。

/**
 * 根據索引，從S盒中獲得元素
 */
static int getNumFromSBox(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S[row][col];
}

/**
 * 字節代換
 */
static void subBytes(int array[4][4]){
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            array[i][j] = getNumFromSBox(array[i][j]);
}

3.行移位的實現

行移位的時候，首先把狀態矩陣中第2，3，4行複製出來，然後對它們行進左移相應的位數，然後再複製回去狀態矩陣array中。

/**
 * 將數組中的元素循環左移step位
 */
static void leftLoop4int(int array[4], int step) {
    int temp[4];
    for(int i = 0; i < 4; i++)
        temp[i] = array[i];

    int index = step % 4 == 0 ? 0 : step % 4;
    for(int i = 0; i < 4; i++){
        array[i] = temp[index];
        index++;
        index = index % 4;
    }
}

/**
 * 行移位
 */
static void shiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    //複製狀態矩陣的第2,3,4行
    for(int i = 0; i < 4; i++) {
        rowTwo[i] = array[1][i];
        rowThree[i] = array[2][i];
        rowFour[i] = array[3][i];
    }
    //循環左移相應的位數
    leftLoop4int(rowTwo, 1);
    leftLoop4int(rowThree, 2);
    leftLoop4int(rowFour, 3);

    //把左移後的行復制回狀態矩陣中
    for(int i = 0; i < 4; i++) {
        array[1][i] = rowTwo[i];
        array[2][i] = rowThree[i];
        array[3][i] = rowFour[i];
    }
}

4.列混合的實現

列混合函數中，先把狀態矩陣初始狀態複製一份到tempArray中，然後把tempArray與colM矩陣相乘，colM爲存放要乘的常數矩陣的數組。其中的GFMul()函數定義了矩陣相乘時的乘法，加法則直接通過異或來實現。GFMul()通過調用乘以各個數對應的函數來實現乘法。例如，S1 * 2 剛通過調用GFMul2(S1)來實現。S1 * 3 剛通過GFMul3(S1)來實現。在這裏，主要實現GFMul2()函數就行了，其它的都可以通過GFMul2()的組合來實現。舉個例子吧，爲計算下面這條等式，需要像下面這樣調用函數

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

/**
 * 列混合要用到的矩陣
 */
static const int colM[4][4] = { 2, 3, 1, 1,
    1, 2, 3, 1,
    1, 1, 2, 3,
    3, 1, 1, 2 };

static int GFMul2(int s) {
    int result = s << 1;
    int a7 = result & 0x00000100;

    if(a7 != 0) {
        result = result & 0x000000ff;
        result = result ^ 0x1b;
    }

    return result;
}

static int GFMul3(int s) {
    return GFMul2(s) ^ s;
}

/**
 * GF上的二元運算
 */
static int GFMul(int n, int s) {
    int result;

    if(n == 1)
        result = s;
    else if(n == 2)
        result = GFMul2(s);
    else if(n == 3)
        result = GFMul3(s);
    else if(n == 0x9)
        result = GFMul9(s);
    else if(n == 0xb)//11
        result = GFMul11(s);
    else if(n == 0xd)//13
        result = GFMul13(s);
    else if(n == 0xe)//14
        result = GFMul14(s);

    return result;
}

/**
 * 列混合
 */
static void mixColumns(int array[4][4]) {

    int tempArray[4][4];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++){
            array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])
                ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);
        }
}

5.輪密鑰加的實現

輪密鑰加的實現很簡單，就是根據傳入的輪數來把狀態矩陣與相應的W[i]異或。

/**
 * 輪密鑰加
 */
static void addRoundKey(int array[4][4], int round) {
    int warray[4];
    for(int i = 0; i < 4; i++) {

        splitIntToArray(w[ round * 4 + i], warray);

        for(int j = 0; j < 4; j++) {
            array[j][i] = array[j][i] ^ warray[j];
        }
    }
}

AES解密函數

AES的解密函數和加密函數有點不同，可以參考上面的等價解密流程圖來理解，解密函數中調用的是各輪操作的逆函數。逆函數在這裏就不詳細講解了，可以參考最後的完整代碼。

/**
 * 參數 c: 密文的字符串數組。
 * 參數 clen: 密文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void deAes(char *c, int clen, char *key) {

    int keylen = strlen(key);
    if(clen == 0 || clen % 16 != 0) {
        printf("密文字符長度必須爲16的倍數！現在的長度爲%d\n",clen);
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16、24和32。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰
    int cArray[4][4];
    for(int k = 0; k < clen; k += 16) {
        convertToIntArray(c + k, cArray);


        addRoundKey(cArray, 10);

        int wArray[4][4];
        for(int i = 9; i >= 1; i--) {
            deSubBytes(cArray);

            deShiftRows(cArray);

            deMixColumns(cArray);
            getArrayFrom4W(i, wArray);
            deMixColumns(wArray);

            addRoundTowArray(cArray, wArray);
        }

        deSubBytes(cArray);

        deShiftRows(cArray);

        addRoundKey(cArray, 0);

        convertArrayToStr(cArray, c + k);

    }
}

完整的程序代碼

Linux版本

aes.h

#ifndef AES_H
#define AES_H

/**
 * 參數 p: 明文的字符串數組。
 * 參數 plen: 明文的長度,長度必須爲16的倍數。
 * 參數 key: 密鑰的字符串數組。
 */
void aes(char *p, int plen, char *key);

/**
 * 參數 c: 密文的字符串數組。
 * 參數 clen: 密文的長度,長度必須爲16的倍數。
 * 參數 key: 密鑰的字符串數組。
 */
void deAes(char *c, int clen, char *key);

#endif

aes.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aes.h"

/**
 * S盒
 */
static const int S[16][16] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

/**
 * 逆S盒
 */
static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };

/**
 * 獲取整形數據的低8位的左4個位
 */
static int getLeft4Bit(int num) {
    int left = num & 0x000000f0;
    return left >> 4;
}

/**
 * 獲取整形數據的低8位的右4個位
 */
static int getRight4Bit(int num) {
    return num & 0x0000000f;
}
/**
 * 根據索引，從S盒中獲得元素
 */
static int getNumFromSBox(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S[row][col];
}

/**
 * 把一個字符轉變成整型
 */
static int getIntFromChar(char c) {
    int result = (int) c;
    return result & 0x000000ff;
}

/**
 * 把16個字符轉變成4X4的數組，
 * 該矩陣中字節的排列順序爲從上到下，
 * 從左到右依次排列。
 */
static void convertToIntArray(char *str, int pa[4][4]) {
    int k = 0;
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++) {
            pa[j][i] = getIntFromChar(str[k]);
            k++;
        }
}

/**
 * 打印4X4的數組
 */
static void printArray(int a[4][4]) {
    for(int i = 0; i < 4; i++){
        for(int j = 0; j < 4; j++)
            printf("a[%d][%d] = 0x%x ", i, j, a[i][j]);
        printf("\n");
    }
    printf("\n");
}

/**
 * 打印字符串的ASSCI，
 * 以十六進制顯示。
 */
static void printASSCI(char *str, int len) {
    for(int i = 0; i < len; i++)
        printf("0x%x ", getIntFromChar(str[i]));
    printf("\n");
}

/**
 * 把連續的4個字符合併成一個4字節的整型
 */
static int getWordFromStr(char *str) {
    int one = getIntFromChar(str[0]);
    one = one << 24;
    int two = getIntFromChar(str[1]);
    two = two << 16;
    int three = getIntFromChar(str[2]);
    three = three << 8;
    int four = getIntFromChar(str[3]);
    return one | two | three | four;
}

/**
 * 把一個4字節的數的第一、二、三、四個字節取出，
 * 入進一個4個元素的整型數組裏面。
 */
static void splitIntToArray(int num, int array[4]) {
    int one = num >> 24;
    array[0] = one & 0x000000ff;
    int two = num >> 16;
    array[1] = two & 0x000000ff;
    int three = num >> 8;
    array[2] = three & 0x000000ff;
    array[3] = num & 0x000000ff;
}

/**
 * 將數組中的元素循環左移step位
 */
static void leftLoop4int(int array[4], int step) {
    int temp[4];
    for(int i = 0; i < 4; i++)
        temp[i] = array[i];

    int index = step % 4 == 0 ? 0 : step % 4;
    for(int i = 0; i < 4; i++){
        array[i] = temp[index];
        index++;
        index = index % 4;
    }
}

/**
 * 把數組中的第一、二、三和四元素分別作爲
 * 4字節整型的第一、二、三和四字節，合併成一個4字節整型
 */
static int mergeArrayToInt(int array[4]) {
    int one = array[0] << 24;
    int two = array[1] << 16;
    int three = array[2] << 8;
    int four = array[3];
    return one | two | three | four;
}

/**
 * 常量輪值表
 */
static const int Rcon[10] = { 0x01000000, 0x02000000,
    0x04000000, 0x08000000,
    0x10000000, 0x20000000,
    0x40000000, 0x80000000,
    0x1b000000, 0x36000000 };
/**
 * 密鑰擴展中的T函數
 */
static int T(int num, int round) {
    int numArray[4];
    splitIntToArray(num, numArray);
    leftLoop4int(numArray, 1);//字循環

    //字節代換
    for(int i = 0; i < 4; i++)
        numArray[i] = getNumFromSBox(numArray[i]);

    int result = mergeArrayToInt(numArray);
    return result ^ Rcon[round];
}

//密鑰對應的擴展數組
static int w[44];

/**
 * 擴展密鑰，結果是把w[44]中的每個元素初始化
 */
static void extendKey(char *key) {
    for(int i = 0; i < 4; i++)
        w[i] = getWordFromStr(key + i * 4);

    for(int i = 4, j = 0; i < 44; i++) {
        if( i % 4 == 0) {
            w[i] = w[i - 4] ^ T(w[i - 1], j);
            j++;//下一輪
        }else {
            w[i] = w[i - 4] ^ w[i - 1];
        }
    }

}

/**
 * 輪密鑰加
 */
static void addRoundKey(int array[4][4], int round) {
    int warray[4];
    for(int i = 0; i < 4; i++) {

        splitIntToArray(w[ round * 4 + i], warray);

        for(int j = 0; j < 4; j++) {
            array[j][i] = array[j][i] ^ warray[j];
        }
    }
}

/**
 * 字節代換
 */
static void subBytes(int array[4][4]){
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            array[i][j] = getNumFromSBox(array[i][j]);
}

/**
 * 行移位
 */
static void shiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    //複製狀態矩陣的第2,3,4行
    for(int i = 0; i < 4; i++) {
        rowTwo[i] = array[1][i];
        rowThree[i] = array[2][i];
        rowFour[i] = array[3][i];
    }
    //循環左移相應的位數
    leftLoop4int(rowTwo, 1);
    leftLoop4int(rowThree, 2);
    leftLoop4int(rowFour, 3);

    //把左移後的行復制回狀態矩陣中
    for(int i = 0; i < 4; i++) {
        array[1][i] = rowTwo[i];
        array[2][i] = rowThree[i];
        array[3][i] = rowFour[i];
    }
}

/**
 * 列混合要用到的矩陣
 */
static const int colM[4][4] = { 2, 3, 1, 1,
    1, 2, 3, 1,
    1, 1, 2, 3,
    3, 1, 1, 2 };

static int GFMul2(int s) {
    int result = s << 1;
    int a7 = result & 0x00000100;

    if(a7 != 0) {
        result = result & 0x000000ff;
        result = result ^ 0x1b;
    }

    return result;
}

static int GFMul3(int s) {
    return GFMul2(s) ^ s;
}

static int GFMul4(int s) {
    return GFMul2(GFMul2(s));
}

static int GFMul8(int s) {
    return GFMul2(GFMul4(s));
}

static int GFMul9(int s) {
    return GFMul8(s) ^ s;
}

static int GFMul11(int s) {
    return GFMul9(s) ^ GFMul2(s);
}

static int GFMul12(int s) {
    return GFMul8(s) ^ GFMul4(s);
}

static int GFMul13(int s) {
    return GFMul12(s) ^ s;
}

static int GFMul14(int s) {
    return GFMul12(s) ^ GFMul2(s);
}

/**
 * GF上的二元運算
 */
static int GFMul(int n, int s) {
    int result;

    if(n == 1)
        result = s;
    else if(n == 2)
        result = GFMul2(s);
    else if(n == 3)
        result = GFMul3(s);
    else if(n == 0x9)
        result = GFMul9(s);
    else if(n == 0xb)//11
        result = GFMul11(s);
    else if(n == 0xd)//13
        result = GFMul13(s);
    else if(n == 0xe)//14
        result = GFMul14(s);

    return result;
}
/**
 * 列混合
 */
static void mixColumns(int array[4][4]) {

    int tempArray[4][4];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++){
            array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j]) 
                ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);
        }
}
/**
 * 把4X4數組轉回字符串
 */
static void convertArrayToStr(int array[4][4], char *str) {
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            *str++ = (char)array[j][i]; 
}
/**
 * 檢查密鑰長度
 */
static int checkKeyLen(int len) {
    if(len == 16)
        return 1;
    else
        return 0;
}

/**
 * 參數 p: 明文的字符串數組。
 * 參數 plen: 明文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void aes(char *p, int plen, char *key){

    int keylen = strlen(key);
    if(plen == 0 || plen % 16 != 0) {
        printf("明文字符長度必須爲16的倍數！\n");
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16、24和32。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰
    int pArray[4][4];

    for(int k = 0; k < plen; k += 16) { 
        convertToIntArray(p + k, pArray);

        addRoundKey(pArray, 0);//一開始的輪密鑰加

        for(int i = 1; i < 10; i++){//前9輪

            subBytes(pArray);//字節代換

            shiftRows(pArray);//行移位

            mixColumns(pArray);//列混合

            addRoundKey(pArray, i);

        }

        //第10輪
        subBytes(pArray);//字節代換

        shiftRows(pArray);//行移位

        addRoundKey(pArray, 10);

        convertArrayToStr(pArray, p + k);
    }
}
/**
 * 根據索引從逆S盒中獲取值
 */
static int getNumFromS1Box(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S2[row][col];
}
/**
 * 逆字節變換
 */
static void deSubBytes(int array[4][4]) {
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            array[i][j] = getNumFromS1Box(array[i][j]);
}
/**
 * 把4個元素的數組循環右移step位
 */
static void rightLoop4int(int array[4], int step) {
    int temp[4];
    for(int i = 0; i < 4; i++)
        temp[i] = array[i];

    int index = step % 4 == 0 ? 0 : step % 4;
    index = 3 - index;
    for(int i = 3; i >= 0; i--) {
        array[i] = temp[index];
        index--;
        index = index == -1 ? 3 : index;
    }
}

/**
 * 逆行移位
 */
static void deShiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    for(int i = 0; i < 4; i++) {
        rowTwo[i] = array[1][i];
        rowThree[i] = array[2][i];
        rowFour[i] = array[3][i];
    }

    rightLoop4int(rowTwo, 1);
    rightLoop4int(rowThree, 2);
    rightLoop4int(rowFour, 3);

    for(int i = 0; i < 4; i++) {
        array[1][i] = rowTwo[i];
        array[2][i] = rowThree[i];
        array[3][i] = rowFour[i];
    }
}
/**
 * 逆列混合用到的矩陣
 */
static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9,
    0x9, 0xe, 0xb, 0xd,
    0xd, 0x9, 0xe, 0xb,
    0xb, 0xd, 0x9, 0xe };

/**
 * 逆列混合
 */
static void deMixColumns(int array[4][4]) {
    int tempArray[4][4];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++){
            array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j]) 
                ^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]);
        }
}
/**
 * 把兩個4X4數組進行異或
 */
static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) {
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            aArray[i][j] = aArray[i][j] ^ bArray[i][j];
}
/**
 * 從4個32位的密鑰字中獲得4X4數組，
 * 用於進行逆列混合
 */
static void getArrayFrom4W(int i, int array[4][4]) {
    int index = i * 4;
    int colOne[4], colTwo[4], colThree[4], colFour[4];
    splitIntToArray(w[index], colOne);
    splitIntToArray(w[index + 1], colTwo);
    splitIntToArray(w[index + 2], colThree);
    splitIntToArray(w[index + 3], colFour);

    for(int i = 0; i < 4; i++) {
        array[i][0] = colOne[i];
        array[i][1] = colTwo[i];
        array[i][2] = colThree[i];
        array[i][3] = colFour[i];
    }

}

/**
 * 參數 c: 密文的字符串數組。
 * 參數 clen: 密文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void deAes(char *c, int clen, char *key) {

    int keylen = strlen(key);
    if(clen == 0 || clen % 16 != 0) {
        printf("密文字符長度必須爲16的倍數！現在的長度爲%d\n",clen);
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16、24和32。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰
    int cArray[4][4];
    for(int k = 0; k < clen; k += 16) {
        convertToIntArray(c + k, cArray);


        addRoundKey(cArray, 10);

        int wArray[4][4];
        for(int i = 9; i >= 1; i--) {
            deSubBytes(cArray);

            deShiftRows(cArray);

            deMixColumns(cArray);
            getArrayFrom4W(i, wArray);
            deMixColumns(wArray);

            addRoundTowArray(cArray, wArray);
        }

        deSubBytes(cArray);

        deShiftRows(cArray);

        addRoundKey(cArray, 0);

        convertArrayToStr(cArray, c + k);

    }
}

main.c

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

#include "aes.h"

#define MAXLEN 1024

void getString(char *str, int len){

    int slen = read(0, str, len);
    for(int i = 0; i < slen; i++,str++){
        if(*str == '\n'){
            *str = '\0';
            break;
        }
    }
}

void printASCCI(char *str, int len) {
    int c;
    for(int i = 0; i < len; i++) {
        c = (int)*str++;
        c = c & 0x000000ff;
        printf("0x%x ", c);
    }
    printf("\n");
}

/**
 * 從標準輸入中讀取用戶輸入的字符串
 */
void readPlainText(char *str, int *len) {
    int plen;
    while(1) {
        getString(str, MAXLEN);
        plen = strlen(str);
        if(plen != 0 && plen % 16 == 0) {
            printf("你輸入的明文爲：%s\n", str);
            break;
        }else{
            printf("明文字符長度必須爲16的倍數,現在的長度爲%d\n", plen);
        }
    }
    *len = plen;
}
/**
 * 把字符串寫進文件
 */
void writeStrToFile(char *str, int len, char *fileName) {
    FILE *fp;
    fp = fopen(fileName, "wb");
    for(int i = 0; i < len; i++)
        putc(str[i], fp);
    fclose(fp);
}


void aesStrToFile(char *key) {

    char p[MAXLEN];
    int plen;
    printf("請輸入你的明文，明文字符長度必須爲16的倍數\n");
    readPlainText(p,&plen);
    printf("進行AES加密..................\n");

    aes(p, plen, key);//AES加密

    printf("加密完後的明文的ASCCI爲：\n");
    printASCCI(p, plen);
    char fileName[64];
    printf("請輸入你想要寫進的文件名，比如'test.txt':\n");
    if(scanf("%s", fileName) == 1) {    
        writeStrToFile(p, plen, fileName);
        printf("已經將密文寫進%s中了,可以在運行該程序的當前目錄中找到它。\n", fileName);
    }
}
/**
 * 從文件中讀取字符串
 */
int readStrFromFile(char *fileName, char *str) {
    FILE *fp = fopen(fileName, "rb");
    if(fp == NULL) {
        printf("打開文件出錯，請確認文件存在當前目錄下！\n");
        exit(0);
    }

    int i;
    for(i = 0; i < MAXLEN && (str[i] = getc(fp)) != EOF; i++);

    if(i >= MAXLEN) {
        printf("解密文件過大！\n");
        exit(0);
    }

    str[i] = '\0';
    fclose(fp);
    return i;
}


void deAesFile(char *key) {
    char fileName[64];
    char c[MAXLEN];//密文字符串
    printf("請輸入要解密的文件名，該文件必須和本程序在同一個目錄\n");
    if(scanf("%s", fileName) == 1) {
        int clen = readStrFromFile(fileName, c);
        printf("開始解密.........\n");
        deAes(c, clen, key);
        printf("解密後的明文ASCII爲：\n");
        printASCCI(c, clen);
        printf("明文爲：%s\n", c);
        writeStrToFile(c,clen,fileName);
        printf("現在可以打開%s來查看解密後的密文了！\n",fileName);
    }
}

void aesFile(char *key) {
    char fileName[64];
    char fileP[MAXLEN];

    printf("請輸入要加密的文件名，該文件必須和本程序在同一個目錄\n");
    if(scanf("%s", fileName) == 1) {
        readStrFromFile(fileName, fileP);
        int plen = strlen(fileP);
        printf("開始加密.........\n");
        printf("加密前文件中字符的ASCII爲：\n");
        printASCCI(fileP, plen);

        aes(fileP, plen, key);//開始加密

        printf("加密後的密文ASCII爲：\n");
        printASCCI(fileP, plen);
        writeStrToFile(fileP,plen,fileName);
        printf("已經將加密後的密文寫進%s中了\n",fileName);
    }
}

int main(int argc, char const *argv[]) {

    char key[17];
    printf("請輸入16個字符的密鑰：\n");
    int klen;
    while(1){
        getString(key,17);
        klen = strlen(key);
        if(klen != 16){
            printf("請輸入16個字符的密鑰,當前密鑰的長度爲%d\n",klen);
        }else{
            printf("你輸入的密鑰爲：%s\n",key);
            break;
        }
    }

    printf("輸入's'表示要加密輸入的字符串,並將加密後的內容寫入到文件\n");
    printf("請輸入要功能選項並按回車，輸入'f'表示要加密文件\n");
    printf("輸入'p'表示要解密文件\n");
    char c;
    if(scanf("%s",&c) == 1) {
        if(c == 's')
            aesStrToFile(key);//用AES加密字符串，並將字符串寫進文件中
        else if(c == 'p')
            deAesFile(key);//把文件中的密文解密，並寫回文件中
        else if(c == 'f')//用AES加密文件
            aesFile(key);
    }
    return 0;
}

通過下面的gcc命令來編譯運行：

gcc -o aes aes.c main.c

VC6.0版本

由於VC6.0的編譯器比較坑，要先聲明，後使用變量，故要對代碼進行相應的修改。

aes.h

#ifndef MY_AES_H
#define MY_AES_H

/**
 * 參數 p: 明文的字符串數組。
 * 參數 plen: 明文的長度,長度必須爲16的倍數。
 * 參數 key: 密鑰的字符串數組。
 */
void aes(char *p, int plen, char *key);

/**
 * 參數 c: 密文的字符串數組。
 * 參數 clen: 密文的長度,長度必須爲16的倍數。
 * 參數 key: 密鑰的字符串數組。
 */
void deAes(char *c, int clen, char *key);

#endif

aes.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "aes.h"

/**
 * S盒
 */
static const int S[16][16] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

/**
 * 逆S盒
 */
static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };

/**
 * 獲取整形數據的低8位的左4個位
 */
static int getLeft4Bit(int num) {
    int left = num & 0x000000f0;
    return left >> 4;
}

/**
 * 獲取整形數據的低8位的右4個位
 */
static int getRight4Bit(int num) {
    return num & 0x0000000f;
}
/**
 * 根據索引，從S盒中獲得元素
 */
static int getNumFromSBox(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S[row][col];
}

/**
 * 把一個字符轉變成整型
 */
static int getIntFromChar(char c) {
    int result = (int) c;
    return result & 0x000000ff;
}

/**
 * 把16個字符轉變成4X4的數組，
 * 該矩陣中字節的排列順序爲從上到下，
 * 從左到右依次排列。
 */
static void convertToIntArray(char *str, int pa[4][4]) {
    int k = 0;
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++) {
            pa[j][i] = getIntFromChar(str[k]);
            k++;
        }
}

/**
 * 打印4X4的數組
 */
static void printArray(int a[4][4]) {
    int i,j;
    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++)
            printf("a[%d][%d] = 0x%x ", i, j, a[i][j]);
        printf("\n");
    }
    printf("\n");
}

/**
 * 打印字符串的ASSCI，
 * 以十六進制顯示。
 */
static void printASSCI(char *str, int len) {
    int i;
    for(i = 0; i < len; i++)
        printf("0x%x ", getIntFromChar(str[i]));
    printf("\n");
}

/**
 * 把連續的4個字符合併成一個4字節的整型
 */
static int getWordFromStr(char *str) {
    int one, two, three, four;
    one = getIntFromChar(str[0]);
    one = one << 24;
    two = getIntFromChar(str[1]);
    two = two << 16;
    three = getIntFromChar(str[2]);
    three = three << 8;
    four = getIntFromChar(str[3]);
    return one | two | three | four;
}

/**
 * 把一個4字節的數的第一、二、三、四個字節取出，
 * 入進一個4個元素的整型數組裏面。
 */
static void splitIntToArray(int num, int array[4]) {
    int one, two, three;
    one = num >> 24;
    array[0] = one & 0x000000ff;
    two = num >> 16;
    array[1] = two & 0x000000ff;
    three = num >> 8;
    array[2] = three & 0x000000ff;
    array[3] = num & 0x000000ff;
}

/**
 * 將數組中的元素循環左移step位
 */
static void leftLoop4int(int array[4], int step) {
    int temp[4];
    int i;
    int index;
    for(i = 0; i < 4; i++)
        temp[i] = array[i];

    index = step % 4 == 0 ? 0 : step % 4;
    for(i = 0; i < 4; i++){
        array[i] = temp[index];
        index++;
        index = index % 4;
    }
}

/**
 * 把數組中的第一、二、三和四元素分別作爲
 * 4字節整型的第一、二、三和四字節，合併成一個4字節整型
 */
static int mergeArrayToInt(int array[4]) {
    int one = array[0] << 24;
    int two = array[1] << 16;
    int three = array[2] << 8;
    int four = array[3];
    return one | two | three | four;
}

/**
 * 常量輪值表
 */
static const int Rcon[10] = { 0x01000000, 0x02000000,
    0x04000000, 0x08000000,
    0x10000000, 0x20000000,
    0x40000000, 0x80000000,
    0x1b000000, 0x36000000 };
/**
 * 密鑰擴展中的T函數
 */
static int T(int num, int round) {
    int numArray[4];
    int i;
    int result;
    splitIntToArray(num, numArray);
    leftLoop4int(numArray, 1);//字循環

    //字節代換
    for(i = 0; i < 4; i++)
        numArray[i] = getNumFromSBox(numArray[i]);

    result = mergeArrayToInt(numArray);
    return result ^ Rcon[round];
}

//密鑰對應的擴展數組
static int w[44];
/**
 * 打印W數組
 */
static void printW() {
    int i, j;
    for(i = 0, j = 1; i < 44; i++,j++){
        printf("w[%d] = 0x%x ", i, w[i]);
        if(j % 4 == 0)
            printf("\n");
    }
    printf("\n");
}


/**
 * 擴展密鑰，結果是把w[44]中的每個元素初始化
 */
static void extendKey(char *key) {
    int i,j;
    for(i = 0; i < 4; i++)
        w[i] = getWordFromStr(key + i * 4);

    for(i = 4, j = 0; i < 44; i++) {
        if( i % 4 == 0) {
            w[i] = w[i - 4] ^ T(w[i - 1], j);
            j++;//下一輪
        }else {
            w[i] = w[i - 4] ^ w[i - 1];
        }
    }

}

/**
 * 輪密鑰加
 */
static void addRoundKey(int array[4][4], int round) {
    int warray[4];
    int i,j;
    for(i = 0; i < 4; i++) {

        splitIntToArray(w[ round * 4 + i], warray);

        for(j = 0; j < 4; j++) {
            array[j][i] = array[j][i] ^ warray[j];
        }
    }
}

/**
 * 字節代換
 */
static void subBytes(int array[4][4]){
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            array[i][j] = getNumFromSBox(array[i][j]);
}

/**
 * 行移位
 */
static void shiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    int i;
    for(i = 0; i < 4; i++) {
        rowTwo[i] = array[1][i];
        rowThree[i] = array[2][i];
        rowFour[i] = array[3][i];
    }

    leftLoop4int(rowTwo, 1);
    leftLoop4int(rowThree, 2);
    leftLoop4int(rowFour, 3);

    for(i = 0; i < 4; i++) {
        array[1][i] = rowTwo[i];
        array[2][i] = rowThree[i];
        array[3][i] = rowFour[i];
    }
}

/**
 * 列混合要用到的矩陣
 */
static const int colM[4][4] = { 2, 3, 1, 1,
    1, 2, 3, 1,
    1, 1, 2, 3,
    3, 1, 1, 2 };

static int GFMul2(int s) {
    int result = s << 1;
    int a7 = result & 0x00000100;

    if(a7 != 0) {
        result = result & 0x000000ff;
        result = result ^ 0x1b;
    }

    return result;
}

static int GFMul3(int s) {
    return GFMul2(s) ^ s;
}

static int GFMul4(int s) {
    return GFMul2(GFMul2(s));
}

static int GFMul8(int s) {
    return GFMul2(GFMul4(s));
}

static int GFMul9(int s) {
    return GFMul8(s) ^ s;
}

static int GFMul11(int s) {
    return GFMul9(s) ^ GFMul2(s);
}

static int GFMul12(int s) {
    return GFMul8(s) ^ GFMul4(s);
}

static int GFMul13(int s) {
    return GFMul12(s) ^ s;
}

static int GFMul14(int s) {
    return GFMul12(s) ^ GFMul2(s);
}

/**
 * GF上的二元運算
 */
static int GFMul(int n, int s) {
    int result;

    if(n == 1)
        result = s;
    else if(n == 2)
        result = GFMul2(s);
    else if(n == 3)
        result = GFMul3(s);
    else if(n == 0x9)
        result = GFMul9(s);
    else if(n == 0xb)//11
        result = GFMul11(s);
    else if(n == 0xd)//13
        result = GFMul13(s);
    else if(n == 0xe)//14
        result = GFMul14(s);

    return result;
}
/**
 * 列混合
 */
static void mixColumns(int array[4][4]) {

    int tempArray[4][4];
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++){
            array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])
                ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);
        }
}
/**
 * 把4X4數組轉回字符串
 */
static void convertArrayToStr(int array[4][4], char *str) {
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            *str++ = (char)array[j][i];
}
/**
 * 檢查密鑰長度
 */
static int checkKeyLen(int len) {
    if(len == 16)
        return 1;
    else
        return 0;
}


/**
 * 參數 p: 明文的字符串數組。
 * 參數 plen: 明文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void aes(char *p, int plen, char *key){

    int keylen = strlen(key);
    int pArray[4][4];
    int k,i;

    if(plen == 0 || plen % 16 != 0) {
        printf("明文字符長度必須爲16的倍數！\n");
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰

    for(k = 0; k < plen; k += 16) {
        convertToIntArray(p + k, pArray);

        addRoundKey(pArray, 0);//一開始的輪密鑰加

        for(i = 1; i < 10; i++){

            subBytes(pArray);//字節代換

            shiftRows(pArray);//行移位

            mixColumns(pArray);//列混合

            addRoundKey(pArray, i);

        }

        subBytes(pArray);//字節代換

        shiftRows(pArray);//行移位

        addRoundKey(pArray, 10);

        convertArrayToStr(pArray, p + k);
    }
}
/**
 * 根據索引從逆S盒中獲取值
 */
static int getNumFromS1Box(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S2[row][col];
}
/**
 * 逆字節變換
 */
static void deSubBytes(int array[4][4]) {
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            array[i][j] = getNumFromS1Box(array[i][j]);
}
/**
 * 把4個元素的數組循環右移step位
 */
static void rightLoop4int(int array[4], int step) {
    int temp[4];
    int i;
    int index;
    for(i = 0; i < 4; i++)
        temp[i] = array[i];

    index = step % 4 == 0 ? 0 : step % 4;
    index = 3 - index;
    for(i = 3; i >= 0; i--) {
        array[i] = temp[index];
        index--;
        index = index == -1 ? 3 : index;
    }
}

/**
 * 逆行移位
 */
static void deShiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    int i;
    for(i = 0; i < 4; i++) {
        rowTwo[i] = array[1][i];
        rowThree[i] = array[2][i];
        rowFour[i] = array[3][i];
    }

    rightLoop4int(rowTwo, 1);
    rightLoop4int(rowThree, 2);
    rightLoop4int(rowFour, 3);

    for(i = 0; i < 4; i++) {
        array[1][i] = rowTwo[i];
        array[2][i] = rowThree[i];
        array[3][i] = rowFour[i];
    }
}
/**
 * 逆列混合用到的矩陣
 */
static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9,
    0x9, 0xe, 0xb, 0xd,
    0xd, 0x9, 0xe, 0xb,
    0xb, 0xd, 0x9, 0xe };

/**
 * 逆列混合
 */
static void deMixColumns(int array[4][4]) {
    int tempArray[4][4];
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++){
            array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j])
                ^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]);
        }
}
/**
 * 把兩個4X4數組進行異或
 */
static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) {
    int i,j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < 4; j++)
            aArray[i][j] = aArray[i][j] ^ bArray[i][j];
}
/**
 * 從4個32位的密鑰字中獲得4X4數組，
 * 用於進行逆列混合
 */
static void getArrayFrom4W(int i, int array[4][4]) {
    int index,j;
    int colOne[4], colTwo[4], colThree[4], colFour[4];
    index = i * 4;
    splitIntToArray(w[index], colOne);
    splitIntToArray(w[index + 1], colTwo);
    splitIntToArray(w[index + 2], colThree);
    splitIntToArray(w[index + 3], colFour);

    for(j = 0; j < 4; j++) {
        array[j][0] = colOne[j];
        array[j][1] = colTwo[j];
        array[j][2] = colThree[j];
        array[j][3] = colFour[j];
    }

}

/**
 * 參數 c: 密文的字符串數組。
 * 參數 clen: 密文的長度。
 * 參數 key: 密鑰的字符串數組。
 */
void deAes(char *c, int clen, char *key) {

    int cArray[4][4];
    int keylen,k;
    keylen = strlen(key);
    if(clen == 0 || clen % 16 != 0) {
        printf("密文字符長度必須爲16的倍數！現在的長度爲%d\n",clen);
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密鑰字符長度錯誤！長度必須爲16、24和32。當前長度爲%d\n",keylen);
        exit(0);
    }

    extendKey(key);//擴展密鑰

    for(k = 0; k < clen; k += 16) {
        int i;
        int wArray[4][4];

        convertToIntArray(c + k, cArray);





        addRoundKey(cArray, 10);

        for(i = 9; i >= 1; i--) {
            deSubBytes(cArray);

            deShiftRows(cArray);

            deMixColumns(cArray);
            getArrayFrom4W(i, wArray);
            deMixColumns(wArray);

            addRoundTowArray(cArray, wArray);
        }

        deSubBytes(cArray);

        deShiftRows(cArray);

        addRoundKey(cArray, 0);

        convertArrayToStr(cArray, c + k);

    }
}