一、头文件
# l9 T4 @  ?0 P/ J
- s9 ^' R5 x! A5 a

1. #ifndef _AES_H
   
2. #define _AES_H
   
3. 
   0 T2 ~( V- j% @9 e8 A0 p. v: F1 R& B
4. 
   
5. // 以bit为单位的密钥长度，只能为 128，192 和 256 三种
   * k; ]+ m1 Z( G% K. r  A$ M4 f
6. #define AES_KEY_LENGTH        128
   
7. 
   
8. // 加解密模式
   ! V8 y) d% ~0 Y: E+ C' g/ t
9. #define AES_MODE_ECB        0                                // 电子密码本模式（一般模式）
   
10. #define AES_MODE_CBC        1                                // 密码分组链接模式
    
11. #define AES_MODE                AES_MODE_CBC
    # p% K/ X- u! U, K, x
12. 
    5 _1 F) Z" o+ v* n) Z
13. 
    ! F5 W/ ?5 V# h1 p4 D
14. ///
      ~- u' h) b6 \0 v5 |# `0 @2 r
15. //        函数名：        aes_init
    : v% j. @* Q' e9 ~
16. //        描述：                初始化，在此执行扩展密钥操作。
    
17. //        输入参数：        pKey -- 原始密钥，其长度必须为 AES_KEY_LENGTH/8 字节。
    
18. //        输出参数：        无。
    
19. //        返回值：        无。
    ( n+ D% O  n) U0 C! H$ @0 I
20. ///
    
21. void aes_init(const void *pKey);
    
22. 
    
23. //
    : i8 V* ]! e5 q8 ]8 M1 H  Y
24. //        函数名：        aes_encrypt
    
25. //        描述：                加密数据
    
26. //        输入参数：        pPlainText        -- 明文，即需加密的数据，其长度为nDataLen字节。
    8 Y# c/ r9 Y8 K" j
27. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
    
28. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
    " `- @0 a/ H/ o
29. //        输出参数：        pCipherText        -- 密文，即由明文加密后的数据，可以与pPlainText相同。
    
30. //        返回值：        无。
    
31. //
    8 q1 ]% ^( i% i8 S
32. void aes_encrypt(const unsigned char *pPlainText, unsigned char *pCipherText,
    
33.                                  unsigned int nDataLen, const unsigned char *pIV);
    8 X& x" R5 h- O* t5 W( v
34. 
    
35. //
    
36. //        函数名：        aes_decrypt
    ; `5 B3 j$ T* P" z0 ?3 w6 g
37. //        描述：                解密数据
    0 t' e! M" l" m/ S
38. //        输入参数：        pCipherText -- 密文，即需解密的数据，其长度为nDataLen字节。
    
39. //                                nDataLen        -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。
    - l/ e2 V: d: f; R0 ]7 p
40. //                                pIV                        -- 初始化向量，如果使用ECB模式，可设为NULL。
    9 x- F/ B* K, v# m# Q/ }
41. //        输出参数：        pPlainText  -- 明文，即由密文解密后的数据，可以与pCipherText相同。
    * `& u9 |7 C- T4 Y0 r
42. //        返回值：        无。
    
43. //
    " \* G; d5 g4 `: I0 t% }8 l5 T
44. void aes_decrypt( const unsigned char *pCipherText,unsigned char *pPlainText,
    $ N+ ^) Q, y3 u5 Q2 r
45.                                  unsigned int nDataLen, const unsigned char *pIV);
    
46. #endif  /* _AES_H */

复制代码

) l# @0 |$ B' Z- f  O二、源文件

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

复制代码

三、使用
使用注意点：
1、AES_KEY_LENGTH取值只能是128，192 和 256
2、密钥和向量表长度为AES_KEY_LENGTH/8个字节
3、加密、解密数据长度为AES_KEY_LENGTH/8的整数倍字节
, f. T- {9 [4 P. n

1. int main(void)
   
2. {
   - t0 W+ C* U) e9 t4 @* I
3.         u8 buf[16],saveBuf[16],descryptBuf[16];
   / T3 i8 M. {) u( T- G# v( z
4.         u16 i;
   
5.         unsigned char AES128key[16] = "123456789abcdefa";//秘钥
   
6.         unsigned char AES_IV[16]= "0102030405123456";//向量表
   ) Q. q9 u- g' {9 }, T
7.         delay_init(168);                  //初始化延时函数
   
8.         LED_Init();                        //初始化LED端口
   
9. 
   : a5 m% K" w5 w& X; H- Y2 [
10.         aes_init(AES128key);//AES初始化
    . D. U/ ]4 u, _( w( J# M
11.         
    / M6 q7 D/ ^1 o( g
12.         for(i=0;i<sizeof(buf);i++)
    1 u" L% _" n5 l) \6 \; p
13.         {
    3 W  j" i: t- e1 g, B: z
14.                 buf=i;
    3 z! h: r2 s; |( E& S+ ^5 Z* j3 a
15.         }
    $ u) i! K7 e0 ]3 N+ S0 z8 V' j% {3 U3 T
16.         while(1)
    ) n5 W; l& V7 R* o  u, v1 K
17.         {
    $ G$ ~' E* w& p& |
18.                 aes_encrypt(buf,saveBuf,sizeof(buf), AES_IV);
    
19.                
    ; D' f% X" Y: h; n* d
20.                
    4 K% s# j% s3 c2 Q7 P) c# e
21.                 aes_decrypt(saveBuf,descryptBuf, sizeof(buf), AES_IV);
    
22.                
    ; U, i0 Y' P+ @2 T: U6 w$ A
23.                
    ! M( L* @3 B# }
24.                 GPIO_ResetBits(GPIOF,GPIO_Pin_9);  //LED0对应引脚GPIOF.9拉低，亮  等同LED0=0;
    
25.                 GPIO_SetBits(GPIOF,GPIO_Pin_10);   //LED1对应引脚GPIOF.10拉高，灭 等同LED1=1;
    $ ^" ]: J+ [8 `2 M, ]1 }( a
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;
    
29.                 delay_ms(500);                     //延时300ms
    5 F# _$ t9 E9 {) x& P/ G% [
30.         }
    * @6 l1 l( ~6 y( m, Y
31. }
    
32. 
    
33. 
    

复制代码

AES加密这么复杂？