一、头文件

1. #ifndef _AES_H
   4 H% c$ ]" L% T9 c
2. #define _AES_H
   0 t2 {  k: J! a, f$ ?
3. 
   8 ~8 T6 S+ e+ S7 G7 Q
4. 
   
5. // 以bit为单位的密钥长度，只能为 128，192 和 256 三种
   ; x+ E: g! Y/ x( @
6. #define AES_KEY_LENGTH        128
   
7. 
   
8. // 加解密模式
   ' }6 E- |  r: v3 ~; ]
9. #define AES_MODE_ECB        0                                // 电子密码本模式（一般模式）
   ) V/ [, ~  P' J! N: i) [
10. #define AES_MODE_CBC        1                                // 密码分组链接模式
    9 y# q4 \' R+ ^; O0 d8 A
11. #define AES_MODE                AES_MODE_CBC
    ! M5 w2 h3 `9 y' |
12. 
    2 l4 T7 R( D# ]2 Z
13. 
    - t& I& F9 }$ z+ q
14. ///
    0 v5 W+ V9 k* @. J/ c$ `
15. //        函数名：        aes_init
    * Y. `- Z7 s& P2 Y2 w
16. //        描述：                初始化，在此执行扩展密钥操作。
    
17. //        输入参数：        pKey -- 原始密钥，其长度必须为 AES_KEY_LENGTH/8 字节。
    ! A6 I+ ]: j2 i) P+ ^! F0 E
18. //        输出参数：        无。
    2 |( f' D% {0 u
19. //        返回值：        无。
    
20. ///
    
21. void aes_init(const void *pKey);
    ) q) c/ E0 B$ [9 L9 W' O3 \+ P
22. 
    
23. //
    0 j* x/ T0 r" P9 [3 _
24. //        函数名：        aes_encrypt
    
25. //        描述：                加密数据
    % h3 Z* z7 i' ~- x+ v* Y' m& q
26. //        输入参数：        pPlainText        -- 明文，即需加密的数据，其长度为nDataLen字节。
    
27. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
    
28. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
    
29. //        输出参数：        pCipherText        -- 密文，即由明文加密后的数据，可以与pPlainText相同。
    
30. //        返回值：        无。
    
31. //
    
32. void aes_encrypt(const unsigned char *pPlainText, unsigned char *pCipherText,
    * y% Y5 }0 T6 g8 L  r7 c8 Q! I! H
33.                                  unsigned int nDataLen, const unsigned char *pIV);
    % B7 K; f9 U! v9 E& d' x  ~
34. 
    
35. //
    1 X! \. x! R( {
36. //        函数名：        aes_decrypt
    
37. //        描述：                解密数据
    . K  f: i4 L; U4 J% ?, L( S( T
38. //        输入参数：        pCipherText -- 密文，即需解密的数据，其长度为nDataLen字节。
    
39. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
    
40. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
    % U4 M& ?! P* p; n/ }
41. //        输出参数：        pPlainText  -- 明文，即由密文解密后的数据，可以与pCipherText相同。
    
42. //        返回值：        无。
    ; l' z( `" N: B  g8 ]" q
43. //
    
44. void aes_decrypt( const unsigned char *pCipherText,unsigned char *pPlainText,
    
45.                                  unsigned int nDataLen, const unsigned char *pIV);
    
46. #endif  /* _AES_H */

复制代码

2 ]5 \6 \) |- Z: Q" I! D) E二、源文件
, I2 `! q4 H! y9 R$ E* B, {. _
5 H7 Z) o/ J/ y) R; Y# E

1. #include "aes.h"
   # F) U, _* l- @* B' G5 @
2. #include "string.h"
   
3. 
   
4. 
   
5. // 为了能针对C51进行优化，并且又使代码可用于ARM和PC等环境，
     x5 b! I/ F6 J9 O) B+ Q) M
6. // 在非C51环境（没有定义__C51__）下需要把C51特定的关键字定义为空
   
7. #ifndef __C51__
   * u% Q8 e3 X* K& P8 S
8.         #define code
   
9.         #define data
   6 |7 X; S. I5 D  e6 r
10.         #define idata
    7 i8 c0 M' v8 U0 [$ z$ d: d. U
11.         #define xdata
    
12.         #define pdata
    + |' }! R+ U4 H9 b7 x# R0 i
13.         typedef unsigned char BOOL;
    
14. #else
    
15.         typedef bit BOOL;
    
16. #endif
    
17. 
    
18. #define Nk        (AES_KEY_LENGTH / 32)                // 以“字”（4字节）为单位的密钥长度
    3 @: X/ o4 J, S, F/ h/ ]) Z1 x9 U/ z# j: v
19. #define Nb        4                                                        // 以“字”（4字节）为单位的加解密数据块大小，固定为4
    8 N. C6 M" U) ~; L8 K
20. 
    
21. // Nr：加密的轮数
    1 t: ~) Z/ C  n" n- G/ [' N
22. #if   AES_KEY_LENGTH == 128
    6 |/ d' A; S6 ?3 r! z+ m
23.         #define Nr        10
    1 A( d0 ?- L! R+ e
24. #elif AES_KEY_LENGTH == 192
    5 N3 q) ^) o+ o
25.         #define Nr        12
    6 a8 ^+ ~& d' D8 O( i+ W
26. #elif AES_KEY_LENGTH == 256
    
27.         #define Nr        14
    
28. #else
    
29.         #error AES_KEY_LENGTH must be 128, 192 or 256 BOOLs!
    7 s/ t+ ?  g5 ^9 [: S# D
30. #endif
    
31. 
    ' \2 E4 [$ }. U/ Y
32. // GF(28) 多项式
    
33. #define BPOLY 0x1B // Lower 8 BOOLs of (x^8 + x^4 + x^3 + x + 1), ie. (x^4 + x^3 + x + 1).
    
34. 
    
35. /*****************************************************************************
    
36. *  Typedef  Enum                        枚举定义
    6 O1 z* m  E8 `2 w
37. *****************************************************************************/
    
38. 
    
39. /*****************************************************************************
    
40. *  Struct                               数据结构定义
    
41. ******************************************************************************/
    
42. 
      z$ Q3 q! f  r) Z
43. 
    
44. /*****************************************************************************
    
45. *  Local variable                       局部变量
    
46. *****************************************************************************/
    ; c/ U( R% V* g% \6 o  ~
47. 
    
48. // AES子密钥表，当密钥长度为128位时，占用176字节空间
    $ i- S" E8 n1 a7 q
49. static xdata unsigned char g_roundKeyTable[4*Nb*(Nr+1)];
    5 d" D4 p8 A7 h5 Q  E5 v! A. L0 i
50. 
    
51. // 加密用的SBox
    
52. static code const unsigned char sBox[256] =
    % @; j, J, s0 [' n# V. H) P
53. {
    , G, j" ]% j6 Y+ K/ D
54.         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    $ l  g# a- Z6 k7 `5 c4 d! n4 g
55.         0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    ' Z8 f$ i8 D  i/ ~
56.         0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    
57.         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    2 V% C4 y& ^5 _" k) O2 V
58.         0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    
59.         0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    
60.         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    
61.         0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    
62.         0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    ' f% L9 t2 _4 P! i
63.         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    4 U2 N  f6 W: A) W
64.         0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    
65.         0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    1 S1 c/ f1 X2 K
66.         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0**, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    8 ^1 C9 e& g7 f2 f/ i* k8 T
67.         0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    
68.         0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    ! i1 r; S, R  Z" q. g6 a1 E& Y7 V! ^2 g
69.         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
    
70. };
    , U! f+ g, x8 w  D4 G, F
71. 
    
72. // 解密用的SBox
    
73. static code const unsigned char invSBox[256] =
    + P7 s' |7 k1 }# L9 O. a
74. {
    ) O- @, M8 m, i* O" W2 z# \' v
75.         0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    . c  l7 `4 f# z3 u
76.         0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    4 P9 c$ P! [- e# ~, G
77.         0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    ; u% ?, P/ f5 q( v6 Q  ]
78.         0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    
79.         0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    ) b: ~( R8 g1 }8 [
80.         0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    - Y" u' C  s: \" P6 g5 Q# E' V
81.         0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    
82.         0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    
83.         0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    ' I; c% Y4 R- D) J
84.         0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    
85.         0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    
86.         0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    9 ?1 N1 a8 {+ A# l4 f! Z
87.         0x1f, 0**, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    
88.         0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    9 l* V" T% n& ^, \0 t2 O
89.         0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    ; @' _. E+ K. ~: D$ X9 R
90.         0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d        
    
91. };
    2 H$ S; e, O, f# X1 |. f
92. 
    ) n1 L6 A1 k2 |3 |
93. 
    ) y7 P) b; R) B. Z+ z5 h( c
94. ///
    
95. //        函数名：        rotation_word
    
96. //        描述：                对一个“字”数据进行循环右移。
    " C' u/ T8 L* m6 O
97. //        输入参数：        pWord -- 要右移的4字节数据。
    1 x( u7 O2 u; J) ]! k
98. //        输出参数：        pWord -- 右移后的4字节数据。
    
99. //        返回值：        无。
    
100. ///
     
101. static void rotation_word(unsigned char *pWord)
     
102. {
     
103.         unsigned char temp = pWord[0];
     ( @, S1 W- W" E& G5 L; v2 T$ `
104.         pWord[0]  = pWord[1];
     
105.         pWord[1]  = pWord[2];
     1 X0 T/ }" F% b6 f; ^* M; d
106.         pWord[2]  = pWord[3];
     
107.         pWord[3]  = temp;
     7 A' h" j# q# z  B- f# W8 R
108. }
     : W0 {; k6 k/ y) z8 E+ p. e
109. 
     6 H2 C4 [% U" N! j, V
110. ///
     
111. //        函数名：        xor_bytes
     
112. //        描述：                批量异或两组数据。
       U; D  {8 G5 G
113. //        输入参数：        pData1 -- 要异或的第一组数据。
     
114. //                                pData1 -- 要异或的第二组数据。
     $ i) v% X0 Y% o$ w7 F; d; }
115. //                                nCount -- 要异或的数据长度。
     
116. //        输出参数：        pData1 -- 异或后的结果。
     # d% i5 I/ d7 Y# w% Y. L$ S1 D3 b
117. //        返回值：        无。
     
118. ///
     # V$ w* ]) d/ @8 l/ C- D' i5 i
119. static void xor_bytes(unsigned char *pData1, const unsigned char *pData2, unsigned char nCount)
     
120. {
     3 E$ O: R, U7 A! g
121.         unsigned char i;
     
122.         
       x, k4 A4 O  p; v, n  J* m  n
123.         for (i = 0; i < nCount; i++)
     
124.         {
     6 D/ e: p9 F9 N/ t' r
125.                 pData1<i> ^= pData2<i>;
     
126.         }
     
127. }
     : ^- o+ h6 N  N0 N
128. 
     
129. ///
     2 C3 y4 i* T# z
130. //        函数名：        AddRoundKey
     / U# f* p: l2 r0 d
131. //        描述：                把 中间状态数据 加上（异或）子密钥，数据长度为16字节。
     
132. //        输入参数：        pState          -- 状态数据。
     ! C5 O+ Y" ]% R! M' C: i
133. //                                pRoundKey -- 子密钥数据。
     ) r1 p* q) w) L# ]- L8 w& r) l$ k
134. //        输出参数：        pState          -- 加上子密钥后的状态数据。
     ' o, Q1 i5 X7 K
135. //        返回值：        无。
     . H4 W6 t8 g8 d, Q  U
136. ///
     
137. // static void AddRoundKey(unsigned char *pState, const unsigned char *pRoundKey)
     ; J+ p" @' u% ^6 m
138. // {
     
139. //         xor_bytes(pState, pRoundKey, 4*Nb);
     
140. // }
     
141. 
     , x3 R' h4 y; U7 [
142. // AddRoundKey的宏形式，比函数形式可以节省4字节的data数据
     
143. #define AddRoundKey(pState, pRoundKey) \
     ) n; M( H! \- T/ u8 I6 Z" [
144.         xor_bytes((pState), (pRoundKey), 4*Nb)
     " w7 ^& P# ^3 p9 R5 u% b' |) U
145. 
     " s! E# ]- @5 w' T- z" y7 i
146. 
     
147. ///
     
148. //        函数名：        sub_bytes
     
149. //        描述：                通过S盒子置换状态数据。
     
150. //        输入参数：        pState        -- 状态数据。
     
151. //                                nCount  -- 状态数据长度。
     & O7 o$ h, @  y: H+ u+ l
152. //                                bInvert        -- 是否使用反向S盒子（解密时使用）。
     
153. //        输出参数：        pState        -- 置换后的状态数据。
     & A$ o- j) X* W; G3 e
154. //        返回值：        无。
     8 S( f2 _! Y5 n9 Z/ t6 {
155. ///
     " z/ C  j8 S! _. I
156. static void sub_bytes(unsigned char *pState, unsigned char nCount, BOOL bInvert)
     
157. {
     % ]$ n* \7 r8 w6 }3 M# i& w1 G
158.         unsigned char i;
     " _  p: w$ W* ?
159.         const unsigned char code *pSBox = bInvert ? invSBox : sBox;
     
160.         
     
161.         for (i = 0; i < nCount; i++)
     
162.         {
     
163.                 pState<i> = pSBox[pState<i>];
     6 `; R6 q, n- d2 E
164.         }
     
165. }
     
166. 
     
167. ///
     
168. //        函数名：        shift_rows
     
169. //        描述：                把状态数据移行。
     : u+ r; }* Y* G8 o  r
170. //        输入参数：        pState        -- 状态数据。
     - h/ c/ d! R) @7 U2 I, D$ o
171. //                                bInvert        -- 是否反向移行（解密时使用）。
       k$ d' ~: v9 r1 R& @+ g
172. //        输出参数：        pState        -- 移行后的状态数据。
     3 P2 \! O7 u8 V  x$ r
173. //        返回值：        无。
     
174. ///
     
175. static void shift_rows(unsigned char *pState, BOOL bInvert)
     ! `7 V8 h" B7 \+ D1 A6 w6 L" @
176. {
     # Y& N' x" W. s- X- k8 @2 g" @
177.         // 注意：状态数据以列形式存放！
     
178. 
     ( c, U2 r3 |0 ^* y# ]
179.         unsigned char r;        // row，   行
     
180.         unsigned char c;        // column，列
     8 z4 S# v+ n$ K9 h
181.         unsigned char temp;
     ' @/ t5 u5 Z1 n
182.         unsigned char rowData[4];
     
183.         
     
184.         for (r = 1; r < 4; r++)
     
185.         {
     
186.                 // 备份一行数据
     " F& ]' |8 b8 m2 h
187.                 for (c = 0; c < 4; c++)
     
188.                 {
     7 y+ M9 z& R( a& y; v
189.                         rowData[c] = pState[r + 4*c];
     3 G; C( m! C7 I; E
190.                 }
     ; C2 ]; h, ~* C; `; k1 o
191.                
     
192.                 temp = bInvert ? (4 - r) : r;
     5 C6 q$ f+ e) x( T) j5 j( F+ D
193.                 for (c = 0; c < 4; c++)
     & _! }8 d. U3 z  h2 U* r0 Y" h
194.                 {
     
195.                         pState[r + 4*c] = rowData[(c + temp) % 4];
     ( }) n; e/ C6 ]4 x! {% y
196.                 }
     ) |2 p' f' Y* a& E2 n
197.         }
     
198. }
     ; p* P" d# b' ?# X  E3 T# e
199. 
     + [. f0 {9 V0 y( [1 z. e
200. ///
     * _8 W$ B* R3 y5 k: M
201. //        函数名：        gf_mult_by02
     
202. //        描述：                在GF(28)域的 乘2 运算。
     
203. //        输入参数：        num        -- 乘数。
     
204. //        输出参数：        无。
     
205. //        返回值：        num乘以2的结果。
     5 v; P& I# V* u( x1 O
206. ///
     * o$ b7 R% W, d) [2 a
207. static unsigned char gf_mult_by02(unsigned char num)
     ) l) E' K: D0 X
208. {
     % `2 |% u2 Z5 f6 r0 ^/ V
209.         if ((num & 0x80) == 0)
     
210.         {
     " O8 `# }  ^3 \, R8 A# ^; e$ ?
211.                 num = num << 1;
     
212.         }
     
213.         else
     ) A0 N% |# R) x+ D8 V' [
214.         {
     
215.                 num = (num << 1) ^ BPOLY;
     
216.         }
     
217.         
     
218.         return num;
     
219. }
     3 _5 ^* q1 D1 B0 ?/ J# K5 Z
220. 
     
221. ///
     
222. //        函数名：        mix_columns
     $ u! k+ H  t' x$ U8 V: P
223. //        描述：                混合状态各列数据。
     $ z  P' q8 }" s+ ]
224. //        输入参数：        pState        -- 状态数据。
     8 x' ]; P1 h" v' i/ c/ j" C
225. //                                bInvert        -- 是否反向混合（解密时使用）。
     0 ~9 k; H. z8 W2 M- f+ [2 |2 W
226. //        输出参数：        pState        -- 混合列后的状态数据。
     
227. //        返回值：        无。
     
228. ///
     
229. static void mix_columns(unsigned char *pState, BOOL bInvert)
     ! o1 C3 @8 E1 T+ ]
230. {
     
231.         unsigned char i;
     
232.         unsigned char temp;
     ) l* r8 }, W4 t
233.         unsigned char a0Pa2_M4;        // 4(a0 + a2)
     . n: d5 L0 c# H
234.         unsigned char a1Pa3_M4;        // 4(a1 + a3)
     
235.         unsigned char result[4];
     * }  `; x8 ^9 Q# Z- H2 P- p
236. 
     
237.         for (i = 0; i < 4; i++, pState += 4)
     4 I3 V% A+ b2 h! V
238.         {
     
239.                 // b0 = 2a0 + 3a1 + a2 + a3
     1 }; K5 B8 e6 |4 H
240.                 //    = (a0 + a1 + a2 + a3) + 2(a0 + a1) + a0
     
241. 
     
242.                 temp = pState[0] ^ pState[1] ^ pState[2] ^ pState[3];
     / g) S- R; {" p0 J7 {' i
243.                 result[0] = temp ^ pState[0] ^ gf_mult_by02((unsigned char) (pState[0] ^ pState[1]));
     
244.                 result[1] = temp ^ pState[1] ^ gf_mult_by02((unsigned char) (pState[1] ^ pState[2]));
     0 @& C0 ?7 X& d3 k; A( ]
245.                 result[2] = temp ^ pState[2] ^ gf_mult_by02((unsigned char) (pState[2] ^ pState[3]));
     7 U' v  F' J. s) w1 k5 g+ A: V
246.                 result[3] = temp ^ pState[3] ^ gf_mult_by02((unsigned char) (pState[3] ^ pState[0]));
     
247. 
     ) O& k7 U; m2 o0 P) P# h
248.                 if (bInvert)
     
249.                 {
     # e8 N7 Y/ `5 t* D: R4 r# ^# C
250.                 // b0' = 14a0 + 11a1 + 13a2 + 9a3
     
251.                 //     = (a0 + a1 + a2 + a3) + 2(a0 + a1) + a0        （这部分为b0）
     * A$ D  V7 c1 r" V
252.                 //       + 2(4(a0 + a2) + 4(a1 + a3))
     
253.                 //       +   4(a0 + a2)
     * n+ ]! |6 b$ V' o7 r
254. 
     & {0 u9 X8 i8 _# @
255.                         a0Pa2_M4 = gf_mult_by02(gf_mult_by02((unsigned char) (pState[0] ^ pState[2])));
     
256.                         a1Pa3_M4 = gf_mult_by02(gf_mult_by02((unsigned char) (pState[1] ^ pState[3])));
     % L9 ^. e2 o# J" i
257.                         temp         = gf_mult_by02((unsigned char) (a0Pa2_M4 ^ a1Pa3_M4));
     
258.                         result[0] ^= temp ^ a0Pa2_M4;
     
259.                         result[1] ^= temp ^ a1Pa3_M4;
     ( u* r; c9 {" f+ _
260.                         result[2] ^= temp ^ a0Pa2_M4;
     # p* |5 G6 @8 d& B) \
261.                         result[3] ^= temp ^ a1Pa3_M4;
     ; K4 e3 V+ O  X; O' T) p  v7 G0 {
262.                 }
     
263. 
     
264.                 memcpy(pState, result, 4);
     
265.         }
     & [5 n0 P8 h' {7 s% C7 K+ Y
266. }
     
267. 
     
268. ///
     " c+ v6 P) @9 {9 S
269. //        函数名：        block_encrypt
     1 x+ {/ T) D/ f* e0 _
270. //        描述：                对单块数据加密。
     ; \. O2 g1 }& m+ l- K4 k( _
271. //        输入参数：        pState -- 状态数据。
     9 V3 f" ~' @5 ~
272. //        输出参数：        pState -- 加密后的状态数据。
     
273. //        返回值：        无。
     ; E' k- Y$ Q$ z: t$ r' }
274. ///
     
275. static void block_encrypt(unsigned char *pState)
     1 s# [1 _! g) L6 r9 U
276. {
     
277.         unsigned char i;
     ' S" D) v. U. [3 a$ ^
278.         
     
279.         AddRoundKey(pState, g_roundKeyTable);
     2 B9 @& V( l$ T4 y- V7 u
280.         
     
281.         for (i = 1; i <= Nr; i++)        // i = [1, Nr]
     
282.         {
     
283.                 sub_bytes(pState, 4*Nb, 0);
     
284.                 shift_rows(pState, 0);
     
285. 
     ' D& s+ u9 D7 u* h1 u1 w. b% B
286.                 if (i != Nr)
     
287.                 {
     ! ]- c2 x) O  Y
288.                         mix_columns(pState, 0);
     
289.                 }
     1 m& `2 C6 Q: P6 D( }5 |
290. 
     
291.                 AddRoundKey(pState, &g_roundKeyTable[4*Nb*i]);
     
292.         }
     
293.         
     
294. // 为了节省代码，合并到循化执行
     
295. //         sub_bytes(pState, 4*Nb);
     
296. //        shift_rows(pState, 0);
     5 h6 ]1 l4 J/ p; |
297. //         AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]);
     % s4 W  H- t/ l1 K! F
298. }
     ( R& c6 C6 @& J$ ^
299. 
     
300. ///
     , f. R/ z6 p% \
301. //        函数名：        block_decrypt
     
302. //        描述：                对单块数据解密。
     - r' y3 R2 d& E1 ~) ~- |
303. //        输入参数：        pState -- 状态数据。
     - a8 G& q( D& d+ l( O
304. //        输出参数：        pState -- 解密后的状态数据。
     
305. //        返回值：        无。
     
306. ///
     
307. static void block_decrypt(unsigned char *pState)
     
308. {
     0 F# ~+ p, o4 [9 @$ d
309.         unsigned char i;
     
310.         
     
311.         AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]);
     : ?8 _2 N+ ~: Z
312.         
     
313.         for (i = Nr; i > 0; i--)        // i = [Nr, 1]
     
314.         {
     
315.                 shift_rows(pState, 1);
     
316.                 sub_bytes(pState, 4*Nb, 1);
     " {# a1 J' s/ q0 g2 w
317.                 AddRoundKey(pState, &g_roundKeyTable[4*Nb*(i-1)]);
     7 ^  ]5 B* d$ ^% r& Q) z! V" U+ N
318. 
     
319.                 if (i != 1)
     
320.                 {
     
321.                         mix_columns(pState, 1);
     % F) V, U1 O) b  g' w5 Z+ a6 K+ J
322.                 }
     4 w8 ]- i1 L7 t! Z/ R7 B- u2 o/ y- `
323.         }
     2 F3 E) I0 V$ Y. |
324.         
     : |9 v% ^' z1 C! [8 z$ I. g! Q2 J
325. // 为了节省代码，合并到循化执行
     
326. //  shift_rows(pState, 1);
     . f: c/ R8 m. m! j% q
327. //  sub_bytes(pState, 4*Nb, 1);
     & Z& ]7 A7 h2 f3 s- M, e6 x7 @
328. //  AddRoundKey(pState, g_roundKeyTable);
     
329. }
     
330. 
     4 f7 i+ y/ L1 y  T
331. /*****************************************************************************
     / P, o: }9 Q% L( x; n
332. *  Global Functions                     全局函数
     
333. ******************************************************************************/
     
334. 
     1 L! I6 ~& B% B/ }- s
335. 
     ' {1 ^/ J! {& d. Y
336. ///
     
337. //        函数名：        aes_init
     
338. //        描述：                初始化，在此执行扩展密钥操作。
     4 e9 C/ w1 l) z2 ?" K& o0 T
339. //        输入参数：        pKey -- 原始密钥，其长度必须为 AES_KEY_LENGTH/8 字节。
     + V% S6 s/ w5 d$ b9 n  d1 v4 }; b
340. //        输出参数：        无。
     8 X9 }7 F; h5 U. V5 ]; N
341. //        返回值：        无。
     4 N6 B+ n$ u  x4 Y: G; \
342. ///
     8 M4 c- p2 A! p4 Y2 }
343. void aes_init(const void *pKey)
     . l. p! p* ^- u- o3 Z
344. {
     
345.         // 扩展密钥
     
346.         unsigned char i;
     
347.         unsigned char *pRoundKey;
     
348.         unsigned char Rcon[4] = {0x01, 0x00, 0x00, 0x00};
     , L1 s+ Q& F+ e: h6 G2 H5 T
349. 
     
350.         memcpy(g_roundKeyTable, pKey, 4*Nk);
     
351. 
     ; W- n6 V8 G$ _' p" @& H8 L
352.         pRoundKey = &g_roundKeyTable[4*Nk];
     
353. 
     
354.         for (i = Nk; i < Nb*(Nr+1); pRoundKey += 4, i++)
     9 B' `: b* r# b# F1 j
355.         {
     ( J# L3 g" y+ P' l7 w0 \
356.                 memcpy(pRoundKey, pRoundKey - 4, 4);
     
357. 
     , c8 A8 V- z$ d; s( K/ R8 a4 \
358.                 if (i % Nk == 0)
     
359.                 {
     . ?& x! u7 D- f- u& b
360.                         rotation_word(pRoundKey);
     ; d8 \) C/ `* E. b0 H) q8 A
361.                         sub_bytes(pRoundKey, 4, 0);
     - I% b6 A; u# B6 @' _0 Z, ]
362.                         xor_bytes(pRoundKey, Rcon, 4);
     % {& W+ a5 A) w1 v
363. 
     
364.                         Rcon[0] = gf_mult_by02(Rcon[0]);
     
365.                 }
     ! d6 |# ^. D5 w- D3 ?* H
366.                 else if (Nk > 6 && i % Nk == Nb)
     
367.                 {
     
368.                         sub_bytes(pRoundKey, 4, 0);
     
369.                 }
     
370. 
     
371.                 xor_bytes(pRoundKey, pRoundKey - 4*Nk, 4);
     7 d) g" C: {% O- R" i# y" d
372.         }
     3 O* R/ I1 f  P& b0 V6 z+ @0 H
373. }
     
374. 
     ; ^$ I- B$ u3 b  {7 [$ L2 s
375. //
     
376. //        函数名：        aes_encrypt
     
377. //        描述：                加密数据
     
378. //        输入参数：        pPlainText        -- 明文，即需加密的数据，其长度为nDataLen字节。
     
379. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
     
380. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
     
381. //        输出参数：        pCipherText        -- 密文，即由明文加密后的数据，可以与pPlainText相同。
     6 h4 X/ V7 I0 S1 J
382. //        返回值：        无。
     ) k4 ?1 l% P/ M( f. Y4 @3 `
383. //
     
384. void aes_encrypt(const unsigned char *pPlainText, unsigned char *pCipherText,
     % I; G  p- ?. j' |4 ~2 v
385.                                  unsigned int nDataLen, const unsigned char *pIV)
     
386. {
     8 I! r8 I% `4 ]2 `& D" t; @* x
387.         unsigned int i;
     
388. 
     7 p. m1 ]) I9 i" v, v2 S- y
389.         if (pPlainText != pCipherText)
     
390.         {
     
391.                 memcpy(pCipherText, pPlainText, nDataLen);
     
392.         }
     2 ^* i! U4 g. q& g
393. 
     & W2 y2 M( c) x: t/ c
394.         for (i = nDataLen/(4*Nb); i > 0 ; i--, pCipherText += 4*Nb)
       P) h0 g5 v/ W: h  m& R
395.         {
     
396.                 #if AES_MODE == AES_MODE_CBC
     
397.                         xor_bytes(pCipherText, pIV, 4*Nb);
     
398.                 #endif
     
399. 
     
400.                 block_encrypt(pCipherText);
     
401.                 pIV = pCipherText;
     # `: u' F8 o0 V" a7 R; Z
402.         }
     2 M, S) K  J$ j7 @
403. }
     
404. 
     % l$ ~: D: |) D- R5 p% P
405. //
     ' d+ h% }/ S6 K, o0 h( m! V: H
406. //        函数名：        aes_decrypt
     
407. //        描述：                解密数据
     
408. //        输入参数：        pCipherText -- 密文，即需解密的数据，其长度为nDataLen字节。
     
409. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
     
410. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
     
411. //        输出参数：        pPlainText  -- 明文，即由密文解密后的数据，可以与pCipherText相同。
     8 Q: o- g# T" H) V1 [  W
412. //        返回值：        无。
     
413. //
     ( f- m: F) D3 S& s9 I
414. void aes_decrypt( const unsigned char *pCipherText,unsigned char *pPlainText,
     $ U- Q3 ~6 J2 C6 h
415.                                  unsigned int nDataLen, const unsigned char *pIV)
     4 T% i" \) h, o. W, H
416. {
     
417.         unsigned int i;
     ! h1 n% p( Z% R2 M- c
418. 
     " R1 z+ ]3 O$ H
419.         if (pPlainText != pCipherText)
     
420.         {
     
421.                 memcpy(pPlainText, pCipherText, nDataLen);
     
422.         }
     
423. 
     
424.         // 从最后一块数据开始解密，这样不用开辟空间来保存IV
     8 n) W* [6 G, H8 S' L
425.         pPlainText += nDataLen - 4*Nb;
     ; E- A& x% h$ y! A: x
426.         for (i = nDataLen/(4*Nb); i > 0 ; i--, pPlainText -= 4*Nb)
     
427.         {
     
428.                 block_decrypt(pPlainText);
     
429. 
     : q$ C, P- W. d4 I* P
430.                 #if AES_MODE == AES_MODE_CBC
     
431.                         if (i == 1)
     
432.                         {// 最后一块数据
     
433.                                 xor_bytes(pPlainText, pIV, 4*Nb);
     
434.                         }
     8 n/ P1 \; D- y5 v% m7 n
435.                         else
     
436.                         {
     " k) o% O" y8 S9 Q# j1 c8 F  U
437.                                 xor_bytes(pPlainText, pPlainText - 4*Nb, 4*Nb);
     
438.                         }
     
439.                 #endif
     0 N# [( N4 i; Y  q1 ^$ l
440.         }
     
441. }</i></i></i></i>

复制代码

三、使用
使用注意点：
( W2 k2 m. A, L+ y1、AES_KEY_LENGTH取值只能是128，192 和 256
% X$ e" @* Z1 b7 e. b, x. C2、密钥和向量表长度为AES_KEY_LENGTH/8个字节
1 g7 X( g8 X% {& u6 }! ~3 |3、加密、解密数据长度为AES_KEY_LENGTH/8的整数倍字节

1. int main(void)
   
2. {
   / T% Y+ _  D+ r. ^
3.         u8 buf[16],saveBuf[16],descryptBuf[16];
   
4.         u16 i;
   
5.         unsigned char AES128key[16] = "123456789abcdefa";//秘钥
   
6.         unsigned char AES_IV[16]= "0102030405123456";//向量表
   . g/ _" ]3 f. D0 V  ^0 B% n
7.         delay_init(168);                  //初始化延时函数
   
8.         LED_Init();                        //初始化LED端口
   
9. 
   
10.         aes_init(AES128key);//AES初始化
    & k. [! P5 \4 s2 q4 Y
11.         
    ! ]: l: V% \8 |: n
12.         for(i=0;i<sizeof(buf);i++)
    1 `% L4 ?: k( r; c5 P* a! Z( _
13.         {
    
14.                 buf=i;
    : ]- W! ]' V: G& [' ?  M
15.         }
    $ P- O5 _; W' z& F4 o3 r5 o9 L6 l
16.         while(1)
    & b9 H0 S' ~* P' W
17.         {
    
18.                 aes_encrypt(buf,saveBuf,sizeof(buf), AES_IV);
    
19.                
    
20.                
    
21.                 aes_decrypt(saveBuf,descryptBuf, sizeof(buf), AES_IV);
      Y- T6 U7 D& W' r6 h+ i9 a' x
22.                
    
23.                
    
24.                 GPIO_ResetBits(GPIOF,GPIO_Pin_9);  //LED0对应引脚GPIOF.9拉低，亮  等同LED0=0;
    
25.                 GPIO_SetBits(GPIOF,GPIO_Pin_10);   //LED1对应引脚GPIOF.10拉高，灭 等同LED1=1;
    : e' f% e1 w  ?
26.                 delay_ms(500);                     //延时300ms
    
27.                 GPIO_SetBits(GPIOF,GPIO_Pin_9);           //LED0对应引脚GPIOF.0拉高，灭  等同LED0=1;
    
28.                 GPIO_ResetBits(GPIOF,GPIO_Pin_10); //LED1对应引脚GPIOF.10拉低，亮 等同LED1=0;
    + D6 F( i6 I/ Q$ c3 {0 ~
29.                 delay_ms(500);                     //延时300ms
    
30.         }
    6 n6 W" w1 \- z- K2 _
31. }
    
32. 
    5 \* ]; Y' ^& D& `& S$ _4 Y
33. 
    : X; X7 y8 R( h6 R

复制代码

$ @' e. X# }! @

AES加密这么复杂？