C++手搓RSA：从大数运算到非对称加密的工程实践

最新推荐文章于 2026-07-14 16:56:39 发布

原创最新推荐文章于 2026-07-14 16:56:39 发布 · 401 阅读

本内容遵循CC 4.0 BY-SA版权协议

1. 项目概述：为什么用C++手搓RSA？

如果你是一名C++开发者，或者正在学习密码学，那么“用C++实现RSA”这个项目绝对是一个能让你功力大增的练手好机会。这不仅仅是把课本上的数学公式翻译成代码那么简单，它要求你深入理解大数运算、模幂计算、密钥生成与存储等一系列底层细节。市面上有很多成熟的密码学库，比如OpenSSL，它们封装得很好，直接调用几个API就能完成加解密。但作为一个想真正搞懂原理、提升工程能力的开发者，亲手从零实现一遍，你会对“非对称加密”这四个字有完全不同的感受。

RSA算法自1977年诞生以来，一直是公钥密码学的基石。它的核心魅力在于，加密和解密使用不同的密钥，公钥可以公开，私钥必须严格保密。这种特性完美解决了对称加密中密钥分发和管理的难题，是HTTPS、SSH、数字签名等众多安全协议的幕后功臣。用C++来实现它，意味着你需要直面几个核心挑战：如何处理远超标准数据类型范围的大整数（比如1024位、2048位的素数）？如何高效地进行模幂运算（计算 a^b mod n ）？如何生成足够“随机”且安全的大素数？这些问题的解决过程，本身就是对算法、数据结构和工程实践的一次深度锤炼。

我之所以推荐这个项目，是因为它麻雀虽小，五脏俱全。它涵盖了从数学理论（数论）到算法设计（Miller-Rabin素性测试、扩展欧几里得算法），再到工程实现（大数类设计、内存管理、文件I/O）的完整链条。无论你是想巩固C++面向对象和模板编程，还是为面试积累一个硬核的底层项目经验，或者单纯对密码学感到好奇，这个项目都能给你带来丰厚的回报。接下来，我将带你从零开始，一步步拆解并实现一个可用的RSA加密解密工具。

2. 核心原理与数学基础拆解

在动手写代码之前，我们必须把RSA背后的数学原理吃透。很多实现只知其然，不知其所以然，导致代码脆弱或存在安全隐患。RSA的安全性建立在“大数分解难题”之上，简单说，给你两个大质数p和q的乘积n，想反过来分解出p和q是极其困难的。

2.1 RSA密钥生成的核心步骤

密钥生成是RSA的起点，也是最关键的一步。整个过程可以分解为以下几个清晰的步骤：

选择两个大素数p和q ：这是安全性的根基。p和q必须足够大（现代标准至少1024位，即约308位十进制数）、随机且独立。在代码中，我们需要一个可靠的随机数生成器和高效的素性检测算法。
计算模数n ： n = p * q 。n的长度（比特数）就是密钥长度，例如2048位的RSA密钥，其n就是一个2048比特的大整数。n将被包含在公钥和私钥中，是公开的。
计算欧拉函数φ(n) ： φ(n) = (p-1) * (q-1) 。这个值必须严格保密，因为它直接关系到私钥的安全性。
选择公钥指数e ：e是一个整数，需要满足两个条件： 1 < e < φ(n) ，且 e 与 φ(n) 互质（即最大公约数gcd(e, φ(n)) = 1）。通常为了计算效率，会选择固定的、小的素数，比如 65537 (0x10001) 。这是一个广泛使用的值，因为它二进制表示中1很少，能加速加密和验签操作，同时安全性有保障。
计算私钥指数d ：d是e关于φ(n)的模逆元。即满足方程： (d * e) mod φ(n) = 1 。计算d需要用到 扩展欧几里得算法 。私钥d是保密的，是解密和签名的关键。

至此，我们就得到了：

公钥：由 (n, e) 组成。
私钥：由 (n, d) 组成。有时也会保存 (p, q, d) 以便使用中国剩余定理（CRT）来加速解密。

2.2 加密与解密的数学过程

理解了密钥的构成，加解密过程就非常直观了。

假设明文消息是一个数字 M （任何数据，如文本，最终都需要转换为整数进行处理），且 M 必须小于 n 。

加密（使用公钥(n, e)） ：计算密文 C = M^e mod n 。
解密（使用私钥(n, d)） ：恢复明文 M = C^d mod n 。

这里的 mod n 就是模运算。算法的正确性由欧拉定理保证。整个安全性的核心在于，攻击者知道公开的 n 和 e ，但无法从 n 分解出 p 和 q ，也就无法计算出 φ(n) 和私钥 d 。

注意：RSA算法本身是确定性的，即同样的明文和公钥，总是产生同样的密文。在实际应用中，这会导致安全隐患（比如可以判断两条密文是否对应相同明文）。因此，标准的RSA加密需要结合 填充方案 （如OAEP），在加密前对明文进行随机化处理。我们项目先实现“教科书式RSA”以理解核心，但务必记住，直接使用它是 不安全 的，生产环境必须使用标准填充。

2.3 必须掌握的数论算法

要在C++中实现上述步骤，我们需要几个关键的辅助算法：

Miller-Rabin素性检测 ：判断一个大数是否是素数。这是一个概率性算法，但通过多次迭代，可以将错误概率降到极低（如 2^{-128} ），完全满足密码学要求。它比确定性算法（如AKS）要快得多。
扩展欧几里得算法 ：用于求解 d * e ≡ 1 (mod φ(n)) 中的 d ，即计算模逆元。
快速模幂算法 ：核心中的核心。直接计算 M^e mod n ，如果e很大（比如65537），先计算 M^e 再取模是绝对不可能的，结果会大到内存溢出。必须使用 快速幂 结合 模运算性质 ，在计算过程中不断取模，避免中间值膨胀。

3. 工程实现：大数类设计与核心算法

C++的标准整数类型（如 long long ）最多处理64位整数，远不能满足RSA的需求。因此，我们首先要解决大数（Big Integer）的表示和基本运算问题。

3.1 大数类的底层存储与基础运算

一个直观且高效的做法是，用 std::vector<uint32_t> 或 std::vector<uint64_t> 来存储大数，每个元素代表数的一位（采用2^32或2^64进制）。我们称之为“ limbs”。例如，一个1024位的数，用 uint32_t 存储需要 1024/32 = 32 个元素。

我们需要为这个大数类实现以下基本操作：

构造与赋值 ：从字符串（十进制/十六进制）或基础整数类型构造。
比较运算 ：等于、不等于、小于、大于等。
基本算术 ：加法、减法（假设非负且被减数大于减数）、乘法、除法（带余数）。
位运算 ：移位（左移、右移）、按位与/或/非。
模运算 ：求模、模加、模减、模乘。

其中，乘法和 除法/求模 是性能关键。对于乘法，可以使用经典的笔算乘法（O(n²)），但对于密钥生成等需要大量运算的场景，实现更高效的算法（如Karatsuba乘法）会带来巨大提升。除法则更为复杂，通常实现Knuth的算法D。

实操心得 ：在项目初期，为了快速验证核心逻辑，可以借助现有的开源大数库，如 GMP（GNU Multiple Precision Arithmetic Library） 或 Boost.Multiprecision 。这能让你跳过最繁琐的大数运算实现，专注于RSA算法本身。例如，使用GMP，你可以用 mpz_class 这个类型，它已经重载了所有算术运算符，并且性能极高。我们的讲解会兼顾“纯手工实现”的思路和使用GMP的“快速实现”路径。

3.2 快速模幂算法的实现

这是RSA加解密的核心函数。我们采用“平方-乘”算法（Square-and-Multiply）。

算法思路 ：将指数 e 用二进制表示。例如 e = 13 ，二进制是 1101 。初始化结果 result = 1 ，底数 base = M mod n 。从指数二进制最高位开始扫描到最低位：

对每一位，先将结果平方并取模： result = (result * result) % n 。
如果当前二进制位是1，则再乘上底数并取模： result = (result * base) % n 。

这样，我们只用 O(log e) 次模乘就完成了计算，完美避免了计算巨大的 M^e 。

// 假设 BigInt 是我们的大数类，重载了 *, % 等运算符
BigInt modular_pow(const BigInt& base, const BigInt& exponent, const BigInt& modulus) {
    BigInt result = 1;
    BigInt b = base % modulus;
    BigInt e = exponent;
    
    while (e > 0) {
        // 如果当前最低位为1
        if (e.is_odd()) { // 判断奇偶，即二进制最低位是否为1
            result = (result * b) % modulus;
        }
        // 右移一位（相当于除以2）
        e = e >> 1;
        // 平方
        b = (b * b) % modulus;
    }
    return result % modulus;
}

3.3 Miller-Rabin素性检测实现

这是一个概率算法，但通过增加测试轮数（ k ），可以将合数误判为素数的概率降到可接受范围（ 4^{-k} ）。

算法步骤 （针对待测奇数 n ）：

将 n-1 分解为 d * 2^s 的形式，其中 d 是奇数。
重复以下步骤 k 轮： a. 随机选择一个整数 a ， 2 <= a <= n-2 。 b. 计算 x = a^d mod n 。 c. 如果 x == 1 或 x == n-1 ，则本轮通过，继续下一轮。 d. 否则，重复 s-1 次：计算 x = (x * x) % n 。如果 x == n-1 ，则本轮通过，跳出内层循环继续下一轮测试。 e. 如果上述过程都没有得到 n-1 ，则 n 一定是合数。
如果所有 k 轮测试都通过，则 n 很可能是素数。

k 的取值与安全性相关。对于密码学用途，通常取 k=40 或更多就足够了。

bool is_probable_prime(const BigInt& n, int k=40) {
    // 处理小素数
    if (n <= 1) return false;
    if (n == 2 || n == 3) return true;
    if (n.is_even()) return false; // 偶数不是素数

    // 分解 n-1 = d * 2^s
    BigInt d = n - 1;
    int s = 0;
    while (d.is_even()) {
        d = d >> 1;
        s++;
    }

    // 进行k轮测试
    for (int i = 0; i < k; ++i) {
        BigInt a = get_random_bigint(2, n - 2); // 获取区间内的随机数
        BigInt x = modular_pow(a, d, n);
        if (x == 1 || x == n - 1) {
            continue; // 本轮通过
        }
        bool composite = true;
        for (int j = 0; j < s - 1; ++j) {
            x = (x * x) % n;
            if (x == n - 1) {
                composite = false; // 本轮通过
                break;
            }
        }
        if (composite) {
            return false; // 确定是合数
        }
    }
    return true; // 很可能是素数
}

3.4 扩展欧几里得算法求模逆元

我们需要解方程 d * e ≡ 1 (mod φ(n)) ，即求 e 模 φ(n) 的逆元 d 。扩展欧几里得算法在求最大公约数（gcd）的同时，能找到一组系数 (x, y) ，使得 a*x + b*y = gcd(a, b) 。

当 a 和 b 互质（gcd=1）时，方程 a*x + b*y = 1 成立。在模 b 的意义下， a*x ≡ 1 (mod b) ，所以 x 就是 a 模 b 的逆元。注意结果可能需要调整到 [0, b) 范围内。

// 返回 (gcd, x, y) 满足 a*x + b*y = gcd(a, b)
std::tuple<BigInt, BigInt, BigInt> extended_gcd(BigInt a, BigInt b) {
    if (b == 0) {
        return {a, 1, 0};
    }
    auto [gcd, x1, y1] = extended_gcd(b, a % b);
    BigInt x = y1;
    BigInt y = x1 - (a / b) * y1;
    return {gcd, x, y};
}

BigInt mod_inverse(const BigInt& a, const BigInt& m) {
    auto [gcd, x, y] = extended_gcd(a, m);
    if (gcd != 1) {
        throw std::runtime_error("模逆元不存在，a和m不互质");
    }
    // 确保结果为正数
    BigInt result = x % m;
    return (result < 0) ? result + m : result;
}

4. RSA密钥对的生成与存储

有了上述基础组件，生成RSA密钥对就水到渠成了。

4.1 密钥生成流程详解

生成随机大素数p和q ：
- 生成一个指定比特长度的随机大奇数。例如，要生成1024位的密钥， n 需要2048位，那么 p 和 q 应各为1024位左右。
- 使用 is_probable_prime 函数测试其素性。如果不是素数，则递增2（保持为奇数）继续测试，直到找到素数。这个过程称为“素数搜寻”。
- 关键点 ： p 和 q 不能太接近，否则 n 容易被费马分解法或其它方法攻破。一个常见的检查是确保 |p-q| 足够大。
计算n和φ(n) ： n = p * q , φ(n) = (p-1)*(q-1) 。
选择公钥指数e ：通常固定为 65537 。需要检查 gcd(e, φ(n)) == 1 。如果不互质（概率极低），则需要重新生成密钥对。
计算私钥指数d ： d = mod_inverse(e, φ(n)) 。
（可选）计算CRT参数以加速解密 ：
- 计算 dP = d mod (p-1)
- 计算 dQ = d mod (q-1)
- 计算 qInv = mod_inverse(q, p)
- 私钥可以保存为五元组 (p, q, dP, dQ, qInv) ，使用中国剩余定理解密速度能提升3-4倍。

4.2 密钥的序列化与存储

生成的密钥需要保存到文件或内存中，以便后续使用。常见的格式有：

PEM格式 ：最常用的格式，使用Base64编码的DER数据，带有 -----BEGIN RSA PRIVATE KEY----- 这样的头尾标识。可读性好，被OpenSSL等工具广泛支持。
DER格式 ：纯二进制格式，是ASN.1编码的密钥数据。
PKCS#1 与 PKCS#8 ：这是定义密钥结构的具体标准。PKCS#1定义了传统的RSA公钥/私钥结构，而PKCS#8定义了更通用的私钥信息语法，可以对私钥进行加密。

对于我们自己的实现，为了简单起见，可以定义一种朴素的存储格式。例如，将 n , e , d 分别以十六进制字符串的形式，按行保存在文本文件中。

公钥文件示例 (public.key) :

n: ABC123...DEF (十六进制字符串)
e: 10001

私钥文件示例 (private.key) :

n: ABC123...DEF (十六进制字符串)
d: 123456...789 (十六进制字符串)
# 可选保存p, q用于CRT加速
p: ...
q: ...

更规范的做法是模仿PKCS#1，使用ASN.1 DER编码。但这涉及到复杂的TLV（类型-长度-值）结构解析，实现起来比较复杂。一个折中的方案是使用现有的库（如OpenSSL）来生成和解析PEM文件，而我们自己的加解密函数则使用从文件中读取的 n, e, d 参数。

注意事项 ：私钥文件是最高机密。在实际项目中，私钥应该被加密存储（例如使用口令进行基于口令的加密，PBKDF2派生密钥，再用AES加密私钥）。我们的演示项目可以暂不实现加密存储，但必须明确告知使用者风险。

5. 数据的分块、填充与加解密流程

RSA算法本身是用于加密“数字”的。我们需要将任意数据（字符串、文件）转换为符合算法要求的大整数。

5.1 数据到整数的转换（编码）

确定块大小 ：由于加密时要求明文 M < n ，所以一次能加密的数据长度受限于 n 的字节数。对于2048位的 n ，其最大值约为 2^2048 ，占256字节。但为了给填充留出空间，实际可加密的明文数据块要更小。
分块：将输入数据（字节流）按固定块大小（例如，对于2048位密钥，使用 256 - 11 = 245 字节，11字节是PKCS#1 v1.5填充的开销）进行分割。
转换为整数 ：将每个数据块视为一个大端序的整数。例如，字节数组 {0x01, 0x02, 0x03} 可以转换为整数 0x010203 。

5.2 填充方案的必要性

“教科书式RSA”（即直接加密编码后的整数）是不安全的，因为它具有确定性，并且对小的指数 e 和特定的明文存在攻击。因此，必须使用填充方案。

PKCS#1 v1.5 Padding ：这是早期广泛使用的方案。在加密前，在明文块前添加一个特定的字节序列。格式为： 0x00 || 0x02 || PS || 0x00 || M 。其中 PS 是至少8字节的非零随机填充字节。这确保了加密结果是随机的。注意：此方案在某些场景下可能存在适应性选择密文攻击的风险，但对于许多应用仍是可接受的。
OAEP (Optimal Asymmetric Encryption Padding) ：这是现代推荐使用的填充方案。它使用哈希函数和掩码生成函数，提供了更强的安全性证明（在随机预言机模型下）。实现比PKCS#1 v1.5更复杂，但安全性更高。

在我们的实现中，强烈建议至少实现PKCS#1 v1.5填充，并明确标注“教科书式RSA”仅用于教学演示。

5.3 完整的加密与解密函数封装

结合分块、填充和模幂运算，我们可以封装出用户友好的加密解密函数。

加密流程（使用公钥） :

输入：明文字节流 plaintext ，公钥 (n, e) 。
计算最大明文块长度 block_len = byte_length(n) - padding_overhead (如11字节)。
将 plaintext 分割成多个 block_len 大小的块。
对每个块 block ： a. 应用填充方案（如PKCS#1 v1.5），得到填充后的数据 padded_block 。 b. 将 padded_block 转换为大整数 M 。 c. 计算密文 C = modular_pow(M, e, n) 。 d. 将大整数 C 转换为固定长度（ byte_length(n) ）的字节流。
将所有密文块连接起来，输出最终的密文字节流。

解密流程（使用私钥） :

输入：密文字节流 ciphertext ，私钥 (n, d) 或 (p, q, dP, dQ, qInv) 。
密文块长度固定为 byte_length(n) 。
将 ciphertext 分割成多个 byte_length(n) 大小的块。
对每个块 cipher_block ： a. 将其转换为大整数 C 。 b. 计算明文整数 M = modular_pow(C, d, n) （或使用CRT加速计算）。 c. 将 M 转换为字节流 padded_block ，长度应为 byte_length(n) 。 d. 移除填充 ：解析 padded_block ，根据填充规则（如查找第二个 0x00 字节）提取出原始的 block 。
将所有解密后的 block 连接起来，得到原始明文。

// 简化伪代码，展示流程
std::vector<unsigned char> rsa_encrypt(const std::vector<unsigned char>& plaintext,
                                        const BigInt& n, const BigInt& e) {
    size_t key_bytes = (n.bit_length() + 7) / 8; // n的字节长度
    size_t block_len = key_bytes - 11; // PKCS#1 v1.5 预留11字节
    std::vector<unsigned char> ciphertext;

    for (size_t i = 0; i < plaintext.size(); i += block_len) {
        // 1. 获取当前数据块
        auto block_begin = plaintext.begin() + i;
        auto block_end = (i + block_len < plaintext.size()) ? plaintext.begin() + i + block_len : plaintext.end();
        std::vector<unsigned char> block(block_begin, block_end);

        // 2. 应用PKCS#1 v1.5填充
        std::vector<unsigned char> padded = pkcs1_v1_5_pad(block, key_bytes);

        // 3. 转换为整数并加密
        BigInt m = bytes_to_bigint(padded);
        BigInt c = modular_pow(m, e, n);

        // 4. 将密文整数转换回字节并追加
        std::vector<unsigned char> encrypted_block = bigint_to_bytes(c, key_bytes);
        ciphertext.insert(ciphertext.end(), encrypted_block.begin(), encrypted_block.end());
    }
    return ciphertext;
}

// 解密是逆过程
std::vector<unsigned char> rsa_decrypt(const std::vector<unsigned char>& ciphertext,
                                        const BigInt& n, const BigInt& d) {
    size_t key_bytes = (n.bit_length() + 7) / 8;
    std::vector<unsigned char> plaintext;

    for (size_t i = 0; i < ciphertext.size(); i += key_bytes) {
        // 1. 获取密文块并转换为整数
        auto block_begin = ciphertext.begin() + i;
        auto block_end = ciphertext.begin() + i + key_bytes;
        std::vector<unsigned char> encrypted_block(block_begin, block_end);
        BigInt c = bytes_to_bigint(encrypted_block);

        // 2. 解密
        BigInt m = modular_pow(c, d, n);

        // 3. 转换回字节并去除填充
        std::vector<unsigned char> padded_block = bigint_to_bytes(m, key_bytes);
        std::vector<unsigned char> block = pkcs1_v1_5_unpad(padded_block);

        // 4. 追加到明文
        plaintext.insert(plaintext.end(), block.begin(), block.end());
    }
    return plaintext;
}

6. 性能优化与安全考量

一个完整的RSA实现，除了功能正确，还需要考虑性能和安全性。

6.1 使用中国剩余定理加速解密

RSA解密（计算 C^d mod n ）是最耗时的操作。利用私钥中包含的 p 和 q ，我们可以使用中国剩余定理将一次大模幂运算分解为两次小模幂运算，速度能提升3-4倍。

CRT解密步骤 ：

计算 m1 = C^{dP} mod p ，其中 dP = d mod (p-1)
计算 m2 = C^{dQ} mod q ，其中 dQ = d mod (q-1)
计算 h = qInv * (m1 - m2) mod p （ qInv 是 q 模 p 的逆元）
最终明文 M = m2 + h * q

在密钥生成时预计算 dP , dQ , qInv 并和 p , q 一起保存为私钥，解密时使用上述步骤。

6.2 大数运算的优化

乘法优化 ：实现Karatsuba算法或更高级的Toom-Cook、FFT乘法，对于超过几百位的大数，性能提升显著。
模运算优化 ：使用Barrett约减或Montgomery乘法来加速模乘和模幂运算。Montgomery乘法特别适合用于快速模幂，因为它能将耗时的模运算转化为移位和加法。
内存管理 ：避免频繁的大数拷贝和临时对象创建。使用移动语义、预分配内存池等技术。

6.3 关键安全陷阱与规避

弱随机数生成 ：密钥安全依赖于 p 和 q 的不可预测性。绝对不要使用 rand() 或伪随机种子。必须使用密码学安全的随机数生成器（CSPRNG），如 /dev/urandom （Linux）或 BCryptGenRandom （Windows）。在C++中，可以使用 <random> 库中的 std::random_device （如果实现是安全的）或链接OpenSSL的 RAND_bytes 函数。
侧信道攻击 ：简单的快速幂实现（根据密钥位是0还是1决定是否做乘法）的执行时间会泄露私钥 d 的位信息。攻击者通过测量解密时间就能分析出私钥。防御方法是使用 恒定时间 的算法，如平方-乘总是执行（无论该位是0还是1），或者使用蒙哥马利阶梯算法。
填充预言攻击 ：如果解密函数在发现填充格式错误时返回不同的错误信息（如“填充错误” vs “解密失败”），攻击者可能利用这一点进行适应性选择密文攻击，从而破解密文。解决方案是：无论填充正确与否，解密流程在验证失败后，都使用一个随机的“假”明文继续执行，最后再统一返回“解密错误”，避免信息泄露。
密钥长度 ：1024位的RSA目前已不被认为足够安全（NIST建议2030年后停止使用）。对于新项目，应至少使用2048位，高安全要求则考虑3072或4096位。密钥长度每增加一倍，加解密耗时大约增加6-8倍，需要权衡。

7. 项目集成、测试与验证

将各个模块组合起来，形成一个完整的命令行工具或库，是项目的最后一步。

7.1 设计一个简单的命令行接口

一个实用的工具应该支持以下功能：

rsa_tool genkeys -b 2048 -o private.pem -pub public.pem  # 生成密钥对
rsa_tool encrypt -i message.txt -o encrypted.bin -pub public.pem  # 加密文件
rsa_tool decrypt -i encrypted.bin -o decrypted.txt -priv private.pem  # 解密文件
rsa_tool sign -i data.txt -o signature.bin -priv private.pem  # 签名（实际是私钥加密哈希）
rsa_tool verify -i data.txt -sig signature.bin -pub public.pem  # 验签（公钥解密并比对哈希）

7.2 编写全面的单元测试

测试是保证代码正确性的关键。应覆盖以下场景：

大数运算 ：测试加减乘除、模运算、快速幂在边界情况（如零、一、大数）下的正确性。
Miller-Rabin测试 ：用已知的素数和合数进行验证。
扩展欧几里得算法 ：验证求得的逆元是否满足 (a * inv) % m == 1 。
完整的RSA流程 ：
- 随机生成一个短明文，用生成的公钥加密，再用私钥解密，验证是否还原。
- 测试分块加密解密。
- 测试使用CRT和不使用CRT的解密结果是否一致。
与标准库交互测试 （如果使用GMP）：用我们的代码加密，用OpenSSL的命令行工具解密，验证互通性。这是最有力的验证。

7.3 性能分析与瓶颈定位

使用性能分析工具（如 gprof , perf , Valgrind的Callgrind）来定位热点函数。通常，模幂运算（ modular_pow ）和大数乘法会消耗绝大部分时间。针对这些函数进行优化（如引入Montgomery乘法）能带来最直接的收益。

7.4 常见编译与运行问题

链接大数库 ：如果使用GMP，需要正确安装开发包（如 libgmp-dev ）并在编译时链接 -lgmp 。
随机数源 ：在Linux/macOS上， std::random_device 通常指向 /dev/urandom ，是安全的。在Windows的某些旧版本MinGW上，它可能使用伪随机算法，需要寻找替代方案。
内存泄漏 ：如果自己管理大数内存，务必确保在析构函数中正确释放。使用Valgrind或AddressSanitizer进行检查。
整数溢出 ：即使在我们的 BigInt 类中，实现基础运算（如两个 uint32_t 相乘）时也要注意中间结果可能溢出到 uint64_t 。

实现一个完整的RSA算法，就像亲手搭建了一座精密的密码学机械。从数论公式到可运行的C++代码，每一步都充满了挑战和收获。这个项目不仅让你深入理解了非对称加密的奥秘，更极大地锻炼了你解决复杂工程问题的能力。记住，我们这里实现的是用于学习和理解的核心版本，真正的生产级应用务必使用像OpenSSL、LibreSSL、BoringSSL这样经过千锤百炼、持续审计的密码学库。但毫无疑问，亲手实现一遍的经历，会让你在使用这些库时，从一个被动的调用者，变成一个真正理解其背后波澜壮阔原理的掌控者。

标签

#C++ #RSA算法 #非对称加密