银行安全传输平台（五）OpenSSL设置和RSA模块

---

前言

为了实现密钥的互换，我们必要将协商好的对称加密密钥利用RSA加密传输，这里我们就要用到OpenSSL库，因为博主本身在校期间已经花了很大一部分时间在学密码，以是本篇条记就不再详细报告RSA或者哈希函数背后的数论知识，只简单介绍接口，封装好我们所要用的模块即可。

---

一、OpenSSL

OpenSSL 是一个安全套接字层密码库，席卷重要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用步伐供测试或其它目的利用。
1.1 设置OpenSSL

因为这个项目重要实在Linux上运行，以是我重要记载Linux下怎样设置，Windows稍微麻烦一点，感兴趣的可以自己相识一下。
安装包下载地址：https://www.openssl.org/source/
这里我以openssl-3.0.13为例
首先解压缩：

1. $ tar zxvf openssl-3.0.13.tar.gzip
2. # 加压完成得到目录: openssl-3.0.13

复制代码

然后进入解压目录openssl-3.0.13，安装：

1. $ ./config
2. $ make
3. $ make test                
4. $ make install         (使用管理员权限)

复制代码

然后验证是否安装乐成：

1. openssl version -a

复制代码

如果安装乐成应该会输出版本号
二、密码学基础

这里我们简单记载一下密码学的一些基础概念，以理解这些东西在整个加密通信过程中做了些什么。
加密三要素、对称加密非对称加密这些概念不再介绍，重要理解对称加密效率高非对称加密效率低和几种常用的加密方式，我们在这个项目中，用rsa来进行密钥互换，用aes进行加密通信即可。
接下来我们重要介绍秘钥互换、数字前面、消息认证码、哈希算法等知识。
2.1 秘钥互换

假设我们有两个要通信的两边客户端c和服务端s
非对称加密秘钥分发方便, 但是效率低 -> 改进: 必要利用对称加密；
利用对称加密 -> 秘钥分发困难 -> 改进: 利用非对称加密进行秘钥分发。

• 分发是对称加密的秘钥, 本质就是一个字符串
  
  
  • 在服务器端天生一个非对称加密的密钥对: 公钥, 私钥
    
  • 服务器将公钥发送给客户端, 客户端有了公钥
    
  • 在客户端天生一个随机字符串 -> 这就是对称加密必要利用的秘钥
    
  • 在客户端利用公钥对天生的对称加密的秘钥进行加密 -> 密文
    
  • 将加密的密文发送给服务器
    
  • 服务器端利用私钥解密 -> 对称加密的秘钥
    
  • 两边利用同一秘钥进行对称加密通信
    
  
  

2.2 哈希算法

简单说，不管原始数据多长，经过哈希算法计算，得到固定长度的数据，一个安全的哈希算法应该是抗碰撞的（很难找到两个数据对应到同一个数据），以是可以用来将进行勾走消息认证码HMAC。
一定要注意的是哈希算法不是加密算法。
2.3 消息认证码

重要作用是用来查验数据是否被篡改
(原始数据 + 秘钥) * 哈希函数 = 消息认证码
发送方将原始数据和消息认证码加密之后发送出去，接收方解密之后用同样的算法对原始数据进行哈希看看是否匹配，匹配则阐明没有被篡改，否则阐明被篡改了。
2.4 数字署名

用私钥署名公钥验证，一个安全的署名算法应该还要加上消息认证码，重要作用是验证发送者的身份，证明发送者是发送者。
三、封装密码学接口

关于openssl的api这里不再介绍，我们直接来看怎样封装我们所要用到的接口。
首先照旧要阐明的是这里面有一个base64编码的用法我们留到下一篇条记表明
3.1 RsaCrypto.h

1. #pragma once
2. #include <string>
3. #include <openssl/rsa.h>
4. #include <openssl/pem.h>
6. using namespace std;
8. enum SignLevel
9. {
10.         Level1 = NID_md5,
11.         Level2 = NID_sha1,
12.         Level3 = NID_sha224,
13.         Level4 = NID_sha256,
14.         Level5 = NID_sha384,
15.         Level6 = NID_sha512
16. };
18. class RsaCrypto
19. {
20. public:
21.         RsaCrypto();
22.         RsaCrypto(string fileName, bool isPrivate = true);
23.         ~RsaCrypto();
25.         // 通过解析字符串得到秘钥
26.         void parseKeyString(string keystr, bool pubKey = true);
27.         // 生成RSA密钥对
28.         void generateRsakey(int bits, string pub = "public.pem", string pri = "private.pem");
29.         // 公钥加密
30.         string rsaPubKeyEncrypt(string data);
31.         // 私钥解密
32.         string rsaPriKeyDecrypt(string encData);
33.         // 使用RSA签名
34.         string rsaSign(string data, SignLevel level = Level3);
35.         // 使用RSA验证签名
36.         bool rsaVerify(string data, string signData, SignLevel level = Level3);
38.         // base64编码
39. private:
40.         string toBase64(const char* str, int len);
41.         // base64解码
42.         char* fromBase64(string str);
43.         // 得到公钥
44.         bool initPublicKey(string pubfile);
45.         // 得到私钥
46.         bool initPrivateKey(string prifile);
48. private:
49.         RSA* m_publicKey;        // 私钥
50.         RSA* m_privateKey;        // 公钥
51. };

复制代码

由于c++中不建议利用宏，以是我们利用常量/枚举/内联->空间换时间，这里我们默认用sha224来进行署名和认证。
3.2 RsaCrypto.cpp

1. #include "RsaCrypto.h"
2. #include <openssl/bio.h>
3. #include <openssl/err.h>
4. #include <iostream>
5. #include <openssl/buffer.h>
6. #include <string.h>
8. RsaCrypto::RsaCrypto()
9. {
10.         m_publicKey = RSA_new();
11.         m_privateKey = RSA_new();
12. }
14. RsaCrypto::RsaCrypto(string fileName, bool isPrivate)
15. {
16.         m_publicKey = RSA_new();
17.         m_privateKey = RSA_new();
18.         if (isPrivate)
19.         {
20.                 initPrivateKey(fileName);
21.         }
22.         else
23.         {
24.                 initPublicKey(fileName);
25.         }
26. }
29. RsaCrypto::~RsaCrypto()
30. {
31.         RSA_free(m_publicKey);
32.         RSA_free(m_privateKey);
33. }
35. // 将公钥/私钥字符串数据解析到 RSA 对象中
36. void RsaCrypto::parseKeyString(string keystr, bool pubKey)
37. {
38.         // 字符串数据 -> BIO对象中
39.         BIO* bio = BIO_new_mem_buf(keystr.data(), keystr.size());
40.         // 公钥字符串
41.         if (pubKey)
42.         {
43.                 PEM_read_bio_RSAPublicKey(bio, &m_publicKey, NULL, NULL);
44.         }
45.         else
46.         {
47.                 // 私钥字符串
48.                 PEM_read_bio_RSAPrivateKey(bio, &m_privateKey, NULL, NULL);
49.         }
50.         BIO_free(bio);
51. }
53. void RsaCrypto::generateRsakey(int bits, string pub, string pri)
54. {
55.         RSA* r = RSA_new();
56.         // 生成RSA密钥对
57.         // 创建bignum对象
58.         BIGNUM* e = BN_new();
59.         // 初始化bignum对象
60.         BN_set_word(e, 456787);
61.         RSA_generate_key_ex(r, bits, e, NULL);
63.         // 创建bio文件对象
64.         BIO* pubIO = BIO_new_file(pub.data(), "w");
65.         // 公钥以pem格式写入到文件中
66.         PEM_write_bio_RSAPublicKey(pubIO, r);
67.         // 缓存中的数据刷到文件中
68.         BIO_flush(pubIO);
69.         BIO_free(pubIO);
71.         // 创建bio对象
72.         BIO* priBio = BIO_new_file(pri.data(), "w");
73.         // 私钥以pem格式写入文件中
74.         PEM_write_bio_RSAPrivateKey(priBio, r, NULL, NULL, 0, NULL, NULL);
75.         BIO_flush(priBio);
76.         BIO_free(priBio);
78.         // 得到公钥和私钥
79.         m_privateKey = RSAPrivateKey_dup(r);
80.         m_publicKey = RSAPublicKey_dup(r);
82.         // 释放资源
83.         BN_free(e);
84.         RSA_free(r);
85. }
87. bool RsaCrypto::initPublicKey(string pubfile)
88. {
89.         // 通过BIO读文件
90.         BIO* pubBio = BIO_new_file(pubfile.data(), "r");
91.         // 将bio中的pem数据读出
92.         if (PEM_read_bio_RSAPublicKey(pubBio, &m_publicKey, NULL, NULL) == NULL)
93.         {
94.                 ERR_print_errors_fp(stdout);
95.                 return false;
96.         }
97.         BIO_free(pubBio);
98.         return true;
99. }
101. bool RsaCrypto::initPrivateKey(string prifile)
102. {
103.         // 通过bio读文件
104.         BIO* priBio = BIO_new_file(prifile.data(), "r");
105.         // 将bio中的pem数据读出
106.         if (PEM_read_bio_RSAPrivateKey(priBio, &m_privateKey, NULL, NULL) == NULL)
107.         {
108.                 ERR_print_errors_fp(stdout);
109.                 return false;
110.         }
111.         BIO_free(priBio);
112.         return true;
113. }
116. string RsaCrypto::rsaPubKeyEncrypt(string data)
117. {
118.         cout << "加密数据长度: " << data.size() << endl;
119.         // 计算公钥长度
120.         int keyLen = RSA_size(m_publicKey);
121.         cout << "pubKey len: " << keyLen << endl;
122.         // 申请内存空间
123.         char* encode = new char[keyLen + 1];
124.         // 使用公钥加密
125.         int ret = RSA_public_encrypt(data.size(), (const unsigned char*)data.data(),
126.                 (unsigned char*)encode, m_publicKey, RSA_PKCS1_PADDING);
127.         string retStr = string();
128.         if (ret >= 0)
129.         {
130.                 // 加密成功
131.                 cout << "ret: " << ret << ", keyLen: " << keyLen << endl;
132.                 retStr = toBase64(encode, ret);
133.         }
134.         else
135.         {
136.                 ERR_print_errors_fp(stdout);
137.         }
138.         // 释放资源
139.         delete[]encode;
140.         return retStr;
141. }
143. string RsaCrypto::rsaPriKeyDecrypt(string encData)
144. {
145.         // text指向的内存需要释放
146.         char* text = fromBase64(encData);
147.         // 计算私钥长度
148.         //cout << "解密数据长度: " << text.size() << endl;
149.         int keyLen = RSA_size(m_privateKey);
150.         // 使用私钥解密
151.         char* decode = new char[keyLen + 1];
152.         // 数据加密完成之后, 密文长度 == 秘钥长度
153.         int ret = RSA_private_decrypt(keyLen, (const unsigned char*)text,
154.                 (unsigned char*)decode, m_privateKey, RSA_PKCS1_PADDING);
155.         string retStr = string();
156.         if (ret >= 0)
157.         {
158.                 retStr = string(decode, ret);
159.         }
160.         else
161.         {
162.                 cout << "私钥解密失败..." << endl;
163.                 ERR_print_errors_fp(stdout);
164.         }
165.         delete[]decode;
166.         delete[]text;
167.         return retStr;
168. }
170. string RsaCrypto::rsaSign(string data, SignLevel level)
171. {
172.         unsigned int len;
173.         char* signBuf = new char[1024];
174.         memset(signBuf, 0, 1024);
175.         int ret = RSA_sign(level, (const unsigned char*)data.data(), data.size(), (unsigned char*)signBuf,
176.                 &len, m_privateKey);
177.         if (ret == -1)
178.         {
179.                 ERR_print_errors_fp(stdout);
180.         }
181.         cout << "sign len: " << len << ", ret: " << ret << endl;
182.         string retStr = toBase64(signBuf, len);
183.         delete[]signBuf;
184.         return retStr;
185. }
187. bool RsaCrypto::rsaVerify(string data, string signData, SignLevel level)
188. {
189.         // 验证签名
190.         int keyLen = RSA_size(m_publicKey);
191.         char* sign = fromBase64(signData);
192.         int ret = RSA_verify(level, (const unsigned char*)data.data(), data.size(),
193.                 (const unsigned char*)sign, keyLen, m_publicKey);
194.         delete[]sign;
195.         if (ret == -1)
196.         {
197.                 ERR_print_errors_fp(stdout);
198.         }
199.         if (ret != 1)
200.         {
201.                 return false;
202.         }
203.         return true;
204. }
205. string RsaCrypto::toBase64(const char* str, int len)
206. {
207.         BIO* mem = BIO_new(BIO_s_mem());
208.         BIO* bs64 = BIO_new(BIO_f_base64());
209.         // mem添加到bs64中
210.         bs64 = BIO_push(bs64, mem);
211.         // 写数据
212.         BIO_write(bs64, str, len);
213.         BIO_flush(bs64);
214.         // 得到内存对象指针
215.         BUF_MEM *memPtr;
216.         BIO_get_mem_ptr(bs64, &memPtr);
217.         string retStr = string(memPtr->data, memPtr->length - 1);
218.         BIO_free_all(bs64);
219.         return retStr;
220. }
222. char* RsaCrypto::fromBase64(string str)
223. {
224.         int length = str.size();
225.         BIO* bs64 = BIO_new(BIO_f_base64());
226.         BIO* mem = BIO_new_mem_buf(str.data(), length);
227.         BIO_push(bs64, mem);
228.         char* buffer = new char[length];
229.         memset(buffer, 0, length);
230.         BIO_read(bs64, buffer, length);
231.         BIO_free_all(bs64);
233.         return buffer;
234. }

复制代码

要想表明清晰这个模块，照旧要介绍一下里面一些比较陌生的api，如下：

1. #include <openssl/rsa.h>
2. // 申请一块内存, 存储了公钥和私钥
3. // 如果想得到RSA类型变量必须使用 RSA_new();
4. RSA *RSA_new(void);
5. void RSA_free(RSA *);
7. BIGNUM* BN_new(void);
8. void BN_free(BIGNUM*);
9. // 生成密钥对, 密钥对存储在内存中
10. int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
11.         参数:
12.                 - rsa: 通过RSA_new()获得
13.                 - bits: 秘钥长度, 单位: bit, 常用的长度 1024*n (n正整数)
14.         - e: 比较大的数(5位以内)
15.             - 通过 BN_new 得到对应的变量
16.             - 初始化: BN_set_word(e, 12345);
17.                 - cb: 回调函数, 用不到, 直接写NULL
19. // rsa公钥私钥类型是一样的: RSA类型
20. // 将参数rsa中的公钥提取出来
21. RSA *RSAPublicKey_dup(RSA *rsa);
22.         - rsa参数: 秘钥信息
23.         - 返回值: rsa公钥
24. // 将参数rsa中的私钥提取出来
25. RSA *RSAPrivateKey_dup(RSA *rsa);
26.         - rsa参数: 秘钥信息
27.         - 返回值: rsa私钥
29. // 创建bio对象
30. // 密钥对写磁盘文件的时候, 需要编码 -> base64
31. // 封装了fopen
32. BIO *BIO_new_file(const char *filename, const char *mode);
33.         参数:
34.                 - filename: 文件名
35.                 - mode: 文件打开方式和fopen打开方式的指定相同
36.                
37. int PEM_write_bio_RSAPublicKey(BIO* bp, const RSA* r);
38. int PEM_write_bio_RSAPrivateKey(BIO* bp, const RSA* r, const EVP_CIPHER* enc,
39.         unsigned char* kstr, int klen, pem_password_cb *cb, void* u);
40. RSA* PEM_read_bio_RSAPublicKey(BIO* bp, RSA** r, pem_password_cb *cb, void* u);
41. RSA* PEM_read_bio_RSAPrivateKey(BIO* bp, RSA** r, pem_password_cb *cb, void* u);
42.         参数:
43.                 - bp: 通过BIO_new_file();函数得到该对象
44.                 - r: 传递一个RSA* rsa指针的地址, 传出参数-> 公钥/私钥
45.                 - cb: 回调函数, 用不到, 指定为NULL
46.                 - u: 给回调传参, 用不到, 指定为NULL
48. //
49. //
50. RSA* PEM_read_RSAPublicKey(FILE* fp, RSA** r, pem_password_cb *cb, void* u);
51. RSA* PEM_read_RSAPrivateKey(FILE* fp, RSA** r, pem_password_cb *cb, void* u);
53. // 写入文件中的公钥私钥数据不是原始数据, 写入的编码之后的数据
54. // 是一种pem的文件格式, 数据使用base64进行编码
55. int PEM_write_RSAPublicKey(FILE* fp, const RSA* r);
56. int PEM_write_RSAPrivateKey(FILE* fp, const RSA* r, const EVP_CIPHER* enc,
57.         unsigned char* kstr, int klen, pem_password_cb *cb, void* u);       
58.         参数:
59.                 - fp: 需要打开一个磁盘文件, 并且指定写权限
60.                 - r: 存储了密钥对
61.                  - 私钥独有的参数
62.                 - enc: 指定的加密算法 -> 对称加密 -> NULL
63.                 - kstr: 对称加密的秘钥 -> NULL
64.                 - klen: 秘钥长度 -> 0
65.                 - cb: 回调函数, 用不到, NULL
66.                 - u: 给回调传参, 用不到, NULL

复制代码

以是整个代码块看下来重要完成了这几个任务：天生密钥对、公钥加密、私钥解密、数据署名、验证署名。至于toBase64和fromBase64就是为相识决我们的加密后的密钥在传输过程中解决的一些问题，这都是后话了，以是团体来看，这段代码可以抽象至如下表示：

1. class MyRSA
2. {
3. public:
4.     MyRSA();
5.     ~MyRSA;
6.     // 生成密钥对
7.     // 公钥加密
8.     // 私钥解密
9.     // 数据签名
10.     // 验证签名
11. private:
12.     RSA* pubkey;
13.     RSA* pirKey;
14. }

复制代码

---

四、关于hsah模块的阐明

我们在这个项目中其实还封装了一个hash模块来调用，不过那是到最后封装外联接口支持网点之间直接用aes加解密的情况了，以是我们也是放到之后在做记载。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。