C语言调用OpenSSL实现RSA加解密：从原理到实战完整指南

1. 项目概述：为什么用C和OpenSSL实现RSA？

如果你正在学习密码学、网络安全，或者需要在C语言项目中集成非对称加密功能，那么“基于OpenSSL的RSA加解密实现”绝对是一个绕不开的经典练手项目。RSA算法作为非对称加密的基石，从HTTPS握手到软件签名，应用无处不在。而OpenSSL，这个开源密码学工具库的“瑞士军刀”，提供了稳定、高效的底层实现。将两者结合，用C语言手动调用OpenSSL的API完成密钥生成、加密、解密这一完整流程，不仅能让你深刻理解RSA“公钥加密，私钥解密”的核心思想，更能让你掌握在原生C环境中处理密码学任务的实战能力。这远比你单纯调用一个现成的加密函数收获大得多。

我见过很多初学者，一提到加密就觉得是黑盒，很神秘。但当你亲手用几行C代码，看着一段明文“Hello, RSA!”变成一串看似乱码的密文，再用另一把钥匙将它完美还原时，那种对原理豁然开朗的感觉是无与伦比的。这个项目适合有一定C语言基础（熟悉指针、内存管理和文件操作）、对系统编程或信息安全感兴趣的开发者。通过它，你不仅能学会如何使用OpenSSL这个庞大的库，更能为日后理解SSL/TLS协议、实现安全通信模块打下坚实的基础。

2. 项目核心思路与OpenSSL选型考量

2.1 RSA算法原理与OpenSSL的角色

在动手写代码之前，我们必须先搞清楚RSA到底在做什么，以及OpenSSL在其中扮演了什么角色。RSA的安全性基于大数分解的难题：给你两个大质数p和q的乘积n，想反向分解出p和q是极其困难的。公钥包含(n, e)，私钥包含(n, d)。加密过程是c = m^e mod n，解密是m = c^d mod n。这里的m是明文（需要先转换为一个整数），c是密文。

我们自己从零实现RSA，包括大数运算、模幂计算、密钥生成，是非常复杂且容易出安全漏洞的。因此，OpenSSL的作用就是为我们提供这些经过严格测试、高度优化且相对安全的密码学原语实现。我们的C语言项目，本质上是成为OpenSSL库的一个“指挥者”，调用它提供的API来生成密钥、执行加密解密运算，并妥善管理这些敏感数据（密钥、密文）。

2.2 为什么选择OpenSSL而不是其他库？

这是一个很实际的问题。市面上也有其他优秀的库，如GnuTLS、mbed TLS等。选择OpenSSL主要基于以下几点考量：

1. 事实上的行业标准：OpenSSL是应用最广泛的开源TLS/SSL工具库，无数服务器、客户端软件（包括Apache、Nginx）以及操作系统都依赖它。学习它的API具有极高的实用价值和普适性。
2. 功能全面且成熟：除了RSA，它还支持AES、DES、ECC、哈希函数、数字签名、证书管理等几乎所有的现代密码学功能。通过这个项目入门后，你能更容易地扩展到其他功能。
3. 丰富的文档和社区资源：虽然其官方文档有时略显晦涩，但庞大的用户基数意味着你在遇到问题时，更容易在Stack Overflow、博客和开源代码中找到案例和解答。
4. 跨平台性：OpenSSL在Linux、Windows、macOS上都有良好的支持，我们的C代码只要链接正确的库，可以轻松移植。

注意：OpenSSL的API设计被很多人诟病不够现代，错误处理需要谨慎，内存管理需要手动进行。但这正是我们学习的好机会——它能强迫你写出更严谨、更安全的C代码。

2.3 项目整体流程设计

一个完整的、有实用价值的RSA加解密demo，应该包含以下清晰的步骤，我们的代码结构也将围绕此展开：

1. 环境准备与初始化：安装OpenSSL开发库，并在代码中初始化OpenSSL的上下文。
2. 生成RSA密钥对：在内存中生成指定长度（如2048位）的RSA密钥对，并理解其结构。
3. 密钥持久化：将生成的密钥对以PEM格式保存到磁盘文件（private.pem,public.pem）。这是关键一步，因为实际应用中密钥需要重复使用。
4. 从文件加载密钥：模拟实际场景，从保存的PEM文件中读取密钥到内存中。
5. 使用公钥加密：准备一段明文数据，使用加载的公钥对其进行加密，得到密文。
6. 使用私钥解密：使用对应的私钥对密文进行解密，验证是否能得到原始明文。
7. 资源清理：妥善释放所有分配的OpenSSL对象和内存，避免泄漏。

这个流程覆盖了从密钥生命周期管理到加解密核心操作的全过程，比一个简单的内存中加密解密函数调用要完整和实用得多。

3. 开发环境搭建与OpenSSL库配置

3.1 安装OpenSSL开发库

OpenSSL分为运行时库和开发库。我们编写程序需要的是包含头文件（.h）和链接库文件（.so或.lib）的开发包。

• 在Ubuntu/Debian系统上：

  sudo apt update sudo apt install libssl-dev

  安装后，头文件通常在/usr/include/openssl，库文件在/usr/lib/x86_64-linux-gnu。

• 在CentOS/RHEL系统上：

  sudo yum install openssl-devel

• 在macOS上（使用Homebrew）：

  brew install openssl

  注意：macOS系统自带了OpenSSL，但通常版本较旧且路径不同。使用Homebrew安装后，其路径可能在/usr/local/opt/openssl下，编译时需要指定。

• 在Windows上： 这是相对复杂的一步。你可以从OpenSSL官网下载编译好的Windows安装包（例如Win64 OpenSSL v1.1.1x Light）。安装时，务必选择“将OpenSSL DLL复制到系统目录”。安装完成后，你需要记住安装路径（如C:\OpenSSL-Win64），其中包含include和lib文件夹。后续在Visual Studio或MinGW中需要配置这些路径。

3.2 配置编译环境（以GCC和VS Code为例）

无论你使用什么编辑器，核心是让编译器能找到OpenSSL的头文件和链接器能找到库文件。

使用GCC命令行编译（Linux/macOS）： 这是最直接的方式。假设你的代码文件是rsa_demo.c。

gcc -o rsa_demo rsa_demo.c -lssl -lcrypto

-lssl -lcrypto就是告诉链接器去链接libssl和libcrypto这两个核心库。

在Visual Studio Code中配置C/C++环境： 如果你用VSCode，通常需要配置tasks.json（编译任务）和c_cpp_properties.json（智能感知）。

1. c_cpp_properties.json：确保IntelliSense能找到头文件。

   { "configurations": [ { "name": "Linux", "includePath": [ "${workspaceFolder}/**", "/usr/include/openssl" // 添加OpenSSL头文件路径 ], "defines": [], "compilerPath": "/usr/bin/gcc" } ], "version": 4 }

   在Windows上，includePath需要添加类似C:\\OpenSSL-Win64\\include的路径。

2. tasks.json：定义编译命令。

   { "tasks": [ { "type": "shell", "label": "gcc build active file", "command": "/usr/bin/gcc", "args": [ "-g", "${file}", "-o", "${fileDirname}/${fileBasenameNoExtension}", "-lssl", "-lcrypto" ], "options": { "cwd": "/usr/bin" } } ], "version": "2.0.0" }

   在Windows上使用MinGW时，command可能是C:\\MinGW\\bin\\gcc.exe，并且可能需要通过-L参数指定库路径，如-L\"C:\\OpenSSL-Win64\\lib\"。

实操心得：在Linux下开发是最顺畅的。Windows环境下，路径包含空格、库的版本（Win32 vs Win64）、动态库（DLL）的放置位置都是常见的坑。建议先在Linux虚拟机或WSL2中完成项目，再挑战Windows环境配置。

4. 核心代码实现与逐行解析

接下来，我们按照项目流程，分模块实现代码。我会对关键函数和逻辑进行详细解释。

4.1 初始化与密钥生成

任何使用OpenSSL的程序，都应该在开始和结束时调用初始化与清理函数。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <openssl/rsa.h> #include <openssl/pem.h> #include <openssl/err.h> // 生成RSA密钥对并保存到文件 int generate_rsa_keypair(const char *pub_key_file, const char *pri_key_file, int bits) { RSA *rsa = NULL; BIO *bp_public = NULL, *bp_private = NULL; int ret = 0; // 1. 生成RSA密钥对 // 使用 RSA_generate_key_ex 替代旧的 RSA_generate_key BIGNUM *bne = BN_new(); if (!BN_set_word(bne, RSA_F4)) { // RSA_F4 = 65537，常用的公钥指数e ERR_print_errors_fp(stderr); goto free_all; } rsa = RSA_new(); if (RSA_generate_key_ex(rsa, bits, bne, NULL) != 1) { ERR_print_errors_fp(stderr); goto free_all; } // 2. 将公钥保存到PEM文件 bp_public = BIO_new_file(pub_key_file, "w+"); if (PEM_write_bio_RSAPublicKey(bp_public, rsa) != 1) { ERR_print_errors_fp(stderr); goto free_all; } printf("公钥已保存至: %s\n", pub_key_file); // 3. 将私钥保存到PEM文件（不加密） bp_private = BIO_new_file(pri_key_file, "w+"); // PEM_write_bio_RSAPrivateKey 最后一个参数为NULL表示不加密私钥文件。 // 实际应用中，务必使用密码加密私钥！例如使用 AES-256-CBC 加密。 if (PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL) != 1) { ERR_print_errors_fp(stderr); goto free_all; } printf("私钥已保存至: %s\n", pri_key_file); ret = 1; // 成功标志 free_all: // 4. 释放所有资源（顺序很重要，先释放BIO，再释放RSA和BIGNUM） BIO_free_all(bp_public); BIO_free_all(bp_private); RSA_free(rsa); BN_free(bne); return ret; }

代码解析与注意事项：

1. 头文件：openssl/rsa.h包含RSA结构体和函数；openssl/pem.h包含PEM格式读写函数；openssl/err.h提供错误处理函数。
2. 密钥长度（bits）：目前推荐使用2048位及以上。1024位已被认为不够安全。生成更长密钥（如4096位）需要更多时间。
3. 公钥指数（e）：通常使用65537（RSA_F4），它是一个素数，且在二进制表示中只有两个1，使得模幂运算速度较快。
4. 私钥文件加密：示例中私钥以明文保存，这是极其危险的，仅用于演示。生产环境必须使用PEM_write_bio_RSAPrivateKey的加密参数，用强密码保护私钥。
5. 错误处理：OpenSSL函数失败时，错误信息会入栈。ERR_print_errors_fp(stderr)是将其打印到标准错误的简便方法，对于调试至关重要。
6. 资源管理：OpenSSL对象（RSA*,BIO*,BIGNUM*）都需要手动释放。务必在函数所有退出路径（包括错误路径）上正确释放，否则会导致内存泄漏。BIO_free_all能安全地释放BIO对象及其链。

4.2 从PEM文件加载密钥

加密和解密前，需要从之前保存的文件中加载密钥。

// 从PEM文件加载公钥 RSA* load_public_key(const char *pub_key_file) { RSA *rsa = NULL; BIO *bp = NULL; bp = BIO_new_file(pub_key_file, "rb"); if (bp == NULL) { perror("打开公钥文件失败"); return NULL; } // 使用 PEM_read_bio_RSAPublicKey 读取公钥 rsa = PEM_read_bio_RSAPublicKey(bp, NULL, NULL, NULL); if (rsa == NULL) { ERR_print_errors_fp(stderr); BIO_free_all(bp); return NULL; } BIO_free_all(bp); return rsa; } // 从PEM文件加载私钥（假设私钥未加密） RSA* load_private_key(const char *pri_key_file) { RSA *rsa = NULL; BIO *bp = NULL; bp = BIO_new_file(pri_key_file, "rb"); if (bp == NULL) { perror("打开私钥文件失败"); return NULL; } // 使用 PEM_read_bio_RSAPrivateKey 读取私钥 // 如果私钥文件有密码，需要提供密码回调函数。这里假设无密码。 rsa = PEM_read_bio_RSAPrivateKey(bp, NULL, NULL, NULL); if (rsa == NULL) { ERR_print_errors_fp(stderr); BIO_free_all(bp); return NULL; } BIO_free_all(bp); return rsa; }

代码解析与注意事项：

1. 文件打开模式："rb"表示以二进制只读模式打开，这在Windows上尤其重要，能避免换行符转换问题。
2. PEM读取函数：PEM_read_bio_RSAPublicKey和PEM_read_bio_RSAPrivateKey是标准的读取函数。还有PEM_read_bio_RSA_PUBKEY，它读取的是SubjectPublicKeyInfo格式的公钥，更具通用性（例如在X.509证书中）。我们保存时用的是PEM_write_bio_RSAPublicKey，所以用对应的读取函数。
3. 私钥密码：如果保存私钥时使用了加密，这里的PEM_read_bio_RSAPrivateKey第四个参数需要传入一个密码字符串或回调函数。否则会读取失败。

4.3 公钥加密与私钥解密实现

这是最核心的部分。RSA算法本身加密的数据长度受密钥长度限制。对于较长的数据，通常采用“混合加密”：用RSA加密一个随机的对称密钥（如AES密钥），再用这个对称密钥加密实际数据。这里我们先演示直接加密短数据。

// 使用公钥加密数据 int rsa_encrypt(RSA *rsa, const unsigned char *plaintext, int plaintext_len, unsigned char **ciphertext) { int rsa_size = RSA_size(rsa); // 获取RSA密钥的模长（字节数） int padding = RSA_PKCS1_PADDING; // 使用PKCS#1 v1.5填充 // 计算使用指定填充模式后，单次能加密的最大明文长度 int max_plain_len = rsa_size - RSA_PKCS1_PADDING_SIZE; if (plaintext_len > max_plain_len) { fprintf(stderr, "错误：明文长度(%d)超过RSA单次加密最大长度(%d)。请分段加密或使用混合加密。\n", plaintext_len, max_plain_len); return -1; } // 分配足够的内存存放密文（大小就是rsa_size） *ciphertext = (unsigned char *)malloc(rsa_size); if (*ciphertext == NULL) { perror("分配密文内存失败"); return -1; } // 执行加密 int ciphertext_len = RSA_public_encrypt(plaintext_len, plaintext, *ciphertext, rsa, padding); if (ciphertext_len == -1) { ERR_print_errors_fp(stderr); free(*ciphertext); *ciphertext = NULL; return -1; } // 注意：ciphertext_len 应该等于 rsa_size return ciphertext_len; } // 使用私钥解密数据 int rsa_decrypt(RSA *rsa, const unsigned char *ciphertext, int ciphertext_len, unsigned char **plaintext) { int rsa_size = RSA_size(rsa); int padding = RSA_PKCS1_PADDING; if (ciphertext_len != rsa_size) { fprintf(stderr, "错误：密文长度(%d)与RSA密钥模长(%d)不符。\n", ciphertext_len, rsa_size); return -1; } // 分配足够的内存存放解密后的明文（大小最多为rsa_size - padding） *plaintext = (unsigned char *)malloc(rsa_size); if (*plaintext == NULL) { perror("分配明文内存失败"); return -1; } // 执行解密 int plaintext_len = RSA_private_decrypt(ciphertext_len, ciphertext, *plaintext, rsa, padding); if (plaintext_len == -1) { ERR_print_errors_fp(stderr); free(*plaintext); *plaintext = NULL; return -1; } return plaintext_len; }

代码解析与注意事项：

1. RSA_size(rsa)：这是最重要的函数之一。它返回RSA密钥模数n的字节大小。对于2048位密钥，rsa_size是256（因为2048位 / 8 = 256字节）。这就是密文的固定长度。
2. 填充（Padding）：绝对不要使用RSA_NO_PADDING（教科书式RSA）。没有填充的RSA是不安全的。RSA_PKCS1_PADDING是PKCS#1 v1.5填充，应用广泛。更推荐的是RSA_PKCS1_OAEP_PADDING（OAEP填充），它提供了更好的安全性，但需要OpenSSL 1.0.2以上版本。填充会占用一部分空间，所以实际可加密的明文长度比rsa_size小。
3. 数据长度限制：对于2048位密钥和PKCS#1 v1.5填充，单次加密的明文最大长度是256 - 11 = 245字节。这是限制RSA直接加密大数据的主要原因。加密函数内部会检查，如果明文超长，必须进行分段处理（复杂且不推荐）或采用前述的混合加密方案。
4. 内存管理：加密/解密函数内部为输出缓冲区（ciphertext/plaintext）分配了内存。调用者负责在使用完毕后释放这些内存（free()）。这是C语言编程的常规责任，但在涉及多级指针时容易忘记。
5. 返回值：RSA_public_encrypt和RSA_private_decrypt成功时返回处理后的数据长度，失败返回-1。务必检查返回值。

4.4 主函数与完整流程串联

最后，我们编写main函数将上述模块串联起来，形成一个完整的演示程序。

int main() { // 初始化OpenSSL（较新版本可能需要，较旧版本自动初始化） OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); const char *pub_file = "public.pem"; const char *pri_file = "private.pem"; const int key_bits = 2048; // 1. 生成密钥对 printf("=== 1. 生成RSA-%d密钥对 ===\n", key_bits); if (!generate_rsa_keypair(pub_file, pri_file, key_bits)) { fprintf(stderr, "密钥对生成失败！\n"); return EXIT_FAILURE; } // 2. 加载密钥 printf("\n=== 2. 从文件加载密钥 ===\n"); RSA *rsa_pub = load_public_key(pub_file); RSA *rsa_pri = load_private_key(pri_file); if (rsa_pub == NULL || rsa_pri == NULL) { fprintf(stderr, "加载密钥失败！\n"); RSA_free(rsa_pub); RSA_free(rsa_pri); return EXIT_FAILURE; } // 3. 准备明文数据 printf("\n=== 3. 准备明文数据 ===\n"); const char *original_text = "This is a secret message for RSA testing! 这是一条测试消息。"; int plaintext_len = strlen(original_text) + 1; // 包含字符串结束符'\0' printf("明文: %s\n", original_text); printf("明文长度: %d 字节\n", plaintext_len); // 4. 使用公钥加密 printf("\n=== 4. 使用公钥加密 ===\n"); unsigned char *ciphertext = NULL; int ciphertext_len = rsa_encrypt(rsa_pub, (unsigned char*)original_text, plaintext_len, &ciphertext); if (ciphertext_len == -1) { fprintf(stderr, "加密失败！\n"); goto cleanup; } printf("加密成功。密文长度: %d 字节\n", ciphertext_len); // 注意：密文是二进制数据，直接打印可能是乱码。可以以十六进制形式查看。 printf("密文(Hex): "); for(int i = 0; i < ciphertext_len && i < 64; ++i) { // 只打印前64字节 printf("%02x", ciphertext[i]); } printf("%s\n", ciphertext_len > 64 ? "..." : ""); // 5. 使用私钥解密 printf("\n=== 5. 使用私钥解密 ===\n"); unsigned char *decrypted_text = NULL; int decrypted_len = rsa_decrypt(rsa_pri, ciphertext, ciphertext_len, &decrypted_text); if (decrypted_len == -1) { fprintf(stderr, "解密失败！\n"); goto cleanup; } printf("解密成功。解密后长度: %d 字节\n", decrypted_len); printf("解密后明文: %s\n", decrypted_text); // 6. 验证解密结果 printf("\n=== 6. 验证结果 ===\n"); if (decrypted_len == plaintext_len && memcmp(original_text, decrypted_text, plaintext_len) == 0) { printf("验证成功！解密文本与原始明文完全一致。\n"); } else { printf("验证失败！解密文本与原始明文不一致。\n"); } cleanup: // 7. 释放所有动态分配的内存和OpenSSL对象 printf("\n=== 7. 清理资源 ===\n"); free(ciphertext); free(decrypted_text); RSA_free(rsa_pub); RSA_free(rsa_pri); // 清理OpenSSL全局状态（可选，程序退出时会自动清理） EVP_cleanup(); ERR_free_strings(); return EXIT_SUCCESS; }

5. 编译、运行与结果验证

将以上所有代码段整合到一个.c文件中（例如rsa_openssl_demo.c），然后进行编译和运行。

编译命令：

gcc -o rsa_demo rsa_openssl_demo.c -lssl -lcrypto

运行程序：

./rsa_demo

预期输出（示例）：

=== 1. 生成RSA-2048密钥对 === 公钥已保存至: public.pem 私钥已保存至: private.pem === 2. 从文件加载密钥 === === 3. 准备明文数据 === 明文: This is a secret message for RSA testing! 这是一条测试消息。 明文长度: 73 字节 === 4. 使用公钥加密 === 加密成功。密文长度: 256 字节 密文(Hex): 1a2b3c4d5e6f...（一串十六进制数字） === 5. 使用私钥解密 === 解密成功。解密后长度: 73 字节 解密后明文: This is a secret message for RSA testing! 这是一条测试消息。 === 6. 验证结果 === 验证成功！解密文本与原始明文完全一致。 === 7. 清理资源 ===

关键验证点：

1. 成功生成了public.pem和private.pem文件。可以用文本编辑器打开public.pem，看到以-----BEGIN PUBLIC KEY-----开头的内容。
2. 程序输出显示加密和解密过程成功。
3. 最终的验证步骤确认解密后的数据与原始明文完全一致。
4. 你可以尝试修改明文，或者故意用错误的私钥解密，观察程序报错和行为。

6. 进阶话题与常见问题深度解析

6.1 如何加密超过密钥长度的数据？

这是RSA实践中最常见的问题。正如之前提到的，直接使用RSA加密大量数据效率低且不安全。标准做法是混合加密（Hybrid Encryption）：

1. 发送方随机生成一个对称密钥（如256位的AES密钥）。
2. 发送方使用接收方的RSA公钥加密这个对称密钥。
3. 发送方使用这个对称密钥，用AES算法加密实际的大段明文数据。
4. 发送方将RSA加密后的对称密钥和AES加密后的数据一起发送给接收方。
5. 接收方使用自己的RSA私钥解密出对称密钥。
6. 接收方使用解密出的对称密钥，用AES解密出原始明文。

这样，RSA只用于加密短的对称密钥，解决了性能瓶颈；AES用于加密实际数据，保证了加密速度。OpenSSL的EVP_*系列高级接口可以很方便地实现这种模式。

6.2 私钥文件到底该如何安全保存？

示例中私钥明文存储是大忌。正确的做法是使用强密码进行加密存储。

// 使用密码加密并保存私钥 BIO *bp_private = BIO_new_file("encrypted_private.pem", "w+"); const char *passphrase = "MySuperStrongPassword123!"; // 实际应从安全渠道获取 // 使用 AES-256-CBC 算法加密私钥 if (PEM_write_bio_RSAPrivateKey(bp_private, rsa, EVP_aes_256_cbc(), NULL, 0, NULL, (void*)passphrase) != 1) { // 错误处理 }

加载加密私钥时，需要提供密码：

// 提供密码回调函数（这里简化，直接传密码字符串） RSA *rsa_pri = PEM_read_bio_RSAPrivateKey(bp, NULL, NULL, (void*)"MySuperStrongPassword123!");

更安全的方式是实现一个密码回调函数，避免在代码中硬编码密码。

6.3 遇到的典型错误与排查技巧

1. undefined reference to 'RSA_public_encrypt'等链接错误

   • 原因：编译器找不到OpenSSL库。
   • 解决：确保编译命令正确包含了-lssl -lcrypto。在Windows上，可能需要用-L指定库路径，并确保.dll文件在可执行文件的路径或系统路径中。

2. PEM_read_bio_RSAPrivateKey: bad password read

   • 原因：读取加密私钥时提供的密码错误，或私钥文件格式损坏。
   • 解决：检查密码是否正确。可以用命令行验证：openssl rsa -in private.pem -check。如果文件是加密的，会提示输入密码。

3. RSA_public_encrypt: data too large for key size

   • 原因：尝试加密的明文数据长度超过了当前填充模式下的最大限制。
   • 解决：检查明文长度。对于长数据，必须采用混合加密方案，而不是直接RSA加密。

4. Segmentation fault (core dumped)

   • 原因：通常是空指针或内存越界访问。常见于未检查malloc、BIO_new_file或PEM_read_bio_*的返回值。
   • 解决：为所有可能返回NULL的OpenSSL API调用添加严格的错误检查。使用gdb或valgrind工具进行调试，定位非法内存访问。

5. 解密后得到乱码或验证失败

   • 原因：
     • 加密和解密使用的密钥不配对（最常见）。
     • 加密和解密使用的填充模式不一致。必须保证RSA_public_encrypt和RSA_private_decrypt的padding参数相同。
     • 密文在传输或处理过程中被损坏。
     • 明文数据包含字符串结束符\0，但strlen计算长度时未包含它，导致解密后数据不完整。我们的示例中+1就是为了解决这个问题。
   • 解决：仔细检查密钥加载路径、填充模式，并确保处理的是完整的二进制数据。

6.4 性能考量与最佳实践

• 密钥长度：平衡安全与性能。目前2048位是Web服务器证书等的基准。对长期保密的数据，考虑4096位。
• 避免频繁的密钥生成：RSA密钥生成是CPU密集型操作，非常耗时。应在服务启动时生成一次并妥善保存，而不是每次加密都生成。
• 使用EVP高级接口：对于生产代码，建议使用OpenSSL的EVP_PKEY和EVP_CIPHER等高级抽象接口，而不是直接使用RSA_*函数。高级接口提供了更统一的错误处理、算法选择和未来兼容性。
• 内存清零：对于存储密钥、明文等敏感数据的缓冲区，在使用完毕后，应用OPENSSL_cleanse()或手动用0覆盖，以防止敏感信息残留在内存中被窃取。

这个项目虽然代码量不大，但涵盖了从环境搭建、库的使用、核心算法调用到错误处理、资源管理和安全实践的完整链条。亲手实现一遍，你对RSA和OpenSSL在C语言中的应用会有质的理解。接下来，你可以尝试挑战混合加密、数字签名或集成到网络通信中，构建更复杂的应用。