加密算法-综述

加密算法分为对称加密算法和非对称加密算法。

对称加密算法：加密和解密使用同一个密钥。

  → 常见的对称加密算法有AES、DES、Blowfish等。

非对称加密算法：存在密钥对（公钥和私钥）。当使用公钥加密时，只能使用私钥解密；当使用私钥加密时，只能使用公钥解密。

  → 常见的非对称加密算法有RSA。

一、 非对称加密算法

1. RSA加密算法

1977年，三位数学家Rivest、Shamir和Adleman设计了一种算法，可以实现非对称加密，因此命名为RSA算法，是当前使用最广的一种非对称加密算法。

RSA算法基于一个简单的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密的密钥。

1.1 预备知识

1.1.1 欧拉定理

对于正整数n，欧拉函数φ(n)表示小于等于n，且与n互质的正整数的个数。

1.2 RSA算法

1.2.1 公钥和私钥的生成

  1）取两个素数p和q，其二进制位能够达到1024个二进制位或者更多（位数越多越难破解）；

  2）计算素数p和q的乘积：n=pq；

  3）计算n的欧拉函数φ(n)：φ(n)=(p-1)(q-1)；

  4）找到一个整数e（1<e<φ(n)），满足gcd(m, e) = 1（即e和φ(n)互素）；

  5）计算e在模φ(n)域上的逆元d（即ed = 1 (mod φ(n))）；

  6）至此，公钥和私钥生成完毕：（n, e）为公钥，（n, d）为私钥

1.2.2 RSA加密

  对于明文x，用公钥（n，e）对x加密的过程，就是将x转换为数字（字符串的话取其ASCII码或者unicode值），然后通过幂取模计算出y，其中y就是密文：

• y = x^e mod n

1.2.3 RSA解密

  对于密文y，用私钥（n，d）对y进行解密的过程和加密类似，同样是计算幂取模，得到明文x：

• x = y^d mod n

1.3 C语言实现

1.3.1 快速幂取模算法

目标：计算(a^b) mod c
预备知识：
1）(a1 × a2) mod c = [(a1 mod c)×(a2 mod c)] mod c
2）(a1 × a2 × a3) mod c = [(a1 mod c)×(a2 mod c)×(a3 mod c)] mod c
3）幂次b可以用二进制位表示，从而将a^b表示为a^bn × a^bn-1 ...... b^64 × b^32 × b^16 × b^8 × b^4 × b^2 × b^1
4）幂次取模的迭代计算：
　　d0 = (a^1) mod c;
　　d1 = (a^2) mod c = (d0^2) mod c;
　　d2 = (a^4) mod c = (d1^2) mod c;
　　d3 = (a^8) mod c = (d2^2) mod c;
　　d4 = (a^16) mod c = (d3^2) mod c;
　　　......
　　dn = ...... = (dn-1^2) mod c.
★★举例：(5^109) mod 9★★
109用二进制数表示为：110 1101
5^109 = 5^64 × 5^32 × 5^8 × 5^4 × 5^1
　　res0 = 1; 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　     d0 = 5;
　　res1 = (5^1) mod 9 = d0 mod 9 = 5; 　　　　　　　　　　　　　　　　　　  　 d1 = (d0^2) mod 9 = 7;
　　res2 = [res1 × [0*(5^2)] mod 9] mod 9 = res1 = 5; 　　　　　　　　　　　　　　d2 = (d1^2) mod 9 = 4;
　　res3 = [res2 × ((5^4) mod 9)] mod 9 = (res2 × d2) mod 9 = 2;                                 d3 = (d2^2) mod 9 = 7;
　　res4 = [res3 × ((5^8) mod 9)] mod 9 = (res3 × d3) mod 9 = 5;                                 d4 = (d3^2) mod 9 = 4;
　　res5 = [res4 × [0*(5^16)] mod 9] mod 9 = res4 = 5;                                                  d5 = (d4^2) mod 9 = 7;
　　res6 = [res5 × ((5^32) mod 9)] mod 9 = (res5 × d5) mod 9 = 8；                             d6 = (d5^2) mod 9 = 4;
　　res7 = [res6 × ((5^64) mod 9)] mod 9 = (res6 × d6) mod 9 = 5;                                d7 = (d6^2) mod 9 = 7;
输出：(5^109) mod 9 = res7 = 5

/**
 * @brief 快速幂取模算法（Exponentiation by Squaring）
 * @detail 计算 (a^b) mod c 的结果。
 *         核心思想：将指数 b 拆解为二进制形式，仅对二进制位为1的项进行累乘，
 *         将 O(b) 的时间复杂度降低为 O(log2 b)。
 * @param a 底数（当前版本实际为32位，存在溢出风险）
 * @param b 指数（使用 long long 确保大指数处理）
 * @param c 模数（int 类型，结果范围限制在 0 ~ c-1）
 * @return int 计算结果 (a^b mod c) 的余数
 */
int modpow(long long a, long long b, int c)
{
  int res = 1;          //存储中间结果

  while(b>0)
    {
        /*第1步：判断当前最低位是否为1。若为1，则说明当前轮次的底数幂(a^(2^i))需要乘入最终结果*/
        //必须使用长乘法，否则将会导致值的溢出
        if(b & 1)
        {
            res = (res * a) % c;    //乘入当前底数贡献，并立即取模压缩至<c
        }
        /*第2步：右移1位，准备处理下一个二进制位*/
        b = b >> 1;
        /*第3步：底数平方取模（为下一轮循环做准备）*/
        a = (a * a) % c;
    }  
    return res;
}

 1.3.2 雅可比算法

　　雅可比算法用于计算雅可比符号

　　1) 二次剩余
　　　　在模7得世界中，只有数字0, 1, 2, 3, 4, 5, 6
　　　　把每个数平方，得到的平方数取模7（即 x² mod 7），从而得到的数只有1、2、4，这三个数就叫“模7的二次剩余”，而3、5、6就叫非二次剩余。
　　　　因此，判断一个数是否为模n的二次剩余，就看它能不能开平方
　　2) 欧拉判别法
　　　　(a/n) ≡ a^(n-1)/2 mod n
　　　　等式左边是勒让德符号，它的值表示a是否为模n的二次剩余，只有三种值：1（是二次剩余）、-1（是二次非剩余）、0（a和n不互质）。需要通过开平方求解。
　　　　等式右边将左边判断“能否开平方”这件事，从“把1到(p-1)挨个平方试一遍”，变成了算一次模幂。a^((n-1)/2) mod n = [a mod n]^((n-1)/2)

　　3）二次互反律

　　　　如果m和n是两个互素的奇正整数，那么有：(m/n)(n/m) = (-1)^{((m-1)/2)·((n-1)/2)}

　　　　通过该二次互反律，我们可以将雅可比符号中的分子和分母进行翻转，而代价仅仅是引入一个由m和n模4的余数决定的简单符号。具体来说，仅当m和n形如4k+3（也即m mod 4和n mod 4 的余数均为3）时，这个符号因子才为-1；在其他情况（即m mod 4和n mod 4 的余数中至少有一个不为3）时，这个符号因子都为1.

　　4）补充定律

• • 第一补充定律----关于(-1/n)

　　　　　　(-1/n) = (-1)^(n-1)/2

　　　　　　这个公式表明，(-1/n)的值完全取决于n模4的余数。如果n ≡ 1 (mod 4)，它就是1；如果n ≡ 3 (mod 4)，它就是-1.

• • 第二补充定律----关于(2/n)：

　　　　　　(2/n) = (-1)^{(n^2-1)/8}

　　　　　　这个公式表明，(2/n) 的值完全取决于n模8的余数。如果n ≡ 1, 7 (mod 8)，它就是1；如果n ≡ 3, 5 (mod 8)，它的值为-1.

　　5）雅可比符号的计算逻辑--二次互反律

1. 化简分子​：首先，利用雅可比符号的周期性，将(an)中的 分子
   a对分母n取模，即a(modn)，使得分子小于分母。
2. 提取因子"2​"：如果分子是偶数，将分子中的所有因子
   2提出来。因为我们知道(2n)的值由n(mod8)决定，所以这一步很容易。
3. 互反翻转​：现在分子是一个奇数。此时，二次互反律允许我们将符号“翻转”为(na)，代价仅仅是乘上一个由a和n模4的余数决定的符号（1或−1）。
4. 重复以上步骤​：翻转之后，我们得到了一个新的雅可比符号，其分母变得更小了。我们可以对这个新符号重复上述过程。

/**
 * @brief 计算雅可比符号 (a/n)
 * 
 * 雅可比符号定义：对于正奇数 n，返回值为 -1、0 或 1。
 *   0  ：a 与 n 不互质（即 gcd(a, n) > 1）
 *   1  ：a 可能是模 n 的二次剩余（当 n 为素数时，一定是）
 *   -1 ：a 一定不是模 n 的二次剩余
 * 
 * 本函数使用二次互反律和欧几里得算法进行快速计算，时间复杂度 O(log n)。
 * 
 * @param a 被判断的整数（分子）
 * @param n 正奇数（分母）
 * @return int 雅可比符号 (a/n)，返回 -1、0 或 1
 * 
 * @note 当前实现未处理 a 为负数的情况，若 a < 0，a % n 可能为负，
 *       会导致后续逻辑错误。实际使用时应先对 a 取模并规范化为非负数。
 *       另外，函数假定 n 为正奇数，若 n 为偶数或非正数，结果无定义。
 */
int jacobi(int a, int n) 
{
    int twos, temp;      // twos 记录提取出的因子 2 的个数；temp 用于交换
    int mult = 1;        // 累积符号因子，初始为 1，最终作为返回值之一

    // 主循环：当 a 大于 1 且 a 不等于 n 时继续处理
    while (a > 1 && a != n) {
        // 利用雅可比符号的周期性：将 a 化简为 a mod n
        // 因此 (a/n) = (a mod n / n)
        a = a % n;

        // step1. 化简分子。如果化简后 a <= 1 或 a == n，则跳出循环，进入最终判断
        if (a <= 1 || a == n) break;

        // step2. 提取因子"2"。提取 a 中的所有因子 2，并统计个数
        twos = 0;
        // 当 a 是偶数时，将其除以 2，并递增 twos
        // 注意：++twos 作为循环条件的一部分，只要 a 是偶数就继续循环
        while (a % 2 == 0 && ++twos) a /= 2;

        // 根据提取出的因子 2 的个数调整符号
        // 公式：当 n ≡ ±1 (mod 8)，即 n%8 == 1 或 7，(2/n) = 1 
        //         当 n ≡ ±3 (mod 8)，即 n%8 == 3 或 5，(2/n) = -1 
        // 若 twos 为奇数，则需要乘上 (2/n) 的值
        // 表达式 (n % 8 == 1 || n % 8 == 7) * 2 - 1 巧妙地将布尔值转为 1 或 -1
        if (twos > 0 && twos % 2 == 1)
            mult *= (n % 8 == 1 || n % 8 == 7) * 2 - 1;

        // 再次检查边界（提取因子 2 后，a 可能变为 1）
        if (a <= 1 || a == n) break;

        // step3. 互反律翻转。二次互反律：当 a 和 n 都是奇数时，翻转 (a/n) 为 (n/a)
        // 代价是乘以 (-1)^((a-1)/2 * (n-1)/2)
        // 该指数为奇数当且仅当 a ≡ 3 (mod 4) 且 n ≡ 3 (mod 4)
        // 因此，若 a%4 != 1 且 n%4 != 1（即两者都余 3），则符号取反
        if (n % 4 != 1 && a % 4 != 1) mult *= -1;

        // 交换 a 和 n，准备下一轮迭代（相当于将 (a/n) 变为 (n/a)）
        temp = a;
        a = n;
        n = temp;
    }

    // 循环结束后的最终判断
    // 情况 1：a == 0，说明 gcd(a, n) != 1，雅可比符号为 0
    if (a == 0) return 0;
    // 情况 2：a == 1，说明互质，返回累积的符号因子 mult（±1）
    else if (a == 1) return mult;
    // 其他情况（例如 a == n），意味着 gcd(a, n) != 1，返回 0
    else return 0;
}

 1.3.3 素数判定

　　1）素数的单轮判定

/**
 * @brief Solovay-Strassen 素性测试的单轮判定函数
 * 
 * 利用欧拉判别法判断 n 是否可能为素数。
 * 如果返回 0，则 n 一定是合数；
 * 如果返回 1，则 n 很可能是素数（但存在被卡迈克尔数欺骗的可能）。
 * 
 * 算法核心：
 *   对于素数 n，任意与 n 互质的 a 都满足欧拉判别法：
 *       a^((n-1)/2) ≡ (a/n) (mod n)
 *   其中 (a/n) 是雅可比符号。
 *   如果等式不成立，则 n 必为合数。
 * 
 * @param a 随机选择的底数，通常满足 1 < a < n
 * @param n 待测试的奇数（大于 2）
 * @return int 返回 1 表示 n 通过本轮测试（可能为素数）；
 *             返回 0 表示 n 一定是合数
 * 
 * @note 单轮测试的误判概率至多为 1/2，实际使用时应对多个随机 a 重复调用。
 *       函数假定 n 为正奇数，且 a 与 n 互质（若不互质，x=0 会直接返回 0）。
 */
int solovayPrime(int a, int n) 
{
    // 1. 计算雅可比符号 (a/n)
    //    返回值可能是 -1、0 或 1
    int x = jacobi(a, n);

    // 2. 将 -1 转换为模 n 下的等价表示 n-1
    //    因为 modpow 的结果是 0 ~ n-1 之间的非负整数，
    //    而雅可比符号的 -1 在模 n 下就是 n-1，这样便于直接比较。
    if (x == -1) {
        x = n - 1;
    }

    // 3. 核心判定：
    //    - 若 x == 0，说明 gcd(a, n) != 1，n 必为合数，直接返回 0（假）。
    //    - 否则计算 a^((n-1)/2) mod n，并与雅可比符号 x 比较。
    //      如果相等，返回 1（真）；否则返回 0（假）。
    //    注意：&& 具有短路特性，若 x == 0，右侧的 modpow 不会执行。
    return x != 0 && modpow(a, (n - 1) / 2, n) == x;
}

　　2）判断整数n是否为“可能素数”

/**
 * @brief 判断 n 是否为 probable prime（可能素数）
 * 
 * 使用 Solovay-Strassen 测试进行 k 轮随机检验。
 * 如果所有轮次都通过，则返回 1（很可能是素数）；
 * 如果任何一轮失败，则返回 0（一定是合数）。
 * 
 * @param n 待测试的整数，要求 n >= 1
 * @param k 测试轮数，越大越可靠，建议 20~50
 * @return int 1 表示可能为素数；0 表示一定是合数
 */
int probablePrime(int n, int k) 
{
    // step1. 处理特殊情况：2 是素数
    if (n == 2) return 1;
    // 其他偶数、1 都不是素数
    else if (n % 2 == 0 || n == 1) return 0;

    // step2. 执行 k 轮随机测试
    while (k-- > 0) {
        // 随机选择底数 a，范围 [2, n-1]
        int a = rand() % (n - 2) + 2;
        // 如果单轮测试失败，立即断定 n 是合数
        if (!solovayPrime(a, n)) return 0;
    }

    // 所有轮次都通过，返回 1（可能素数）
    return 1;
}

　　3）生成随机素数

/**
 * @brief 随机生成一个小于 n 的素数（probable prime）
 * 
 * 算法思路：
 *   1. 随机选取一个 [0, n-1] 的起点；
 *   2. 将 n 调整为偶数，确保后续 (prime + 2) % n 的结果仍为奇数；
 *   3. 将起点调整为奇数，然后每次加 2 循环扫描所有奇数；
 *   4. 对每个奇数调用 probablePrime 进行素性测试，成功则返回。
 * 
 * @param n 上限（不包含）。要求 n > 2，否则可能陷入死循环。
 * @return int 找到的素数（小于 n）
 * 
 * @note 依赖外部宏 ACCURACY 定义素性测试轮数。
 *       使用标准库 rand()，随机性质量有限，不适合密码学安全场景。
 *       函数内部会修改局部变量 n，但不影响调用者。
 */
int randPrime(int n) 
{
    int prime = rand() % n;          // 1. 随机取 [0, n-1] 之间的整数
    n += n % 2;                      // 2. 将 n 调整为偶数
    prime += 1 - prime % 2;          // 3. 将 prime 调整为奇数
    while(1) {                       // 4. 无限循环，直到找到素数
        if(probablePrime(prime, ACCURACY)) return prime; // 5. 素性测试
        prime = (prime + 2) % n;     // 6. 跳到下一个奇数（循环扫描）
    }
}

1.3.4 欧几里得算法--计算两个非负整数的最大公约数

/**
 * @brief 计算两个非负整数的最大公约数（欧几里得算法）
 * 
 * 欧几里得算法原理：gcd(a, b) = gcd(b, a % b)，反复迭代直到 b == 0。
 * 
 * @param a 第一个整数（非负）
 * @param b 第二个整数（非负）
 * @return int a 和 b 的最大公约数
 * 
 * @note 若输入可能为负数，应在调用前取绝对值。
 */
int gcd(int a, int b) 
{
    int temp;                    // 临时变量，用于交换 a 和 b

    // 当 b 不为 0 时，继续辗转相除
    while (b != 0) {
        temp = b;                // 暂存当前的 b
        b = a % b;               // 计算 a 除以 b 的余数，作为新的 b
        a = temp;                // 将原来的 b 赋给 a
    }

    // 当 b 为 0 时，a 即为最大公约数
    return a;
}

1.3.5 生成RSA公钥指数e

/**
 * @brief 随机生成一个与 phi 互质的整数 e，用作 RSA 公钥指数
 * 
 * 算法：随机选取 [0, n-1] 的起点，然后线性扫描，
 *       找到第一个与 phi 互质的数返回。
 * 
 * @param phi 欧拉函数 φ(n)
 * @param n   RSA 模数 n = p * q
 * @return int 与 phi 互质的 e，满足 gcd(e, phi) == 1
 * 
 * @note 跳过 0、1、2，强制从 3 开始。
 *       使用 rand()，不适合密码学安全场景。
 *       未检查 e < phi，实际使用时应确保 e < phi。
 */
int randExponent(int phi, int n) 
{
    int e = rand() % n;           // 1. 随机生成 [0, n-1] 的起始值
    while(1) {                    // 2. 无限循环，直到找到合适的 e
        if(gcd(e, phi) == 1)      // 3. 检查 e 与 phi 是否互质
            return e;             //    若互质，直接返回 e
        e = (e + 1) % n;          // 4. 否则 e 加 1 并模 n，尝试下一个数
        if(e <= 2) e = 3;         // 5. 跳过 0、1、2，强制从 3 开始
    }
}

1.3.6 计算模逆元（扩展欧几里得算法）

/**
 * @brief 计算 n 在模 modulus 下的乘法逆元（扩展欧几里得算法）
 * 
 * 算法：扩展欧几里得算法
 *   在计算 gcd(n, modulus) 的同时，维护系数 x0, y0，使得：
 *       a = x0 * n + y0 * modulus
 *   当循环结束时 a = gcd(n, modulus)。若 gcd = 1，则：
 *       1 = x0 * n + y0 * modulus
 *   两边对 modulus 取模得：
 *       1 ≡ x0 * n (mod modulus)
 *   因此 x0 就是 n 的模逆元。
 * 
 * @param n       要求逆元的整数（通常为正数，且与 modulus 互质）
 * @param modulus 模数，必须大于 1
 * @return int    n 在模 modulus 下的逆元，范围 [0, modulus-1]
 * 
 * @note 前提条件：gcd(n, modulus) == 1，否则逆元不存在，返回值无意义。
 *       若 n 或 modulus 为负数，需先规范化为非负数。
 *       对于大整数，应使用 long long 或大数类型防止溢出。
 */
int inverse(int n, int modulus)
 {
    int a = n, b = modulus;                     // a, b 为辗转相除的余数序列
    int x = 0, y = 1, x0 = 1, y0 = 0, q, temp;  // 系数序列
    while(b != 0) {
        q = a / b;                              // 商
        temp = a % b;                           // 余数
        a = b;                                  // 更新 a 为旧 b
        b = temp;                               // 更新 b 为余数

        temp = x;                               // 更新 x 系数
        x = x0 - q * x;
        x0 = temp;

        temp = y;                               // 更新 y 系数
        y = y0 - q * y;
        y0 = temp;
    }
    if(x0 < 0) x0 += modulus;                   // 将负的逆元转为正数表示
    return x0;
}

1.3.7 读取文件数据

/**
 * @brief 从文件流读取全部数据，并填充到 bytes 的整数倍
 * 
 * 读取文件所有内容到动态缓冲区，末尾填充零字节，
 * 确保总长度是 bytes 的整数倍。如果原始长度正好是 bytes 的倍数，
 * 则额外添加一个全零块，以明确标记数据结束。
 * 
 * @param fd     已打开的文件流
 * @param buffer 输出参数，指向动态分配的缓冲区指针
 * @param bytes  块大小（必须 > 0）
 * @return int   读取并填充后的总字节数（bytes 的整数倍）
 * 
 * @note 调用者负责释放 *buffer。函数未处理内存分配失败和读取错误。
 */
int readFile(FILE* fd, char** buffer, int bytes) 
{
    int len = 0;                        // 已读取的数据长度
    int cap = BUF_SIZE;                 // 当前缓冲区容量
    int r;                              // 本次 fread 实际读取的字节数
    char buf[BUF_SIZE];                 // 栈上临时缓冲区

    // 初始分配 BUF_SIZE 字节的堆缓冲区
    *buffer = (char *)malloc(BUF_SIZE * sizeof(char));

    // 循环读取文件，直到 fread 返回 0（文件结束或错误）
    while ((r = fread(buf, sizeof(char), BUF_SIZE, fd)) > 0) {
        // 如果当前容量不足以容纳新数据，则翻倍扩容
        if (len + r >= cap) {
            cap *= 2;
            *buffer = (char *)realloc(*buffer, cap);
        }
        // 将新读的数据追加到缓冲区末尾
        memcpy(&(*buffer)[len], buf, r);
        len += r;
    }

    // 计算填充后的总长度：补齐到 bytes 的整数倍
    // 若 len % bytes == 0，则额外增加一个完整块（len + bytes）
    int padded_len = len + bytes - len % bytes;
    if (padded_len > cap) {
        *buffer = (char *)realloc(*buffer, padded_len);
    }

    // 填充零字节，直到长度是 bytes 的整数倍
    // do-while 保证至少填充一个字节（即使原始长度已是倍数）
    do {
        (*buffer)[len] = '\0';
        len++;
    } while (len % bytes != 0);

    return len;                         // 返回填充后的总长度
}

 

 

1.4 工程代码汇总

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define ACCURACY 5
#define SINGLE_MAX 10000
#define EXPONENT_MAX 1000
#define BUF_SIZE 1024

/**
 * Computes a^b mod c，计算a^b mod c
 */
int modpow(long long a, long long b, int c) {
    int res = 1;
    while(b > 0) {
        /* Need long multiplication else this will overflow...
         必须使用长乘法，否则这将溢出*/
        if(b & 1) {
            res = (res * a) % c;
        }
        b = b >> 1;
        a = (a * a) % c; /* Same deal here */
    }
    return res;
}

/**
 * Computes the Jacobi symbol, (a, n)，计算Jacobi符号（a,n）
 */
int jacobi(int a, int n) {
    int twos, temp;
    int mult = 1;
    while(a > 1 && a != n) {
        a = a % n;
        if(a <= 1 || a == n) break;
        twos = 0;
        while(a % 2 == 0 && ++twos) a /= 2; /* Factor out multiples of 2 ,减去2的倍数*/
        if(twos > 0 && twos % 2 == 1) mult *= (n % 8 == 1 || n % 8 == 7) * 2 - 1;
        if(a <= 1 || a == n) break;
        if(n % 4 != 1 && a % 4 != 1) mult *= -1; /* Coefficient for flipping，翻转系数 */
        temp = a;
        a = n;
        n = temp;
    }
    if(a == 0) return 0;
    else if(a == 1) return mult;
    else return 0; /* a == n => gcd(a, n) != 1 */
}

/**
 * Check whether a is a Euler witness for n，检查a是否为n的欧拉见证 */
int solovayPrime(int a, int n) {
    int x = jacobi(a, n);
    if(x == -1) x = n - 1;
    return x != 0 && modpow(a, (n - 1)/2, n) == x;
}

/**
 * Test if n is probably prime, using accuracy of k (k solovay tests)，用k的精度检查n是否可能是素数 */
int probablePrime(int n, int k) {
    if(n == 2) return 1;
    else if(n % 2 == 0 || n == 1) return 0;
    while(k-- > 0) {
        if(!solovayPrime(rand() % (n - 2) + 2, n)) return 0;
    }
    return 1;
}

/**
 * Find a random (probable) prime between 3 and n - 1在3和（n-1）之间找一个随机素数, this distribution is，
 * nowhere near uniform, see prime gaps
 */
int randPrime(int n) {
    int prime = rand() % n;
    n += n % 2; /* n needs to be even so modulo wrapping preserves oddness */
    prime += 1 - prime % 2;
    while(1) {
        if(probablePrime(prime, ACCURACY)) return prime;
        prime = (prime + 2) % n;
    }
}

/**
 * Compute gcd(a, b)，计算gcd（a,b）
 */
int gcd(int a, int b) {
    int temp;
    while(b != 0) {
        temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

/**
 * Find a random exponent x between 3 and n - 1 such that gcd(x, phi) = 1,在3和n-1之间找到随机指数x，使得gcd(x,phi)=1
 * this distribution is similarly nowhere near uniform,这种分布同样不接近制服
 */
int randExponent(int phi, int n) {
    int e = rand() % n;
    while(1) {
        if(gcd(e, phi) == 1) return e;
        e = (e + 1) % n;
        if(e <= 2) e = 3;
    }
}

/**
 * Compute n^-1 mod m by extended euclidian method，用扩展欧几里得法计算n^-1 mod m
 */
int inverse(int n, int modulus) {
    int a = n, b = modulus;
    int x = 0, y = 1, x0 = 1, y0 = 0, q, temp;
    while(b != 0) {
        q = a / b;
        temp = a % b;
        a = b;
        b = temp;
        temp = x; x = x0 - q * x; x0 = temp;
        temp = y; y = y0 - q * y; y0 = temp;
    }
    if(x0 < 0) x0 += modulus;
    return x0;
}

/**
 * Read the file fd into an array of bytes ready for encryption.将文件fd读入准备加密的字节数组
 * The array will be padded with zeros until it divides the number of数组将填充零，知道它划分每个块加密的字节数
 * bytes encrypted per block. Returns the number of bytes read.返回读取的字节数
 */
int readFile(FILE* fd, char** buffer, int bytes) {
    int len = 0, cap = BUF_SIZE, r;
    char buf[BUF_SIZE];
    *buffer = (char *)malloc(BUF_SIZE * sizeof(char));
    while((r = fread(buf, sizeof(char), BUF_SIZE, fd)) > 0) {
        if(len + r >= cap) {
            cap *= 2;
            *buffer = (char *)realloc(*buffer, cap);
        }
        memcpy(&(*buffer)[len], buf, r);
        len += r;
    }
    /* Pad the last block with zeros to signal end of cryptogram. An additional block is added if there is no room，将最后一个带有零的块插入密码的信号端。 如果没有房间，则增加一个额外的街区 */
    if(len + bytes - len % bytes > cap) *buffer = (char *)realloc(*buffer, len + bytes - len % bytes);
    do {
        (*buffer)[len] = '\0';
        len++;
    }
    while(len % bytes != 0);
    return len;
}

/**
 * Encode the message m using public exponent and modulus, c = m^e mod n使用公共指数和模量对消息m进行编码，c = m^e Mod n
 */
int encode(int m, int e, int n) {
    return modpow(m, e, n);
}

/**
 * Decode cryptogram c using private exponent and public modulus, m = c^d mod n，用私有指数和公共模量解码密码c，m = c^d Mod n
 */
int decode(int c, int d, int n) {
    return modpow(c, d, n);
}

/**
 * Encode the message of given length, using the public key (exponent, modulus)
 * The resulting array will be of size len/bytes, each index being the encryption
 * of "bytes" consecutive characters, given by m = (m1 + m2*128 + m3*128^2 + ..),
 * encoded = m^exponent mod modulus
 * 使用公钥（指数、模数)对给定长度的消息进行编码）
 得到的数组将是大小为len/字节，每个索引是由m=(m1m2*128m3*128^2.)给出的“字节”连续字符的加密，编码=m^指数mod模量
 */
int* encodeMessage(int len, int bytes, char* message, int exponent, int modulus) {
    int *encoded = (int *)malloc((len/bytes) * sizeof(int));
    int x, i, j;
    for(i = 0; i < len; i += bytes) {
        x = 0;
        for(j = 0; j < bytes; j++) x += message[i + j] * (1 << (7 * j));
        encoded[i/bytes] = encode(x, exponent, modulus);
#ifndef MEASURE
        printf("%d ", encoded[i/bytes]);
#endif
    }
    return encoded;
}

/**
 * Decode the cryptogram of given length, using the private key (exponent, modulus)
 * Each encrypted packet should represent "bytes" characters as per encodeMessage.
 * The returned message will be of size len * bytes.
 * 使用私钥（指数、模数)解码给定长度的密码）
 每个加密的数据包应该按照编码消息表示“字节”字符。
 返回的消息大小为len*字节。
 */
int* decodeMessage(int len, int bytes, int* cryptogram, int exponent, int modulus) {
    int *decoded = (int *)malloc(len * bytes * sizeof(int));
    int x, i, j;
    for(i = 0; i < len; i++) {
        x = decode(cryptogram[i], exponent, modulus);
        for(j = 0; j < bytes; j++) {
            decoded[i*bytes + j] = (x >> (7 * j)) % 128;
#ifndef MEASURE
            if(decoded[i*bytes + j] != '\0') printf("%c", decoded[i*bytes + j]);
#endif
        }
    }
    return decoded;
}

/**
 * Main method to demostrate the system. Sets up primes p, q, and proceeds to encode and
 * decode the message given in "text.txt"
 * 系统降级的主要方法。 设置素数p，q，并开始编码和
 *解码“text.txt”中给出的消息；
 */
int main(void) {
    int p, q, n, phi, e, d, bytes, len;
    int *encoded, *decoded;
    char *buffer;
    FILE *f;
    srand(time(NULL));
    while(1) {
        p = randPrime(SINGLE_MAX);
        printf("生成第一个随机素数, p = %d ... ", p);
        getchar();

        q = randPrime(SINGLE_MAX);
        printf("生成第二个随机素数, q = %d ... ", q);
        getchar();

        n = p * q;
        printf("计算p和q的乘积n, n = pq = %d ... ", n);
        if(n < 128) {
            printf("Modulus is less than 128, cannot encode single bytes. Trying again ... ");
            getchar();
        }
        else break;
    }
    if(n >> 21) bytes = 3;
    else if(n >> 14) bytes = 2;
    else bytes = 1;
    getchar();

    phi = (p - 1) * (q - 1);
    printf("计算欧拉函数的值phi, phi = %d ... ", phi);
    getchar();

    e = randExponent(phi, EXPONENT_MAX);
    printf("选取一个随机素数e, e = %d...\n获得公钥 (%d, %d) ... ", e, e, n);
    getchar();

    d = inverse(e, phi);
    printf("计算模反元素d, d = %d...\n获得密钥 (%d, %d) ... ", d, d, n);
    getchar();

    printf("打开文件 \"text.txt\" 用于读取信息\n");
    f = fopen("text.txt", "r");
    if(f == NULL) {
        printf("Failed to open file \"text.txt\". Does it exist?\n");
        return EXIT_FAILURE;
    }
    len = readFile(f, &buffer, bytes); /* len will be a multiple of bytes, to send whole chunks伦将是多个字节，以发送整个块 */
    fclose(f);

    printf("文件 \"text.txt\" 读取成功, 读取到%d字节. 以%d字节的字节流编码 ... ", len, bytes);
    getchar();
    printf("加密得密文为：");
    encoded = encodeMessage(len, bytes, buffer, e, n);
    printf("\n编码成功完成 ... ");
    getchar();


    printf("正在解码编码的信息 ... ");
    getchar();
    printf("解码得明文为：");
    decoded = decodeMessage(len/bytes, bytes, encoded, d, n);


    printf("\nRSA算法演示完成!\n");

    free(encoded);
    free(decoded);
    free(buffer);
    return EXIT_SUCCESS;
}

 

引用来源：

1. (6 封私信 / 80 条消息) RSA —— 经典的非对称加密算法 - 知乎

2. RSA算法原理（一） - 阮一峰的网络日志

3. C语言实现RSA算法 - MoreKing - 博客园

4. 雅可比符号及其互反律 | Bohrium