devbox
代码创作者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言 - AES软件加解密算法_c语言 aes加密

作者：代码创作者 | 2024-01-31 19:51:21

赞

踩

c语言 aes加密

概述

       （AES）RIJNDAEL算法是一个数据块长度盒密钥长度都可变的分组加密算法，其数据块长度和密钥长度都可独立地选定为大于等于128位且小于等于256位的32位任意倍数。深入学习请参考《密码学》书籍，谢谢各位参阅。

验证环境：STM32F401CEU6，已通过。

1、code

aes.h

  1. //
  2. // Created by asus on 2023/7/7.
  3. //
  4.  
  5. #ifndef TEST_C_PROJECT_AES_H
  6. #define TEST_C_PROJECT_AES_H
  7.  
  8. #define Nb	4 //加解密数据块大小，固定为4
  9.  
  10. //加密类型对应的密匙长度，单位bit
  11. typedef enum {
  12.     AES128 = 128,
  13.     AES192 = 192,
  14.     AES256 = 256,
  15. } AESType_t;
  16.  
  17. //加解密模式
  18. typedef enum {
  19.     AES_MODE_ECB = 0,   // 电子密码本模式
  20.     AES_MODE_CBC = 1,   // 密码分组链接模式
  21. } AESMode_t;
  22.  
  23. typedef struct {
  24.     int Nk;  //用户不需要填充，密钥长度，单位字节, AES128:Nk=16、AES192:Nk=24、AES256:Nr=32
  25.     int Nr;  //用户不需要填充，加密的轮数 AES128:Nr=10、AES192:Nr=12、AES256:Nr=14
  26.     int type;//用户需填充，关联AESType_t
  27.     int mode;//用户需填充，关联AESMode_t
  28.     const void* key;//用户需填充，密匙
  29.     const void* pIV;//用户需填充，初始化向量, 当mode=AES_MODE_CBC时需要设置，指向unsigned char IV[4*Nb];
  30.     //AES拓展密匙, 空间大小 AES128:4*Nb*(10+1):4*Nb*(12+1)、AES256:4*Nb*(14+1)
  31.     unsigned char expandKey[4 * Nb * (14 + 1)];//用户不需要填充，[4*Nb*(Nr+1)]、这里按最大的AES256进行初始化
  32. } AESInfo_t;
  33.  
  34. /*****************************************************************************
  35. *	函数名：	AESInit
  36. *	功能描述：	初始化
  37. *	输入参数：	aesInfoP -- 用户需要填充
  38. *	输出参数：	无。
  39. *	返回值：	无。
  40. *****************************************************************************/
  41. void AESInit(AESInfo_t* aesInfoP);
  42.  
  43. /*****************************************************************************
  44. *	函数名：	AESEncrypt
  45. *	功能描述：	加密数据
  46. *	输入参数：  aesInfoP    -- 包含key、加密方式等初始化信息
  47. *              pPlainText  -- 要加密的数据，其长度为nDataLen字节。
  48. *			   dataLen	   -- 数据长度，以字节为单位，需要是整倍数，AES128:16倍数、AES192:24倍数、AES256:32倍数。
  49. *	输出参数：	pCipherText	-- 密文，即由明文加密后的数据，可以与pPlainText相同。
  50. *	返回值：	解密后的数据长度。。
  51. *****************************************************************************/
  52. unsigned int AESEncrypt(AESInfo_t* aesInfoP, const unsigned char* pPlainText, unsigned char* pCipherText, unsigned int nDataLen);
  53.  
  54. /*****************************************************************************
  55. *	函数名：	AESDecrypt
  56. *	描述：		解密数据
  57. *	输入参数：	aesInfoP    -- 包含key、加密方式等初始化信息
  58. *              pPlainText  -- 要加密的数据，其长度为nDataLen字节。
  59. *			   dataLen	   -- 数据长度，以字节为单位，需要是整倍数，AES128:16倍数、AES192:24倍数、AES256:32倍数。
  60. *	输出参数：	pCipherText	-- 加密后的数据，可以与pCipherText相同
  61. *	返回值：	返回解密后的数据长度。
  62. *****************************************************************************/
  63. unsigned int AESDecrypt(AESInfo_t* aesInfoP, unsigned char* pPlainText, const unsigned char* pCipherText, unsigned int nDataLen);
  64.  
  65.  
  66. #endif //TEST_C_PROJECT_AES_H

aes.c

  1. //
  2. // Created by asus on 2023/7/7.
  3. //
  4. #include "aes.h"
  5. #include <string.h>
  6.  
  7. // GF(2^8) 多项式
  8. #define BPOLY 0x1B //x^4 + x^3 + x^1 + x^0= 从右边开始算，bit0、bit1、bit3、bit4、为1，bit2、bit5、bit6、bit7为0，即00011011=0x1B
  9.  
  10. /*
  11. SubstituteBytes()
  12. 加密时：使用S盒，将待加密数据为S盒索引将加密数据替换为S盒的内容
  13. 解密时：使用逆S盒，将已加密数据为逆S盒索引将已加密数据替换为逆S盒子的内容
  14. 其实就是将数据按表替换，
  15. 例如待加密数据unsigned char data = 9;
  16. 加密数据:encryptData = SBox[data] = SBox[9] = 0x01;//注意索引从0开始
  17. 解密数据:decryptData = InvSBox[encryptData] = InvSBox[0x01] = 9;
  18. SBox和InvSBox的关系是 data = InvSBox[SBox[data]];还跟GF(2^8) 多项式有关
  19. */
  20.  
  21. // 加密用的S盒
  22. static const unsigned char SBox[256] =
  23. {
  24. 		0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  25. 		0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  26. 		0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  27. 		0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  28. 		0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  29. 		0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  30. 		0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  31. 		0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  32. 		0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  33. 		0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  34. 		0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  35. 		0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  36. 		0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  37. 		0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  38. 		0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  39. 		0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
  40. };
  41.  
  42. // 解密用的SBox
  43. static const unsigned char InvSBox[256] =
  44. {
  45. 		0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
  46. 		0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
  47. 		0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
  48. 		0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
  49. 		0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
  50. 		0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
  51. 		0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
  52. 		0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
  53. 		0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
  54. 		0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
  55. 		0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
  56. 		0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
  57. 		0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
  58. 		0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
  59. 		0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
  60. 		0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
  61. };
  62.  
  63. /*****************************************************************************
  64. *	函数名：	RShiftWord
  65. *	功能描述：	对一个pWord 4字节数据进行循环右移。
  66. *	输入参数：	pWord -- 要右移的4字节数据。
  67. *	输出参数：	pWord -- 右移后的4字节数据。
  68. *	返回值：      无。
  69. *****************************************************************************/
  70. static void RShiftWord(unsigned char* pWord)
  71. {
  72.     unsigned char temp = pWord[0];
  73.     pWord[0] = pWord[1];
  74.     pWord[1] = pWord[2];
  75.     pWord[2] = pWord[3];
  76.     pWord[3] = temp;
  77. }
  78.  
  79. /*****************************************************************************
  80. *	函数名：	XorBytes
  81. *	功能描述：	异或两组数据。
  82. *	输入参数：	pData1 -- 要异或的第一组数据。
  83. *			   pData2 -- 要异或的第二组数据。
  84. *			   nCount -- 参与异或的数据长度。
  85. *	输出参数：	pData1 -- 异或后的结果。
  86. *	返回值：    无。
  87. *****************************************************************************/
  88. static void XorBytes(unsigned char* pData1, const unsigned char* pData2, unsigned char nCount)
  89. {
  90.     unsigned char i;
  91.     for (i = 0; i < nCount; i++) {
  92.         pData1[i] ^= pData2[i];
  93.     }
  94. }
  95.  
  96. /*****************************************************************************
  97. *	函数名：	AddKey
  98. *	功能描述：	把 pData数据 加上（异或）pKey密钥，数据长度为16字节。
  99. *	输入参数：	pData	  -- 数据。
  100. *			   	pKey      -- 密钥。
  101. *	输出参数：	pData	  -- 加上子密钥后的数据。
  102. *	返回值：	无。
  103. *****************************************************************************/
  104. static void AddKey(unsigned char* pData, const unsigned char* pKey)
  105. {
  106.     XorBytes(pData, pKey, 4 * Nb);
  107. }
  108.  
  109. /*****************************************************************************
  110. *	函数名：	SubstituteBytes
  111. *	功能描述：	通过S盒子置换数据。
  112. *	输入参数：	pData  	-- 数据。
  113. *			   dataCnt -- 数据长度。
  114. *			   pBox	   -- 置换盒子，加密时使用SBox, 解密时使用InvSBox
  115. *	输出参数：	pData	-- 置换后的状态数据。
  116. *	返回值：	无。
  117. *****************************************************************************/
  118. static void SubstituteBytes(unsigned char* pData, unsigned char dataCnt, const unsigned char* pBox)
  119. {
  120.     unsigned char i;
  121.     for (i = 0; i < dataCnt; i++) {
  122.         pData[i] = pBox[pData[i]];
  123.     }
  124. }
  125.  
  126. /*****************************************************************************
  127. *	函数名：	ShiftRows
  128. *	功能描述：	把状态数据移行。
  129. *	输入参数：	pState	-- 状态数据。
  130. *			   bInvert	-- 是否反向移行（解密时使用）。
  131. *	输出参数：	pState	-- 移行后的状态数据。
  132. *	返回值：	无。
  133. *****************************************************************************/
  134. static void ShiftRows(unsigned char* pState, unsigned char bInvert)
  135. {
  136.     // 注意：状态数据以列形式存放！
  137.     unsigned char r;	// row，   行
  138.     unsigned char c;	// column，列
  139.     unsigned char temp;
  140.     unsigned char rowData[4];
  141.  
  142.     for (r = 1; r < 4; r++) {
  143.         // 备份一行数据
  144.         for (c = 0; c < 4; c++) {
  145.             rowData[c] = pState[r + 4 * c];
  146.         }
  147.  
  148.         temp = bInvert ? (4 - r) : r;
  149.         for (c = 0; c < 4; c++) {
  150.             pState[r + 4 * c] = rowData[(c + temp) % 4];
  151.         }
  152.     }
  153. }
  154.  
  155. /*****************************************************************************
  156. *	函数名：	GfMultBy02
  157. *	功能描述：	在GF(28)域的 乘2 运算。
  158. *	输入参数：	num	-- 乘数。
  159. *	输出参数：	无。
  160. *	返回值：	num乘以2的结果。
  161. *****************************************************************************/
  162. static unsigned char GfMultBy02(unsigned char num)
  163. {
  164.     if (0 == (num & 0x80)) {
  165.         num = num << 1;
  166.     }
  167.     else {
  168.         num = (num << 1) ^ BPOLY;
  169.     }
  170.  
  171.     return num;
  172. }
  173.  
  174. /*****************************************************************************
  175. *	函数名：	MixColumns
  176. *	功能描述：	混合各列数据。
  177. *	输入参数：	pData	 -- 数据。
  178. *			   bInvert	-- 是否反向混合（解密时使用）。
  179. *	输出参数：	pData	 -- 混合列后的状态数据。
  180. *	返回值：	无。
  181. *****************************************************************************/
  182. static void MixColumns(unsigned char* pData, unsigned char bInvert)
  183. {
  184.     unsigned char i;
  185.     unsigned char temp;
  186.     unsigned char a0Pa2_M4;	// 4(a0 + a2)
  187.     unsigned char a1Pa3_M4;	// 4(a1 + a3)
  188.     unsigned char result[4];
  189.  
  190.     for (i = 0; i < 4; i++, pData += 4) {
  191.         temp = pData[0] ^ pData[1] ^ pData[2] ^ pData[3];
  192.         result[0] = temp ^ pData[0] ^ GfMultBy02((unsigned char)(pData[0] ^ pData[1]));
  193.         result[1] = temp ^ pData[1] ^ GfMultBy02((unsigned char)(pData[1] ^ pData[2]));
  194.         result[2] = temp ^ pData[2] ^ GfMultBy02((unsigned char)(pData[2] ^ pData[3]));
  195.         result[3] = temp ^ pData[3] ^ GfMultBy02((unsigned char)(pData[3] ^ pData[0]));
  196.  
  197.         if (bInvert) {
  198.             a0Pa2_M4 = GfMultBy02(GfMultBy02((unsigned char)(pData[0] ^ pData[2])));
  199.             a1Pa3_M4 = GfMultBy02(GfMultBy02((unsigned char)(pData[1] ^ pData[3])));
  200.             temp = GfMultBy02((unsigned char)(a0Pa2_M4 ^ a1Pa3_M4));
  201.             result[0] ^= temp ^ a0Pa2_M4;
  202.             result[1] ^= temp ^ a1Pa3_M4;
  203.             result[2] ^= temp ^ a0Pa2_M4;
  204.             result[3] ^= temp ^ a1Pa3_M4;
  205.         }
  206.  
  207.         memcpy(pData, result, 4);
  208.     }
  209. }
  210.  
  211. /*****************************************************************************
  212. *	函数名：	BlockEncrypt
  213. *	功能描述：	对单块数据加密。
  214. *	输入参数：	pData -- 要加密的块数据。
  215. *	输出参数：	pData -- 加密后的块数据。
  216. *	返回值：	无。
  217. *****************************************************************************/
  218. static void BlockEncrypt(AESInfo_t* aesInfoP, unsigned char* pData)
  219. {
  220.     unsigned char i;
  221.  
  222.     AddKey(pData, aesInfoP->expandKey);
  223.     for (i = 1; i <= aesInfoP->Nr; i++) {
  224.         SubstituteBytes(pData, 4 * Nb, SBox);
  225.         ShiftRows(pData, 0);
  226.  
  227.         if (i != aesInfoP->Nr) {
  228.             MixColumns(pData, 0);
  229.         }
  230.  
  231.         AddKey(pData, &aesInfoP->expandKey[4 * Nb * i]);
  232.     }
  233. }
  234.  
  235. /*****************************************************************************
  236. *	函数名：	BlockDecrypt
  237. *	功能描述：	对单块数据解密。
  238. *	输入参数：	pData -- 要解密的数据。
  239. *	输出参数：	pData -- 解密后的数据。
  240. *	返回值：	无。
  241. *****************************************************************************/
  242. static void BlockDecrypt(AESInfo_t* aesInfoP, unsigned char* pData)
  243. {
  244.     unsigned char i;
  245.  
  246.     AddKey(pData, &aesInfoP->expandKey[4 * Nb * aesInfoP->Nr]);
  247.  
  248.     for (i = aesInfoP->Nr; i > 0; i--) {
  249.         ShiftRows(pData, 1);
  250.         SubstituteBytes(pData, 4 * Nb, InvSBox);
  251.         AddKey(pData, &aesInfoP->expandKey[4 * Nb * (i - 1)]);
  252.  
  253.         if (1 != i) {
  254.             MixColumns(pData, 1);
  255.         }
  256.     }
  257. }
  258.  
  259.  
  260. /*****************************************************************************
  261. *	函数名：	AESAddPKCS7Padding
  262. *	描述：		PKCS7 方式填充数据
  263. *	输入参数：	data -- 后面最多预留16个字节空间用于存放填充值
  264. *			   len --  数据的长度
  265. *	输出参数：	data  -- 添加填充码后的数据
  266. *	返回值：	填充后的长度
  267. *****************************************************************************/
  268. static unsigned int AESAddPKCS7Padding(unsigned char* data, unsigned int len)
  269. {
  270.     unsigned int newLen;
  271.     newLen = len + 16 - (len % 16);
  272.     memset(&data[len], newLen - len, newLen - len);
  273.     return newLen;
  274. }
  275.  
  276. /*****************************************************************************
  277. *	函数名：	AESDelPKCS7Padding
  278. *	描述：		PKCS7Padding 填充密文解密后剔除填充值
  279. *	输入参数：	pData -- 解密后的数据
  280. *			   len --  数据的长度
  281. *	输出参数：	pData  -- 删除填充码后的数据
  282. *	返回值：	删除后的实际有效数据长度，为0表示传入的数据异常
  283. *****************************************************************************/
  284. static unsigned int AESDelPKCS7Padding(unsigned char* pData, unsigned int len)
  285. {
  286.     if (0 != (len & 0x0F)) {//1组16字节，(0 != (len & 0x0F)说明不是16的倍数
  287.         return 0;
  288.     }
  289.     if (pData[len - 1] > len) {
  290.         return 0;
  291.     }
  292.  
  293.     return len - pData[len - 1];
  294. }
  295.  
  296. /*****************************************************************************
  297. *	函数名：	AESInit
  298. *	功能描述：	初始化
  299. *	输入参数：	aesInfoP -- 用户需要填充
  300. *	输出参数：	无。
  301. *	返回值：	无。
  302. *****************************************************************************/
  303. void AESInit(AESInfo_t* aesInfoP)
  304. {
  305.  
  306.     unsigned char i;
  307.     unsigned char* pExpandKey;//扩展密钥
  308.     unsigned char Rcon[4] = { 0x01, 0x00, 0x00, 0x00 };
  309.  
  310.     switch (aesInfoP->type) {
  311.         case AES128:
  312.             aesInfoP->Nr = 10;
  313.             aesInfoP->Nk = 16;
  314.             break;
  315.         case AES192:
  316.             aesInfoP->Nr = 12;
  317.             aesInfoP->Nk = 24;
  318.             break;
  319.         case AES256:
  320.             aesInfoP->Nr = 14;
  321.             aesInfoP->Nk = 32;
  322.             break;
  323.         default:
  324.             aesInfoP->Nr = 10;
  325.             aesInfoP->Nk = 16;
  326.             break;
  327.     }
  328.  
  329.     //拓展密匙
  330.     memcpy(aesInfoP->expandKey, aesInfoP->key, 4 * aesInfoP->Nk);//第一个是原始密匙，
  331.     pExpandKey = &aesInfoP->expandKey[4 * aesInfoP->Nk]; //拓展密匙AES128:10个、AES192:12个、AES256:14个
  332.     for (i = aesInfoP->Nk; i < Nb * (aesInfoP->Nr + 1); pExpandKey += 4, i++) {
  333.         memcpy(pExpandKey, pExpandKey - 4, 4);
  334.  
  335.         if (0 == i % aesInfoP->Nk) {
  336.             RShiftWord(pExpandKey);
  337.             SubstituteBytes(pExpandKey, 4, SBox);
  338.             XorBytes(pExpandKey, Rcon, 4);
  339.  
  340.             Rcon[0] = GfMultBy02(Rcon[0]);
  341.         }
  342.         else if (6 < aesInfoP->Nk && i % aesInfoP->Nk == Nb) {
  343.             SubstituteBytes(pExpandKey, 4, SBox);
  344.         }
  345.  
  346.         XorBytes(pExpandKey, pExpandKey - 4 * aesInfoP->Nk, 4);
  347.     }
  348. }
  349.  
  350. /*****************************************************************************
  351. *	函数名：	AESEncrypt
  352. *	功能描述：	加密数据
  353. *	输入参数：  aesInfoP    -- 包含key、加密方式等初始化信息
  354. *              pPlainText  -- 要加密的数据，其长度为nDataLen字节。
  355. *			   dataLen	   -- 数据长度，以字节为单位，需要是整倍数，AES128:16倍数、AES192:24倍数、AES256:32倍数。
  356. *	输出参数：	pCipherText	-- 加密后的数据，预留长度：dataLen+16
  357. *	返回值：	解密后的数据长度。
  358. *****************************************************************************/
  359. unsigned int AESEncrypt(AESInfo_t* aesInfoP, const unsigned char* pPlainText, unsigned char* pCipherText, unsigned int nDataLen)
  360. {
  361.     unsigned int i;
  362.     const void* pIV = NULL;
  363.  
  364.     if (pPlainText != pCipherText) {
  365.         memcpy(pCipherText, pPlainText, nDataLen);
  366.     }
  367.  
  368.     //必须是16的整倍数，不够的填充，pkcs7算法是缺n补n个n，比如13字节数据缺了3个，后面就补3个3;如果刚好是16的倍数，就填充16个16
  369.     nDataLen = AESAddPKCS7Padding(pCipherText, nDataLen);
  370.  
  371.     if (aesInfoP->pIV) {
  372.         pIV = aesInfoP->pIV;
  373.     }
  374.  
  375.     for (i = nDataLen / (4 * Nb); i > 0; i--, pCipherText += 4 * Nb) {
  376.         if (AES_MODE_CBC == aesInfoP->mode) {
  377.             XorBytes(pCipherText, pIV, 4 * Nb);
  378.         }
  379.  
  380.         BlockEncrypt(aesInfoP, pCipherText);
  381.         if (aesInfoP->pIV) {
  382.             pIV = pCipherText;
  383.         }
  384.     }
  385.     return nDataLen;
  386. }
  387.  
  388. /*****************************************************************************
  389. *	函数名：	AESDecrypt
  390. *	功能描述：	解密数据
  391. *	输入参数：	aesInfoP    -- 包含key、加密方式等初始化信息
  392. *              pPlainText  -- 要加密的数据，其长度为dataLen字节。
  393. *			   dataLen	   -- 数据长度，以字节为单位，需要是整倍数，AES128:16倍数、AES192:24倍数、AES256:32倍数。
  394. *	输出参数：	pCipherText	-- 加密后的数据，可以与pCipherText相同
  395. *	返回值：	返回解密后的数据长度。
  396. *****************************************************************************/
  397. unsigned int AESDecrypt(AESInfo_t* aesInfoP, unsigned char* pPlainText, const unsigned char* pCipherText, unsigned int dataLen)
  398. {
  399.     unsigned int i;
  400.     unsigned char* pPlainTextBack = pPlainText;
  401.  
  402.     if (pPlainText != pCipherText) {
  403.         memcpy(pPlainText, pCipherText, dataLen);
  404.     }
  405.  
  406.     //当mode=AES_MODE_CBC时需要从最后一块数据开始解密
  407.     pPlainText += dataLen - 4 * Nb;
  408.     for (i = dataLen / (4 * Nb); i > 0; i--, pPlainText -= 4 * Nb) {
  409.         BlockDecrypt(aesInfoP, pPlainText);
  410.         if (AES_MODE_CBC == aesInfoP->mode) {
  411.             if (1 == i) {//原来的第一块数据是初始变量加密的
  412.                 XorBytes(pPlainText, aesInfoP->pIV, 4 * Nb);
  413.             }
  414.             else {
  415.                 XorBytes(pPlainText, pPlainText - 4 * Nb, 4 * Nb);
  416.             }
  417.         }
  418.     }
  419.  
  420.     //因为数据需要16字节对齐，可能有填充数据，需要去除后面的填充数据
  421.     return AESDelPKCS7Padding(pPlainTextBack, dataLen);
  422. }
  423.  
  424.  
  425.

main.c

  1. #include "aes.h"
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <ctype.h> //isprint
  5.  
  6. void PrintData(const char* head, unsigned char* data, unsigned int len)
  7. {
  8.     unsigned int i;
  9.  
  10.     printf("%s, len:%u:\r\n", head, len);
  11.  
  12.     //按16进制打印出来
  13.     printf("HEX:[");
  14.     for (i = 0; i < len; i++) {
  15.         printf("%02X ", data[i]);
  16.     }
  17.     printf("]\r\n");
  18.  
  19.     //按ASCII码打印出来
  20.     printf("ASCII:[");
  21.     for (i = 0; i < len; i++) {
  22.         if (isprint(data[i])) {//可打印字符
  23.             printf("'%c' ", data[i]);
  24.         }
  25.         else {
  26.             printf("\\%02X ", data[i]);
  27.         }
  28.  
  29.     }
  30.     printf("]\r\n");
  31. }
  32.  
  33. void test_fun(void)
  34. {
  35.     unsigned int len;
  36.     printf("Build %s %s\r\n", __DATE__, __TIME__);
  37.  
  38.     for (int i = 1; i <= 6; i++)
  39.     {
  40.         switch (i)
  41.         {
  42.             case 1: {
  43.  
  44.             //秘钥, AES128 用16字节
  45.             unsigned char key[16] = {
  46.                 0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,
  47.                 0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38
  48.             };
  49.             //初始化向量, 固定长度8个, 当mode=AES_MODE_CBC时用到
  50.             unsigned char IV[2 * Nb] = { 0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38 };
  51.  
  52.             //要加密的内容
  53.             unsigned char sourceMsg[] = "Hello AES 128 Hello AES 128 Hello AES 128 Hello AES 128";
  54.             //加密后的内容
  55.             unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  56.             //解密后的内容
  57.             unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  58.  
  59.             //设置加密方式、密匙
  60.             AESInfo_t aesInfo = {
  61.                 .type = AES128,
  62.                 .mode = AES_MODE_CBC,
  63.                 .key = key,
  64.                 .pIV = IV
  65.             };
  66. 			printf("\r\n");
  67. 			printf("                   AES MODE CBC    .pIV = IV	               \r\n");
  68.             printf("*************************** AES128 ******************************\n");
  69.             PrintData("sourceMsg", sourceMsg, strlen((const char*)sourceMsg));
  70.  
  71.             //初始化
  72.             AESInit(&aesInfo);
  73.  
  74.             //加密
  75.             len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char*)sourceMsg));
  76.             PrintData("encryptMsg", encryptMsg, len);
  77.  
  78.             //解密
  79.             len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  80.             PrintData("decryptMsg", decryptMsg, len);
  81. 			} break;
  82. 			
  83.             case 2: {
  84.                 //秘钥, AES192 用24字节
  85.                 unsigned char key[24] = {
  86.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,
  87.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42
  88.                 };
  89.                 //初始化向量, 固定长度12个, 当mode=AES_MODE_CBC时用到
  90.                 unsigned char IV[3 * Nb] = { 0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42 };
  91.  
  92.                 //要加密的内容
  93.                 unsigned char sourceMsg[] = "Hello AES 192";
  94.                 //加密后的内容
  95.                 unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  96.                 //解密后的内容
  97.                 unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  98.  
  99.                 //设置加密方式、密匙
  100.                 AESInfo_t aesInfo = {
  101.                         .type = AES192,
  102.                         .mode = AES_MODE_CBC,
  103.                         .key = key,
  104.                         .pIV = IV
  105.                 };
  106.  
  107.                 printf("*************************** AES192 ******************************\n");
  108.                 PrintData("sourceMsg", sourceMsg, strlen((const char*)sourceMsg));
  109.  
  110.                 //初始化
  111.                 AESInit(&aesInfo);
  112.  
  113.                 //加密
  114.                 len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char*)sourceMsg));
  115.                 PrintData("encryptMsg", encryptMsg, len);
  116.  
  117.                 //解密
  118.                 len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  119.                 PrintData("decryptMsg", decryptMsg, len);
  120.             } break;
  121.             case 3: {
  122.                 //秘钥, AES256 用32字节
  123.                 unsigned char key[32] = {
  124.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46,
  125.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46
  126.                 };
  127.                 //初始化向量, 固定长度16个, 当mode=AES_MODE_CBC时用到
  128.                 unsigned char IV[4 * Nb] = { 0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46 };
  129.  
  130.                 //要加密的内容
  131.                 unsigned char sourceMsg[] = "Hello AES 256";
  132.                 //加密后的内容
  133.                 unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  134.                 //解密后的内容
  135.                 unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  136.  
  137.                 //设置加密方式、密匙
  138.                 AESInfo_t aesInfo = {
  139.                         .type = AES256,
  140.                         .mode = AES_MODE_CBC,
  141.                         .key = key,
  142.                         .pIV = IV
  143.                 };
  144.  
  145.                 printf("*************************** AES256 ******************************\n");
  146.                 PrintData("sourceMsg", sourceMsg, strlen((const char*)sourceMsg));
  147.  
  148.                 //初始化
  149.                 AESInit(&aesInfo);
  150.  
  151.                 //加密
  152.                 len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char*)sourceMsg));
  153.                 PrintData("encryptMsg", encryptMsg, len);
  154.  
  155.                 //解密
  156.                 len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  157.                 PrintData("decryptMsg", decryptMsg, len);
  158.             } break;
  159. 			
  160. 			case 4: {
  161. 				//秘钥, AES128 用16字节
  162. 				unsigned char key[16] = { 
  163. 					0x2b,0x7e,0x15,0x16,0x17,0x18,0xd2,0xa6,
  164. 					0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c 
  165. 				};
  166.  
  167. 				//要加密的内容
  168. 				unsigned char sourceMsg[] = { 
  169. 					0x32,0x43,0xf6,0xa8,0x88,0x89,0x30,0x8d,
  170. 					0x31,0x32,0x98,0xa2,0xe0,0x37,0x07,0x34 
  171. 				};
  172.  
  173. 				//加密后的内容
  174. 				unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  175. 				//解密后的内容
  176. 				unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  177.  
  178. 				//设置加密方式、密匙
  179. 				AESInfo_t aesInfo = {
  180. 						.type = AES128,
  181. 						.mode = AES_MODE_ECB,
  182. 						.key = key,
  183. 						.pIV = NULL
  184. 				};
  185. 				
  186. 				printf("\r\n");
  187. 				printf("                  AES MODE ECB    .pIV = NULL                  \r\n");
  188. 				printf("*************************** AES128 ******************************\n");
  189. 				PrintData("sourceMsg", sourceMsg, sizeof(sourceMsg)/sizeof(unsigned char));
  190.  
  191. 				//初始化
  192. 				AESInit(&aesInfo);
  193.  
  194. 				//加密
  195. 				len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, sizeof(sourceMsg) / sizeof(unsigned char));
  196. 				PrintData("encryptMsg", encryptMsg, len);
  197.  
  198. 				//解密
  199. 				len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  200. 				PrintData("decryptMsg", decryptMsg, len);	
  201.             } break;
  202. 			
  203. 			case 5: {
  204.                 //秘钥, AES192 用24字节
  205.                 unsigned char key[24] = {
  206.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,
  207.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42
  208.                 };
  209.                 
  210.                 //要加密的内容
  211.                 unsigned char sourceMsg[] = { 
  212. 					0x32,0x43,0xf6,0xa8,0x88,0x89,0x30,0x8d,0x25,
  213. 					0x31,0x32,0x98,0xa2,0xe0,0x37,0x07,0x34,0x11 
  214. 				};
  215. 				
  216.                 //加密后的内容
  217.                 unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  218.                 //解密后的内容
  219.                 unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  220.  
  221.                 //设置加密方式、密匙
  222.                 AESInfo_t aesInfo = {
  223.                         .type = AES192,
  224.                         .mode = AES_MODE_ECB,
  225.                         .key = key,
  226.                         .pIV = NULL
  227.                 };
  228.  
  229.                 printf("*************************** AES192 ******************************\n");
  230.                 PrintData("sourceMsg", sourceMsg, strlen((const char*)sourceMsg));
  231.  
  232.                 //初始化
  233.                 AESInit(&aesInfo);
  234.  
  235.                 //加密
  236.                 len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char*)sourceMsg));
  237.                 PrintData("encryptMsg", encryptMsg, len);
  238.  
  239.                 //解密
  240.                 len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  241.                 PrintData("decryptMsg", decryptMsg, len);
  242.             } break;
  243.             case 6: {
  244.                 //秘钥, AES256 用32字节
  245.                 unsigned char key[32] = {
  246.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46,
  247.                         0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46
  248.                 };
  249.  
  250.                 //要加密的内容
  251.                 unsigned char sourceMsg[] = { 
  252. 					0x32,0x43,0xf6,0xa8,0x88,0x89,0x30,0x8d,0x55,
  253. 					0x31,0x32,0x98,0xa2,0xe0,0x37,0x07,0x34,0x53 
  254. 				};
  255. 				
  256.                 //加密后的内容
  257.                 unsigned char encryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  258.                 //解密后的内容
  259.                 unsigned char decryptMsg[sizeof(sourceMsg) + 16] = { 0 };
  260.  
  261.                 //设置加密方式、密匙
  262.                 AESInfo_t aesInfo = {
  263.                         .type = AES256,
  264.                         .mode = AES_MODE_ECB,
  265.                         .key = key,
  266.                         .pIV = NULL
  267.                 };
  268.  
  269.                 printf("*************************** AES256 ******************************\n");
  270.                 PrintData("sourceMsg", sourceMsg, strlen((const char*)sourceMsg));
  271.  
  272.                 //初始化
  273.                 AESInit(&aesInfo);
  274.  
  275.                 //加密
  276.                 len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char*)sourceMsg));
  277.                 PrintData("encryptMsg", encryptMsg, len);
  278.  
  279.                 //解密
  280.                 len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
  281.                 PrintData("decryptMsg", decryptMsg, len);
  282.             } break;
  283. 			
  284. 			
  285.             default:
  286.                 break;
  287.         }
  288.     }
  289.  
  290. }
  291.  
  292. int main(int argc, char* argv[])
  293. {
  294.  
  295.     test_fun();
  296.  
  297.     return 0;
  298. }
  299.  
  300.  
  301.

3、运行结果

  在线验证工具    1、链接    2、链接 

4、总结

        希望能帮助到需要的攻城狮。

参考文章 https://blog.csdn.net/nanfeibuyi/article/details/125474445

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号