C语言从零实现RSA加密算法：深入理解非对称加密原理与工程实践

1. 项目概述：为什么选择从零实现RSA？

如果你对密码学感兴趣，或者想深入理解现代互联网安全通信的基石，那么亲手用C语言实现一遍RSA加密算法，绝对是一个无法替代的“硬核”学习路径。RSA，这个以三位发明者姓氏首字母命名的算法，自1977年诞生以来，就成为了非对称加密的代名词。我们每天使用的HTTPS、SSH登录、数字签名，背后都有它的身影。但很多人对它的理解，可能仅仅停留在“公钥加密，私钥解密”这句口号上。

这个项目的核心价值，就在于亲手“造轮子”。通过C语言这个贴近硬件的语言，你将被迫去理解每一个数学运算的细节：大素数如何生成、欧拉函数怎么算、模逆元如何求解、以及最核心的模幂运算如何高效实现。这个过程会让你真正明白，为什么RSA是安全的，它的安全边界又在哪里。相比于调用一个现成的openssl库函数，自己实现一遍，你对密钥长度选择、填充方案重要性的认识，会深刻得多。这不仅是编程练习，更是一次密码学原理的深度穿越。

2. 核心原理拆解：RSA的数学心脏

在动手写代码之前，我们必须吃透RSA赖以生存的数学基础。如果你觉得数学枯燥，可以把它想象成一个精心设计的“数学锁”：找到两个大素数，就能打造一把独一无二的锁（公钥）和钥匙（私钥）。

2.1 密钥生成：寻找独一无二的“锁和钥匙”

RSA密钥生成是整个算法的起点，它决定了加密系统的安全性。其过程可以分解为五个清晰的步骤：

1. 选择两个大素数p和q：这是所有安全性的根源。p和q必须足够大（例如1024位以上），并且是随机生成的素数。素数越大，将其乘积分解的难度就呈指数级增长。在实际中，我们使用米勒-拉宾素性测试这类概率性算法来高效地寻找大素数，因为它比确定性测试（如AKS算法）快得多，并且对于加密用途来说，误差概率低到可以忽略不计。
2. 计算模数n：n = p * q。这个n就是模数，既是公钥的一部分，也是私钥的一部分。它的长度（比特数）就是我们常说的“密钥长度”，比如2048位的RSA，指的就是n有2048比特。
3. 计算欧拉函数φ(n)：φ(n) = (p-1) * (q-1)。欧拉函数计算的是小于n且与n互质的正整数的个数。由于p和q都是素数，这个计算变得非常简单。φ(n)的值必须绝对保密，因为它直接关系到私钥的生成。
4. 选择公钥指数e：公钥是(e, n)。e是一个整数，需要满足两个条件：1 < e < φ(n)，且e与φ(n)互质（即最大公约数gcd(e, φ(n)) = 1）。为了计算高效，通常选择一个较小的、二进制表示中1的位数少的素数，比如65537 (0x10001)。这个数用得非常广泛，因为它既满足了安全要求，又能让加密运算更快。
5. 计算私钥指数d：私钥是(d, n)。d是e对于模φ(n)的模逆元。也就是说，d需要满足：(e * d) % φ(n) = 1。计算d需要用到扩展欧几里得算法。这个d就是那把唯一的“钥匙”。

注意：整个过程中，p,q,φ(n)在生成密钥对后必须立即从内存中安全地清除，任何泄露都会导致整个RSA体系被瞬间攻破。

2.2 加密与解密：模幂运算的舞台

密钥准备好后，加密和解密在数学上就变成了简单的模幂运算。但“简单”只是形式上的，因为涉及的数字极其庞大。

• 加密（用公钥）：假设明文消息是一个整数M（需要小于n）。那么密文C = M^e mod n。这里M^e可能是一个天文数字，直接计算不现实，必须借助高效的模幂算法。
• 解密（用私钥）：拿到密文C后，用私钥解密恢复明文：M = C^d mod n。

根据欧拉定理，可以证明(C^d) mod n = (M^(e*d)) mod n = M mod n，从而确保解密的正确性。这里的核心挑战在于，如何快速计算M^e mod n和C^d mod n，尤其是当d这个指数非常大的时候。

2.3 为什么是安全的？核心在于大数分解难题

RSA的安全性基于一个公认的数学难题：大整数分解问题。也就是说，给定一个大的合数n（它是两个大素数p和q的乘积），在可接受的时间内找出p和q是极其困难的。

• 攻击者知道公钥(e, n)。
• 如果想得到私钥d，他需要计算e模φ(n)的逆元。
• 而计算φ(n)需要知道p和q，因为φ(n) = (p-1)(q-1)。
• 因此，攻击者必须从n倒推出p和q，这就是大数分解。

只要n足够大（目前推荐2048位或以上），即使用世界上最快的超级计算机，进行暴力分解也需要数百年甚至更久的时间。这就是RSA安全的基石。但请注意，这指的是“经典计算机”。量子计算机上的Shor算法能在多项式时间内分解大整数，因此后量子密码学是当前的研究热点。

3. 环境准备与核心工具选型

工欲善其事，必先利其器。用C语言实现RSA，意味着我们要自己处理大量底层细节，因此选择合适的工具和库至关重要。

3.1 开发环境搭建

对于C语言开发，一个轻量、高效的组合是VSCode + MinGW-w64。

1. 安装MinGW-w64：这是Windows下的GCC编译器工具链。建议下载离线安装包，将其bin目录（例如C:\mingw64\bin）添加到系统的PATH环境变量中。在终端输入gcc --version验证是否安装成功。
2. 配置VSCode：
   • 安装C/C++扩展（Microsoft官方出品）。
   • 创建一个项目文件夹，在里面新建.vscode文件夹，并创建两个文件：
     • c_cpp_properties.json：配置编译器路径和包含路径。
     • tasks.json：配置编译构建任务（例如，使用gcc编译当前文件）。
   • 这样你就可以在VSCode中直接按Ctrl+Shift+B来编译，按F5进行调试，体验接近IDE的便捷。

如果你更喜欢开箱即用的集成环境，Visual Studio Community版本是另一个绝佳选择。安装时勾选“使用C++的桌面开发”工作负载即可。它内置了强大的调试器和项目管理功能，非常适合中大型项目。

3.2 大数运算库的选择与考量

这是本项目最关键的决策点。C语言的标准整数类型（如long long）通常只有64位，远远不足以表示RSA所需的上千位整数。因此，我们必须借助大数运算库。

• GMP (GNU Multiple Precision Arithmetic Library)：这是业界标准，性能极高，功能全面。如果你是追求极致性能和深入学习，GMP是不二之选。但它的API相对底层，在Windows上配置稍显麻烦。

  // 在Linux/macOS下安装GMP通常很简单 // Ubuntu/Debian: sudo apt-get install libgmp-dev // macOS: brew install gmp

• OpenSSL的BN库：OpenSSL不仅提供了完整的RSA实现，也将其底层的大数运算库BN（Bignum）暴露出来。如果你未来想深入网络和安全编程，直接使用OpenSSL BN是一个顺理成章的选择。它的文档丰富，且和生态结合紧密。
• 轻量级自定义实现（仅用于学习）：为了彻底理解原理，你可以尝试用数组或字符串来表示大数，并自己实现加减乘除、取模等运算。这极具教育意义，但仅适用于教学和原理验证，性能和安全性与专业库有数量级差距，切勿用于生产环境。

本项目实践建议：为了在学习深度和实践可行性之间取得平衡，我们选择OpenSSL的BN库作为基础。它足够强大，避免了重复造轮子，又能让我们聚焦于RSA算法本身的实现逻辑。同时，OpenSSL的广泛使用也使得这份经验更具迁移价值。

3.3 安装与链接OpenSSL开发库

1. Windows：从OpenSSL官网下载编译好的Windows版本（例如Win64 OpenSSL v1.1.1w Light）。安装后，记住安装目录（如C:\OpenSSL-Win64）。
2. 在VSCode中配置：修改.vscode/c_cpp_properties.json中的includePath和compilerPath，添加OpenSSL的头文件路径和库路径。同时，在tasks.json的编译参数中，需要链接libcrypto库。

   // tasks.json 示例片段 "args": [ "-g", "${file}", "-o", "${fileDirname}\\${fileBasenameNoExtension}.exe", "-I", "C:\\OpenSSL-Win64\\include", // 你的头文件路径 "-L", "C:\\OpenSSL-Win64\\lib", // 你的库文件路径 "-lcrypto" ],

3. Linux/macOS：通常通过包管理器安装即可。

   // Ubuntu/Debian sudo apt-get install libssl-dev // macOS brew install openssl

   编译时使用gcc -o rsa_demo rsa_demo.c -lcrypto。

4. 核心模块的C语言实现

现在，我们进入编码实战环节。我们将使用OpenSSL BN库，将RSA的数学步骤转化为C代码。

4.1 大数结构与初始化

OpenSSL BN库的核心结构是BIGNUM。我们首先需要包含头文件并理解如何创建和释放这些大数对象。

#include <stdio.h> #include <stdlib.h> #include <openssl/bn.h> void handle_errors() { // 简单的错误处理，实际项目应更完善 fprintf(stderr, "An OpenSSL error occurred.\n"); exit(EXIT_FAILURE); } int main() { BIGNUM *p = BN_new(); BIGNUM *q = BN_new(); BIGNUM *n = BN_new(); BIGNUM *e = BN_new(); BIGNUM *d = BN_new(); BIGNUM *phi_n = BN_new(); BIGNUM *one = BN_new(); BN_CTX *ctx = BN_CTX_new(); // 运算上下文，用于临时变量 if (!p || !q || !n || !e || !d || !phi_n || !one || !ctx) { handle_errors(); } // 初始化常数1 BN_one(one); // ... 后续算法实现 ... // ！！！关键：释放内存 ！！！ BN_free(p); BN_free(q); BN_free(n); BN_free(e); BN_free(d); BN_free(phi_n); BN_free(one); BN_CTX_free(ctx); return 0; }

实操心得：BN_CTX是一个非常重要的优化工具。它用于管理BN运算中的临时变量内存。在频繁的模运算中，使用ctx可以避免反复分配和释放内存带来的性能开销。务必在程序结束时用BN_CTX_free释放它。

4.2 密钥生成流程代码实现

接下来，我们实现密钥生成的核心步骤。注意，生成密码学安全的随机大素数是一个复杂过程，这里我们使用OpenSSL提供的函数。

int rsa_key_generation(BIGNUM **out_n, BIGNUM **out_e, BIGNUM **out_d, int bits) { BIGNUM *p = BN_new(); BIGNUM *q = BN_new(); BIGNUM *n = BN_new(); BIGNUM *e = BN_new(); BIGNUM *d = BN_new(); BIGNUM *phi_n = BN_new(); BIGNUM *p_minus_one = BN_new(); BIGNUM *q_minus_one = BN_new(); BIGNUM *gcd_result = BN_new(); BN_CTX *ctx = BN_CTX_new(); int ret = 0; if (!p || !q || !n || !e || !d || !phi_n || !p_minus_one || !q_minus_one || !gcd_result || !ctx) { goto cleanup; } // 1. 生成两个大素数p和q printf("Generating %d-bit prime p...\n", bits/2); if (!BN_generate_prime_ex(p, bits/2, 1, NULL, NULL, NULL)) { fprintf(stderr, "Failed to generate prime p.\n"); goto cleanup; } printf("Generating %d-bit prime q...\n", bits/2); if (!BN_generate_prime_ex(q, bits/2, 1, NULL, NULL, NULL)) { fprintf(stderr, "Failed to generate prime q.\n"); goto cleanup; } // 2. 计算 n = p * q if (!BN_mul(n, p, q, ctx)) { goto cleanup; } // 3. 计算 φ(n) = (p-1)*(q-1) // 先计算 p-1 和 q-1 if (!BN_sub(p_minus_one, p, BN_value_one()) || !BN_sub(q_minus_one, q, BN_value_one())) { goto cleanup; } if (!BN_mul(phi_n, p_minus_one, q_minus_one, ctx)) { goto cleanup; } // 4. 选择公钥指数e，通常为65537 BN_set_word(e, 65537); // 设置e为65537 // 检查e是否与φ(n)互质 if (!BN_gcd(gcd_result, e, phi_n, ctx)) { goto cleanup; } if (!BN_is_one(gcd_result)) { // 如果gcd不为1，说明不互质，需要选择另一个e（极小概率事件） fprintf(stderr, "e=65537 is not coprime with phi(n). This is extremely rare!\n"); // 在实际应用中，这里应循环尝试其他小素数，如17, 257等 goto cleanup; } // 5. 计算私钥指数d，满足 e*d ≡ 1 (mod φ(n)) // 使用扩展欧几里得算法求模逆元 if (!BN_mod_inverse(d, e, phi_n, ctx)) { fprintf(stderr, "Failed to compute modular inverse for d.\n"); goto cleanup; } // 输出结果 printf("\n--- RSA Key Pair Generated (%d bits) ---\n", bits); char *n_str = BN_bn2hex(n); char *e_str = BN_bn2hex(e); char *d_str = BN_bn2hex(d); printf("Public Key (n, e):\n"); printf(" n = %s\n", n_str); printf(" e = %s\n", e_str); printf("\nPrivate Key (n, d):\n"); printf(" d = %s\n", d_str); OPENSSL_free(n_str); OPENSSL_free(e_str); OPENSSL_free(d_str); // 6. 将生成的密钥赋值给输出参数 *out_n = n; *out_e = e; *out_d = d; // 将局部指针设为NULL，防止cleanup时被重复释放 n = e = d = NULL; ret = 1; // 成功 cleanup: // 安全释放所有BIGNUM资源，包括未赋给外部的 BN_free(p); BN_free(q); if (n) BN_free(n); if (e) BN_free(e); if (d) BN_free(d); BN_free(phi_n); BN_free(p_minus_one); BN_free(q_minus_one); BN_free(gcd_result); BN_CTX_free(ctx); return ret; }

这段代码清晰地展示了密钥生成的每一步，并加入了基本的错误处理和状态输出。BN_generate_prime_ex函数是OpenSSL提供的密码学安全素数生成器，其内部实现了复杂的素性检测。

4.3 加密与解密函数实现

有了密钥，加密和解密函数就相对直观了，核心是模幂运算BN_mod_exp。

// RSA加密函数：C = M^e mod n int rsa_encrypt(BIGNUM *out_cipher, const BIGNUM *plain_msg, const BIGNUM *e, const BIGNUM *n, BN_CTX *ctx) { // 检查明文M是否小于n（RSA要求） if (BN_cmp(plain_msg, n) >= 0) { fprintf(stderr, "Error: Plaintext message must be less than modulus n.\n"); return 0; } // 执行模幂运算：C = M^e mod n return BN_mod_exp(out_cipher, plain_msg, e, n, ctx); } // RSA解密函数：M = C^d mod n int rsa_decrypt(BIGNUM *out_plain, const BIGNUM *cipher_msg, const BIGNUM *d, const BIGNUM *n, BN_CTX *ctx) { // 理论上也应检查密文C是否小于n，但由正确加密产生的密文必然满足。 // 执行模幂运算：M = C^d mod n return BN_mod_exp(out_plain, cipher_msg, d, n, ctx); }

这两个函数非常简洁，但却是RSA的核心。BN_mod_exp函数内部实现了高效的模幂算法（如平方-乘算法），能够处理指数和模数都非常大的情况。

4.4 主函数与完整流程演示

我们将上述模块组合起来，形成一个完整的演示程序。

int main() { BN_CTX *ctx = BN_CTX_new(); if (!ctx) handle_errors(); BIGNUM *n = NULL, *e = NULL, *d = NULL; BIGNUM *plaintext = BN_new(); BIGNUM *ciphertext = BN_new(); BIGNUM *decrypted = BN_new(); // 1. 生成RSA密钥对（例如1024位，用于演示） printf("=== RSA Key Generation ===\n"); if (!rsa_key_generation(&n, &e, &d, 1024)) { fprintf(stderr, "Key generation failed.\n"); goto main_cleanup; } // 2. 准备一个测试明文（这里用一个较小的数字模拟） // 在实际中，明文需要经过填充（如OAEP）并转换为大整数。 BN_set_word(plaintext, 123456789); // 模拟明文消息 printf("\n=== RSA Encryption & Decryption Demo ===\n"); char *plain_str = BN_bn2dec(plaintext); printf("Original Plaintext (as number): %s\n", plain_str); OPENSSL_free(plain_str); // 3. 加密 if (!rsa_encrypt(ciphertext, plaintext, e, n, ctx)) { fprintf(stderr, "Encryption failed.\n"); goto main_cleanup; } char *cipher_str = BN_bn2hex(ciphertext); printf("Ciphertext (hex): %s\n", cipher_str); OPENSSL_free(cipher_str); // 4. 解密 if (!rsa_decrypt(decrypted, ciphertext, d, n, ctx)) { fprintf(stderr, "Decryption failed.\n"); goto main_cleanup; } char *decrypted_str = BN_bn2dec(decrypted); printf("Decrypted Plaintext (as number): %s\n", decrypted_str); OPENSSL_free(decrypted_str); // 5. 验证 if (BN_cmp(plaintext, decrypted) == 0) { printf("\n✅ Success! Decrypted text matches the original.\n"); } else { printf("\n❌ Failure! Decryption did not recover the original message.\n"); } main_cleanup: // 安全释放所有资源 if (n) BN_free(n); if (e) BN_free(e); if (d) BN_free(d); BN_free(plaintext); BN_free(ciphertext); BN_free(decrypted); BN_CTX_free(ctx); return 0; }

编译并运行这个程序，你将看到密钥生成、加密、解密的全过程，并验证其正确性。这只是一个最基础的、教科书式的RSA实现。

5. 从教科书走向实践：关键问题与优化

上面的实现是“裸”RSA，它存在严重的安全和实用缺陷。一个工业级的RSA实现必须解决以下问题：

5.1 数据编码与填充方案

原始RSA要求加密的整数M必须小于模数n。但现实中的数据是任意长度的字节流。因此，我们需要一个方案将数据“包装”成符合要求的大整数，这就是填充。更重要的是，没有填充的RSA是确定性加密，即同样的明文永远产生同样的密文，并且容易受到多种攻击（如猜明文攻击）。

• PKCS#1 v1.5 Padding：这是早期广泛使用的方案。它在明文前添加特定格式的随机字节，然后再进行加密。虽然比裸RSA安全，但已被证明在某些场景下存在缺陷（如Bleichenbacher攻击）。
• OAEP (Optimal Asymmetric Encryption Padding)：这是目前推荐使用的填充方案。它结合了哈希函数和掩码生成函数，提供了“概率加密”的特性（同样的明文每次加密结果不同），并且可证明安全（在随机预言机模型下）。任何用于加密的RSA新实现，都必须使用OAEP填充。

// 伪代码示意：使用OpenSSL进行RSA-OAEP加密 #include <openssl/rsa.h> #include <openssl/pem.h> RSA *rsa = RSA_new(); // ... 设置RSA密钥 (n, e, d) 到 rsa 结构体中 ... unsigned char plaintext[] = "Hello, RSA!"; unsigned char ciphertext[2048]; // 缓冲区需足够大 unsigned char decrypted[2048]; int ciphertext_len = RSA_public_encrypt(strlen(plaintext), plaintext, ciphertext, rsa, RSA_PKCS1_OAEP_PADDING); if (ciphertext_len == -1) { /* 处理错误 */ } int decrypted_len = RSA_private_decrypt(ciphertext_len, ciphertext, decrypted, rsa, RSA_PKCS1_OAEP_PADDING); if (decrypted_len == -1) { /* 处理错误 */ } decrypted[decrypted_len] = '\0'; // 添加字符串结束符

强烈建议：在生产环境中，直接使用OpenSSL等成熟库提供的RSA_public_encrypt/RSA_private_decrypt函数并指定RSA_PKCS1_OAEP_PADDING，而不是自己实现填充逻辑。

5.2 性能优化：模幂运算与CRT

RSA的解密（C^d mod n）非常耗时，因为私钥指数d很大。中国剩余定理可以将其分解为两个更小的模幂运算，从而将解密速度提升约4倍。

• 原理：利用密钥生成时保存的p和q。
  • 计算m1 = C^(d mod (p-1)) mod p
  • 计算m2 = C^(d mod (q-1)) mod q
  • 然后利用CRT组合m1和m2得到最终的明文M。
• OpenSSL中的使用：当你使用RSA结构体并设置好p,q,dmp1（d mod (p-1)）,dmq1（d mod (q-1)）,iqmp（q的模p逆元）这些CRT参数后，RSA_private_decrypt函数内部会自动使用CRT进行优化。这也是为什么密钥生成后需要安全地保存p和q的原因之一（除了备份，也用于性能优化）。

5.3 密钥的存储与格式

生成的密钥对（n, e, d）以及CRT参数需要持久化存储。常见的格式有：

• PEM格式：一种基于Base64编码的文本格式，以-----BEGIN RSA PRIVATE KEY-----和-----END RSA PRIVATE KEY-----包裹。可读性好，便于在配置文件或邮件中传输。
• DER格式：二进制格式，是ASN.1编码的序列化结果。体积更小，常用于程序内部处理。
• PKCS#8：一种更通用的私钥封装标准，可以封装各种算法的私钥，并支持密码加密。

OpenSSL提供了丰富的API在内存、文件和这些格式之间转换RSA密钥。

// 示例：将RSA私钥写入PEM文件（未加密） FILE *fp = fopen("private_key.pem", "w"); if (!PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL)) { // 处理错误 } fclose(fp); // 示例：从PEM文件读取RSA公钥 FILE *fp_pub = fopen("public_key.pem", "r"); RSA *rsa_pub = PEM_read_RSAPublicKey(fp_pub, NULL, NULL, NULL); fclose(fp_pub);

6. 常见问题、调试技巧与安全警示

在实现和调试过程中，你肯定会遇到各种问题。以下是一些常见坑点和解决思路。

6.1 编译与链接问题

• 问题：fatal error: openssl/bn.h: No such file or directory
• 解决：编译器找不到OpenSSL头文件。确保在编译命令中正确使用了-I参数指定头文件路径，并且该路径下确实有openssl目录。
• 问题：undefined reference toBN_new‘` 等链接错误。
• 解决：没有链接libcrypto库。确保在编译命令末尾加上-lcrypto，并且用-L指定了库文件路径（如果不在系统默认路径）。

6.2 运行时错误与调试

• 内存泄漏：这是使用BN库最常见的问题。每一个BN_new()或BN_dup()都必须有对应的BN_free()。使用valgrind（Linux）或Visual Studio的诊断工具来检测内存泄漏。
• 运算返回0：OpenSSL的许多函数在成功时返回1，失败时返回0。务必检查每个关键函数的返回值。可以使用ERR_print_errors_fp(stderr);来打印详细的OpenSSL错误信息。
• “明文过长”错误：在使用填充（如OAEP）时，明文长度有最大限制。对于RSA-2048和OAEP with SHA-256，最大明文长度约为256 - 2*32 - 2字节。加密更长的数据需要使用混合加密：即用RSA加密一个随机的对称密钥（如AES密钥），再用这个对称密钥加密实际数据。

6.3 安全警示：不要在生产环境使用自己的实现

这是最重要的一点，我必须用最强烈的语气强调：

警告：本项目实现的RSA，以及任何出于学习目的、未经严格安全审计的密码学实现，都绝对禁止用于任何真实的生产环境、线上系统或保护敏感数据。

原因如下：

1. 侧信道攻击：你的代码在计算C^d mod n时，执行时间、功耗、电磁辐射可能依赖于私钥d的每一位。专业的密码库（如OpenSSL, LibreSSL, BoringSSL）包含了大量针对时序攻击、缓存攻击等侧信道攻击的防御代码。
2. 随机数质量：密钥生成依赖于密码学安全的随机数。自己实现的随机数生成器几乎肯定是脆弱的。
3. 算法边界条件：对填充方案的处理、错误信息的反馈等，都存在微妙的攻击面。一个不经意的错误就可能引入严重的漏洞（如著名的“Padding Oracle”攻击）。
4. 代码审计：工业级的密码库经过了全球安全专家数十年的审查和攻击测试。

正确的做法是：在理解原理后，在生产环境中使用经过严格验证的、成熟的密码学库（如OpenSSL, libsodium, 或你所用编程语言的标准安全库），并遵循其最佳实践指南。

7. 项目扩展与深入学习方向

完成基础实现后，你可以沿着以下方向继续探索，深化对密码学和系统安全的理解：

1. 实现完整的RSA-OAEP：不依赖OpenSSL的RSA_public_encrypt，自己实现OAEP填充和移除的逻辑。这需要你理解MGF1（掩码生成函数）和哈希函数（如SHA-256）的使用。
2. 集成到网络通信中：编写一个简单的客户端-服务器程序，使用你实现的RSA进行密钥交换，然后切换到AES对称加密进行后续的高速通信。这就是TLS/SSL中“握手”阶段的简化版。
3. 探究数字签名：RSA除了加密，另一个核心用途是数字签名（如PKCS#1 v1.5签名或PSS）。尝试实现Sign = Hash(M)^d mod n和Verify: Hash(M)’ == Sign^e mod n的过程。
4. 阅读OpenSSL源码：找一份OpenSSL库中RSA实现的源码（如crypto/rsa/目录），看看工业级的代码是如何处理错误、进行优化和防御攻击的。这会是极大的提升。
5. 了解椭圆曲线密码学：RSA密钥较长，计算较慢。现代TLS更倾向于使用基于椭圆曲线的算法（如ECDHE、EdDSA）。对比学习ECC，理解其更小的密钥尺寸和更高的安全性。

从零实现RSA，就像亲手搭建了一座密码学大厦的地基。你可能会为了一段内存泄漏调试半天，也可能为了理解一个数学定理而翻阅无数资料。但当你最终看到“加密-解密”验证通过的那一刻，你对“公钥”、“私钥”、“数字签名”这些概念的理解，将不再是浮于表面的词汇，而是变成了你思维中坚实而清晰的一部分。这份通过动手实践获得的理解，是任何理论阅读都无法替代的。