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

代码示例：OpenSSL AES CBC 加密_openssl aes加密

作者：你好赵伟 | 2024-04-14 15:16:15

赞

踩

openssl aes加密

初级代码游戏的专栏介绍与文章目录-CSDN博客

我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。

这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。

        这是一个基于OpenSSL的AES-CBC加密的例子，其中CBC是自行实现的，原因是OpenSSL的CBC始终有问题，可能是我还没做对吧。这个例程的目的是对配置数据加密，不用于对外交换，所以CBC有没写对我也不能担保——反正这个程序自己加密的自己解密是没问题的。

目录

1 介绍

 2 代码概要

3 主要代码

4 辅助代码

5 openSSL的AES用法

5.1 设置KEY

5.2 加密解密AES_encrypt/AES_decrypt

1 介绍

        这个例程是基于CentOS7/8的，64位，OpenSSL大概是1.1，我也在windows上做了测试，代码可能需要修改，CBC的问题同样存在（所以我就放弃解决了，自己写了一个）。

        使用OpenSSL需要头文件位置和库，如果头文件安装到标准位置则不需要-I参数，库是 -lssl -lcrypt

 2 代码概要

  1. //需要的OpenSSL的两个头文件
  2. #include <openssl/aes.h>
  3. #include <openssl/rand.h>
  4.  
  5. class CMyOpenSSL
  6. {
  7. private:
  8.     //用来输出十六进制数据
  9. 	static void show_buf(char const* title, unsigned char const* buf, int len)
  10. 	{
  11. 		。。。。。。
  12. 	}
  13. 	//需要一个从用户密码生成密钥的函数
  14.     //这个函数我没写，有标准算法从密码生成密钥，类似于对密码进行哈希
  15. public:
  16.     //这就是一般所说的“盐”
  17. 	class IV
  18. 	{
  19. 	private:
  20. 		unsigned char iv[AES_BLOCK_SIZE * 5];//其实不需要*5，但我原来就是这么写的，为了调试吧
  21. 	public:
  22. 		//执行异或
  23. 		static void XOR(unsigned char const * iv,unsigned char* data)
  24. 		{
  25. 			。。。。。。
  26. 		}
  27. 		//用随机数设置
  28. 		void Create()
  29. 		{
  30. 			。。。。。。
  31. 		}
  32.     。。。。。。
  33. 	};
  34. 	//由于网上的例子也一样无法解密，所以自行实现CBC
  35. 	static void my_AES_cbc_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, const int enc)
  36. 	{
  37. 		。。。。。。
  38. 	}
  39.     //AES加密
  40. 	static int aes_encrypt(unsigned char const* userpasswd, int userpasswd_len, vector<unsigned char> const& in_plain, vector<unsigned char>& out_ciphertext, IV& iv)
  41. 	{
  42. 		。。。。。。
  43. 	}
  44.     //AES解密
  45. 	static int aes_decrypt(unsigned char const* userpasswd, int userpasswd_len, vector<unsigned char> const& in_ciphertext, vector<unsigned char>& out_plain, IV& iv)
  46. 	{
  47. 		。。。。。。
  48. 	}
  49. 	//保护数据，用密码加密并做格式转换
  50. 	static bool protect_encode(CBuffer const& passwd, CBuffer const& input, CBuffer& output)
  51. 	{
  52. 		。。。。。。
  53. 	}
  54. 	//保护数据，用密码加密并做格式转换
  55. 	static bool protect_decode(CBuffer const& passwd, CBuffer const& input, CBuffer& output)
  56. 	{
  57. 		。。。。。。
  58. 	}
  59.     //下面两个就是网上别人写的程序，一样得不到正确结果
  60. 	// a simple hex-print routine. could be modified to print 16 bytes-per-line
  61. 	static void hex_print(const void* pv, size_t len)
  62. 	{
  63. 		。。。。。。
  64. 	}
  65.  
  66. 	// main entrypoint
  67. 	static int a()
  68. 	{
  69. 		。。。。。。
  70. 	}
  71.     //测试代码
  72. 	static bool aes_test()
  73. 	{
  74. 		。。。。。。
  75. 	}
  76. };

        主要函数如下：

my_AES_cbc_encrypt 我自己写的AES-CBC加密和解密，调用了openSSL的AES_encrypt和AES_decrypt，想学习AES怎么用看看这个函数就可以了

aes_encrypt AES加密，调用了openSSL的AES_set_encrypt_key和我自己写的my_AES_cbc_encrypt，为了方便把明文长度作为第一个数据块

 aes_decrypt AES解密，调用了openSSL的AES_set_decrypt_key和我自己写的my_AES_cbc_encrypt

protect_encode和protect_decode是我自己写的加密配置数据的方法，完全是自定义的

a 是网上找来的测试代码，证明AES-CBC确实有问题，不是我一个人的问题

3 主要代码

        下面是主要代码，上面有一些注释是我临时加的，不在完整代码里面，还有一些辅助类后面列出。

  1. #include <openssl/aes.h>
  2. #include <openssl/rand.h>
  3.  
  4. class CMyOpenSSL
  5. {
  6. private:
  7. 	static unsigned char const ver;
  8.  
  9. 	static void show_buf(char const* title, unsigned char const* buf, int len)
  10. 	{
  11. 		cout << title << " ";
  12. 		for (int i = 0; i < len; ++i)
  13. 		{
  14. 			cout << hex << setw(2) << setfill('0') << (unsigned int)buf[i] << " ";
  15. 		}
  16. 		cout << endl;
  17. 	}
  18. 	//需要一个从用户密码生成密钥的函数
  19. public:
  20. 	class IV
  21. 	{
  22. 	private:
  23. 		unsigned char iv[AES_BLOCK_SIZE * 5];
  24. 	public:
  25. 		IV()
  26. 		{
  27. 			memset(iv, 0, AES_BLOCK_SIZE * 5);
  28. 		}
  29. 		//执行异或
  30. 		static void XOR(unsigned char const * iv,unsigned char* data)
  31. 		{
  32. 			//show_buf("IV  ", iv, AES_BLOCK_SIZE);
  33. 			//show_buf("DATA", data, AES_BLOCK_SIZE);
  34. 			for (int i = 0; i < AES_BLOCK_SIZE; ++i)
  35. 			{
  36. 				data[i] ^= iv[i];
  37. 			}
  38. 			//show_buf("DATA", data, AES_BLOCK_SIZE);
  39. 		}
  40. 		int size()const
  41. 		{
  42. 			return AES_BLOCK_SIZE;
  43. 		}
  44. 		//用随机数设置
  45. 		void Create()
  46. 		{
  47. 			time_t t = time(NULL);
  48. 			srand(t);
  49. 			for (int i = 0; i < AES_BLOCK_SIZE; i += sizeof(int))
  50. 			{
  51. 				int a = rand();
  52. 				memcpy(iv + i, &a, sizeof(int));
  53. 			}
  54. 		}
  55. 		void Set(unsigned char const* a)
  56. 		{
  57. 			memcpy(iv, a, AES_BLOCK_SIZE);
  58. 		}
  59. 		//注意，会修改内容
  60. 		unsigned char* Get()
  61. 		{
  62. 			//show_buf("", iv, AES_BLOCK_SIZE * 2);
  63. 			return iv;
  64. 		}
  65. 	};
  66. 	//由于网上的例子也一样无法解密，所以自行实现CBC
  67. 	static void my_AES_cbc_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, const int enc)
  68. 	{
  69. 		for (int i = 0; i < length; i += AES_BLOCK_SIZE)
  70. 		{
  71. 			if (AES_ENCRYPT == enc)
  72. 			{
  73. 				unsigned char tmpin[AES_BLOCK_SIZE];
  74. 				memcpy(tmpin, in + i, AES_BLOCK_SIZE);
  75. 				IV::XOR(ivec, tmpin);
  76. 				AES_encrypt(tmpin, out + i, key);
  77. 				memcpy(ivec, out + i, AES_BLOCK_SIZE);
  78. 			}
  79. 			else
  80. 			{
  81. 				unsigned char tmpiv[AES_BLOCK_SIZE];
  82. 				memcpy(tmpiv, in + i, AES_BLOCK_SIZE);
  83. 				AES_decrypt(in + i, out + i, key);
  84. 				IV::XOR(ivec, out + i);
  85. 				memcpy(ivec, tmpiv, AES_BLOCK_SIZE);
  86. 			}
  87. 		}
  88. 	}
  89. 	static int aes_encrypt(unsigned char const* userpasswd, int userpasswd_len, vector<unsigned char> const& in_plain, vector<unsigned char>& out_ciphertext, IV& iv)
  90. 	{
  91. 		out_ciphertext.clear();
  92. 		unsigned char userkey[32];//必须是16/24/32
  93. 		memset((void*)userkey, '\0', 32);
  94. 		memcpy(userkey, userpasswd, (userpasswd_len > 32 ? 32 : userpasswd_len));
  95. 		/*设置加密key及密钥长度*/
  96. 		AES_KEY key;
  97. 		if (AES_set_encrypt_key(userkey, 32 * 8, &key) < 0)
  98. 		{
  99. 			return __LINE__;
  100. 		}
  101.  
  102. 		int len = 0;
  103. 		/*循环加密，每次只能加密AES_BLOCK_SIZE长度的数据*/
  104. 		out_ciphertext.reserve(in_plain.size() + AES_BLOCK_SIZE);
  105. 		while (len < in_plain.size())
  106. 		{
  107. 			if (0 == len)
  108. 			{//第一个块是明文长度
  109. 				out_ciphertext.resize(out_ciphertext.size() + AES_BLOCK_SIZE);
  110. 				unsigned char tmp[AES_BLOCK_SIZE];
  111. 				memset((void*)tmp, '\0', AES_BLOCK_SIZE);
  112. 				long tmp_len = in_plain.size();
  113. 				memcpy(tmp, &tmp_len, sizeof(long));
  114. 				//show_buf("明文长度加密前 ", tmp, AES_BLOCK_SIZE);
  115. 				my_AES_cbc_encrypt(tmp, &out_ciphertext[out_ciphertext.size() - AES_BLOCK_SIZE], AES_BLOCK_SIZE, &key, iv.Get(), AES_ENCRYPT);
  116. 				//show_buf("明文长度加密后", &out_ciphertext[out_ciphertext.size() - AES_BLOCK_SIZE], AES_BLOCK_SIZE);
  117. 			}
  118. 			out_ciphertext.resize(out_ciphertext.size() + AES_BLOCK_SIZE);
  119. 			if (in_plain.size() - len < AES_BLOCK_SIZE)
  120. 			{
  121. 				unsigned char tmp[AES_BLOCK_SIZE];
  122. 				memset((void*)tmp, '\0', AES_BLOCK_SIZE);
  123. 				memcpy(tmp, &in_plain[len], in_plain.size() - len);
  124. 				my_AES_cbc_encrypt(tmp, &out_ciphertext[out_ciphertext.size() - AES_BLOCK_SIZE], AES_BLOCK_SIZE, &key, iv.Get(), AES_ENCRYPT);
  125. 			}
  126. 			else
  127. 			{
  128. 				my_AES_cbc_encrypt(&in_plain[len], &out_ciphertext[out_ciphertext.size() - AES_BLOCK_SIZE], AES_BLOCK_SIZE, &key, iv.Get(), AES_ENCRYPT);
  129. 			}
  130. 			len += AES_BLOCK_SIZE;
  131. 		}
  132.  
  133. 		return 0;
  134. 	}
  135. 	static int aes_decrypt(unsigned char const* userpasswd, int userpasswd_len, vector<unsigned char> const& in_ciphertext, vector<unsigned char>& out_plain, IV& iv)
  136. 	{
  137. 		out_plain.clear();
  138. 		unsigned char userkey[32];//必须是16/24/32
  139. 		memset((void*)userkey, '\0', 32);
  140. 		memcpy(userkey, userpasswd, (userpasswd_len > 32 ? 32 : userpasswd_len));
  141. 		/*设置解密key及密钥长度*/
  142. 		AES_KEY key;
  143. 		if (AES_set_decrypt_key(userkey, 32 * 8, &key) < 0)
  144. 		{
  145. 			return __LINE__;
  146. 		}
  147.  
  148. 		int len = 0;
  149. 		/*循环解密*/
  150. 		out_plain.reserve(in_ciphertext.size());
  151. 		long out_len = 0;//原始长度，放在第一个加密块
  152. 		while (len < in_ciphertext.size())
  153. 		{
  154. 			if (0 == len)
  155. 			{//第一个块是明文长度
  156. 				unsigned char tmp[AES_BLOCK_SIZE];
  157. 				//show_buf("明文长度解密前", &in_ciphertext[len], AES_BLOCK_SIZE);
  158. 				my_AES_cbc_encrypt(&in_ciphertext[len], tmp, AES_BLOCK_SIZE, &key, iv.Get(), AES_DECRYPT);
  159. 				//show_buf("明文长度解密后", tmp, AES_BLOCK_SIZE);
  160. 				memcpy(&out_len, tmp, sizeof(long));
  161. 				//thelog << "明文长度应该是 " << out_len << endi;
  162. 				len += AES_BLOCK_SIZE;
  163. 			}
  164. 			out_plain.resize(out_plain.size() + AES_BLOCK_SIZE);
  165. 			my_AES_cbc_encrypt(&in_ciphertext[len], &out_plain[out_plain.size() - AES_BLOCK_SIZE], AES_BLOCK_SIZE, &key, iv.Get(), AES_DECRYPT);
  166. 			len += AES_BLOCK_SIZE;
  167. 		}
  168.  
  169. 		//恢复原始长度
  170. 		if (out_plain.size() > out_len)out_plain.resize(out_len);
  171.  
  172. 		return 0;
  173. 	}
  174. 	//保护数据，用密码加密并做格式转换
  175. 	static bool protect_encode(CBuffer const& passwd, CBuffer const& input, CBuffer& output)
  176. 	{
  177. 		output.setSize(0);
  178. 		IV iv;
  179. 		iv.Create();
  180.  
  181. 		CBuffer tmp;
  182. 		tmp.AddData(&ver, 1);//第一个字节是版本
  183. 		tmp.AddData(iv.Get(), iv.size());//然后是IV，必须在加密之前保存，加密之后会改变
  184.  
  185. 		//加密
  186. 		vector<unsigned char> in_plain;
  187. 		in_plain.resize(input.size());
  188. 		memcpy(&in_plain[0], input.data(), input.size());
  189. 		vector<unsigned char> out_ciphertext;
  190. 		aes_encrypt(passwd.data(), passwd.size(), in_plain, out_ciphertext, iv);
  191. 		thelog << out_ciphertext.size() << endi;
  192.  
  193. 		//添加加密后数据
  194. 		tmp.AddData(&out_ciphertext[0], out_ciphertext.size());
  195. 		thelog << tmp.size() << endi;
  196.  
  197. 		output.reserve(tmp.size() * 4 / 3 + 4 + 1);//三字节转为4字节，编码函数在最后还会加上一个字符串结束符
  198. 		thelog << output.capacity() << " " << output.size() << endi;
  199. 		int n = CBase64::Base64Enc(output.lockBuffer(), tmp.data(), tmp.size());
  200. 		output.releaseBuffer();
  201. 		if (n > output.capacity())thelog << "长度不足" << ende;
  202. 		output.setSize(n);
  203. 		thelog << output.size() << " [" << output.data() << "]" << endi;
  204.  
  205. 		return true;
  206. 	}
  207. 	//保护数据，用密码加密并做格式转换
  208. 	static bool protect_decode(CBuffer const& passwd, CBuffer const& input, CBuffer& output)
  209. 	{
  210. 		output.setSize(0);
  211.  
  212. 		CBuffer tmp;
  213. 		//这里导致了奇怪的内存错误，实际并不需要这么长
  214. 		tmp.reserve(input.size() + 100);//实际需要的是4转3,解码函数最后会加上一个字符串结束符
  215. 		//thelog << input.size() << " " << tmp.capacity() << " " << tmp.size() << endi;
  216. 		int n = CBase64::Base64Dec(tmp.lockBuffer(), input.data(), input.size());
  217. 		tmp.releaseBuffer();
  218. 		if (n<0 || n > tmp.capacity())thelog << "长度不足" << ende;
  219. 		tmp.setSize(n);
  220.  
  221. 		if (tmp.data()[0] != ver)
  222. 		{
  223. 			thelog << "加密版本错误" << ende;
  224. 			return false;
  225. 		}
  226. 		else
  227. 		{
  228. 			//thelog << "加密版本 " << (int)tmp.data()[0]<<" " << (int)ver << ende;
  229. 		}
  230.  
  231. 		IV iv;
  232. 		iv.Set(tmp.data() + 1);
  233.  
  234. 		vector<unsigned char> in_plain;
  235. 		in_plain.resize(tmp.size() - 1 - iv.size());
  236. 		memcpy(&in_plain[0], tmp.data() + 1 + iv.size(), tmp.size() - 1 - iv.size());
  237. 		//thelog << tmp.size() << " " << in_plain.size() << endi;
  238. 		vector<unsigned char> out_ciphertext;
  239. 		aes_decrypt(passwd.data(), passwd.size(), in_plain, out_ciphertext, iv);
  240.  
  241. 		output.AddData(&out_ciphertext[0], out_ciphertext.size());
  242.  
  243. 		return true;
  244. 	}
  245. 	// a simple hex-print routine. could be modified to print 16 bytes-per-line
  246. 	static void hex_print(const void* pv, size_t len)
  247. 	{
  248. 		const unsigned char* p = (const unsigned char*)pv;
  249. 		if (NULL == pv) {
  250. 			printf("NULL");
  251. 		}
  252. 		else {
  253. 			size_t i = 0;
  254. 			for (; i < len; ++i) {
  255. 				printf("%02X ", *p++);
  256. 			}
  257. 		}
  258. 		printf("\n");
  259. 	}
  260.  
  261. 	// main entrypoint
  262. 	static int a()
  263. 	{
  264. 		int const keylength = 128;
  265.  
  266. 		/* generate a key with a given length */
  267. 		unsigned char aes_key[keylength / 8];
  268. 		memset(aes_key, 0, keylength / 8);
  269. 		if (!RAND_bytes(aes_key, keylength / 8)) {
  270. 			exit(-1);
  271. 		}
  272.  
  273. 		size_t const inputslength = 16;
  274.  
  275. 		/* generate input with a given length */
  276. 		unsigned char aes_input[inputslength];
  277. 		memset(aes_input, 1, inputslength);
  278.  
  279. 		/* init vector */
  280. 		unsigned char iv_enc[AES_BLOCK_SIZE], iv_dec[AES_BLOCK_SIZE];
  281. 		RAND_bytes(iv_enc, AES_BLOCK_SIZE);
  282. 		memcpy(iv_dec, iv_enc, AES_BLOCK_SIZE);
  283.  
  284. 		// buffers for encryption and decryption
  285. 		const size_t encslength = ((inputslength + AES_BLOCK_SIZE) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
  286. 		unsigned char enc_out[encslength];
  287. 		unsigned char dec_out[inputslength];
  288. 		memset(enc_out, 0, sizeof(enc_out));
  289. 		memset(dec_out, 0, sizeof(dec_out));
  290.  
  291. 		// so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
  292. 		AES_KEY enc_key, dec_key;
  293. 		AES_set_encrypt_key(aes_key, keylength, &enc_key);
  294. 		AES_cbc_encrypt(aes_input, enc_out, inputslength, &enc_key, iv_enc, AES_ENCRYPT);
  295.  
  296. 		AES_set_decrypt_key(aes_key, keylength, &dec_key);
  297. 		AES_cbc_encrypt(enc_out, dec_out, encslength, &dec_key, iv_dec, AES_DECRYPT);
  298.  
  299. 		printf("original:\t");
  300. 		hex_print(aes_input, sizeof(aes_input));
  301.  
  302. 		printf("encrypt:\t");
  303. 		hex_print(enc_out, sizeof(enc_out));
  304.  
  305. 		printf("decrypt:\t");
  306. 		hex_print(dec_out, sizeof(dec_out));
  307.  
  308. 		return 0;
  309. 	}
  310. 	static bool aes_test()
  311. 	{
  312. 		if (true)
  313. 		{
  314. 			unsigned char userkey[32];//必须是16/24/32
  315. 			memset((void*)userkey, '\0', 32);
  316. 			memcpy(userkey, "12345", 5);
  317. 			AES_KEY key;
  318. 			if (AES_set_encrypt_key(userkey, 16 * 8, &key) < 0)
  319. 			{
  320. 				return __LINE__;
  321. 			}
  322. 			unsigned char iv[AES_BLOCK_SIZE];
  323. 			unsigned char data[AES_BLOCK_SIZE];
  324. 			memset(data, 1, AES_BLOCK_SIZE);
  325. 			unsigned char data2[AES_BLOCK_SIZE];
  326. 			memset(data2, 0, AES_BLOCK_SIZE);
  327. 			unsigned char data3[AES_BLOCK_SIZE * 3];
  328. 			memset(data3, 0, AES_BLOCK_SIZE * 3);
  329.  
  330. 			memset(iv, 0, AES_BLOCK_SIZE);
  331. 			show_buf("简单输入 ", data, AES_BLOCK_SIZE);
  332. 			show_buf("iv ", iv, AES_BLOCK_SIZE);
  333. 			AES_cbc_encrypt(data, data2, AES_BLOCK_SIZE, &key, iv, AES_ENCRYPT);
  334. 			show_buf("加密后   ", data2, AES_BLOCK_SIZE);
  335. 			show_buf("iv ", iv, AES_BLOCK_SIZE);
  336.  
  337. 			if (AES_set_decrypt_key(userkey, 16 * 8, &key) < 0)
  338. 			{
  339. 				return __LINE__;
  340. 			}
  341. 			memset(iv, 0, AES_BLOCK_SIZE);
  342. 			show_buf("解密前   ", data2, AES_BLOCK_SIZE);
  343. 			show_buf("iv ", iv, AES_BLOCK_SIZE);
  344. 			AES_cbc_encrypt(data2, data3, AES_BLOCK_SIZE, &key, iv, AES_DECRYPT);
  345. 			show_buf("简单输出 ", data3, AES_BLOCK_SIZE * 3);
  346. 			show_buf("iv ", iv, AES_BLOCK_SIZE);
  347.  
  348. 			a();
  349. 		}
  350. 		if (true)
  351. 		{
  352. 			string passwd = "13579";
  353. 			vector<unsigned char> plaintext;
  354. 			for (int i = 0; i < 65; ++i)
  355. 			{
  356. 				plaintext.push_back(i);
  357. 			}
  358. 			vector<unsigned char> out;
  359. 			IV iv;
  360. 			iv.Create();
  361. 			IV iv2;
  362. 			iv2.Set(iv.Get());
  363. 			//show_buf("初始IV", iv.Get(), iv.size());
  364. 			aes_encrypt((unsigned char*)passwd.c_str(), passwd.size(), plaintext, out, iv);
  365. 			vector<unsigned char> plaintext2;
  366. 			//show_buf("初始IV", iv2.Get(), iv2.size());
  367. 			aes_decrypt((unsigned char*)passwd.c_str(), passwd.size(), out, plaintext2, iv2);
  368.  
  369. 			thelog << plaintext.size() << " " << out.size() << " " << plaintext2.size() << ENDI;
  370. 			printf("plantext2: \n");
  371. 			for (int i = 0; i < plaintext2.size(); i++)
  372. 			{
  373. 				printf("%.2x ", plaintext2[i]);
  374. 				if ((i + 1) % 32 == 0)
  375. 				{
  376. 					printf("\n");
  377. 				}
  378. 			}
  379. 			printf("\n");
  380. 		}
  381.  
  382. 		if (true)
  383. 		{
  384. 			try
  385. 			{
  386. 				char const* plaintext = "1234567890";
  387. 				CBuffer pass;
  388. 				CBuffer in;
  389. 				CBuffer out;
  390. 				pass.SetData("123");
  391. 				in.SetData(plaintext);
  392. 				thelog << in.data() << endi;
  393. 				protect_encode(pass, in, out);
  394. 				thelog << out.size() << " [" << out.data() << "]" << endi;
  395. 				CBuffer out2;
  396. 				if (!protect_decode(pass, out, out2))thelog << "解码失败" << ende;
  397. 				thelog << out2.data() << endi;
  398. 				if (0 == strcmp(plaintext, (char*)out2.data()))
  399. 				{
  400. 					thelog << "匹配成功" << endi;
  401. 				}
  402. 				else
  403. 				{
  404. 					thelog << "匹配失败" << ende;
  405. 				}
  406. 				//out2.lockBuffer();
  407. 				//out2.setSize(10240);
  408. 			}
  409. 			catch (...)
  410. 			{
  411. 				thelog << "异常发生" << ende;
  412. 			}
  413. 		}
  414.  
  415. 		return true;
  416. 	}
  417. };

4 辅助代码

        thelog可以替换为cout，endi、ende可以替换为endl。

        CBuffer就是个包装的缓冲区，代码如下：

  1. 	//内部隐含保持一个结束符，不计算在容量和大小之内，确保数据可以被当作字符串使用
  2. 	class CBuffer
  3. 	{
  4. 	private:
  5. 		string name;
  6. 		unsigned char* p = NULL;
  7. 		size_t buffer_size = 0;
  8. 		size_t data_size = 0;
  9. 		bool bLockBuffer = false;
  10.  
  11. 		void _init()
  12. 		{
  13. 			static int i = 0;
  14. 			char buf[64];
  15. 			sprintf(buf, "CBuffer%d", i++);
  16. 			name = buf;
  17.  
  18. 			if (p)throw "p不为空指针";
  19. 			p = new unsigned char[1];
  20. 			if (!p)throw "内存不足";
  21. 			p[0] = '\0';
  22. 			buffer_size = 0;
  23. 		}
  24. 	public:
  25. 		CBuffer()
  26. 		{
  27. 			_init();
  28. 		}
  29. 		CBuffer(CBuffer const & tmp)
  30. 		{
  31. 			_init();
  32. 			SetData(tmp.data(), tmp.data_size);
  33. 		}
  34. 		CBuffer & operator=(CBuffer const & tmp)
  35. 		{
  36. 			_init();
  37. 			SetData(tmp.data(), tmp.data_size);
  38. 			return *this;
  39. 		}
  40. 		~CBuffer()
  41. 		{
  42. 			//cout << "~CBuffer " << name <<" "<<(long)p<<" "<< buffer_size<<" "<<data_size << endl;
  43. 			if (p)delete[]p;
  44. 			data_size = 0;
  45. 			buffer_size = 0;
  46. 			p = NULL;
  47. 		}
  48. 		size_t capacity()const { return buffer_size; }
  49. 		size_t size()const { return data_size; }
  50. 		unsigned char const * data()const { return p; }
  51. 		unsigned char* lockBuffer()
  52. 		{
  53. 			bLockBuffer = true;
  54. 			return p;
  55. 		}
  56. 		void releaseBuffer() { bLockBuffer = false; }
  57. 		void setSize(long s)
  58. 		{
  59. 			reserve(s);
  60. 			p[s] = '\0';
  61. 			data_size = s;
  62. 		}
  63. 		bool reserve(size_t n)
  64. 		{
  65. 			if (n > buffer_size)
  66. 			{
  67. 				if (bLockBuffer)
  68. 				{
  69. 					cout << "缓冲区已锁定" << endl;
  70. 					throw "缓冲区已锁定";
  71. 				}
  72. 				//cout << name << " "<< "reserve "  << (long)p << " " << buffer_size << " " << data_size << endl;
  73. 				//cout << name<<"需要扩展 " << buffer_size << " -> " << n << endl;
  74. 				unsigned char * p2 = new unsigned char[n + 1];
  75. 				if (p2)
  76. 				{
  77. 					if (p)
  78. 					{
  79. 						memmove(p2, p, data_size);
  80. 						delete[]p;
  81. 					}
  82. 					buffer_size = n;
  83. 					p2[data_size] = '\0';
  84. 					p = p2;
  85. 					//cout << name<< "扩展成功 " << buffer_size << " -> " << n << endl;
  86. 					return true;
  87. 				}
  88. 				else
  89. 				{
  90. 					//cout << name<<"扩展失败 " << buffer_size << " -> " << n << endl;
  91. 					return false;
  92. 				}
  93. 			}
  94. 			return true;
  95. 		}
  96. 		bool AddData(void const * data, long len)
  97. 		{
  98. 			if (!reserve(data_size + len))return false;
  99. 			memmove(p + data_size, data, len);
  100. 			setSize(data_size + len);
  101. 			return true;
  102. 		}
  103. 		bool SetData(char const * sz)
  104. 		{
  105. 			setSize(0);
  106. 			return AddData((void *)sz, strlen(sz));
  107. 		}
  108. 		bool SetData(unsigned char const* sz, long len)
  109. 		{
  110. 			return SetData((char const*)sz,len);
  111. 		}
  112. 		bool SetData(char const* sz, long len)
  113. 		{
  114. 			setSize(0);
  115. 			return AddData((void *)sz, len);
  116. 		}
  117. 		bool Compare(CBuffer const & tmp)const
  118. 		{
  119. 			if (data_size != tmp.data_size)return false;
  120. 			if (data_size > 0)return 0 == memcmp(tmp.data(), data(), data_size);
  121. 			else return true;
  122. 		}
  123. 	};

        CBase64是Base64编码，代码如下：

  1. 	class CBase64
  2. 	{
  3. 	public:
  4. 		static int Base64Enc(unsigned char *buf, unsigned char const *text,int size)
  5. 		{ 
  6. 			static unsigned char const * base64_encoding = (unsigned char const*)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  7. 			int buflen = 0; 
  8.  
  9. 			while(size>0)
  10. 			{
  11. 				*buf++ = base64_encoding[ (text[0] >> 2 ) & 0x3f];
  12. 				if(size>2)
  13. 				{
  14. 					*buf++ = base64_encoding[((text[0] & 3) << 4) | (text[1] >> 4)];
  15. 					*buf++ = base64_encoding[((text[1] & 0xF) << 2) | (text[2] >> 6)];
  16. 					*buf++ = base64_encoding[text[2] & 0x3F];
  17. 				}
  18. 				else
  19. 				{
  20. 					switch(size)
  21. 					{
  22. 					case 1:
  23. 						*buf++ = base64_encoding[(text[0] & 3L) << 4L ];
  24. 						*buf++ = '=';
  25. 						*buf++ = '=';
  26. 						break;
  27. 					case 2: 
  28. 						*buf++ = base64_encoding[((text[0] & 3) << 4) | (text[1] >> 4)]; 
  29. 						*buf++ = base64_encoding[((text[1] & 0x0F) << 2) | (text[2] >> 6)]; 
  30. 						*buf++ = '='; 
  31. 						break; 
  32. 					} 
  33. 				} 
  34.  
  35. 				text +=3; 
  36. 				size -=3; 
  37. 				buflen +=4;
  38. 			} 
  39.  
  40. 			*buf = 0;
  41. 			return buflen; 
  42. 		} 
  43.  
  44. 		//base64解码的实现
  45.  
  46. 		static unsigned char GetBase64Value(unsigned char ch)
  47. 		{
  48. 			if ((ch >= 'A') && (ch <= 'Z')) 
  49. 				return ch - 'A'; 
  50. 			if ((ch >= 'a') && (ch <= 'z')) 
  51. 				return ch - 'a' + 26; 
  52. 			if ((ch >= '0') && (ch <= '9')) 
  53. 				return ch - '0' + 52; 
  54. 			switch (ch) 
  55. 			{ 
  56. 			case '+': 
  57. 				return 62; 
  58. 			case '/': 
  59. 				return 63; 
  60. 			case '=': /* base64 padding */ 
  61. 				return 0; 
  62. 			default: 
  63. 				return 0; 
  64. 			} 
  65. 		}
  66.  
  67. 		//进行base64解码输入应该是4的倍数(根据mime标准)
  68. 		//如果不是4倍数返回错误
  69. 		//注意 如果是最后一个字符 那么长度不准备 可能会多1 
  70. 		//返回buf长度
  71. 		static int Base64Dec(unsigned char *buf, unsigned char const *text,int size)
  72. 		{
  73. 			if(size%4)
  74. 				return -1;
  75. 			unsigned char chunk[4];
  76. 			int parsenum=0;
  77.  
  78. 			while(size>0)
  79. 			{
  80. 				chunk[0] = GetBase64Value(text[0]); 
  81. 				chunk[1] = GetBase64Value(text[1]); 
  82. 				chunk[2] = GetBase64Value(text[2]); 
  83. 				chunk[3] = GetBase64Value(text[3]); 
  84.  
  85. 				*buf++ = (chunk[0] << 2) | (chunk[1] >> 4); 
  86. 				*buf++ = (chunk[1] << 4) | (chunk[2] >> 2); 
  87. 				*buf++ = (chunk[2] << 6) | (chunk[3]);
  88.  
  89. 				text+=4;
  90. 				size-=4;
  91. 				parsenum+=3;
  92. 			}
  93.  
  94. 			buf[parsenum]='\0';
  95. 			return parsenum;
  96. 		} 
  97. 	};

5 openSSL的AES用法

5.1 设置KEY

        加密解密的密钥存储为AES_KEY，需要通过AES_set_encrypt_key或AES_set_decrypt_key来设置：

  1. 	static int aes_encrypt(unsigned char const* userpasswd, int userpasswd_len, vector<unsigned char> const& in_plain, vector<unsigned char>& out_ciphertext, IV& iv)
  2. 	{
  3. 		out_ciphertext.clear();
  4. 		unsigned char userkey[32];//必须是16/24/32
  5. 		memset((void*)userkey, '\0', 32);
  6. 		memcpy(userkey, userpasswd, (userpasswd_len > 32 ? 32 : userpasswd_len));
  7. 		/*设置加密key及密钥长度*/
  8. 		AES_KEY key;
  9. 		if (AES_set_encrypt_key(userkey, 32 * 8, &key) < 0)
  10. 		{
  11. 			return __LINE__;
  12. 		}
  13. 。。。。。。

         注意加密和解密的函数是不一样的。

5.2 加密解密AES_encrypt/AES_decrypt

        这两个函数非常简单，参数只有输入、输出、KEY，简单明了。

（这里是文档结束）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/422737
推荐阅读
相关标签

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

  

闽ICP备14008679号