使用C++实现SM4软加密算法，对文件、字符串加解密

admin

本文介绍SM4软加密算法算法C/C++代码实现，可用于本地文件的加密使用。

两种模式  

1、对整个文件进行加密解密

2、对字符串加密解密，本人使用的场景是将字符串先加密，然后将密文写入到文件保存，读取时，先读取再解密使用。

由于sm4加密时一次为128bit即16个字节，分组加密时可能会补字节，所以文件保存时宜记录加密前后数据长度。

以下为源码，亲测可用，vs2015，Linux下编译报错可将<string>换<string.h>

Sm4.h头文件如下：

1. //sm4.h
   
2. #pragma once
   
3. /**
   
4. * \file sm4.h
   
5. */
   
6. #define SM4_ENCRYPT     1
   
7. #define SM4_DECRYPT     0
   
8. 
   
9. /**
   
10. * \brief          SM4 context structure 上下文结构
    
11. */
    
12. typedef struct
    
13. {
    
14.         int mode;                   /*!<  encrypt/decrypt 控制加密还是解密 */
    
15.         unsigned long sk[32];       /*!<  SM4 subkeys  存放每次迭代的轮密钥     */
    
16. }sm4_context;
    
17. 
    
18. 
    
19. #ifdef __cplusplus
    
20. extern "C" {
    
21. #endif
    
22. //
    
23.         /**
    
24.         * \brief          SM4 key schedule (128-bit, encryption)设置加密秘钥
    
25.         *
    
26.         * \param ctx      SM4 context to be initialized
    
27.         * \param key      16-byte secret key
    
28.         */
    
29.         void sm4_setkey_enc(sm4_context *ctx, unsigned char key[16]);
    
30. 
    
31.         /**
    
32.         * \brief          SM4 key schedule (128-bit, decryption)
    
33.         *
    
34.         * \param ctx      SM4 context to be initialized
    
35.         * \param key      16-byte secret key
    
36.         */
    
37.         void sm4_setkey_dec(sm4_context *ctx, unsigned char key[16]);
    
38. 
    
39.         /**
    
40.         * \brief          SM4-ECB block encryption/decryption
    
41.         * \param ctx      SM4 context
    
42.         * \param mode     SM4_ENCRYPT or SM4_DECRYPT
    
43.         * \param length   length of the input data
    
44.         * \param input    input block
    
45.         * \param output   output block
    
46.         */
    
47.         int sm4_crypt_ecb(sm4_context *ctx,
    
48.                 int mode,
    
49.                 int length,
    
50.                 unsigned char *input,
    
51.                 unsigned char *output);
    
52. 
    
53.         /**
    
54.         * \brief          SM4-CBC buffer encryption/decryption
    
55.         * \param ctx      SM4 context
    
56.         * \param mode     SM4_ENCRYPT or SM4_DECRYPT
    
57.         * \param length   length of the input data
    
58.         * \param iv       initialization vector (updated after use)
    
59.         * \param input    buffer holding the input data
    
60.         * \param output   buffer holding the output data
    
61.         */
    
62.         void sm4_crypt_cbc(sm4_context *ctx,
    
63.                 int mode,
    
64.                 int length,
    
65.                 unsigned char iv[16],
    
66.                 unsigned char *input,
    
67.                 unsigned char *output);
    
68. 
    
69. #ifdef __cplusplus
    
70. }
    
71. #endif
    
72. #include <iostream>
    
73. class Sm4EncDec
    
74. {
    
75. public:
    
76.         /**********************************************************************************************
    
77.         * @brief 构造函数 密钥赋值
    
78.         **********************************************************************************************/
    
79.         Sm4EncDec();
    
80. 
    
81.         /**********************************************************************************************
    
82.         * @brief 构造函数 密钥赋值
    
83.         * @param SrcPath (传入) 需要赋值的密钥
    
84.         **********************************************************************************************/
    
85.         Sm4EncDec(unsigned char key[]);
    
86. 
    
87.         /**********************************************************************************************
    
88.         * @brief 加密文件
    
89.         * @param SrcPath (传入) 加密源文件名
    
90.         * @param DestPath (传出) 加密后的密文文件名
    
91.         **********************************************************************************************/
    
92.         void Encrypt(std::string DestPath, std::string SrcPath);
    
93. 
    
94.         /**********************************************************************************************
    
95.         * @brief 解密文件
    
96.         * @param SrcPath (传入) 解密源文件名
    
97.         * @param DestPath (传出) 解密后的明文文件名
    
98.         **********************************************************************************************/
    
99.         void Decrypt(std::string DestPath, std::string SrcPath);
    
100. 
     
101. 
     
102.         /**********************************************************************************************
     
103.         * @brief 加密文件
     
104.         * @param SrcPath (传入传出) 加密源文件名
     
105.         **********************************************************************************************/
     
106.         void Encrypt(std::string SrcPath);
     
107. 
     
108.         /**********************************************************************************************
     
109.         * @brief 解密文件
     
110.         * @param SrcPath (传入传出) 解密源文件名
     
111.         **********************************************************************************************/
     
112.         void Decrypt(std::string SrcPath);
     
113. 
     
114. 
     
115.         /**********************************************************************************************
     
116.         * @brief 加密字符串
     
117.         * @param SrcPath (传入) 需要加密的字符串
     
118.         * @param DestPath (传出) 加密后的密文字符串
     
119.         **********************************************************************************************/
     
120.         int Encrypt(unsigned char *destBuf, unsigned char *srcStr, int srcLen);
     
121. 
     
122.         /**********************************************************************************************
     
123.         * @brief 解密字符串
     
124.         * @param SrcPath (传入) 需要解密的字符串
     
125.         * @param DestPath (传出) 解密后的明文字符串
     
126.         **********************************************************************************************/
     
127.         int Decrypt(unsigned char *destBuf, unsigned char *srcStr, int srcLen);
     
128. 
     
129. private:
     
130.         //密钥
     
131.         unsigned char key[16];
     
132. };
     

复制代码

Sm4.cpp

1. //sm4.cpp
   
2. #pragma pack(4)
   
3. #include "sm4.h"
   
4. #include <string.h>
   
5. #include <stdio.h>
   
6. #include <iostream>
   
7. #include <algorithm>
   
8. 
   
9. /*
   
10. * 32-bit integer manipulation macros (big endian)
    
11. * //将字符型数组b的第i到第i+3位的二进制拼接成一个4*8=32bit的整数，存入n中
    
12. */
    
13. #ifndef GET_ULONG_BE
    
14. #define GET_ULONG_BE(n,b,i)                             \
    
15. {                                                       \
    
16.     (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
    
17.         | ( (unsigned long) (b)[(i) + 1] << 16 )        \
    
18.         | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
    
19.         | ( (unsigned long) (b)[(i) + 3]       );       \
    
20. }
    
21. #endif
    
22. 
    
23. //将整数n的32位的二进制表示转换为4个char的数组，存入数组b的第i到第i+3位
    
24. #ifndef PUT_ULONG_BE
    
25. #define PUT_ULONG_BE(n,b,i)                             \
    
26. {                                                       \
    
27.     (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    
28.     (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    
29.     (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    
30.     (b)[(i) + 3] = (unsigned char) ( (n)       );       \
    
31. }
    
32. #endif
    
33. 
    
34. /*
    
35. *rotate shift left marco definition
    
36. * 循环移位
    
37. */
    
38. #define  SHL(x,n) (((x) & 0xFFFFFFFF) << n)
    
39. #define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))
    
40. 
    
41. #define SWAP(a,b) { unsigned long t = a; a = b; b = t; t = 0; }
    
42. 
    
43. /*
    
44. * Expanded SM4 S-boxes  S盒
    
45. /* Sbox table: 8bits input convert to 8 bits output*/
    
46. 
    
47. static const unsigned char SboxTable[16][16] =
    
48. {
    
49.         { 0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05 },
    
50.         { 0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99 },
    
51.         { 0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62 },
    
52.         { 0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6 },
    
53.         { 0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8 },
    
54.         { 0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35 },
    
55.         { 0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87 },
    
56.         { 0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e },
    
57.         { 0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1 },
    
58.         { 0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3 },
    
59.         { 0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f },
    
60.         { 0xd5,0xdb,0x37,0x45,0xde,0xfd,0x8e,0x2f,0x03,0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51 },
    
61.         { 0x8d,0x1b,0xaf,0x92,0xbb,0xdd,0xbc,0x7f,0x11,0xd9,0x5c,0x41,0x1f,0x10,0x5a,0xd8 },
    
62.         { 0x0a,0xc1,0x31,0x88,0xa5,0xcd,0x7b,0xbd,0x2d,0x74,0xd0,0x12,0xb8,0xe5,0xb4,0xb0 },
    
63.         { 0x89,0x69,0x97,0x4a,0x0c,0x96,0x77,0x7e,0x65,0xb9,0xf1,0x09,0xc5,0x6e,0xc6,0x84 },
    
64.         { 0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48 }
    
65. };
    
66. 
    
67. /* System parameter 系统参数FK */
    
68. static const unsigned long FK[4] = { 0xa3b1bac6,0x56aa3350,0x677d9197,0xb27022dc };
    
69. 
    
70. /* fixed parameter 固定参数 */
    
71. static const unsigned long CK[32] =
    
72. {
    
73.         0x00070e15,0x1c232a31,0x383f464d,0x545b6269,
    
74.         0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
    
75.         0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,
    
76.         0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
    
77.         0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,
    
78.         0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
    
79.         0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,
    
80.         0x10171e25,0x2c333a41,0x484f565d,0x646b7279
    
81. };
    
82. 
    
83. 
    
84. /*
    
85. * private function:
    
86. * look up in SboxTable and get the related value.
    
87. * args:    [in] inch: 0x00~0xFF (8 bits unsigned value).
    
88. */
    
89. static unsigned char sm4Sbox(unsigned char inch)
    
90. {
    
91.         unsigned char *pTable = (unsigned char *)SboxTable;
    
92.         unsigned char retVal = (unsigned char)(pTable[inch]);
    
93.         return retVal;
    
94. }
    
95. 
    
96. /*
    
97. * private F(Lt) function:
    
98. * "T algorithm" == "L algorithm" + "t algorithm".
    
99. * args:    [in] a: a is a 32 bits unsigned value;
    
100. * return: c: c is calculated with line algorithm "L" and nonline algorithm "t"
     
101. */
     
102. /*
     
103. 合成置换T ，由非线性变换t和线性变换L复合而成
     
104. 将输入的整数ka转换为8比特一个的字符PUT_ULONG_BE(ka,a,0)，
     
105. 然后使用S盒进行非线性变换，再将变换结果转换为32比特的整数
     
106. GET_ULONG_BE(bb,b,0)，最后对得到的32位整数bb进行线性变换：
     
107. c = bb异或(bb << <2)异或(bb << <10)异或(bb << <18)异或(bb << <24)。
     
108. 从而得到复合变换的结果c。
     
109. */
     
110. 
     
111. static unsigned long sm4Lt(unsigned long ka)
     
112. {
     
113.         unsigned long bb = 0;
     
114.         unsigned long c = 0;
     
115.         unsigned char a[4];
     
116.         unsigned char b[4];
     
117. 
     
118.         PUT_ULONG_BE(ka, a, 0);
     
119. 
     
120.         //函数T与密钥扩展中的函数T相同
     
121.         b[0] = sm4Sbox(a[0]);
     
122.         b[1] = sm4Sbox(a[1]);
     
123.         b[2] = sm4Sbox(a[2]);
     
124.         b[3] = sm4Sbox(a[3]);
     
125. 
     
126.         GET_ULONG_BE(bb, b, 0);
     
127. 
     
128.         //L处理变为B与左移2位及左移10位及左移18位及左移24位的B进行异或处理
     
129.         c = bb ^ (ROTL(bb, 2)) ^ (ROTL(bb, 10)) ^ (ROTL(bb, 18)) ^ (ROTL(bb, 24));
     
130.         return c;
     
131. }
     
132. 
     
133. /*
     
134. * private F function:
     
135. * Calculating and getting encryption/decryption contents.
     
136. * args:    [in] x0: original contents;
     
137. * args:    [in] x1: original contents;
     
138. * args:    [in] x2: original contents;
     
139. * args:    [in] x3: original contents;
     
140. * args:    [in] rk: encryption/decryption key;
     
141. * return the contents of encryption/decryption contents.
     
142. */
     
143. /*
     
144. 轮函数F 每一轮加密中，输入为(x0, x1, x2, x3)，xi为32位比特，
     
145. 共计128比特。通过x0^sm4Lt(x1^x2^x3^rk)得到该轮加密的结果。
     
146. */
     
147. static unsigned long sm4F(unsigned long x0, unsigned long x1, unsigned long x2, unsigned long x3, unsigned long rk)
     
148. {
     
149.         //明文拆分后的4个字的后3个字与该轮的子密钥进行异或处理
     
150.         //经过一个函数T得到C，之后再将明文拆分后的第一个字与C进行异或。
     
151.         return (x0^sm4Lt(x1^x2^x3^rk));
     
152. }
     
153. 
     
154. 
     
155. /*
     
156. * 变换T’ 先进行Sbox的非线性替换，然后进行线性变换，
     
157. * 线性变换L改为了： rk = bb ^ (ROTL(bb, 13)) ^ (ROTL(bb, 23));
     
158. */
     
159. 
     
160. static unsigned long sm4CalciRK(unsigned long ka)
     
161. {
     
162.         unsigned long bb = 0;
     
163.         unsigned long rk = 0;
     
164.         unsigned char a[4];
     
165.         unsigned char b[4];
     
166.         //将A拆分为4个8bit的字节
     
167.         PUT_ULONG_BE(ka, a, 0)
     
168.                 //S盒变换
     
169.                 b[0] = sm4Sbox(a[0]);
     
170.         b[1] = sm4Sbox(a[1]);
     
171.         b[2] = sm4Sbox(a[2]);
     
172.         b[3] = sm4Sbox(a[3]);
     
173. 
     
174.         //4个S盒的输出组成32位的值B
     
175.         GET_ULONG_BE(bb, b, 0)
     
176. 
     
177.                 //B与左移13位及左移23位的B进行异或处理作为函数T的输出C
     
178.                 rk = bb ^ (ROTL(bb, 13)) ^ (ROTL(bb, 23));
     
179.         return rk;
     
180. }
     
181. 
     
182. /*
     
183. * 密钥扩展算法，对当前传入的主密钥进行32轮的迭代，
     
184. * 每次迭代的轮密钥都被存放到ctx结构中的sk数组中
     
185. * 类似于加密中的操作，首先通过宏将初始的密钥拆分为4个32位bit的字，
     
186. * MK0，MK1，MK2，MK3，并为计算各轮密钥预先准备好初始值
     
187. */
     
188. static void sm4_setkey(unsigned long SK[32], unsigned char key[16])
     
189. {
     
190.         unsigned long MK[4]; //拆分后的4个32bit秘钥
     
191.         unsigned long k[36]; //存放MK与系统参数FK异或运算得到的K
     
192.         unsigned long i = 0;
     
193. 
     
194.         //将密钥拆分为4字
     
195.         GET_ULONG_BE(MK[0], key, 0);
     
196.         GET_ULONG_BE(MK[1], key, 4);
     
197.         GET_ULONG_BE(MK[2], key, 8);
     
198.         GET_ULONG_BE(MK[3], key, 12);
     
199. 
     
200.         //线性变换 L 位移异或,与系统参数的每个字做异或运算得到（K0, K1, K2, K3）
     
201.         k[0] = MK[0] ^ FK[0];
     
202.         k[1] = MK[1] ^ FK[1];
     
203.         k[2] = MK[2] ^ FK[2];
     
204.         k[3] = MK[3] ^ FK[3];
     
205. 
     
206.         //对于第i轮的密钥SK[i] ，其是由k[i]
     
207.         //和对k[i+1]^k[i+2]^k[i+3]^CK[i]的复合变换T’异或得到的：
     
208.         for (; i < 32; i++)
     
209.         {
     
210.                 k[i + 4] = k[i] ^ (sm4CalciRK(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i]));
     
211.                 SK[i] = k[i + 4];
     
212.         }
     
213. }
     
214. 
     
215. /*
     
216. * SM4 standard one round processing
     
217. *
     
218. */
     
219. 
     
220. /*
     
221. * 轮加密
     
222. * 先将明文输入input的整数，放入ulbuf[4]中，
     
223. * 然后迭代地调用函数static unsigned long sm4F() 进行32轮加密
     
224. * 每一轮加密都需要使用之前的结果 ulbuf[i], ulbuf[i+1], ulbuf[i+2], ulbuf[i+3]
     
225. * 和该轮的密钥 sk[i]，产生出该轮的密文 ulbuf[i+4]，
     
226. * 最后的密文存储在ulbuf[35]~ulbuf[32]中，转换为字符数组的形式放入output中。
     
227. */
     
228. static void sm4_one_round(unsigned long sk[32],
     
229.         unsigned char input[16],
     
230.         unsigned char output[16])
     
231. {
     
232.         unsigned long i = 0;
     
233.         unsigned long ulbuf[36];
     
234. 
     
235.         //将128bit的明文分成4个32bit的字X1,X2,X3,X4
     
236.         memset(ulbuf, 0, sizeof(ulbuf));
     
237.         GET_ULONG_BE(ulbuf[0], input, 0);
     
238.         GET_ULONG_BE(ulbuf[1], input, 4);
     
239.         GET_ULONG_BE(ulbuf[2], input, 8);
     
240.         GET_ULONG_BE(ulbuf[3], input, 12);
     
241. 
     
242.         //进行32轮的轮操作
     
243.         while (i < 32)
     
244.         {
     
245.                 ulbuf[i + 4] = sm4F(ulbuf[i], ulbuf[i + 1], ulbuf[i + 2], ulbuf[i + 3], sk[i]);
     
246.                 i++;
     
247.         }
     
248. 
     
249.         PUT_ULONG_BE(ulbuf[35], output, 0);
     
250.         PUT_ULONG_BE(ulbuf[34], output, 4);
     
251.         PUT_ULONG_BE(ulbuf[33], output, 8);
     
252.         PUT_ULONG_BE(ulbuf[32], output, 12);
     
253. }
     
254. 
     
255. /*
     
256. * SM4 key schedule (128-bit, encryption) 设置加密秘钥
     
257. */
     
258. void sm4_setkey_enc(sm4_context *ctx, unsigned char key[16])
     
259. {
     
260.         ctx->mode = SM4_ENCRYPT;   /*!< SM4_ENCRYPT 加密  SM4_DECRYPT解密 */
     
261.         sm4_setkey(ctx->sk, key);
     
262. }
     
263. 
     
264. /*
     
265. * SM4 key schedule (128-bit, decryption)
     
266. */
     
267. 设置解密秘钥 轮密钥的使用顺序相反
     
268. void sm4_setkey_dec(sm4_context *ctx, unsigned char key[16])
     
269. {
     
270.         int i;
     
271.         ctx->mode = SM4_ENCRYPT;
     
272.         sm4_setkey(ctx->sk, key);
     
273.         for (i = 0; i < 16; i++)
     
274.         {
     
275.                 SWAP(ctx->sk[i], ctx->sk[31 - i]);
     
276.         }
     
277. }
     
278. 
     
279. 
     
280. /*
     
281. * SM4-ECB block encryption/decryption  
     
282. * ECB模式密文被分割成分组长度相等的块（不足补齐），
     
283. * 然后单独一个个加密，一个个输出组成密文。
     
284. */
     
285. int sm4_crypt_ecb(sm4_context *ctx,
     
286.         int mode,
     
287.         int length,
     
288.         unsigned char *input,
     
289.         unsigned char *output)
     
290. {
     
291.         int retlen = 0;
     
292.         while (length > 0 )
     
293.         {
     
294.                 sm4_one_round(ctx->sk, input, output);
     
295.                 input += 16;
     
296.                 output += 16;
     
297.                 length -= 16;
     
298.                 retlen += 16;
     
299.         }
     
300.         return retlen;
     
301. }
     
302. 
     
303. /*
     
304. * SM4-CBC buffer encryption/decryption
     
305. * 循环模式（链式），前一个分组的密文和当前分组的明文操作后再加密，
     
306. * 增强破解难度。（不容易主动攻击，安全性好于ECB，是SSL、IPSec的标准）
     
307. */
     
308. void sm4_crypt_cbc(sm4_context *ctx,
     
309.         int mode,
     
310.         int length,
     
311.         unsigned char iv[16],
     
312.         unsigned char *input,
     
313.         unsigned char *output)
     
314. {
     
315.         int i;
     
316.         unsigned char temp[16];
     
317. 
     
318.         if (mode == SM4_ENCRYPT)
     
319.         {
     
320.                 while (length > 0)
     
321.                 {
     
322.                         for (i = 0; i < 16; i++)
     
323.                                 output[i] = (unsigned char)(input[i] ^ iv[i]);
     
324. 
     
325.                         sm4_one_round(ctx->sk, output, output);
     
326.                         memcpy(iv, output, 16);
     
327. 
     
328.                         input += 16;
     
329.                         output += 16;
     
330.                         length -= 16;
     
331.                 }
     
332.         }
     
333.         else /* SM4_DECRYPT */
     
334.         {
     
335.                 while (length > 0)
     
336.                 {
     
337.                         memcpy(temp, input, 16);
     
338.                         sm4_one_round(ctx->sk, input, output);
     
339. 
     
340.                         for (i = 0; i < 16; i++)
     
341.                                 output[i] = (unsigned char)(output[i] ^ iv[i]);
     
342. 
     
343.                         memcpy(iv, temp, 16);
     
344. 
     
345.                         input += 16;
     
346.                         output += 16;
     
347.                         length -= 16;
     
348.                 }
     
349.         }
     
350. }
     
351. 
     
352. 
     
353. //初始化密钥赋值 默认unsigned char key1[16] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10 };
     
354. Sm4EncDec::Sm4EncDec()
     
355. {
     
356.         memset(key, 0, 16);
     
357.         unsigned char key1[16] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10 };
     
358.         memcpy(key, key1,16);
     
359. }
     
360. 
     
361. Sm4EncDec::Sm4EncDec(unsigned char _key[])
     
362. {
     
363.         memset(key,0,16);
     
364.         if (_key == NULL)
     
365.                 Sm4EncDec();
     
366.         memcpy(key, _key, 16);
     
367. }
     
368. 
     
369. //加密
     
370. void Sm4EncDec::Encrypt(std::string DestPath,std::string SrcPath)
     
371. {
     
372.         if (SrcPath.empty())
     
373.                 return;
     
374. 
     
375.         FILE* InFile = fopen(SrcPath.c_str(), "rb");
     
376.         if (InFile == NULL)
     
377.         {
     
378.                 return;
     
379.         }
     
380. 
     
381.         FILE* OutFile = fopen(DestPath.c_str(), "wb");
     
382.         if (OutFile == NULL)
     
383.         {
     
384.                 fclose(InFile);
     
385.                 return;
     
386.         }
     
387. 
     
388.         fseek(InFile, 0, SEEK_END);
     
389.         long filelen = ftell(InFile);
     
390.         fseek(InFile, 0, SEEK_SET);
     
391. 
     
392.         long last = filelen;
     
393.         long offset = 1024;
     
394. 
     
395.         unsigned char* SrcBuffer = new unsigned char[offset];
     
396.         unsigned char*  DestBuffer = new  unsigned char[offset];
     
397.         sm4_context ctx;
     
398. 
     
399.         while (last > 0)
     
400.         {
     
401.                 memset(SrcBuffer, 0, offset);
     
402.                 memset(DestBuffer, 0, offset);
     
403.                 offset = std::min(offset, last);
     
404. 
     
405.                 fread(SrcBuffer, offset, 1, InFile);
     
406.                 last -= offset;
     
407. 
     
408.                 //设置秘钥
     
409.                 sm4_setkey_enc(&ctx, key);
     
410.                 //加密
     
411.                 int elen = sm4_crypt_ecb(&ctx, SM4_ENCRYPT, offset, SrcBuffer, DestBuffer); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
412. 
     
413.                 fwrite(DestBuffer, elen, 1, OutFile);
     
414.         }
     
415.         delete[]SrcBuffer;
     
416.         delete[]DestBuffer;
     
417.         fclose(InFile);
     
418.         fclose(OutFile);
     
419. 
     
420.         return;
     
421. }
     
422. 
     
423. //解密
     
424. void Sm4EncDec::Decrypt(std::string DestPath, std::string SrcPath)
     
425. {
     
426.         if (SrcPath.empty())
     
427.                 return;
     
428.        
     
429.         FILE* InFile = fopen(SrcPath.c_str(), "rb");
     
430.         if (InFile == NULL)
     
431.         {
     
432.                 return;
     
433.         }
     
434. 
     
435.         FILE* OutFile = fopen(DestPath.c_str(), "wb");
     
436.         if (OutFile == NULL)
     
437.         {
     
438.                 fclose(InFile);
     
439.                 return;
     
440.         }
     
441. 
     
442.         fseek(InFile, 0, SEEK_END);
     
443.         long filelen = ftell(InFile);
     
444.         fseek(InFile, 0, SEEK_SET);
     
445. 
     
446.         long last = filelen;
     
447.         long offset = 1024;
     
448.         sm4_context ctx;
     
449.         unsigned char* SrcBuffer = new unsigned char[offset];
     
450.         unsigned char*  DestBuffer = new  unsigned char[offset];
     
451.         while (last > 0)
     
452.         {
     
453.                 memset(SrcBuffer, 0, offset);
     
454.                 memset(DestBuffer, 0, offset);
     
455. 
     
456.                 offset = std::min(offset, last);
     
457. 
     
458.                 fread(SrcBuffer, offset, 1, InFile);
     
459. 
     
460.                 sm4_setkey_dec(&ctx, key);
     
461.                 int dlen = sm4_crypt_ecb(&ctx, SM4_DECRYPT, offset, SrcBuffer, DestBuffer); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
462. 
     
463.                 fwrite(DestBuffer, dlen, 1, OutFile);
     
464.                 last -= offset;
     
465.         }
     
466.         delete[]SrcBuffer;
     
467.         delete[]DestBuffer;
     
468.         fclose(InFile);
     
469.         fclose(OutFile);
     
470.         return;
     
471. }
     
472. 
     
473. //加密
     
474. void Sm4EncDec::Encrypt(std::string SrcPath)
     
475. {
     
476.         FILE* InFile = fopen(SrcPath.c_str(), "rb+");
     
477.         if (InFile == NULL)
     
478.         {
     
479.                 return;
     
480.         }
     
481.         fseek(InFile, 0, SEEK_END);
     
482.         int filelen = ftell(InFile);
     
483.         fseek(InFile, 0, SEEK_SET);
     
484.        
     
485.         int last = filelen;
     
486.         int offset = 1024;
     
487. 
     
488.         unsigned char* SrcBuffer = new unsigned char[offset];
     
489.         unsigned char* DestBuffer = new unsigned char[offset];
     
490. 
     
491.         sm4_context ctx;
     
492. 
     
493.         int fileindex = 0;
     
494.        
     
495.         while (last > 0)
     
496.         {
     
497.                 memset(SrcBuffer, 0, offset);
     
498.                 memset(DestBuffer, 0, offset);
     
499. 
     
500.                 offset = std::min(offset, last);
     
501.                
     
502.                 fseek(InFile, fileindex,SEEK_SET);
     
503. 
     
504.                 int rn = fread(SrcBuffer,offset,1, InFile);
     
505. 
     
506.                 fileindex = ftell(InFile);  //读位置
     
507.        
     
508.                 //设置秘钥
     
509.                 sm4_setkey_enc(&ctx, key);
     
510.                 //加密
     
511.                 int retlen = sm4_crypt_ecb(&ctx, SM4_ENCRYPT, offset, SrcBuffer, DestBuffer); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
512. 
     
513.                 fseek(InFile, fileindex - offset, SEEK_SET);
     
514.                
     
515.                 int wn = fwrite(DestBuffer, retlen,1, InFile);
     
516.                 fseek(InFile, fileindex, SEEK_SET);
     
517. 
     
518.                 last -= offset;
     
519.         }
     
520.         fclose(InFile);
     
521.         return;
     
522. }
     
523. 
     
524. //解密
     
525. void Sm4EncDec::Decrypt( std::string SrcPath)
     
526. {
     
527.         FILE* InFile = fopen(SrcPath.c_str(), "rb+");
     
528.        
     
529.         if (InFile == NULL)
     
530.         {
     
531.                 return;
     
532.         }
     
533.         sm4_context ctx;
     
534. 
     
535.         fseek(InFile, 0, SEEK_END);
     
536.         int filelen = ftell(InFile);
     
537.         fseek(InFile, 0, SEEK_SET);
     
538.        
     
539.         int last = filelen;
     
540.         int offset = 1024;
     
541. 
     
542.         unsigned char* SrcBuffer = new unsigned char[offset];
     
543.         unsigned char* DestBuffer = new unsigned char[offset];
     
544. 
     
545.         int fileindex =0;
     
546.        
     
547.         while (last > 0)
     
548.         {
     
549.                 memset(SrcBuffer, 0, offset);
     
550.                 memset(DestBuffer, 0, offset);
     
551. 
     
552.                 offset = std::min(offset, last);
     
553. 
     
554.                 fseek(InFile, fileindex, SEEK_SET);
     
555.                 int tn = fread(SrcBuffer,offset,1, InFile);
     
556.                 fileindex = ftell(InFile);   //记录读的位置
     
557. 
     
558.                 sm4_setkey_dec(&ctx, key);
     
559.                 int retlen = sm4_crypt_ecb(&ctx, SM4_DECRYPT, offset, SrcBuffer, DestBuffer); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
560. 
     
561.                 fseek(InFile, fileindex - offset,SEEK_SET);
     
562.                 int wn = fwrite(DestBuffer, retlen,1, InFile);
     
563.                 fseek(InFile, fileindex, SEEK_SET);
     
564. 
     
565.                 last -= offset;
     
566.         }
     
567.        
     
568.         fclose(InFile);
     
569.         return;
     
570. }
     
571. 
     
572. 
     
573. //加密字符串
     
574. int Sm4EncDec::Encrypt(unsigned char *destBuf, unsigned char *srcStr, int srcLen)
     
575. {
     
576.         if (srcStr == NULL)
     
577.                 return 0;
     
578.         int last = srcLen;
     
579.         int offset = 128;
     
580.         unsigned char* dest = destBuf;
     
581.         unsigned char* src = srcStr;
     
582.         sm4_context ctx;
     
583.         int retlen = 0;
     
584.         while (last > 0)
     
585.         {
     
586.                 offset = std::min(offset, last);
     
587. 
     
588.                 last -= offset;
     
589.                 //设置秘钥
     
590.                 sm4_setkey_enc(&ctx, key);
     
591.                 //加密
     
592.                 int elen = sm4_crypt_ecb(&ctx, SM4_ENCRYPT, offset, src, dest); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
593. 
     
594.                 src += offset;
     
595.                 dest += offset;
     
596.                 retlen += elen;
     
597.         }
     
598.         return retlen;
     
599. }
     
600. 
     
601. //解密字符串
     
602. int Sm4EncDec::Decrypt(unsigned char *destBuf, unsigned char *srcStr, int srcLen)
     
603. {
     
604.         if (srcStr == NULL)
     
605.                 return 0;
     
606.         int last = srcLen;
     
607.         int offset = 128;
     
608.         int retlen = 0;
     
609. 
     
610.         unsigned char*  dest = destBuf;
     
611.         unsigned char*  src = srcStr;
     
612.         sm4_context ctx;
     
613. 
     
614.         while (last > 0)
     
615.         {
     
616.                 offset = std::min(offset, last);
     
617. 
     
618.                 last -= offset;
     
619.                 sm4_setkey_dec(&ctx, key);
     
620.                 int dlen = sm4_crypt_ecb(&ctx, SM4_DECRYPT, offset, src, dest); //SM4_ENCRYPT为加密 SM4_DECRYPT为解密
     
621. 
     
622.                 src += offset;
     
623.                 dest += offset;
     
624.                 retlen += dlen;
     
625.         }
     
626.         return retlen;
     
627. }
     
628. 
     
629. #pragma pack()
     

复制代码

key为16字节，支持特殊字符，自测中文可用，加密文件或字符串支持中文特殊字符。

调用Sm4EncDec类成员Encrypt和Decrypt可实现加密解密。