OpenSSL RSA加密实战：C++在Windows下的密钥生成、分段加密与避坑指南

简介：这是一份面向Windows平台C++开发者的OpenSSL RSA加密解密实战源码，针对网上多数示例仅适配Linux、代码老旧且内容残缺导致难以调试的问题，提供可直接运行的完整工程。资源包共12个文件，约450KB，包含cpp与h源码文件、cbp工程配置、layout布局文件、exe可执行程序及o目标文件等，覆盖从工程配置到编译产物的完整链路，使用Code::Blocks即可打开调试。内容围绕RSA非对称加密解密流程展开，涉及大整数运算、Base64编解码等关键模块，适合正在学习密码学应用、需要在Windows下集成OpenSSL的初中级开发者参考。目前已有2929人学习下载，读者可借此快速搭建可运行的RSA加解密环境，理解密钥生成、加解密调用与编码转换的完整实现思路，减少在环境配置与老旧代码兼容上耗费的时间。

1. RSA 加密：为什么 2048 位密钥撑起了整个信任链

很多人第一次写 RSA 加密代码时都会有一个错觉：以为调用一个RSA_public_encrypt就完事了，结果编译报错、链接失败、运行崩溃三连击。更反直觉的是，RSA 本身其实只能加密比密钥长度短得多的数据——2048 位密钥最多只能直接加密 245 字节。那问题来了：我们平时用 HTTPS 传输的网页、图片、视频，动辄几 MB，RSA 到底是怎么撑起整个信任链的？

答案藏在「混合加密」这四个字里。RSA 真正的作用不是加密数据本身，而是加密一个对称密钥，然后用这个对称密钥去加密真正的数据。理解了这一点，你才能明白为什么 OpenSSL 的 RSA 接口设计成现在这个样子，为什么 padding 模式选错会直接导致解密失败，为什么 Windows 上编译 OpenSSL 会让人抓狂。这篇内容就围绕 C++ 在 Windows 环境下通过 OpenSSL 实现 RSA 加密解密这条主线，把底层机制、源码实现和踩坑经验一次讲透。

2. RSA 的数学骨架：从密钥生成到加解密到底发生了什么

2.1 密钥对是怎么「算」出来的

RSA 的安全性建立在一个数学事实上：把两个大质数乘起来很容易，但把乘积分解回两个质数极其困难。密钥生成的核心流程是这样的：

第一步，随机选取两个大质数 p 和 q。OpenSSL 内部用的是 BN_generate_prime_ex 系列函数，底层依赖 Miller-Rabin 素性检测。第二步，计算 n = p × q，这个 n 就是模数，它的二进制位数就是常说的「密钥长度」。第三步，计算欧拉函数 φ(n) = (p-1)(q-1)。第四步，选取一个整数 e，通常取 65537，满足 1 < e < φ(n) 且 gcd(e, φ(n)) = 1。第五步，计算 d = e⁻¹ mod φ(n)，也就是 e 关于 φ(n) 的模逆元。

最终公钥是 (n, e)，私钥是 (n, d)。加密时计算 c = m^e mod n，解密时计算 m = c^d mod n。整个过程的正确性由欧拉定理保证。

这里有一个容易被忽略的细节：实际存储的私钥不只有 d，还包含 p、q、d mod (p-1)、d mod (q-1)、q⁻¹ mod p 这几个参数。它们的作用是加速解密——用中国剩余定理可以把解密速度提升大约 4 倍。OpenSSL 的 RSA 结构体会把这些全部存下来，所以你会看到导出的私钥文件比公钥文件大不少。

2.2 Padding：为什么不能直接拿 RSA 加密明文

如果直接对明文做 m^e mod n，会面临几个致命问题。第一，同样的明文每次加密结果都一样，攻击者可以通过比对密文推断内容。第二，如果明文很小，m^e 可能小于 n，那直接开 e 次方就还原了。第三，攻击者可以构造特定密文来探测私钥信息。

所以实际使用中必须加 padding。OpenSSL 支持的主要 padding 模式有：

PKCS#1 v1.5 填充的格式是：0x00 || 0x02 || 随机非零字节 || 0x00 || 明文。解密时按这个格式解析，如果格式不对就报错。这就是为什么 padding 选错一定解密失败——格式对不上。

OAEP 填充则更复杂，它用两次哈希运算构造出一个几乎不可能被伪造的填充结构。代价是同样密钥长度下能加密的数据更短：2048 位密钥用 PKCS#1 v1.5 最多加密 245 字节，用 OAEP（SHA-256）只能加密 190 字节。

2.3 一次完整的加解密时序

把上面的流程串起来，一次 RSA 加解密的完整时序是这样的：

1. 接收方生成密钥对，私钥自己保留，公钥发给发送方
2. 发送方拿到公钥，用公钥对数据（或对称密钥）做加密
3. 密文通过网络传输到接收方
4. 接收方用私钥解密，拿到原始数据

在 OpenSSL 的 C++ 实现中，这个时序对应到具体的 API 调用链是：RSA_generate_key_ex→PEM_write_bio_RSAPublicKey/PEM_write_bio_RSAPrivateKey→PEM_read_bio_RSAPublicKey/PEM_read_bio_RSAPrivateKey→RSA_public_encrypt→RSA_private_decrypt。

每一步都有对应的错误处理分支，漏掉任何一个都可能导致内存泄漏或者解密失败。后面会具体展开。

3. OpenSSL 的 RSA 实现：源码级拆解与 C++ 封装

3.1 RSA 结构体里到底存了什么

OpenSSL 1.1.1 之后，RSA 结构体变成了不透明类型，你不能直接访问内部字段，必须通过RSA_get0_key、RSA_get0_factors、RSA_get0_crt_params这些函数来读取。这个设计是为了防止开发者直接操作内部字段导致状态不一致。

结构体内部大致包含这些关键字段：

struct rsa_st { int version; // 版本号 BIGNUM *n; // 模数 BIGNUM *e; // 公钥指数 BIGNUM *d; // 私钥指数 BIGNUM *p, *q; // 两个大质数 BIGNUM *dmp1, *dmq1; // d mod (p-1), d mod (q-1) BIGNUM *iqmp; // q^-1 mod p int flags; // 标志位 // ... 省略其他字段 };

BIGNUM 是 OpenSSL 的大数结构，内部用数组存储任意精度的整数。所有 RSA 运算本质上都是 BIGNUM 上的模幂运算。BN_mod_exp是核心函数，它内部会根据指数大小和模数特性选择不同的算法——比如指数很小的时候用平方-乘法，指数很大的时候用滑动窗口法。

3.2 密钥生成与 PEM 读写

下面这段代码展示了完整的密钥生成和 PEM 格式读写流程：

#include <openssl/rsa.h> #include <openssl/pem.h> #include <openssl/bn.h> #include <openssl/err.h> #include <cstdio> // 生成 RSA 密钥对并写入文件 bool GenerateRSAKey(const char* pubPath, const char* priPath, int bits) { RSA* rsa = RSA_new(); BIGNUM* e = BN_new(); BN_set_word(e, RSA_F4); // RSA_F4 = 65537 // 生成密钥，bits 通常取 2048 或 4096 if (RSA_generate_key_ex(rsa, bits, e, nullptr) != 1) { ERR_print_errors_fp(stderr); BN_free(e); RSA_free(rsa); return false; } // 写公钥 FILE* fp = fopen(pubPath, "wb"); if (!fp) { BN_free(e); RSA_free(rsa); return false; } PEM_write_RSAPublicKey(fp, rsa); fclose(fp); // 写私钥 fp = fopen(priPath, "wb"); if (!fp) { BN_free(e); RSA_free(rsa); return false; } PEM_write_RSAPrivateKey(fp, rsa, nullptr, nullptr, 0, nullptr, nullptr); fclose(fp); BN_free(e); RSA_free(rsa); return true; }

RSA_F4就是 65537，选它是因为二进制表示只有两个 1，模幂运算快，而且足够大不会被小指数攻击。RSA_generate_key_ex的第四个参数是回调函数，一般传 nullptr 就行。

PEM 格式本质上是 DER 编码再做 Base64，外面包上-----BEGIN XXX-----和-----END XXX-----。公钥文件头是BEGIN RSA PUBLIC KEY，私钥是BEGIN RSA PRIVATE KEY。注意 PKCS#8 格式的私钥头是BEGIN PRIVATE KEY，两者不通用，读的时候要用对应的函数。

3.3 加密解密的完整实现

#include <openssl/rsa.h> #include <openssl/pem.h> #include <vector> #include <cstring> // 公钥加密 std::vector<unsigned char> RSAEncrypt(const std::string& plain, const char* pubPath) { FILE* fp = fopen(pubPath, "rb"); if (!fp) return {}; RSA* rsa = PEM_read_RSAPublicKey(fp, nullptr, nullptr, nullptr); fclose(fp); if (!rsa) return {}; int rsaLen = RSA_size(rsa); // 密钥字节数，2048位=256字节 std::vector<unsigned char> cipher(rsaLen); int ret = RSA_public_encrypt( plain.size(), reinterpret_cast<const unsigned char*>(plain.data()), cipher.data(), rsa, RSA_PKCS1_PADDING // 填充模式 ); RSA_free(rsa); if (ret < 0) { ERR_print_errors_fp(stderr); return {}; } cipher.resize(ret); return cipher; } // 私钥解密 std::string RSADecrypt(const std::vector<unsigned char>& cipher, const char* priPath) { FILE* fp = fopen(priPath, "rb"); if (!fp) return ""; RSA* rsa = PEM_read_RSAPrivateKey(fp, nullptr, nullptr, nullptr); fclose(fp); if (!rsa) return ""; int rsaLen = RSA_size(rsa); std::vector<unsigned char> plain(rsaLen); int ret = RSA_private_decrypt( cipher.size(), cipher.data(), plain.data(), rsa, RSA_PKCS1_PADDING ); RSA_free(rsa); if (ret < 0) { ERR_print_errors_fp(stderr); return ""; } return std::string(reinterpret_cast<char*>(plain.data()), ret); }

RSA_size返回的是密钥模数的字节数，2048 位密钥返回 256。加密时输出缓冲区必须至少这么大，否则会缓冲区溢出。RSA_public_encrypt的返回值是实际密文长度，正常情况下等于RSA_size。

解密时输出缓冲区同样要RSA_size大小，返回值是实际明文长度。如果返回 -1，说明解密失败——最常见的原因就是 padding 不匹配或者密钥不对。

3.4 分段加密：突破 245 字节的限制

前面提到 2048 位密钥用 PKCS#1 padding 最多加密 245 字节。如果要加密更长的数据，有两个方案：一是用混合加密（RSA 加密对称密钥，对称密钥加密数据），二是分段加密。

分段加密的思路很简单：把数据按 245 字节切块，每块单独加密，解密时再拼起来。但要注意每块加密后都是 256 字节，所以密文总长度是块数 × 256。

std::vector<unsigned char> RSAEncryptLong(const std::string& plain, const char* pubPath) { FILE* fp = fopen(pubPath, "rb"); if (!fp) return {}; RSA* rsa = PEM_read_RSAPublicKey(fp, nullptr, nullptr, nullptr); fclose(fp); if (!rsa) return {}; int rsaLen = RSA_size(rsa); int maxBlock = rsaLen - 11; // PKCS1 padding 占 11 字节 std::vector<unsigned char> result; for (size_t offset = 0; offset < plain.size(); offset += maxBlock) { int blockSize = std::min(maxBlock, static_cast<int>(plain.size() - offset)); std::vector<unsigned char> block(rsaLen); int ret = RSA_public_encrypt( blockSize, reinterpret_cast<const unsigned char*>(plain.data() + offset), block.data(), rsa, RSA_PKCS1_PADDING); if (ret < 0) { RSA_free(rsa); return {}; } result.insert(result.end(), block.begin(), block.begin() + ret); } RSA_free(rsa); return result; }

rsaLen - 11里的 11 是 PKCS#1 v1.5 填充的固定开销：至少 8 字节随机数 + 3 字节格式标记。如果换成 OAEP 填充，开销会更大，具体取决于哈希算法。

分段加密虽然能解决问题，但性能很差——每块都要做一次完整的模幂运算。实际项目中更推荐混合加密方案。

4. Windows 平台避坑：编译、链接与运行时排查

4.1 找不到头文件或链接失败

现象：编译时报cannot open include file: 'openssl/rsa.h'，或者链接时报unresolved external symbol RSA_public_encrypt。

原因：OpenSSL 在 Windows 上不是系统自带的，需要手动安装或编译。而且它的库文件名在不同版本和不同编译方式下不一样。

解决：推荐用 vcpkg 安装，执行vcpkg install openssl:x64-windows，然后在项目里集成 vcpkg。如果手动配置，需要把 include 目录加到附加包含目录，把 lib 目录加到附加库目录，并在链接器输入里加上libssl.lib和libcrypto.lib。注意 Debug 和 Release 版本的库不能混用，否则会出现运行时崩溃。

4.2 运行时崩溃在 RSA_free

现象：程序在调用RSA_free时崩溃，或者出现堆损坏的错误。

原因：通常是因为跨模块分配和释放内存。比如在 DLL 里创建了 RSA 对象，在主程序里释放，两边的 CRT 堆不一致。

解决：确保 RSA 对象的创建和释放发生在同一个模块内。如果确实需要跨模块传递，封装一层接口，在 DLL 内部提供释放函数。另外，OpenSSL 1.1.0 之后很多结构体变成了不透明类型，不能再直接用free()释放，必须用对应的RSA_free。

4.3 解密返回 -1 但不知道原因

现象：RSA_private_decrypt返回 -1，但不知道具体哪里出了问题。

原因：OpenSSL 的错误信息不会自动打印，需要主动调用错误处理函数。

解决：在每次 RSA 操作失败后调用ERR_print_errors_fp(stderr)或者用ERR_get_error()获取错误码。常见的错误码有RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE（数据太长）、RSA_R_DECRYPTION_FAILED（解密失败，通常是 padding 问题）。另外注意，如果密文被篡改过，解密也会失败，这是 RSA 的安全特性，不是 bug。

4.4 中文乱码问题

现象：加密中文后解密出来是乱码。

原因：std::string存储的是字节序列，如果源文件编码和运行时编码不一致，中文字符的字节表示会不同。

解决：统一用 UTF-8 编码。在 Windows 上，Visual Studio 默认用 GBK 编码保存源文件，需要在项目属性里把「源字符集」设为 UTF-8，或者在文件开头加#pragma execution_character_set("utf-8")。加密前确认明文的字节序列是正确的，解密后按同样的编码解析。

4.5 密钥格式不匹配

现象：PEM_read_RSAPublicKey返回 nullptr，但文件确实存在且内容看起来正常。

原因：公钥文件可能是 PKCS#8 格式（头是BEGIN PUBLIC KEY），而不是 PKCS#1 格式（头是BEGIN RSA PUBLIC KEY）。这两个函数不通用。

解决：PKCS#1 用PEM_read_RSAPublicKey，PKCS#8 用PEM_read_bio_PUBKEY然后EVP_PKEY_get1_RSA。或者用命令行工具转换：openssl rsa -pubin -in pkcs8.pem -RSAPublicKey_out -out pkcs1.pem。私钥同理，PKCS#1 是BEGIN RSA PRIVATE KEY，PKCS#8 是BEGIN PRIVATE KEY。

5. 设计取舍：为什么 OpenSSL 的 API 长成这样

5.1 不透明类型与 EVP 抽象层

OpenSSL 1.1.0 把 RSA、DSA、EC 等结构体全部改成了不透明类型，强制开发者通过函数访问。这个改动在当时引起了不小的迁移成本，但回头看是必要的——之前太多人直接操作内部字段，导致 OpenSSL 升级时大量代码崩溃。

更上层的抽象是 EVP 接口。EVP_PKEY 可以代表任意类型的密钥，EVP_PKEY_encrypt和EVP_PKEY_decrypt可以统一处理 RSA、EC 等算法。如果你的项目以后可能换算法，直接用 EVP 接口比直接用 RSA 接口更合适。代价是 EVP 接口的参数更多、初始化步骤更繁琐。

5.2 内存管理：谁分配谁释放

OpenSSL 的内存管理原则很简单：谁创建谁释放。RSA_new创建的用RSA_free释放，BN_new创建的用BN_free释放，BIO_new创建的用BIO_free释放。混用或者漏掉都会导致内存泄漏。

在 C++ 里更推荐用 RAII 封装，比如用std::unique_ptr配合自定义 deleter：

struct RSADeleter { void operator()(RSA* rsa) const { RSA_free(rsa); } }; using RSAPtr = std::unique_ptr<RSA, RSADeleter>; RSAPtr rsa(RSA_new()); // 不需要手动 RSA_free，离开作用域自动释放

这样即使中间抛异常，资源也能正确释放。我一般会在项目里把所有 OpenSSL 资源都做一层 RAII 封装，能省掉大量排查内存泄漏的时间。

5.3 性能与安全的平衡

RSA 的性能瓶颈在模幂运算。2048 位密钥做一次私钥解密大约需要 1-5 毫秒（取决于 CPU），公钥加密快得多，大约 0.1 毫秒。4096 位密钥的解密时间大约是 2048 位的 6-8 倍。

如果业务场景需要频繁加解密，纯 RSA 方案基本不可行。正确的做法是用 RSA 加密一个 AES 密钥，然后用 AES 加密数据。AES 的吞吐量比 RSA 高好几个数量级，而且密钥可以每次会话重新生成。

另一个取舍是密钥长度。2048 位目前是安全底线，4096 位更安全但更慢。如果系统生命周期超过 2030 年，建议直接上 4096 位。如果只是内部系统短期使用，2048 位足够。

5.4 验证你的实现是否正确

写完加密解密代码后，不要只测「加密再解密等于原文」这一条路径。至少还要验证这几个场景：用错误的私钥解密应该失败；篡改密文后解密应该失败；加密超过长度限制的数据应该报错而不是崩溃；空字符串加密解密应该正常返回空。

可以用 OpenSSL 命令行做交叉验证：用你的代码加密，用openssl rsautl -decrypt解密；反过来用命令行加密，用你的代码解密。两边结果一致，才能说明实现是对的。

从那以后我每次写加密相关代码，都会先用命令行工具跑一遍标准流程，确认密钥格式和 padding 模式匹配之后，再写 C++ 代码。这个习惯帮我省掉了无数次「代码没问题但就是解不开」的排查时间。希望帮到你。

本文还有配套的精品资源，点击获取