• C语言 AES加解密

                                              C语言 AES加解密

    一、简述

           记--C语言实现的AES加解密。       

           示例代码打包：外链:https://wwm.lanzouq.com/b0camwuah 密码:7ios

    二、AES简述

    AES加密
    名称内容备注
    AES描述AES属于对称加密，就是用一个密匙K将数据Data1加密得到Data2, 解密时需要密匙K对Data2解密还原为Data1。对称加密算法也就是加密和解密用相同的密钥。
    密匙长度

    AES128是16字节，也就是128bit；

    AES192是24字节，也就是192bit；

    AES256是32字节，也就是256bit；

    加密轮数

    AES128是10轮；

    AES192是12轮；

    AES256是14轮；

    		根据给出的初始密匙再拓展出多个密匙。轮数多的安全性相对更高些。
    明文分组

    明文也就是要加密的数据，按16字节为一组进行分别加密，不够16字节的可进行数据填充。如果选择了填充方式，解密后需要将填充的数据剔除。

    填充方式：

    NoPadding:不填充，那就只能加密长度为16倍数的数据，一般不使用
    Zeros：补0，如果原数据长度恰好是16的倍数，也要补16个0
    ISO10126: 最后一个字节是填充的字节数（包括最后一字节），其他全部填随机数

    PKCS5（PKCS7）:应用比较多，最后一组缺几个字节就填充几

    PKCS7示例：

    要加密的数据是0123456789abc共13个数据，再填充3个才够16个，PKCS7填充时会在后面填充3个3。

    加密方式

    电码本模式（Electronic Codebook Book (ECB)）：将明文按16字节分组，每个明文使用同一个初始块向量，每组分别加密后拼接。

    密码分组链接模式（Cipher Block Chaining (CBC)）：因为ECB每个明文使用同一个初始化向量，所以明文内相同的明文分组，加密的密文也是相同的；针对这个问题就有了CBC模式，每一小段明文先与初始块向量或者上一段的密文段进行异或运算后，再与密钥进行加密；简单来说就是每一段的明文的初始块向量都是不一样的，这样明文内相同的明文分组，加密的密文也因此不同。

    		实际应用比较多的是ECB和CBC。

    三、示例代码

    main.c

    1. #include "aes.h"
    2. #include <stdio.h>
    3. #include <string.h>
    4. #include <ctype.h> //isprint
    5.  
    6. /* 编译指令
    7. D:\R\Qt5.7\Tools\mingw530_32\bin\gcc.exe -fdiagnostics-color=always -g D:\VSCode\AES\main.c D:\VSCode\AES\aes.c -o D:\VSCode\AES\main.exe
    8. */
    9.  
    10. void PrintData(const char *head, unsigned char *data, unsigned int len)
    11. {
    12.     unsigned int i;
    13.  
    14.     printf("%s, len:%u:\r\n", head, len);
    15.  
    16.     //按16进制打印出来
    17.     printf("HEX:[");
    18.     for (i=0; i<len; i++) {
    19.         printf("%02X ", data[i]);
    20.     }
    21.     printf("]\r\n");
    22.  
    23.     //按ASCII码打印出来
    24.     printf("ASCII:[");
    25.     for (i=0; i<len; i++) {
    26.         if (isprint(data[i])) {//可打印字符
    27.             printf("'%c' ", data[i]);
    28.         } else {
    29.             printf("\\%02X ", data[i]);
    30.         }
    31.         
    32.     }
    33.     printf("]\r\n");
    34. }
    35.  
    36. int main(int argc, char *argv[])
    37. {
    38.     unsigned int len;
    39.     //秘钥，根据实际情况自己定义，AES128 用16字节、AES192 用24字节、AES256 用32字节
    40.     unsigned char key[32] = {
    41. 		0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46,
    42. 		0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46
    43. 	};
    44.  
    45.     //初始化向量, 固定长度16个, 当mode=AES_MODE_CBC时用到
    46.     unsigned char IV[4*Nb] = {0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x30,0x41,0x42,0x43,0x44,0x45,0x46};
    47.  
    48.     //要加密的内容
    49.     unsigned char sourceMsg[] = "Hello AES 128/192/256";
    50.     //加密后的内容
    51.     unsigned char encryptMsg[sizeof(sourceMsg)+16] = {0};
    52.     //解密后的内容
    53.     unsigned char decryptMsg[sizeof(sourceMsg)+16] = {0};
    54.  
    55.     //设置加密方式、密匙
    56. 	AESInfo_t aesInfo = {
    57. 		.type = AES256,
    58. 		.mode = AES_MODE_CBC,
    59. 		.key = key,
    60.         .pIV = IV
    61. 	};
    62.  
    63. 	printf("Build %s %s\r\n", __DATE__, __TIME__);
    64.     PrintData("sourceMsg", sourceMsg, strlen((const char *)sourceMsg));
    65.  
    66. 	//初始化
    67.     AESInit(&aesInfo);
    68.  
    69. 	//加密
    70.     len = AESEncrypt(&aesInfo, sourceMsg, encryptMsg, strlen((const char *)sourceMsg));
    71.     PrintData("encryptMsg", encryptMsg, len);
    72.  
    73. 	//解密
    74.     len = AESDecrypt(&aesInfo, decryptMsg, encryptMsg, len);
    75.     PrintData("decryptMsg", decryptMsg, len);
    76.  
    77.     return 0;
    78. }

    aes.c

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

    aes.h

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

    测试结果：

    linux环境下 

    Windows环境下：

     

     参考自:https://blog.csdn.net/chengjunchengjun/article/details/109322987

  • 相关阅读:
    css line-height属性是什么
    左耳朵耗子：云原生时代的开发者应具备这5大能力
    2022.11.17补题祭
    广告大师——奥格威的广告准则
    前端数据可视化：ECharts使用
    手机无线耳机什么牌子的好用？2022好用的无线蓝牙耳机排行榜
    【每日一题】三个无重叠子数组的最大和
    【C++】特殊类的设计（只在堆、栈创建对象，单例对象）
    mysql 运行参数优化
    torchvision_transform(图像增强)
  • 原文地址：https://blog.csdn.net/nanfeibuyi/article/details/125474445