上一章我们介绍了 Coppersmith 相关攻击的基本原理和实现方法，帮助大家了解了如何利用 Coppersmith 方法来攻击 RSA 加密算法。接下来，我们将继续深入探讨 Coppersmith 相关攻击的应用。

欢迎来到《密码学核心算法实战》的 Coppersmith 相关攻击二专题！这里没有纸上谈兵的理论空谈（真的不画大饼😉），只有一把把能直接撬动数据安全的精密齿轮⚙️。

$d_q$ 的低位泄露攻击 🙃

这种情况多见于破损pem文件，或者某些特定的实现中，攻击者可能会获得 $d_q$ 的部分低位信息。我们可以利用这些泄露的低位信息来恢复完整的 $d_q$，进而推导出私钥。

和前一篇文章中的私钥低位泄露一样，我们认识到低位，可以理解成原来的方程在取模时的值，然后我们就可以求解另外的参数的低位，最后通过 Coppersmith 方法求解高位。

$d_q$ 的低位泄露攻击例题

$d_q$ 的低位泄露攻击例题下载

'''破损私钥以及密文-----BEGIN RSA PRIVATE KEY-----MIICXgIBAAKBgQDXFSUGqpzsBeUzXWtG9UkUB8MZn9UQkfH2Aw03YrngP0nJ3NwHUFTgzBSLl0tBhUvZO07haiqHbuYgBegO+Aa3qjtksb+bH6dz41PQzbn/l4Pd1fXmdJmtEPNh6TjQC4KmpMQqBTXF52cheY6GtFzUuNA7DX51wr6HZqHoQ73GQQIDAQAB​​​​​​​​yQvOzxy6szWFheigQdGxAkEA4wFss2CcHWQ8FnQ5w7k4uIH0I38khg07HLhaYm1czUcmlk4PgnDWxN+ev+vMU45O5eGntzaO3lHsaukX9461mA==-----END RSA PRIVATE KEY-----如何进行手工分离参数就不一一分析了，详情看之前的文章，这里直接给出数据'''n = 0xd7152506aa9cec05e5335d6b46f5491407c3199fd51091f1f6030d3762b9e03f49c9dcdc075054e0cc148b974b41854bd93b4ee16a2a876ee62005e80ef806b7aa3b64b1bf9b1fa773e353d0cdb9ff9783ddd5f5e67499ad10f361e938d00b82a6a4c42a0535c5e76721798e86b45cd4b8d03b0d7e75c2be8766a1e843bdc641e = 0x10001dq_l = 0xc90bcecf1cbab3358585e8a041d1b1q_inv_p = 0xe3016cb3609c1d643c167439c3b938b881f4237f24860d3b1cb85a626d5ccd4726964e0f8270d6c4df9ebfebcc538e4ee5e1a7b7368ede51ec6ae917f78eb598c = 30867633715813868869594516898484466949832562855682390289015078636128522331216753026144388726648565996116979180534633656943032219373784742974695394149452376092090200793002116674808387426569939440254310919848751355794417768901965964656988835770326844588984815500667657575205646452291264006781430216086103523765

直接取模，然后构建出方程：

$$e \cdot d_q - 1 \equiv k(q - 1) \mod 2^{know\_bits}$$

因为 $d_q < q - 1$，所以可以知道 $k$ 的范围是 $[1, e]$，我们可以枚举 $k$ 来求解 $q$ 的低位。

小技巧：因为求解 $q$时用到了 $k^{-1}$，即 $k$ 是奇数（要和模互质），所以我们可以直接跳过偶数的 $k$ 来加速枚举。

注意，我们还有一个额外的参数，它是 $q^{-1} \mod p$，我们由关系 $q \cdot q^{-1} \equiv 1 \mod p$ 可以知道

$$q^{-1} \cdot q - 1 \equiv sp$$

两边同时乘 $q$，就可以得到

$$q^{-1} \cdot q^2 - q \equiv sn$$

所以，在模 $n$ 的情况下，我们构造出 Coppersmith 来解出高位的方程是

$$q^{-1} \cdot q^2 - q \equiv 0 \mod n$$

解题代码示例：

from Crypto.Util.number import *from sage.all import *n = 0xd7152506aa9cec05e5335d6b46f5491407c3199fd51091f1f6030d3762b9e03f49c9dcdc075054e0cc148b974b41854bd93b4ee16a2a876ee62005e80ef806b7aa3b64b1bf9b1fa773e353d0cdb9ff9783ddd5f5e67499ad10f361e938d00b82a6a4c42a0535c5e76721798e86b45cd4b8d03b0d7e75c2be8766a1e843bdc641e = 0x10001dq_l = 0xc90bcecf1cbab3358585e8a041d1b1q_inv_p = 0xe3016cb3609c1d643c167439c3b938b881f4237f24860d3b1cb85a626d5ccd4726964e0f8270d6c4df9ebfebcc538e4ee5e1a7b7368ede51ec6ae917f78eb598c = 30867633715813868869594516898484466949832562855682390289015078636128522331216753026144388726648565996116979180534633656943032219373784742974695394149452376092090200793002116674808387426569939440254310919848751355794417768901965964656988835770326844588984815500667657575205646452291264006781430216086103523765nbits = n.nbits()konw_bits = dq_l.nbits()mod = 2**konw_bitsP.<x> = PolynomialRing(Zmod(n))print("Start solving...")for k in range(1, e + 1):    if k % 2 == 0:         continue    q_l = ((e * dq_l - 1) * inverse_mod(k, mod) + 1) % mod    # 构造二次多项式    f = q_inv_p * (x * mod + q_l)**2 - (x * mod + q_l)    f = f.monic()    roots = f.small_roots(X=2**(nbits // 2 - konw_bits + 1), beta=1)    if roots:        x_val = int(roots[0])        q = x_val * mod + q_l        if n % q == 0:            print(f"[*] Found q with k = {k}")            p = n // q            d = inverse_mod(e, (p-1)*(q-1))            m = pow(c, d, n)            print("Message:", long_to_bytes(int(m)))            break# b'flag{the_broken_pem_is_dangerous!}'

双元变量 Coppersmith 攻击 😅

在某些特定的攻击场景中，我们可能会同时获得两个相关参数的部分信息。这时，我们可以构造一个包含两个变量的多项式方程，利用 Coppersmith 方法来同时求解这两个未知数。

但是，相较于单元变量的 Coppersmith 攻击，双元变量需要自己构造格，并且需要自己实现 LLL 算法来进行格的约简，因此难度较大。不过这里我会给出一种简单的构造方式。

对于双元变量方程：

$$xy + a x^2 + b y^2 + c x + d y + e \equiv 0 \mod P$$

我们可以构造出如下的格：

$$\begin{bmatrix}P & 0 & 0 & 0 & 0 & 0\\0 & P \cdot X & 0 & 0 & 0 & 0\\0 & 0 & P \cdot Y & 0 & 0 & 0\\0 & 0 & 0 & P \cdot X^2 & 0 & 0\\0 & 0 & 0 & 0 & P \cdot Y^2 & 0\\e & c & d & a & b & X \cdot Y\end{bmatrix}$$

其中 $X$ 和 $Y$ 是我们对未知数 $x$ 和 $y$ 的范围的估计。通过对这个格进行 LLL 约简，我们可以得到一个新的基，其中包含一个短向量，这个短向量对应的多项式在 $x$ 和 $y$ 的范围内有一个小根，这个小根就是我们要找的解。

双元变量 Coppersmith 攻击例题

双元变量 Coppersmith 攻击例题下载

from sage.all import *from Crypto.Util.number import *from secret import mp = getPrime(1024)k = getPrime(64)r1 = getPrime(512)r2 = getPrime(512)t1 = (k * inverse(m + r1, p)) % pt2 = (k * inverse(m + r2, p)) % pleak1 = t1 >> 244leak2 = t2 >> 244print("leak1 =",leak1)print("leak2 =",leak2)print("p =",p)print("k =",k)print("r1 =",r1)print("r2 =",r2)# leak1 = 1098816764286426157385797801363396675371118108280094592042050672573359525317258628504654733753781201133132612254789332026374788761747254155970613812606464205839077461898387247572628046476143045468089557793517353783804524800718752833296# leak2 = 1049656482213011765520700817730759174299375637725089075248860293784388137259519537644863360085943551872969496676976510844694589456499043770509884151671385719255903566416708982265930991647265599750836450978226653691655928529034866663445# p = 108209265779528487066534499136599909709853973107950537298744390757900138945182229902606206423050930011269860879007733713146197683046339710813223062191831446119265107116553831108599559354822644205393315657677544783720147837009193921493082268867053418119324279998822097576668591119657920848005423817059278923289# k = 12365281680381288671# r1 = 9144410517756126435013029016083002712735801054642387622098751193487101216215562293703971866241356055783669611204550875272227458679304511201946361648448397# r2 = 12776175140844604979090713660094736561506184755499536907757209332776967059175177777412075292688365522364612020362287897485306481341531072303954683485324863

在这个例题中，我们同时获得了两个相关参数的部分信息，即 $t1$ 和 $t2$ 的高位泄露。我们可以利用这些泄露的信息来构造一个包含两个变量的多项式方程，并使用 Coppersmith 方法来求解这两个未知数 $x$ 和 $y$。

设 $x$ 和 $y$ 分别是我们要求解的未知数，$A$ 和 $B$ 是已知的高位泄露，那么我们可以构造出如下的方程：

$$t_1 \cdot (m + r1) \equiv t_2 \cdot (m + r2) \mod p$$

由 $t_1 \cdot (m + r1) \equiv k \mod p$ 可以得到：

$$m \equiv k \cdot t_1^{-1} - r1 \mod p$$

带入上面式子，我们可以得到一个关于 $t_1$ 和 $t_2$ 的二次多项式方程：

$$k (t_1 - t_2) + t_1 t_2 (r1 - r2) \equiv 0 \mod p$$

带入 $t_1 = A + x$ 和 $t_2 = B + y$，进而化简成可以使用格基方法求解的方程：

$$f(x, y) = xy + C_x \cdot x + C_y \cdot y + C_0 \equiv 0 \mod p$$

解题代码示例：

from sage.all import *from Crypto.Util.number import *p = 108209265779528487066534499136599909709853973107950537298744390757900138945182229902606206423050930011269860879007733713146197683046339710813223062191831446119265107116553831108599559354822644205393315657677544783720147837009193921493082268867053418119324279998822097576668591119657920848005423817059278923289k = 12365281680381288671r1 = 9144410517756126435013029016083002712735801054642387622098751193487101216215562293703971866241356055783669611204550875272227458679304511201946361648448397r2 = 12776175140844604979090713660094736561506184755499536907757209332776967059175177777412075292688365522364612020362287897485306481341531072303954683485324863leak1 = 1098816764286426157385797801363396675371118108280094592042050672573359525317258628504654733753781201133132612254789332026374788761747254155970613812606464205839077461898387247572628046476143045468089557793517353783804524800718752833296leak2 = 1049656482213011765520700817730759174299375637725089075248860293784388137259519537644863360085943551872969496676976510844694589456499043770509884151671385719255903566416708982265930991647265599750836450978226653691655928529034866663445A = leak1 << 244B = leak2 << 244D = (r1 - r2) % pX_bound = 2**244Y_bound = 2**244# 构造二次多项式的系数c_xy = Dc_x = (D * B + k) % pc_y = (D * A - k) % pc_0 = (D * A * B - k * (B - A)) % p# 归一化多项式，使得最高次项系数为1inv_D = inverse_mod(D, p)C_x = (c_x * inv_D) % pC_y = (c_y * inv_D) % pC_0 = (c_0 * inv_D) % p# 构造格M = Matrix(ZZ,[    [p, 0, 0, 0],    [0, p * X_bound, 0, 0],    [0, 0, p * Y_bound, 0],    [C_0, C_x * X_bound, C_y * Y_bound, X_bound * Y_bound]])L = M.LLL()PR.<x,y> = PolynomialRing(ZZ)polys = []for row in L : # 恢复多项式    ploy = (row[0]) + (row[1] // X_bound) * x + (row[2] // Y_bound) * y + (row[3] // (X_bound * Y_bound)) * x * y    if not ploy.is_constant():        polys.append(ploy)    if len(polys) >= 2: # 由于我们构造的格中有两个短向量，所以我们只需要前两个非零多项式来求解        breakx_root = Nonef1 = polys[0]f2 = polys[1]res = f1.resultant(f2, y) # 消去 y，得到关于 x 的单变量多项式if not res.is_constant():    roots = res.univariate_polynomial().roots() # 求解 x 的根    for r, _ in roots:        if 0 <= r < X_bound:            f1_x = f1.subs(x=r) # 将 x 的值代入 f1，得到关于 y 的单变量多项式            y_roots = f1_x.univariate_polynomial().roots()            for ry, _ in y_roots: # 验证 (x, y) 是否满足原方程                if (r * ry + C_x * r + C_y * ry + C_0) % p == 0:                    x_root = r                    breakt1 = A + Integer(x_root)m = (k * inverse(t1, p) - r1) % pflag = long_to_bytes(int(m))print(flag)# b'flag{u_know_the_bivariate_coppersmith!!!}'

Boneh Durfee 攻击 😝

Boneh Durfee 攻击是一种针对 RSA 加密算法的攻击方法，主要用于攻击 RSA 的私钥 $d$ 的构造不当的情况。具体来说，当 RSA 的私钥 $d$ 满足 $d < N^{0.292}$ 时，攻击者可以利用 Boneh Durfee 攻击来恢复私钥 $d$。这种方法是优于 Wiener 攻击的，因为它可以攻击更大的私钥范围。

从 $e \cdot d = k \cdot \phi(n) + 1$ 开始，直接取模 $e$，我们得到：

$$k \cdot \phi(n) + 1 \equiv 0 \mod e$$

由 $n = p \cdot q$ 和 $\phi(n) = (p-1)(q-1)$，我们可以将 $\phi(n)$ 表示为 $n - (p + q) + 1$。因此，我们可以将上面的方程改写为：

$$k \cdot (n - (p + q) + 1) + 1 \equiv 0 \mod e$$

转化一下，我们可以得到：

$$2 k (\frac{n + 1}{2} - \frac{p + q}{2}) + 1 \equiv 0 \mod e$$

设 $A = \frac{n + 1}{2}$，$x = 2 k$，$y = \frac{p + q}{2}$，我们可以将上面的方程改写为：

$$f(x, y) = x \cdot (A - y) + 1 \mod e$$

我们可以构造多项式 $f(x,y)$，要求找到它在模 $e$ 下 的小根。为了通过LLL算法求解，我们需
要构造一个格，其基向量由 $f(x,y)$ 在模 $e^m$ 下的多个平移（shifts）构成。

我们定义两类平移多项式:
x-shifts：

$$g_{k,i}(x,y) = x^і f(x,y)^k e^{m-k}, 其中 k \in [0,m],i \in [0,m-k]$$

y-shifts：

$$h_{k,j}(x,y) = y^j f(x,y)^k e^{m-k}, 其中 k \in [0,m],j \in [1,m-k]$$

然后，我们将 $x$ 替换为 $xX$，$y$ 替换为 $yY$ 以便在格中编码目标上界，根据这些多项式的系数向量构造出一个方阵(Lattice Matrix)。通过运行LLL算法对格进行格基规约，即可在规约后的基中找到范数足够低的向量，这些向量对应于在 $\mathbb{Z}$ 上有相同小根的多项式。

设 $m$ 为格的阶，$t$ 为位移次数，以两者取 $1$ 为例构造格：

$$\begin{bmatrix}e & 0 & 0 & 0 & 0 \\0 & eX & 0 & 0 & 0 \\0 & 0 & Y & A \cdot Y & - X \cdot Y^2 \\1 & A \cdot X & 0 & - X \cdot Y & 0\end{bmatrix}$$

在真正的 Boneh-Durfee 攻击脚本中（比如 $m = 4$，$t = 2$ 时），矩阵维度会到达数十维。如果我们巧妙地排序（通常按照 $x$ 的次数和组合），矩阵会呈现出分块对角或下三角的形状：

$$M = \begin{bmatrix}M_x & M_{xy} \\0 & M_y\end{bmatrix}$$

其中：

• 左上角的块 $M_x$ 对应于 x-shifts，在合理排序后，这部分恰好是一个关于单项式的下三角矩阵，主对角线上的元素都是 $e^{m-k}X^i Y^j$ 形式的对角元。
• 右下角的块 $M_y$，对应于 y-shifts。这些多项式会在矩阵的右侧带来额外的列（代表高阶的 $y$ 和 $xy$ 单项式），需要将这部分一并丢入LLL 算法进行规约。

LLL格基规约的作用就是通过行变换，使得底部的向量（即矩阵的行）变得尽可能短。由于所有行对应的多项式在模 $e^m$ 的意义下根不变，规约后得到的最最短向量对应的那个多项式如果在全空间上的值绝对值小于 $e^m$，就可以直接在整数环 $\mathbb{Z}$ 上求解其根 $x_0$，$y_0$ 了。

Boneh Durfee 攻击例题

Boneh Durfee 攻击例题下载

from Crypto.Util.number import *from secret import mp = getPrime(512)q = getPrime(512)n = p * qphi = (p - 1) * (q - 1)print("n =", hex(n))d = getPrime(int(1024 * 0.270))e = inverse(d,phi)print("e =", hex(e))c = pow(m, e, n)print("c =", hex(c))# n = 0xe788a2054a29f6769c2586a6faec7b2b5880317d5ca6a4595e9f07e164c00e34a0e469ef5127a46d1a4a0e9957189031d735d81bd4a8c80ce4b14b9c76aaa4863b629536ad6d7095a2358375d87155a65f981151b5e0d3591636da13ec004f1b545999ee1de21c790c73fd2ed7338b325ad5df231a193398cb1905a81f499bf1# e = 0x3d2638e4f1975d3e30470f9b99c799229016f24a74560c92f83a5157a1276bb25eae05ca6a5f9f345d4333602d6c3af54ad4d433eaab55d4f457fbbd78807e85d7f6c3266655dc9cf86d6dcf1d06c5a2c630a4b5ef10a67bb6eacb2e188c33399b1a636ad0bd8b912cb42ec54f73ec965c1ecca7df8d74923b98e93b175bfaf7# c = 0x694e83ff962e9e98e3aeea50eac9c97f22ce06bff699819c68c6b91c71ad49fad7b2f2bf6eb8dd92aee3234229ce8f8bb52e5894f5551bde341a5e18682776d33353a571d883da4ab40d55efdcc0517d4a8c16a63b01926bfbc6594c9123fc8b19b1cc8996f6466f4363f83e3541929c7c1b73221bf2127b1165d027e925f55d

在这个例题中，我们构造了一个 RSA 加密系统，其中私钥 $d$ 满足 Boneh Durfee 攻击的条件。我们使用 SageMath 来实现 Boneh Durfee 攻击，通过构造格并进行 LLL 规约来恢复私钥 $d$，最终解密出消息 $m$。

from sage.all import *from Crypto.Util.number import *n = 0xe788a2054a29f6769c2586a6faec7b2b5880317d5ca6a4595e9f07e164c00e34a0e469ef5127a46d1a4a0e9957189031d735d81bd4a8c80ce4b14b9c76aaa4863b629536ad6d7095a2358375d87155a65f981151b5e0d3591636da13ec004f1b545999ee1de21c790c73fd2ed7338b325ad5df231a193398cb1905a81f499bf1e = 0x3d2638e4f1975d3e30470f9b99c799229016f24a74560c92f83a5157a1276bb25eae05ca6a5f9f345d4333602d6c3af54ad4d433eaab55d4f457fbbd78807e85d7f6c3266655dc9cf86d6dcf1d06c5a2c630a4b5ef10a67bb6eacb2e188c33399b1a636ad0bd8b912cb42ec54f73ec965c1ecca7df8d74923b98e93b175bfaf7c = 0x694e83ff962e9e98e3aeea50eac9c97f22ce06bff699819c68c6b91c71ad49fad7b2f2bf6eb8dd92aee3234229ce8f8bb52e5894f5551bde341a5e18682776d33353a571d883da4ab40d55efdcc0517d4a8c16a63b01926bfbc6594c9123fc8b19b1cc8996f6466f4363f83e3541929c7c1b73221bf2127b1165d027e925f55ddef boneh_durfee_attack(N, e, m, t, X, Y):    """    Boneh-Durfee 攻击主函数    N, e: RSA 公钥    m, t: 决定格大小的超参数    X, Y: 根的上界    """    PR.<x,y> = PolynomialRing(ZZ)    A = (N + 1) // 2    f = x*(A - y) + 1    shifts = []    # x-shifts    for k in range(m + 1):        for i in range(m - k + 1):            shifts.append(x^i * f^k * e^(m - k))    # y-shifts    for k in range(m + 1):        for j in range(1, t + 1):            shifts.append(y^j * f^k * e^(m - k))    # 提取所有的单项式 (x^i * y^j)    monomials = set()    for shift in shifts:        monomials.update(shift.monomials())    monomials = sorted(list(monomials)) # 固定单项式顺序，即矩阵的列    # 构建格矩阵    dim = len(shifts)    M = Matrix(ZZ, dim, dim)    for i, shift in enumerate(shifts):        shift_scaled = shift(X*x, Y*y)        for j, mon in enumerate(monomials):            M[i, j] = shift_scaled.monomial_coefficient(mon)    print(f"[+] 格矩阵构造完成，维度: {dim}x{dim}")    print("[+] 正在执行 LLL 格基规约...")    M_lll = M.LLL()    # 还原多项式，寻找代数无关解    PR2.<x, y> = PolynomialRing(ZZ)    polys = []    for i in range(M_lll.nrows()):        if M_lll[i].is_zero():            continue        poly = 0        for j, mon in enumerate(monomials):            val = M_lll[i, j] // mon(X, Y)            poly += val * mon(x, y)        if poly != 0:            polys.append(poly)    print(f"[+] 获取到了 {len(polys)} 个短多项式，开始求解公根...")    # 因为计算 Resultant 非常慢，这里我们只取前三个最短的非零多项式进行两两组合求解    for i in range(min(3, len(polys))):        for j in range(i+1, min(4, len(polys))):            p1 = polys[i]            p2 = polys[j]            try:                # 使用结式消元                res = p1.resultant(p2, x)                if res.is_zero():                    continue                res_y = res.univariate_polynomial()                roots = res_y.roots()                if roots:                    for y0, _ in roots:                        p1_univariate = p1.subs(y=y0).univariate_polynomial()                        if p1_univariate.is_zero():                            p1_univariate = p2.subs(y=y0).univariate_polynomial()                        if not p1_univariate.is_zero():                            x_roots = p1_univariate.roots()                            if x_roots:                                x0 = x_roots[0][0]                                if (x0 * (A - y0) + 1) % e == 0:                                    return x0, y0            except Exception as ex:                continue    return None, Nonedelta = 0.27bits = 1024X = floor(2 * e**delta)Y = floor(n**0.5)m = 7t = int((m + 1) * (1 - 2*delta)) + 1x0, y0 = boneh_durfee_attack(n, e, m, t, X, Y)if x0 is not None:    print(f"[!] 找到小根 x = {x0}, y = {y0}")        # 根据我们设定的 y = (p+q)/2    half_sum = y0    sum_pq = 2 * half_sum    # 构造二次方程 Z^2 - (p+q)Z + N = 0 求解 p, q    R.<Z> = PolynomialRing(ZZ)    f = Z^2 - sum_pq * Z + n    pq_roots = f.roots()    if pq_roots:        p = pq_roots[0][0]        q = pq_roots[1][0]        phi = (p - 1) * (q - 1)        d = inverse_mod(e, phi)        m = pow(c, d, n)        flag = long_to_bytes(m)        print(f"Flag: {flag}")# Flag: b'flag{boneh_durfee_attack_is_fun!}'

上一章：RSA加解密专题 - Coppersmith 相关攻击一 👈
下一章：RSA加解密专题 - 预言机相关攻击 👈
回到开始：关于我 👈

相关链接：
RSA加解密专题 - 公私钥格式相关攻击 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4006.html 2026-03-10T14:33:00.000Z

上一章我们介绍了 Coppersmith 相关攻击的基本原理和实现方法，帮助大家了解了如何利用 Coppersmith 方法来攻击 RSA 加密算法。接下来，我们将继续深入探讨 Coppersmith 相关攻击的应用。

欢迎来到《密码学核心算法实战》的 Cop]]>

2026-03-15T01:59:08.779Z Dorange 上一章我们介绍了 BSGS（Baby-Step Giant-Step）算法的基本原理和实现方法，帮助大家快速求解离散对数问题。接下来，我们将继续深入探讨 BSGS 算法的另一种应用。除了在离散对数问题中，BSGS 算法也可以用于求解 ECC（Elliptic Curve Cryptography）中的离散对数问题，这在现代密码学中具有重要的实际意义。

欢迎来到《密码学核心算法实战》的 BSGS 算法二专题！这里没有纸上谈兵的理论空谈（真的不画大饼😉），只有一把把能直接撬动数据安全的精密齿轮⚙️。

ECC中的BSGS算法 🌟

在 ECC 中，离散对数问题的形式是：给定一个椭圆曲线 $E$ 上的点 $P$ 和 $Q$，找到一个整数 $k$ 使得 $Q = kP$。这个问题被称为椭圆曲线离散对数问题（ECDLP），是 ECC 加密算法安全性的基础。而 BSGS 算法可以用来求解 ECDLP，从而在某些情况下破解 ECC 加密。

ECC中的BSGS算法的原理 😵

既然有前一章的铺垫，那么原理就直接简单讲解了。

求解 $x$ 使得 $Q = xP$，我们可以将 $x$ 表示为 $x = i \cdot m - j$，其中 $m = \lceil \sqrt{n} \rceil$，$i \in [0, m)$ （大步），$j \in [0, m)$ （小步）。这样我们可以将 ECDLP 转化为以下形式：

$$i \cdot mP = Q + jP$$

小步（Baby Step）：计算 $Q + jP$，对于 $j \in [0, m)$，将结果存入哈希表（键为点的坐标，值为 $j$）。每次都是加 $P$，所以叫做小步。

大步（Giant Step）：计算 $mP$，对于 $i \in [0, m)$，计算 $i \cdot mP$，检查是否在哈希表中存在对应的点，如果存在，则可以得到 $x = i \cdot m - j$。每次都是加 $mP$，所以叫做大步。

ECC中的BSGS算法的实现 🙃

import mathclass EllipticCurve:    def __init__(self, a, b, p):        self.a = a        self.b = b        self.p = p    # 求逆元 (Fermat's little theorem)    def inverse(self, val):        return pow(val, self.p - 2, self.p)    # 点加运算 P + Q    def add(self, P, Q):        if P is None: return Q        if Q is None: return P        x1, y1 = P        x2, y2 = Q        if x1 == x2 and (y1 + y2) % self.p == 0:            return None # 也就是无穷远点 O        if P == Q:            # 斜率 k = (3x^2 + a) / 2y            lam = (3 * x1 * x1 + self.a) * self.inverse(2 * y1) % self.p        else:            if x1 == x2: return None # 垂直切线            # 斜率 k = (y2 - y1) / (x2 - x1)            lam = (y2 - y1) * self.inverse(x2 - x1) % self.p        x3 = (lam * lam - x1 - x2) % self.p        y3 = (lam * (x1 - x3) - y1) % self.p        return (x3, y3)    # 标量乘法 k * P (Double-and-Add 算法)    def multiply(self, k, P):        res = None        current = P        while k > 0:            if k % 2 == 1:                res = self.add(res, current)            current = self.add(current, current)            k //= 2        return resdef bsgs_ecc(curve, P, Q, order):    """    ECC 上的 BSGS 算法    求解 x 使得 Q = xP    原理: x = i * m - j => i * mP = Q + jP    :param curve: 椭圆曲线对象    :param P: 基点 (Generator)    :param Q: 目标点 (Public Key)    :param order: 群的阶 n (或者一个足够大的数)    :return: 离散对数 x    """    # 1. 计算步长 m = ceil(sqrt(n))    m = math.ceil(math.sqrt(order))    # 2. 小步 (Baby Step)    # 计算 Q + jP，其中 j ∈ [0, m)    # 我们构建一个哈希表: { Point: j }    step_dict = dict()    current_point = Q # 初始值为 Q + 0P    for j in range(m):        # 将点作为 key 存入 (注意点需要是可哈希的类型，元组是可以的)        if current_point not in step_dict:             step_dict[current_point] = j        # 下一步：Q + (j+1)P = (Q + jP) + P        current_point = curve.add(current_point, P)    # 3. 大步 (Giant Step)    # 计算 i * (mP)，其中 i ∈ [1, m] (通常遍历到 m+1 保证覆盖)    # 先算出 mP    mP = curve.multiply(m, P)    current_giant = mP # 初始值为 1 * mP    for i in range(1, m + 1):        # 检查 i * mP 是否在 Baby Steps 中        if current_giant in step_dict:            j = step_dict[current_giant]            # 找到碰撞：i * mP = Q + jP            # Q = i * mP - jP = (i * m - j) P            x = i * m - j            return x        # 下一步：(i+1)mP = imP + mP        current_giant = curve.add(current_giant, mP)    return None

SageMath 偷懒 🤓👆

有同学说：“博主，博主，你的算法确实很厉害，但是还是太吃操作了，有没有更加简单无脑的用法？”👻
有的，兄弟有的，这样的算法在 SageMath 中早就已经被封装好了🤫，我们直接调用就行了：

from sage.all import discrete_log# 1. 定义椭圆曲线 E: y² = x³ + ax + b mod pp = pE = EllipticCurve(GF(p), [a, b])  # 格式：EllipticCurve(有限域, [a, b])，对应 y²=x³+ax+b# 2. 定义基点 P 和公钥 QP = E(x_p, y_p)  # 基点 Q = E(x_q, y_q)  # 公钥 n = P.order()# 3. 求解离散对数：找 x 使得 x*P = Q（底层用BSGS/Pollard's Rho等算法，更加完善）private_key = discrete_log(Q, P, n, operation='+')print(f"私钥 x = {private_key}")

怎么样，是不是非常简单？🤣👉🤡

上一章：密码学算法 - BSGS一 算法 👈
下一章：密码学算法 - AMM 算法 👈
回到开始：关于我 👈

相关链接：
加解密模式分析 - ECC 加密算法 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/3009.html 2026-03-09T11:03:00.000Z

上一章我们介绍了 BSGS（Baby-Step Giant-Step）算法的基本原理和实现方法，帮助大家快速求解离散对数问题。接下来，我们将继续深入探讨 BSGS 算法的另一种应用。除了在离散对数问题中，BSGS 算法也可以用于求解 ECC（Elliptic Curve C]]>

2026-03-14T07:16:20.547Z Dorange Coppersmith 攻击是一种针对 RSA 加密算法的攻击方法，主要用于在特定条件下恢复 RSA 私钥或解密 RSA 密文。该攻击方法由 Don Coppersmith 在 1996 年提出，利用了 RSA 加密算法中的数学结构和性质。

这里我们并不会深入到 Coppersmith 攻击的数学细节，但我们会介绍一些相关的攻击场景和原理，以帮助你理解 Coppersmith 攻击的基本思想和应用。

部分明文泄露攻击 😋

单一变量的情况下，我们主要关注构建一个多项式方程，并使用 Coppersmith 方法来寻找小根。这种方法可以在某些特定条件下成功，例如当明文的某些部分已知或满足特定的数学关系时。

最简单的情况莫过于明文的某些部分已知，不管是哪一种泄露直接套用加密的方程就好：

$$\begin{align*}(m_h + x)^e &\equiv c \pmod{n} \\(m_h + x \ll m_l.\text{nbits}() + m_l)^e &\equiv c \pmod{n} \\(x \ll m_l.\text{nbits}() + m_l)^e &\equiv c \pmod{n}\end{align*}$$

其中 $m_h$ 是已知的明文部分，$x$ 是未知的部分，$e$ 是公钥指数，$c$ 是密文，$n$ 是模数。

部分明文泄露攻击例题

部分明文泄露攻击例题下载

from Crypto.Util.number import *from secret import mp = getPrime(512)q = getPrime(512)n = p*qe = 5m_h = (m >> 72) << 72c = pow(m, e, n)print("n =", n)print("c =", c)print("e =", e)print("m_h =", m_h)# n = 71406081470098943664147354595360130965949415477183415925937691459300487381042569174133696785917044437192425109528474145856370063591801161214117594482262437036039582313557538014983339960352144743243869648717280156439092931956094810765560689842129272908038382363737252851872602935800129772310097494871743999683# c = 60258767266725462475089309010639723372675479396874103345307979963872676339512613518477686690014996946520051358953694535853808486956187104018894409809787475031000910824770481120529345447944422364229572306876886435743357596246183561495740412854973420619617616182147277760953828917472063677119186309853762339354# e = 5# m_h = 777244835068427274667156821981506353228924473235252582307290753380891138229664743424

在这个例题中，我们生成了一个 RSA 密钥对，并加密了一个明文消息。我们知道明文的高位部分 $m_h$，并且我们有密文 $c$ 和公钥指数 $e$。使用 Coppersmith 方法，我们可以尝试找到未知的部分 $x$，从而恢复完整的明文消息。

解题代码示例：

from sage.all import *n = 71406081470098943664147354595360130965949415477183415925937691459300487381042569174133696785917044437192425109528474145856370063591801161214117594482262437036039582313557538014983339960352144743243869648717280156439092931956094810765560689842129272908038382363737252851872602935800129772310097494871743999683c = 60258767266725462475089309010639723372675479396874103345307979963872676339512613518477686690014996946520051358953694535853808486956187104018894409809787475031000910824770481120529345447944422364229572306876886435743357596246183561495740412854973420619617616182147277760953828917472063677119186309853762339354e = 5m_h = 777244835068427274667156821981506353228924473235252582307290753380891138229664743424P.<x> = PolynomialRing(Zmod(n))f = (x + m_h)^e - croots = f.small_roots(bound=2^72, epsilon=1/32)for r in roots:    flag = long_to_bytes(int(r + m_h))    print(flag)# b'flag{the_leaked_flag_is_not_secure}'

模数部分泄露攻击 😎

在某些情况下，攻击者可能会获得 RSA 模数 $p$ 的部分信息，例如知道 $p$ 的高位或低位。这种信息泄露可以被利用来构建多项式方程，并使用 Coppersmith 方法来寻找小根，从而恢复完整的模数 $p$。

模数相关的方程构建直接使用 $n$ 的定义就好，高位泄露和低位泄露都是一样的思路：

$$\begin{aligned}(p_h + x)q &\equiv 0 \mod n \\(x \ll p_h.nbits() + p_h)q &\equiv 0 \mod n\end{aligned}$$

其中 $p_h$ 是已知的模数部分，$x$ 是未知的部分，$q$ 是另一个素数。

模数部分泄露攻击例题

模数部分泄露攻击例题下载

from Crypto.Util.number import *from secret import mp = getPrime(512)q = getPrime(512)n = p*qe = 65537p_h = (p >> 128) << 128c = pow(m, e, n)print("n =", n)print("c =", c)print("e =", e)print("p_h =", p_h)# n = 148343204993341213021619313428058654106890149696397492706333896400186219477227728301676148709241129304306574087724304991489318859287047163276539541481697268017678181261322191026527154404707813733872358303403566566327058403912886903786387007581372068922650740322771090553555674369191355108765322667860494558677# c = 39156544505474625229023477922212602423468384619737085007608097248472070125608788562256041364458195493803172264223273233547146479148821267828148585094956004078892557930333392606045896106072959524844360325819706205800762438141913680222858798397571618769159479716837722530469152413770655154791443613805271743833# e = 65537# p_h = 12734678186795088622000398950939657451514087254410587977928786315334611555210018653020273683790430319996027334767103524767798553242990607416419371588780032

在这个例题中，我们生成了一个 RSA 密钥对，并加密了一个明文消息。我们知道模数 $p$ 的高位部分 $p_h$，并且我们有密文 $c$ 和公钥指数 $e$。使用 Coppersmith 方法，我们可以尝试找到未知的部分 $x$，从而恢复完整的模数 $p$，进而解密消息。

解题代码示例：

from sage.all import *n = 148343204993341213021619313428058654106890149696397492706333896400186219477227728301676148709241129304306574087724304991489318859287047163276539541481697268017678181261322191026527154404707813733872358303403566566327058403912886903786387007581372068922650740322771090553555674369191355108765322667860494558677c = 39156544505474625229023477922212602423468384619737085007608097248472070125608788562256041364458195493803172264223273233547146479148821267828148585094956004078892557930333392606045896106072959524844360325819706205800762438141913680222858798397571618769159479716837722530469152413770655154791443613805271743833e = 65537p_h = 12734678186795088622000398950939657451514087254410587977928786315334611555210018653020273683790430319996027334767103524767798553242990607416419371588780032P.<x> = PolynomialRing(Zmod(n))f = x + p_hroots = f.small_roots(bound=2^128, beta = 0.4, epsilon=1/32)for r in roots:    p = int(r + p_h)    q = n // p    phi = (p-1)*(q-1)    d = inverse_mod(e, phi)    m = pow(c, d, n)    flag = long_to_bytes(m)    print(flag)# b'flag{the_leaked_p_is_not_secure}'

私钥低位泄露攻击 🧐

在某些情况下，攻击者可能会获得 RSA 私钥 $d$ 的部分信息，例如知道 $d$ 的低位。这种信息泄露可以被利用来构建多项式方程，并使用 Coppersmith 方法来寻找小根，从而恢复完整的私钥 $d$。

这个时候就好灵活构建方程了，要先认识到低位，可以理解成原来的方程在取模时的值，这样在取模后就可以达到一个未知数暂时不参与的效果。

私钥低位泄露攻击例题

私钥低位泄露攻击例题下载

from Crypto.Util.number import *from secret import mp = getPrime(512)q = getPrime(512)n = p*qe = 3d = inverse_mod(e, (p-1)*(q-1))d_l = d & ((1 << 512) - 1)c = pow(m, e, n)print("n = ", n)print("e = ", e)print("c = ", c)print("d_l = ", d_l)# n = 78036226711261137562635523171733270722300007283095085193438779642343110620250804479566251132258821498672359932995596424916036883417080280241580905118033281785063140297467453715900194715947245388137276189087436097121831057248623061596822311980543096721479575328572293908180835278420031510114830258210990389017# e = 3# c = 4458558515804294040125006969671194268520221962979792020774793426952905371959925004280044612155954386479615226026601709155668384798849357146766830652052906333248686079022711702984275745125# d_l = 1548125634003834517457946342794474179624692403859149914470848791910513316602949323478233517628159099938386644246361533546700081991087641483936928476761795

根据RSA相关参数我们可以知道的是 $e \cdot d = k \cdot \phi(n) + 1$，其中 $k$ 是一个整数。我们设 $s = p + q$，则有 $e \cdot d = k \cdot (n - s + 1) + 1$。

重点来了，已知 $d$ 的低位部分 $d_l$，我们可以直接将方程取模 $2^{512}$，得到：

$$\begin{aligned}e \cdot d_l = k \cdot (n - s + 1) + 1 \mod 2^{512} \\s \equiv n + 1 - (e \cdot d_l - 1) \cdot k^{-1} \mod 2^{512}\end{aligned}$$

然后联系根为 $p$ 和 $q$ 方程 $x^2 - s \cdot x + n = 0$，我们就可以构建一个关于 $x$ 的多项式方程，并使用贪心加剪枝的方法求解 $512$ 位的 $p$ 和 $q$。如果 $p$ 和 $q$ 都大于 $512$ 位，那么我们可以通过 Coppersmith 方法来寻找小根。

解题代码示例：

from sage.all import *from Crypto.Util.number import *n = 78036226711261137562635523171733270722300007283095085193438779642343110620250804479566251132258821498672359932995596424916036883417080280241580905118033281785063140297467453715900194715947245388137276189087436097121831057248623061596822311980543096721479575328572293908180835278420031510114830258210990389017e = 3c = 4458558515804294040125006969671194268520221962979792020774793426952905371959925004280044612155954386479615226026601709155668384798849357146766830652052906333248686079022711702984275745125d_l = 1548125634003834517457946342794474179624692403859149914470848791910513316602949323478233517628159099938386644246361533546700081991087641483936928476761795def recover_p_general(d_l, e, n):    d_l_sage = Integer(d_l)  # 转换为Sage的Integer类型    known_bits = d_l_sage.nbits()  # 现在可以正常调用nbits()    for k in range(1, e + 1):        A = e * d_l - 1        if A % k != 0: continue        # 1. 也是算出只模已知位数的 s_mod        s_mod = (n + 1 - (A // k)) % (2**known_bits)        # 2. 也是逐位解 x^2 - s_mod*x + n = 0        res = [1]        for i in range(1, known_bits):            next_res = []            for r in res:                for b in (0, 1):                    x = r | (b << i)                    if (x**2 - s_mod*x + n) % (2**(i+1)) == 0:                        next_res.append(x)            res = next_res        # 3. 对每一个得到的部分低位 p_low 使用 small_roots 求高位        for p_low in res:            # 如果碰巧拿到全量位了，直接除除看            if n % p_low == 0 and p_low != 1 and p_low != n:                return p_low            # 如果没拿到全量，用 small_roots 把剩下高位求出来            PR.<x> = PolynomialRing(Zmod(n))            f = x * (2**known_bits) + p_low    # p = x * 2^m + p_low            f = f.monic()            # X是预估未知高位的值域上限，假设 p 大约在靠近 sqrt(n) 附近            n_sage = Integer(n)            unknown_bits = (n_sage.nbits() // 2) - known_bits            X_bound = 2**(unknown_bits + 5)   # +5 留一点余量            if X_bound > 2: # 也就是确实有未知位需要求                try:                    # beta=0.4 反映了我们要找的 p 的位数约占总位数的比例（略小于一半）                    roots = f.small_roots(X=X_bound, beta=0.4)                    if roots:                        p = int(roots[0]) * (2**known_bits) + p_low                        if n % p == 0:                            return p                except Exception as e:                    pass    return Nonep = recover_p_general(d_l, e, n)q = n // pphi = (p-1)*(q-1)d = inverse_mod(e, phi)m = pow(c, d, n)print(long_to_bytes(m))# b'flag{the_leak_of_d_is_bad}'

Håstad 广播攻击扩展 🤠

前面我们提到过 Håstad 广播攻击，而 Coppersmith 方法也可以被用来扩展 Håstad 广播攻击的适用范围。在 Coppersmith 方法的帮助下，我们可以将问题推广到更一般的情况，就是加密的不再是相同的 $m$，而是具有线性关系的 $m_i$。

Håstad 广播攻击扩展例题

Håstad 广播攻击扩展例题下载

from Crypto.Util.number import *from secret import mp1 = getPrime(256)p2 = getPrime(256)p3 = getPrime(256)q1 = getPrime(256)q2 = getPrime(256)q3 = getPrime(256)n1 = p1*q1n2 = p2*q2n3 = p3*q3e = 3c1 = pow(m, e, n1)c2 = pow(m+1, e, n2)c3 = pow(2*m+2, e, n3)print("n1 = ", n1)print("c1 = ", c1)print("n2 = ", n2)print("c2 = ", c2)print("n3 = ", n3)print("c3 = ", c3)# n1 =  7436297924479111288858365740455970275623094012645820223363041858682843243234345296777579027762343770914910949000282160537982015904948267903325514335621283# c1 =  4325495502980350621916618330673099516626441599498586125877854511173538779941000124091552361831740416431308367276617945025243861814840900084833354971434577# n2 =  6456104243856281808527299663033415352202343985414289970319782054731415622452561418810434572150687245284010827848197758737921807475656221001397521660559891# c2 =  2003003821228318250607284803400253958526269528049733743569235891789477388365756120493530569516748649272916121719028297249295064499105886124376055740719578# n3 =  8769049710633699648972640916530598241721246817703490720809168840216439564713379108405895103749642237199313984669343902262587767037986004793227502470940611# c3 =  7583851145248429122395092819244845051341655099143487890806191663124326571012675198159624097396942593587956402263246628310823739943969343448935180194204

这一题我们使用 CRT 构造一组标准基向量，通过线性组合正确合并三个多项式：

$$l_i \equiv \begin{cases} 1 \pmod{n_i} \\ 0 \pmod{n_j} (j \neq i) \end{cases}$$

后面用 $F = l_1f_1 + l_2f_2 + l_3f_3$ 就可以把三个方程合成一个方程，使得满足 $F \equiv 0 \pmod{n_i}$。剩下的就是求这个方程的整数根了。

解题代码示例：

from Crypto.Util.number import *from sage.all import *n1 =  7436297924479111288858365740455970275623094012645820223363041858682843243234345296777579027762343770914910949000282160537982015904948267903325514335621283c1 =  4325495502980350621916618330673099516626441599498586125877854511173538779941000124091552361831740416431308367276617945025243861814840900084833354971434577n2 =  6456104243856281808527299663033415352202343985414289970319782054731415622452561418810434572150687245284010827848197758737921807475656221001397521660559891c2 =  2003003821228318250607284803400253958526269528049733743569235891789477388365756120493530569516748649272916121719028297249295064499105886124376055740719578n3 =  8769049710633699648972640916530598241721246817703490720809168840216439564713379108405895103749642237199313984669343902262587767037986004793227502470940611c3 =  7583851145248429122395092819244845051341655099143487890806191663124326571012675198159624097396942593587956402263246628310823739943969343448935180194204N = n1*n2*n3R_mod.<m> = PolynomialRing(Zmod(N))f1 = m**3 - c1f2 = (m+1)**3 - c2f3 = ((2*m+2)**3 - c3) * inverse_mod(8, N)c_1 = crt([1, 0, 0], [n1, n2, n3])c_2 = crt([0, 1, 0], [n1, n2, n3])c_3 = crt([0, 0, 1], [n1, n2, n3])F_mod = c_1 * f1 + c_2 * f2 + c_3 * f3F_mod = F_mod.monic()X = 2**256roots = F_mod.small_roots(X=X, beta=1.0)flag = long_to_bytes(int(roots[0]))print(flag)# b'flag{coppersmith_is_very_useful}'

上一章：RSA加解密专题 - 公私钥格式相关攻击 👈
下一章：RSA加解密专题 - Coppersmith 相关攻击二 👈
回到开始：关于我 👈

相关链接：
密码学算法 - 中国剩余定理CRT 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4005.html 2026-03-04T11:33:00.000Z

Coppersmith 攻击是一种针对 RSA 加密算法的攻击方法，主要用于在特定条件下恢复 RSA 私钥或解密 RSA 密文。该攻击方法由 Don Coppersmith 在 1996 年提出，利用了 RSA 加密算法中的数学结构和性质。

这里我们并不会深入]]>

2026-03-15T12:12:29.535Z Dorange pem 格式的文件通常用于数字证书认证机构(Certificate Authorities，CA)，其文件形式主要为 base64 编码的文件，头尾有类似于——-BEGIN PUBLIC KEY——-和——-END PUBLIC KEY——-的头尾标记

本文的目的就是如何从 .pem 格式的证书中，获取公钥、私钥信息。在 RSA 加密中，实际上公钥和私钥都是由一系列数字组成的，这些数字在.pem格式的证书中以特定的格式存储。通过解析这些数字，我们可以获取到公钥和私钥的相关信息，从而进行加密和解密操作。

PEM文件生成与使用 🥳

在python中，可以通过 from Crypto.PublicKey import RSA 生成想要的公私钥文件。

生成公钥文件的代码如下：

from Crypto.PublicKey import RSAfrom Crypto.Util.number import *p,q = getPrime(512),getPrime(512)n = p * qe = 0x10001pub = RSA.construct((n,e))with open('out.pem','wb') as f:    f.write(pub.exportKey('PEM'))with open('out.pem','rb') as f:    print(f.read().decode())'''-----BEGIN PUBLIC KEY-----MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCuRPouMRTcLWPBEUlhjCrZ6MNQrSy29BrHjH4+lGMykB23azPtT9fk7IsEFXoodm6tsPL8kheJ6cP+0WPldlQOw/K3c9LUGzeCCAhNJuBjUoeW32ruE2HS7RoIF6vkP36zLs167ZZMK7Fg0cqW6VNXoJHTzaKdqysBe+3W1VHl6QIDAQAB-----END PUBLIC KEY-----'''

生成私钥文件的代码如下：

from Crypto.PublicKey import RSAfrom Crypto.Util.number import *p,q = getPrime(512),getPrime(512)n = p * qe = 0x10001d = inverse(e,(p - 1) * (q - 1))pub = RSA.construct((n,e,d,p,q))with open('out.pem','wb') as f:    f.write(pub.exportKey('PEM'))with open('out.pem','rb') as f:    print(f.read().decode())'''-----BEGIN RSA PRIVATE KEY-----MIICXAIBAAKBgQCnHIvLP0IERPVRaED+71dlCRBcm3be4jlHgqVqIIXyIvrzc8ZCIIbIDqlBybNgq32i6PVlzBCsWiiTfBYS6J24qCjYVTywKk+yieNshieNNohmvQRFbZOZITJiP99URkhtGWo3trQfoAZEQ7NfMoS1N3PDvPet1lMfFK81AyWt1wIDAQABAoGAIq74DK0KZJxzVfwPUVoXh27EKJRTrZrCTKc+8bHiWwkLkK+8vEjH8Imqc28LfcrZ/o/fLsuVwk/MECA27KG+6hiRPJDWZmFgCInCABuhd+xitSBciMSGrO5ITjoqYdgMsR5xJTI8vhXIJ1iCkkCz6fD6Di7s+3n/+Ti3iuK87jECQQDOY/pLyH0ppOk049pieQRshckQMXqsKhahEDZmWMu70JqDLF0U3aIfup1R87uogB8hJj8+K5RQavG44l0W5ghTAkEAz0eTNEWTe2iJ/Dq+8JKTN/MA/a8MiG7wvAkXqjx+B+Eow77IdoN8D5ehD0x6ou73yaorTddidDAplNmvyq0D7QJAJbcPXhndBWclVozss2H59Prdqx/fkuZ+DCCyUDGZyVBta9sHh3CY18N6TCeF+1yuU5hxpiLAj5F7apWy/SQ8EQJBAMtvAxGda6cGLc8o1PeF1AlobUONxy4sPAdAoUJKRqNzH7AmEdcHKv6eoctDE2XQRc9ePUwTpSRFlLnrgLXZYu0CQBKKT+oY4ssnwKDQqGPsh9MtPyilySL9sWJilk1cSXmQXm7gjDq5S/x4k1gJyQFXbUnxTfsbLWs6BljHHlKSRes=-----END RSA PRIVATE KEY-----'''

如果是生成一组随机的公私钥文件，可以直接直接使用 RSA.generate(bits)，其中的 bits 参数为生成的公钥文件中n的二进制位数，且 bits>=1024，默认为 1024。

from Crypto.PublicKey import RSAfrom Crypto.Util.number import *key = RSA.generate(1024)print(key.publickey)with open('out.pem','wb') as f:    f.write(key.exportKey('PEM'))with open('out.pem','rb') as f:    print(f.read().decode())'''<bound method RsaKey.public_key of RsaKey(n=99929675131146107818047790971049703803161677332600984800831117021637597471437271599719384035180982326470249457001083005224626356572009901255841391966616564984242588913592789383087326511196585443834216472384770224810255153922375944881215835774119177009570247468911673932973239275741131654695253944455708641727, e=65537, d=27501740780061900509028777360107084282858928440567277451824014559115713670042546183199393779857817534085793587304881725189343016621314014739780326627796196251470626677550096120689732366473717193895036548926100990548453802714993577259273117223098888966957225092204230317866243049867167880710514827901086931493, p=9959145719455053414348729655771312861460726396890001110536788452571591154277537325754067618769136991544158484849077735057792084414015625760536769751415507, q=10033960536990122517580769502852456118641921945920255759007869111269242067226468943041901092934902353013133963062909073461567977701122665256982872188799461, u=2111771661302217183343493746406805348965531581492223651147849337466575464897027597797323383307376291792334461891498947953036261381547003770335520720819326)>-----BEGIN RSA PRIVATE KEY-----MIICXQIBAAKBgQCOTfkFWAc5UsCT07Y4bU9jKfpT5pt+ScHFIk/39jsE8yDHSFAopcQMlJ6GKRYfU7F/3xbY2udbvXBj9jJVLBmh3ORbZT06xwYDeqhvE2kJB+QfGk+JPOqzjCkFiDorxMUzWEq4us8nXmkv6WsrJMGSQZ0SQ7c29N9M0/8K622JvwIDAQABAoGAJyntaVuXLV8JcgW3piLrUNLKOpICZEi/Q9ZUJN2G069n64CK0wz//ihe0nR3SqrZdGQ84PSp7LUfu9sTch5fdSQLH/OAQtVf/rwWuwulm8wS0njrU9xxQQWrwZoeL9W7DlBWf5+PbmYdgyoLIwL3+wskvxiWswlvVcSR7RkXGiUCQQC+J0pN+1W2U3qea8rhAwX7XMSXoblFuqfBfH/duLZvseEEjtuTcj0ISlJgts2aZT1J8yHnllUoiqAuWQPUK/rTAkEAv5T6OwPHj+4J/4WzQgJTN89Xj9ihR45wpr8Rr6WPXUCgXTe82UFzny68nIzALvKrLTf58yu8/E5wy2+SejBJ5QJASNUnwsK3y8QhvTgwVwsfaW3Y5vNM0YZy5stW9offaNzLAUHunIUvF1PQRbb+/Vo1pXN40wljyMmAHQB/VO8bfQJBAIGQnVKAEdyzHavjngHMVL9vyEYOObSNDn6Wxb1GeJiWdl3UrjE35JwJHaG6Rtb5Yu7n5nCgaeUwn3PV9vgP5EkCQQCWIiD5b8Qb5Mma8/iDNhchmRkosUug/iCBeqNh3nJctxZnUy1fjc0toXxJY3ZBzTl3TNsk8p8x4H9y/NXoDtvu-----END RSA PRIVATE KEY-----'''

在 python 中，利用公私钥文件，通过 PKCS1_OAEP 算法填充可以实现加解密，例如：

from Crypto.PublicKey import RSAfrom Crypto.Cipher import PKCS1_OAEPfrom Crypto.Util.number import *flag = b'This_is_a_message_qwer'​key = RSA.generate(1024)pub = key.publickey().exportKey()public_key = RSA.importKey(pub)pk = PKCS1_OAEP.new(public_key)enc = pk.encrypt(flag)print(enc)​priv = key.exportKey()priv_key = RSA.importKey(priv)sk = PKCS1_OAEP.new(priv_key)msg = sk.decrypt(enc)print(msg)# b'\xd1/Ou\xae\xba]z\xc0\t\xc6\xd7\xc4f\x13\x96\x9a\xeb5\xdb8\x92\xc7\x19\x12y\x9c\x18\xf7A\x9d\xe9\n&=<\x16\x07\xefz\xad2-\x983\xec\x932\xcb\xf0\x87~\xdf\xc1\xd2\x9f\xd7@\\H\x1f\x87#\xf3\x84\xa0\xfc\xd9\xcfV$>\xd7Of\xe6G\x06\xcb\x91\xa1\xcc\x0c\xad\xc2\x9a\xad\xe46\x91x\xad\xa51\xbb\xfb\xc1E\x93~e%\xd1~\xf8l\x19n\x88\xff\xac^\xca\x8fs*}\xb9c0\xc0N\xf2\xfa\xa4\xd8\x18g'# b'This_is_a_message_qwer'

PEM文件解析 🤠

在文件进行 base64 解码后，可以看到 pem 文件的结构（专门用于 RSA 私钥）如下：

RSAPrivateKey ::= SEQUENCE {    version           Version,     0表示两个素数的RSA  1表示多素数的RSA    modulus           INTEGER,  -- n    publicExponent    INTEGER,  -- e    privateExponent   INTEGER,  -- d    prime1            INTEGER,  -- p    prime2            INTEGER,  -- q    exponent1         INTEGER,  -- d mod (p-1) dp    exponent2         INTEGER,  -- d mod (q-1) dq    coefficient       INTEGER,  -- (inverse of q) mod p    otherPrimeInfos   OtherPrimeInfos OPTIONAL}十六进制格式如下：表示头 30表示长度 82 xx xx版本信息 02 01 00n 02 xx xxe 02 xxd 02 xx xxp 02 xxq 02 xxdp 02 xxdq 02 xxinv 02 xx如果数据长度超过 128 字节，则长度部分会多出两个字节表示实际长度

对于完整的 pem 格式文件，我们可以使用 openssl 工具进行解析，例如：

读公钥 openssl rsa -pubin -text -modulus -in 1.pem读私钥 openssl rsa -in 1.pem -text

当然，对于残缺的 pem 格式文件，我们也可以 base64 解码后，通过分析上述结构，手动解析出其中的数字信息，这也是我们重点讲解的内容。

残缺私钥解析 👻

我们从上面的结构知道，我们要的数据都是以 02 开头的整数类型，后面跟着长度和数据内容。对于残缺的 pem 格式文件，我们可以通过分析这些整数类型的数据，来获取我们需要的信息。

残缺私钥解析例题

残缺私钥解析例题下载

Ciphertext = 0x6d482cbbc60b146ce064754910f5ce845a6eedeff2a20589b97c342677219c324debe4fc7324106bbeccc633ec819383f019856e700f027a39987500873a5700491f2828df4d5c01d179febac4f7589ed6846701e4d78daea6265df0fe1853e43984a3760b5257144842f9f4d316c3d314dfedb2ded08b90b957bf040258400a-----BEGIN RSA PRIVATE KEY-----MIICewIBAAKBgQCdA0+pqynKvc3/BH5ojnUABMdWy9Lzi9TwSAOgiJ6ky//QBrWGCNAn98CYNcoKuA2yOtHKIjAUrPh+LdgjmW+/pAWPJyrnoQw5SqD+FvqNTjG7AkvA+TUAyMflL9qodrWBEbl/AmN01Qbivo36+U1mFDB+6LENk/3BwWAHVj0DvQIhAL7tVc3/3jEFe+pAWKNoTV++2B8D1T+ii7ZYsy3kU1yNAoGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkCQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJAJrKFhI5pl/oBN2BZqLTf+NAcGqTFrzmbi7RVFAN43kAYAu11urAyLTncfJABpRhtGFdsL31jiswhiYRp9yjT+wJBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-----END RSA PRIVATE KEY-----

在这个例题中，我们可以看到，私钥文件中的一些数据残缺了，不过我们可以通过解码后的 02 头直接解析，因为数据的顺序都是严格按照上面的结构来的。

解析代码示例：

from base64 import b64decodeimport binasciis = """-----BEGIN RSA PRIVATE KEY-----MIICewIBAAKBgQCdA0+pqynKvc3/BH5ojnUABMdWy9Lzi9TwSAOgiJ6ky//QBrWGCNAn98CYNcoKuA2yOtHKIjAUrPh+LdgjmW+/pAWPJyrnoQw5SqD+FvqNTjG7AkvA+TUAyMflL9qodrWBEbl/AmN01Qbivo36+U1mFDB+6LENk/3BwWAHVj0DvQIhAL7tVc3/3jEFe+pAWKNoTV++2B8D1T+ii7ZYsy3kU1yNAoGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkCQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJAJrKFhI5pl/oBN2BZqLTf+NAcGqTFrzmbi7RVFAN43kAYAu11urAyLTncfJABpRhtGFdsL31jiswhiYRp9yjT+wJBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-----END RSA PRIVATE KEY-----"""s = b64decode(s)print(binascii.hexlify(s))"""手动分行解析，注意02后面的长度部分，这是我们确定数据长度的方式，如果长度超过128字节，则会多出两个字节表示实际长度3082027b020100028181 #n009d034fa9ab29cabdcdff047e688e751704c756cbd2f38bd4f049a3a0889ea4cbffd006b58608d6a7f7c09835ca0abb1db23ad1ca223c54acf87e2dd823996fbfa5a58f272ae7a10c394aa0fe16fa8d4e31bb024bf1f93517c8c7e52fdaa876b58111b97fc66374d506e2be8dfaf94d6614307ee8b10d93fdc1c165c7563d03bd0221   #e00beed55cdffde31057bea5a58a3684d5fbed81f03d53fa28bb658b32de4535c8d028180 #d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090241   #p00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000241   #q00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030240   #dp26b285848e6997fa01376059a8b4dff8d69c1aa4c5af399b8bb45515a378de45d85eed75bab5f22d39dc7c95c1a5186d18576c2f7d638acc21898469f728d3fb0241   #dq00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030241   #inv0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"""

通过上述代码，我们可以成功解析出私钥中的各个参数，我们发现就是一个 $d_p$ 泄露的情况，利用这个参数，我们可以通过以下代码计算出 $p$ 和 $q$ 的值：

from Crypto.Util.number import long_to_bytes, bytes_to_long, inverse, GCDfrom secret import mn_hex = "0x9d034fa9ab29cabdcdff047e688e751704c756cbd2f38bd4f049a3a0889ea4cbffd006b58608d6a7f7c09835ca0abb1db23ad1ca223c54acf87e2dd823996fbfa5a58f272ae7a10c394aa0fe16fa8d4e31bb024bf1f93517c8c7e52fdaa876b58111b97fc66374d506e2be8dfaf94d6614307ee8b10d93fdc1c165c7563d03bd"n = int(n_hex,16)e_hex = "0xbeed55cdffde31057bea5a58a3684d5fbed81f03d53fa28bb658b32de4535c8d"e = int(e_hex,16)c_hex = "0x6d482cbbc60b146ce064754910f5ce845a6eedeff2a20589b97c342677219c324debe4fc7324106bbeccc633ec819383f019856e700f027a39987500873a5700491f2828df4d5c01d179febac4f7589ed6846701e4d78daea6265df0fe1853e43984a3760b5257144842f9f4d316c3d314dfedb2ded08b90b957bf040258400a"c = int(c_hex,16)dp_hex = "0x26b285848e6997fa01376059a8b4dff8d69c1aa4c5af399b8bb45515a378de45d85eed75bab5f22d39dc7c95c1a5186d18576c2f7d638acc21898469f728d3fb"dp = int(dp_hex,16)p = GCD((pow(2,e*dp,n) -2) ,n)q = n // pif n == p * q and p > 1 and q > 1:    print("成功分解n:")    print("p =", p)    print("q =", q)    phi = (p - 1) * (q - 1)    d = inverse(e, phi)    m = pow(c, d, n)    print(long_to_bytes(m))# b'flag{u_know_the_pem_structure}'

上一章：RSA加解密专题 - 私钥 d 相关攻击 👈
下一章：RSA加解密专题 - Coppersmith 相关攻击一 👈
回到开始：关于我 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4004.html 2026-03-03T11:33:00.000Z

pem 格式的文件通常用于数字证书认证机构(Certificate Authorities，CA)，其文件形式主要为 base64 编码的文件，头尾有类似于——-BEGIN PUBLIC KEY——-和——-END PUBLIC KEY——-的头尾标记

本文的]]>

2026-03-14T12:27:09.189Z Dorange 当你在处理离散对数问题时，发现暴力破解的方法效率太低了😩，这时候 BSGS（Baby-Step Giant-Step）算法 就像一把神奇的钥匙🔑，能帮你快速找到离散对数的解。这个算法也别戏称为“北上广深”算法。🤐

欢迎来到《密码学核心算法实战》的 BSGS 专题！这里没有纸上谈兵的理论空谈（真的不画大饼😉），只有一把把能直接撬动数据安全的精密齿轮⚙️。

BSGS算法 🌟

BSGS（Baby-Step Giant-Step）算法是一种用于求解离散对数问题的算法。给定质数 $p$，整数 $a$ 和 $b$，我们想要找到一个整数 $x$，使得 $a^x \equiv b \pmod{p}$（其中 $a$ 与 $p$ 互质）。

BSGS算法的原理 😵

根据群中生成元的性质，我们可以知道元素 $a$ 的阶（即 $a$ 的幂等于 1 的最小正整数）是 $p-1$，然后产生一种循环的效果。因此，离散对数问题的解 $x$ 必须满足 $0 \leq x \leq p-1$。

我们考虑先求出一部分 $a$ 的幂次模 $p$ 意义下的值，将它们存起来，然后使得剩下没有求值的部分能够想个办法利用已求值直接查出来。这就让我们联想到根号。

将 $x$ 表示为 $x = im - j$，其中 $m = \lceil \sqrt{p} \rceil$，$i$ 和 $j$ 是非负整数。这样我们可以将离散对数问题转化为以下形式：

$$a^{i \cdot m - j} \equiv b \pmod{p} \Rightarrow (a^i)^m \equiv b \cdot a^j \pmod{p}$$

小步（Baby Step）：与计算所有 $b \cdot a^j \pmod{p}$ $(j \in [0,m))$，存入哈希表（键为值，值为 $j$）。每次都是乘 $a$，所以叫做小步。

大步（Giant Step）：计算 $a^m \pmod{p}$，遍历 $i \in [1,m]$，计算 $(a^m)^i \pmod{p}$，检查是否在哈希表中存在对应的值，如果存在，则可以得到 $x = im - j$。每次都是乘 $a^m$，所及叫做大步。

$j$ 是小步的步数，范围为 $0 \leq j < m$，因为 $j$ 是拆分后的余项，必须小于块大小 $m$ （类似除法中的余数）。当然，如果 $j \geq m$，可以通过 $i$ 来调整，本质是上是多余的。

$i$ 是大步的步数，范围为 $1 \leq i \leq m$，我们分两步证明：

先证明：所有 $x \in [0, p-1]$ 都可以表示为 $x = im - j$，其中 $i \in [1, m]$，$j \in [0, m)$。

由于 $m = \lceil \sqrt{p} \rceil$，我们有 $m^2 \geq p$。对于任意 $x \in [0, p-1]$，我们可以将其除以 $m$ 得到商 $i$ 和余数 $j$，即 $x = im + j$。由于 $x < p \leq m^2$，我们有 $i < m$ 和 $j < m$。因此，所有的 $x$ 都可以表示为 $x = im - j$。

再证明： $i$ 不用超过 $m$。

若 $i > m$，则 $x = im - j > m^2 - j \geq m^2 - (m-1) = m^2 - m + 1$。由于 $m^2 \geq p$，我们有 $x > p - m + 1$。因此，如果 $i > m$，则 $x$ 将超过 $p-1$，这与 $x \in [0, p-1]$ 矛盾。因此，$i$ 不用超过 $m$。

BSGS算法的实现 🙃

下面是 BSGS 算法的一个简单实现：

import mathdef bsgs(a, b, mod):    # 前提断言：a 与 mod 必须互质，否则直接报错    assert math.gcd(a, mod) == 1, "a 与 mod 不互质，基础 BSGS 无法求解"    a = a % mod  # 先取模，防止底数过大    b = b % mod  # 先取模，防止结果过大    # 特殊情况：b ≡ 1 mod mod，直接返回 x=0    if b == 1:        return 0    k = math.ceil(math.sqrt(mod))    step_dict = dict()    # 小步 (Baby Step)     # 计算: b * a^q mod mod，q ∈ [0, k)    right_val = b  # 初始值: b * a^0    for q in range(k):        # 只存第一次出现的q（保证q最小，从而解x最小）        if right_val not in step_dict:            step_dict[right_val] = q        right_val = right_val * a % mod    # 大步 (Giant Step)     # 计算: (a^k)^p mod mod，p ∈ [1, k]    ak = pow(a, k, mod)    left_val = 1  # 初始值: (a^k)^0    for p in range(1, k + 1):        # 用递推代替重复幂运算        left_val = left_val * ak % mod        if left_val in step_dict:            q = step_dict[left_val]            x = k * p - q            # 验证解的有效性（防止哈希碰撞或理论误差）            if pow(a, x, mod) == b:                return x    return None  # 遍历结束未找到，无解

扩展BSGS算法 🥰

当 $a$ 和 $mod$ 不互质时，基础的 BSGS 算法无法直接求解。这时候我们可以使用扩展 BSGS 算法来处理这种情况。

我们把题目所给的这个式子搬出来：

$$a^x \equiv b \pmod{p}$$

我们不妨设 $gcd(a, p) = d$，如果 $d$ 不整除 $b$，则方程无解；如果 $d$ 整除 $b$，我们可以将方程两边同时除以 $d$，得到：

$$\left(\frac{a}{d}\right) \cdot a^{x-1} \equiv \frac{b}{d} \pmod{\frac{p}{d}}$$

但是即使这样，我们也不能直接使用 BSGS 算法来求解，因为 $\frac{a}{d}$ 和 $\frac{p}{d}$ 可能仍然不互质。我们需要继续进行约简，直到 $\frac{a}{d}$ 和 $\frac{p}{d}$ 互质为止，即：

$$\frac{a}{\prod_k g_i} \cdot a^{x-k} \equiv \frac{b}{\prod_k g_i} \pmod{\frac{p}{\prod_k g_i}}$$

这个时候，我们再处理一下：

$$a^{x-k} \equiv \frac{b}{\prod_k g_i} \cdot \left(\frac{a}{\prod_k g_i}\right)^{-1} \pmod{\frac{p}{\prod_k g_i}}$$

这样我们就得到了一个新的离散对数问题，其中底数和模数已经互质了，我们就可以使用 BSGS 算法来求解了。

扩展BSGS算法的实现 🤪

下面是这个算法的python简单实现：

def extended_bsgs(a, b, mod):    # 保存原始值（关键！用于小解验证）    orig_a = a    orig_b = b    orig_mod = mod    a = a % mod    b = b % mod    # 特殊情况：b ≡ 1 mod mod，x=0    if b == 1:        return 0    # 特殊情况：mod=1，所有 x 都满足，返回最小非负解 0    if mod == 1:        return 0    k = 0    C = 1  # 记录左边累积的系数    while True:        d = math.gcd(a, mod)        if d == 1:            break  # 已经互质，停止提取        # 如果 b 不是 d 的倍数，无解        if b % d != 0:            return None        # 提取公因数（注意：a 不除 d！之前的 a//=d 是错误的）        # 正确逻辑：a 保持原值，只除 mod 和 b        b = b // d        mod = mod // d        k += 1        # 累积系数：C = C * (a//d) mod mod         C = (C * (orig_a // d)) % mod    # 现在 a（orig_a）与 mod 互质，转化方程：C * orig_a^(x-k) ≡ b (mod mod)    # 求 C 的逆元    try:        inv_C = pow(C, -1, mod)    except ValueError:        return None  # 逆元不存在，理论上不会发生    B = (b * inv_C) % mod    # 调用 BSGS 时用原始 a，不是提取后的 a    y = bsgs(orig_a, B, mod)    if y is None:        return None    x = y + k    # 验证小解：x < k 的情况（用原始值验证）    for i in range(k):        if pow(orig_a, i, orig_mod) == orig_b:            return i    # 验证最终解是否满足原方程    if pow(orig_a, x, orig_mod) == orig_b:        return x    return None

SageMath 偷懒 🤓👆

有同学说：“博主，博主，你的算法确实很厉害，但是还是太吃操作了，有没有更加简单无脑的用法？”👻
有的，兄弟有的，这样的算法在 SageMath 中早就已经被封装好了🤫，我们直接调用就行了：

from sage.all import discrete_log# discrete_log中内置了BSGS算法，当然更加完善r = discrete_log(b, a, mod)# 但是需要注意：如果 a 和 mod 不互质，discrete_log 可能会抛出异常，这时候我们需要先处理一下，或者直接使用 extended_bsgs 来求解。

怎么样，是不是非常简单？🤣👉🤡

上一章：密码学算法 - Miller-Rabin素数检验 👈
下一章：密码学算法 - BSGS算法二 👈
回到开始：关于我 👈

相关链接：
密码学数学基础 - 群论基础 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/3008.html 2026-03-02T15:58:00.000Z

当你在处理离散对数问题时，发现暴力破解的方法效率太低了😩，这时候 BSGS（Baby-Step Giant-Step）算法 就像一把神奇的钥匙🔑，能帮你快速找到离散对数的解。这个算法也别戏称为“北上广深”算法。🤐

欢迎来到《密码学核心算法实战》的 BSG]]>

2026-03-12T08:37:46.141Z Dorange 在RSA加解密算法中，私钥是一个非常重要的参数，它与公钥指数和模数之间存在着密切的关系。如果私钥的选择不当，或者在某些特定情况下，攻击者可能会利用这些关系来破解RSA加密算法，从而获取到原始消息或者分解出模数。

本文将介绍一些与RSA私钥 $d$ 相关的攻击方法，包括常见的攻击手段如维纳攻击、$d_p$ 泄露攻击等。

$d_p$ 泄露攻击 😸

在RSA算法中，私钥 $d$ 可以通过模数 $n$ 和公钥指数 $e$ 来计算得到。然而，如果攻击者能够获取到私钥的某些部分信息，例如 $d_p$（即 $d \mod (p-1)$），就可能会利用这些信息来破解RSA加密算法。

我们可以使用小费马定理：
如果p是一个质数，整数a不是p的倍数，那么 $a^{p-1} \equiv 1 \mod p$

根据 $d_p$ 的定义，我们有 $d \equiv d_p \mod (p-1)$，因此存在一个整数 $k$ 使得 $d = d_p + k(p-1)$。

带入RSA的加密解密公式，我们可以得到：

$$a^{e×dp} \equiv a \cdot (a^{p-1})^k$$

带入小费马定理得：

$$a^{e×dp} \equiv a \cdot 1^k \equiv a \mod p$$

令a = 2，显然与p互质

$$2^{e×dp} \equiv 2 \mod p$$

故找到 $2^{e×dp} - 2$ 和 $n$ 的最大公约数即可得到 $p$。

$d_p$ 泄露攻击例题

$d_p$ 泄露攻击例题下载

from Crypto.Util.number import long_to_bytes, bytes_to_longfrom secret import mn = 110258232065996936040119382717057533219407439132082940253584584843182789072223349906230791856973287972123865907521188214279276036006315106449207819895384374593369624196851954653849023080919521562472625060120241327872006503587923172763038424169766164805827768917668909645409183750383690108690297577306064749501e = 86358776187347673493647406489815610508873901999008033525516761692023880375437dp = 2026744663215773394057368328828715466612074334163244052273782180970389150112352609040984669970258057823988294286780317419979188752707883050227364941845499c = pow(bytes_to_long(m.encode()), e, n)print("c =", c)#c = 57824787462538624115079284407485175696376125079926154812508611561859936644607308884917900487579845271493649664537572020799918933437291303394878105158410745800945703317112722575982308950734393152733789992168072260114287421251670816067142160465467661371596611685239421550264474850090840444467287904457322154326

在这个例题中，攻击者可以通过获取到 $d_p$ 的值来计算出 $p$，从而进一步分解出模数 $n$，最终获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import long_to_bytes, inverse, GCDn = 110258232065996936040119382717057533219407439132082940253584584843182789072223349906230791856973287972123865907521188214279276036006315106449207819895384374593369624196851954653849023080919521562472625060120241327872006503587923172763038424169766164805827768917668909645409183750383690108690297577306064749501e = 86358776187347673493647406489815610508873901999008033525516761692023880375437dp = 2026744663215773394057368328828715466612074334163244052273782180970389150112352609040984669970258057823988294286780317419979188752707883050227364941845499c = 57824787462538624115079284407485175696376125079926154812508611561859936644607308884917900487579845271493649664537572020799918933437291303394878105158410745800945703317112722575982308950734393152733789992168072260114287421251670816067142160465467661371596611685239421550264474850090840444467287904457322154326p = GCD(pow(2, e*dp, n) - 2, n)q = n // pphi = (p-1) * (q-1)d = inverse(e, phi)m = pow(c, d, n)print(long_to_bytes(m))# b'flag{dp_leak_is_very_dangerous}'

$d$ 泄露攻击 😎

如果攻击者同时知道了公钥指数 $e$ 和私钥指数 $d$，并且我们发现模数的大小与 $e \cdot d$ 之间差值符合爆破范围。

我们由密钥关系推导$e × d = 1 + k × \phi(n)$。
确定 $\phi(n)$ 的范围(用n近似)和 $e \cdot d$ 范围进行爆破 $k$。

$$\frac{e \cdot d - 1}{\phi(n)} = k$$

当然，我们可以使用 $d$ 泄露攻击来分解模数，获取到 $p$ 和 $q$。这种情况一般会出现在系列题目中，分解模数代表完全掌握了RSA的加密解密过程，后续的题目可能会在此基础上进行一些变形或者增加一些限制条件来增加难度。

首先，已知RSA的公钥 $(e, n)$ 和私钥 $d$ 满足以下关系：

$$e \cdot d \equiv 1 \mod \phi(n)$$

所以，存在整数 $k$，使得

$$e \cdot d - 1 = k \cdot \phi(n)$$

又 $ \forall a \in Z_n^*$，满足 $a^{ed - 1} \equiv 1 \mod n$，令

$$ed - 1 \equiv 2^{s}t$$

其中，$t$ 为奇数，可以证明至少一半的 $a$ 满足，存在 $i \in [1, s]$，使得

$$a^{2^{i-1}t} \not \equiv \pm 1 \mod n, a^{2^{i}t} \equiv 1 \mod n$$

如果 $a,i$ 满足上述条件，则 $gcd(a^{2^{i-1}t} - 1, n)$ 为 $n$ 的非平凡因子。

代码演示：

def factor(e, d, n):    k = e * d - 1    if k % 2 == 1:        return None    r = 0    t = k    while t % 2 == 0:        t //= 2        r += 1    for i in range(100):        g = random.randint(2, n - 1)        y = pow(g, t, n)        if y == 1 or y == n - 1:            continue        for j in range(r):            x = pow(y, 2, n)            if x == 1:                p = GCD(y - 1, n)                q = GCD(y + 1, n)                if p != n and q != n:                    return p, q            if x == n - 1:                break            y = x    return None

$d$ 泄露攻击例题

$d$ 泄露攻击例题下载

from Crypto.Util.number import *from secret import mdef nextPrime(n):    n += 2 if n & 1 else 1    while not isPrime(n):        n += 2    return np = getPrime(1024)q = nextPrime(p)n = p*qe = 65537d = inverse(e, (p-1)*(q-1))c = pow(bytes_to_long(m.encode()), e, n)print(f"c = {c}")print(f"d = {d}")# c = 2351513466711699961275642938145920567717064187415670287856662165691734583511498511849556884324985836944759340430602518816433675154658136461956198063979927374588752761285276022407348897862403266636524918180127033165885832562693771076754684722731688431429937047605808304439473588318383001177577056016593797108647431975635650094036889708447244444614378357243277541322659755051936643582756858815668485878335755801145194320825814381728758757706480457190526292370291648284303227561156220999669622281957677370592060075572209068255726871622636790395044724399719011386821145933178352805650027741623500937510313518945469155302# d = 19148105720056666554199884501635824534269326983585168429616104055501403262584188036915335459586648180711891951597484047750673362212665198365799020084440783235574443041732573269843811986291526627281503946572630916067824489440197669541850813141337499242644990995736824092775241919506559628875472249640582214556197841501452934104799319015596870245520721236032106961363621543195345434346863657436265360961414326566644881685137687179094740959374192583443543425968907126818396159939075323461512947503693730501859850872858036346011436175151526444655727243816528687577922841002832868639902639633674684653878564522063533978273

在这个例题中，攻击者可以通过已知的 $e$ 和 $d$ 来计算出 $\phi(n)$，从而获取到 $p$ 和 $q$，最终获取到原始消息 $m$。
重点在于通过bit位成功确定爆破范围，成功爆破出 $k$。

解题代码示例：

from Crypto.Util.number import *import sympyimport gmpy2 as gpe = 65537c = 2351513466711699961275642938145920567717064187415670287856662165691734583511498511849556884324985836944759340430602518816433675154658136461956198063979927374588752761285276022407348897862403266636524918180127033165885832562693771076754684722731688431429937047605808304439473588318383001177577056016593797108647431975635650094036889708447244444614378357243277541322659755051936643582756858815668485878335755801145194320825814381728758757706480457190526292370291648284303227561156220999669622281957677370592060075572209068255726871622636790395044724399719011386821145933178352805650027741623500937510313518945469155302d = 19148105720056666554199884501635824534269326983585168429616104055501403262584188036915335459586648180711891951597484047750673362212665198365799020084440783235574443041732573269843811986291526627281503946572630916067824489440197669541850813141337499242644990995736824092775241919506559628875472249640582214556197841501452934104799319015596870245520721236032106961363621543195345434346863657436265360961414326566644881685137687179094740959374192583443543425968907126818396159939075323461512947503693730501859850872858036346011436175151526444655727243816528687577922841002832868639902639633674684653878564522063533978273ed = bin(e*d - 1) [2:]print("ed =", ed) # 位数2064# 已知n是2048位的数，e*d-1是2048位的数，所以k的位数为16for k in range(pow(2,15),pow(2,16)):    if (e*d - 1 ) % k == 0:        phi = (e*d - 1) // k        p = sympy.prevprime(gp.iroot(phi,2) [0])        q = sympy.nextprime(p)        if (p - 1) * (q - 1) == phi:            breakn = p * qm = pow(c, d, n)print(long_to_bytes(m))# b'flag{u_can_catch_flag_without_n}'

wiener攻击 👻

当d比较小（$d<\frac{1}{3}N^\frac{1}{4}$）时,可以使用 Wiener 算法来获取私钥 $d$。

通常出题人为了要使得生成的私钥 $d$ 比较小，通常会先生成一个比较小的 $d$，然后再去求 $e$，从而使得 $e$ 的取值范围位于（$1,\phi(n)$）之间，会导致 $e$ 很大，基本上可以和模数 $n$ 大小相似。

从两条关系出发

$$\begin{align*}\phi(n) = (p-1) \cdot (q-1) &= n - (p + q) + 1 \\e \cdot d &= 1 + k \cdot \phi(n)\end{align*}$$

带入有

$$e \cdot d = 1 + k \cdot [ n - (p + q) +1]$$

两边同时除以 $nd$，得到

$$\frac{e}{n} = \frac{k}{d}(1 - \delta)$$

式子左边均已知，右边均未知，右边和左边非常接近。
这种情况可以使用连分数来将左边的比值展开，在连分数的展开式中，很大概率存在 $k$ 和 $d$，从而可以求出私钥 $d$，进行解密。

当然，这个算法也不一定是用来求解 $d$，实际上任何满足的近似值都可以用这个算法直接计算出我们要的解。

wiener攻击例题一

wiener攻击例题下载

from Crypto.Util.number import *from secret import mn = 101991809777553253470276751399264740131157682329252673501792154507006158434432009141995367241962525705950046253400188884658262496534706438791515071885860897552736656899566915731297225817250639873643376310103992170646906557242832893914902053581087502512787303322747780420210884852166586717636559058152544979471e = 46731919563265721307105180410302518676676135509737992912625092976849075262192092549323082367518264378630543338219025744820916471913696072050291990620486581719410354385121760761374229374847695148230596005409978383369740305816082770283909611956355972181848077519920922059268376958811713365106925235218265173085c = pow(bytes_to_long(m.encode()), e, n)print("c =",c)# c = 80101582494604437223741383588717025600300047023426616620891241783981638998150472682835072801153995869502522450301302385220129781465036908562359475679205173120186042784572146009306633860957439559980202876647026507563827608212430617525606857990848945461179334863717971248735308788929007826292228060661672434321

在这个例题中，肉眼可见模数 $n$ 和公钥指数 $e$ 大小相似，说明私钥 $d$ 比较小，那么我们就可以使用 Wiener 攻击来求解出私钥 $d$，从而获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import *from sage.all import *n = 101991809777553253470276751399264740131157682329252673501792154507006158434432009141995367241962525705950046253400188884658262496534706438791515071885860897552736656899566915731297225817250639873643376310103992170646906557242832893914902053581087502512787303322747780420210884852166586717636559058152544979471e = 46731919563265721307105180410302518676676135509737992912625092976849075262192092549323082367518264378630543338219025744820916471913696072050291990620486581719410354385121760761374229374847695148230596005409978383369740305816082770283909611956355972181848077519920922059268376958811713365106925235218265173085c = 80101582494604437223741383588717025600300047023426616620891241783981638998150472682835072801153995869502522450301302385220129781465036908562359475679205173120186042784572146009306633860957439559980202876647026507563827608212430617525606857990848945461179334863717971248735308788929007826292228060661672434321e_sage = Integer(e)n_sage = Integer(n)cf = continued_fraction(e_sage / n_sage).convergents()for k_frac in cf[1:]:    d = k_frac.denominator()    k = k_frac.numerator()    if k == 0 or d == 0:        continue    if (e * d - 1) % k != 0:        continue    m = long_to_bytes(pow(c, d, n))    print(m)# b'flag{the_big_e_is_dangerous}'

wiener攻击例题二

wiener攻击例题下载

import sympyfrom Crypto.Util.number import *from secret import flagflag1 = flag[:19].encode()flag2 = flag[19:].encode()assert(len(flag) == 38)P1 = getPrime(1038)P2 = sympy.nextprime(P1)assert(P2 - P1 < 1000)Q1 = getPrime(512)Q2 = sympy.nextprime(Q1)N1 = P1 * P1 * Q1N2 = P2 * P2 * Q2E1 = getPrime(1024)E2 = sympy.nextprime(E1)m1 = bytes_to_long(flag1)m2 = bytes_to_long(flag2)c1 = pow(m1, E1, N1)c2 = pow(m2, E2, N2)print("N1=",N1)print("E1=",E1)print("c1=",c1)print("N2=",N2)print("E2=",E2)print("c2=",c2)# N1=60143104944034567859993561862949071559877219267755259679749062284763163484947626697494729046430386559610613113754453726683312513915610558734802079868190554644983911078936369464590301246394586190666760362763580192139772729890492729488892169933099057105842090125200369295070365451134781912223048179092058016446222199742919885472867511334714233086339832790286482634562102936600597781342756061479024744312357407750731307860842457299116947352106025529309727703385914891200109853084742321655388368371397596144557614128458065859276522963419738435137978069417053712567764148183279165963454266011754149684758060746773409666706463583389316772088889398359242197165140562147489286818190852679930372669254697353483887004105934649944725189954685412228899457155711301864163839538810653626724347# E1=125932919717342481428108392434488550259190856475011752106073050593074410065655587870702051419898088541590032209854048032649625269856337901048406066968337289491951404384300466543616578679539808215698754491076340386697518948419895268049696498272031094236309803803729823608854215226233796069683774155739820423103# N2=60143104944034567859993561862949071559877219267755259679749062284763163484947626697494729046430386559610613113754453726683312513915610558734802079868195633647431732875392121458684331843306730889424418620069322578265236351407591029338519809538995249896905137642342435659572917714183543305243715664380787797562011006398730320980994747939791561885622949912698246701769321430325902912003041678774440704056597862093530981040696872522868921139041247362592257285423948870944137019745161211585845927019259709501237550818918272189606436413992759328318871765171844153527424347985462767028135376552302463861324408178183842139330244906606776359050482977256728910278687996106152971028878653123533559760167711270265171441623056873903669918694259043580017081671349232051870716493557434517579121# E2=125932919717342481428108392434488550259190856475011752106073050593074410065655587870702051419898088541590032209854048032649625269856337901048406066968337289491951404384300466543616578679539808215698754491076340386697518948419895268049696498272031094236309803803729823608854215226233796069683774155739820425393# c1 = 14073319586163781679481641179662582612304692176580961784953477838609276616064589846809270198729540715245691991740464261550360788284937834670050775858366101085348280669179408813113362405053335009206731776590481373734764383540364750799676070346518475581682516426563732231616057180451762625401173375609189648138854979940971607994443347332491396247789654295359301772332945336628799244150289351676680721435465563648104813778503434793931626482475134001659540217915771568233343281055830752661539150794979736067742502306279761313481724154724055466231123359431082147305556479579346284553457892479595918187550211451065607322614000006859723843438948537608221042231108152696040678683554497540495126798195723931414990643263282854475908809930686235855491686777629698984201000658669936961615186# c2 = 7741133573061898991718841569604686293847712651459642535825877765243067060193308133385557355381962779171678392611432953529802863894965082406081770549435804237257142410673170863585027671844837301406995739036818126803525925392123724367462856577481458451934142005470762416077608148210778025980305611228050923521365912250581454107545415887539097404367263553527441676600625832138948968108210407415663388184702852913387236486545458819686141479064069733023490788623703473254743320501358595518028968805977839380155887651172992548200623712353654087865742820046863844682793639042663279707824154464544589525016155769813415003482652443230965612123925078843715142264156868627471931778131372410481557419293475673728501696136293542695689649954773759684775991749503582720389352345218448368591510

在这个例题中，我们发现 $P1$ 和 $P2$ 大小接近，$Q1$ 和 $Q2$ 大小接近，那么我们可以认为 $\frac{N1}{N2} = \frac{P1^2 \cdot Q1}{P2^2 \cdot Q2} \approx \frac{Q1}{Q2}$，从而可以通过连分数来求解出 $Q1$ 和 $Q2$，再解出 $P1$ 和 $P2$，最终获取到原始消息 $m$。

解题代码示例：

from sage.all import *import gmpy2 as gpfrom Crypto.Util.number import *N1=60143104944034567859993561862949071559877219267755259679749062284763163484947626697494729046430386559610613113754453726683312513915610558734802079868190554644983911078936369464590301246394586190666760362763580192139772729890492729488892169933099057105842090125200369295070365451134781912223048179092058016446222199742919885472867511334714233086339832790286482634562102936600597781342756061479024744312357407750731307860842457299116947352106025529309727703385914891200109853084742321655388368371397596144557614128458065859276522963419738435137978069417053712567764148183279165963454266011754149684758060746773409666706463583389316772088889398359242197165140562147489286818190852679930372669254697353483887004105934649944725189954685412228899457155711301864163839538810653626724347E1=125932919717342481428108392434488550259190856475011752106073050593074410065655587870702051419898088541590032209854048032649625269856337901048406066968337289491951404384300466543616578679539808215698754491076340386697518948419895268049696498272031094236309803803729823608854215226233796069683774155739820423103N2=60143104944034567859993561862949071559877219267755259679749062284763163484947626697494729046430386559610613113754453726683312513915610558734802079868195633647431732875392121458684331843306730889424418620069322578265236351407591029338519809538995249896905137642342435659572917714183543305243715664380787797562011006398730320980994747939791561885622949912698246701769321430325902912003041678774440704056597862093530981040696872522868921139041247362592257285423948870944137019745161211585845927019259709501237550818918272189606436413992759328318871765171844153527424347985462767028135376552302463861324408178183842139330244906606776359050482977256728910278687996106152971028878653123533559760167711270265171441623056873903669918694259043580017081671349232051870716493557434517579121E2=125932919717342481428108392434488550259190856475011752106073050593074410065655587870702051419898088541590032209854048032649625269856337901048406066968337289491951404384300466543616578679539808215698754491076340386697518948419895268049696498272031094236309803803729823608854215226233796069683774155739820425393c1 = 14073319586163781679481641179662582612304692176580961784953477838609276616064589846809270198729540715245691991740464261550360788284937834670050775858366101085348280669179408813113362405053335009206731776590481373734764383540364750799676070346518475581682516426563732231616057180451762625401173375609189648138854979940971607994443347332491396247789654295359301772332945336628799244150289351676680721435465563648104813778503434793931626482475134001659540217915771568233343281055830752661539150794979736067742502306279761313481724154724055466231123359431082147305556479579346284553457892479595918187550211451065607322614000006859723843438948537608221042231108152696040678683554497540495126798195723931414990643263282854475908809930686235855491686777629698984201000658669936961615186c2 = 7741133573061898991718841569604686293847712651459642535825877765243067060193308133385557355381962779171678392611432953529802863894965082406081770549435804237257142410673170863585027671844837301406995739036818126803525925392123724367462856577481458451934142005470762416077608148210778025980305611228050923521365912250581454107545415887539097404367263553527441676600625832138948968108210407415663388184702852913387236486545458819686141479064069733023490788623703473254743320501358595518028968805977839380155887651172992548200623712353654087865742820046863844682793639042663279707824154464544589525016155769813415003482652443230965612123925078843715142264156868627471931778131372410481557419293475673728501696136293542695689649954773759684775991749503582720389352345218448368591510N1 = Integer(N1)N2 = Integer(N2)c1 = Integer(c1)c2 = Integer(c2)E1 = Integer(E1)E2 = Integer(E2)cf = continued_fraction(N1 / N2).convergents()for x_frac in cf[1:]:    Q1 = x_frac.numerator()    Q2 = x_frac.denominator()    if N1 % Q1 == 0 and N2 % Q2 == 0:        P1, ok1 = gp.iroot(N1 // Q1,2)        P2, ok2 = gp.iroot(N2 // Q2,2)        if ok1 and ok2:            if P1 * P1 * Q1 == N1 and P2 * P2 * Q2 == N2:                phi1 = (P1 - 1) * (P1) * (Q1 - 1)                phi2 = (P2 - 1) * (P2) * (Q2 - 1)                if (phi1 != 0):                    d1 = inverse(E1, phi1)                    m1 = pow(c1, d1, N1)                    flag1 = long_to_bytes(m1)                if (phi2 != 0):                    d2 = inverse(E2, phi2)                    m2 = pow(c2, d2, N2)                    flag2 = long_to_bytes(m2)                    print(flag1 + flag2)print("Done")

共私钥攻击

设同一个 RSA 加密系统中有 $r$ 个 RSA 加密共用同一个私钥 $d$，这些加密的公钥分别为 $(e_1,N_1), \cdots ,(e_r,N_r)$。设 $N_i, \cdots ,N_r$ 依次增大，并且由于是同一个系统中的加密，故认为 $N_1, \cdots ,N_r$ 具有近似相同的比特长度，于是有 $N_i < N_2 < \cdots < N_r < 2N_1$。

那我们可以得到一串式子：

$$\begin{cases}e_1d=1+k_1\varphi(N_1) \newline e_2d=1+k_2\varphi(N_2) \newline {\vdots} \newline e_rd=1+k_r\varphi(N_r)\end{cases}$$

其中，$N_1 \lt N_2 \lt \cdots \lt N_r \lt 2N_1$。

构造格：

$\mathcal{B}r = \begin{bmatrix}{M}&{e_1}&{e_2}&{\cdots}&{e{r}}\newline
{0}&{-N_1}&{0}&{\cdots}&{0}\newline{0}&{0}&{-N_2}&{\cdots}&{0}\newline{\vdots}&{\vdots}&{\vdots}&{\ddots}&{\vdots}\newline{0}&{0}&{0}&{\cdots}&{-N_r}\newline\end{bmatrix}$

其中 $M=\lfloor N_r^{\frac{1}{2}} \rfloor$。

则有 $x_r \mathcal{B}_r = v_r$。注意到$\mathcal{B}_r$的行向量组生成了一个 $r+1$ 维的格，而 $v_r$ 是格中的一个向量。

当不等式 $|v_r| < (\det(\mathcal{B}_r))^{1/(r+1)}$ 成立时，攻击者只要解出格 $\mathcal{L}$ 上的 $SVP$ 问题即可解出$v_r$，从而得到$v_r$ 第一个分量 $dM$。$M$ 已知，因此攻击者可求出$d$，从而攻破这些加密。

共私钥攻击例题

共私钥攻击例题下载

from Crypto.Util.number import *from random import randintfrom secret import mflag = bytes_to_long(m)d = getPrime(randint(370, 390))def enc(i):    print()    p = getPrime(512)    q = getPrime(512)    n = p * q    phi = (p - 1) * (q - 1)    e = inverse(d, phi)    c = pow(flag, e, n)    print(f'e_{i} =', e)    print(f'n_{i} =', n)    print(f'c_{i} =', c)if __name__ == '__main__':    for i in range(3):        enc(i)# e_0 = 65273226782938365337746916273730336693400864987226527768629555154328678878476135267049386675622260483462220524488000354329161815186124642838496578365092125560635683645652071790968480727817124418736448310995681377289580390945033014829116595493634248909648715641159852982292802459935880193569900887152429411847# n_0 = 68273324976926984651373562317651913900179693126653185371759797219277881642295726703952462364177190633417720186224603741096752660090376579503727572378024303201815180519953050892027877371422177476434135471869132077433509929481856863664414488106874978031117040155569240599125372440850335176938915089228631971431# c_0 = 16463194277385538006493566728001486227786740657948067325252587295940494532065739047726911635855222798083564798297575745875829939089155104617971353187283800644588271503369243499488369408980732160648403981697621858247469275317713246150930367274375918283239982926149575828206494609703891781265641859935914641074# e_1 = 53183464145552802360531688680606198853528727337569529128017476892680955108627614437658132384170885260306496461692012374021037184681776910963904643763330840441120876734164247981352314520467566316707955441110480325303720433156607378590168931447833282902975068598066007058786049095275193605661581759764776542387# n_1 = 90833211551873588270723217667845249495678823850090802136881865517157637454704099665876807553866070458443591809771270518186644833084553243489440868805023263983493252562278743540874001449613551511883028751718014192333516201168480774970739015419610164062537605779410456513031793199999777014894788382706200020757# c_1 = 22230407808384569931627303117203531383384351503543847426279650122016349747727471353664420880494793722905388983532487901293245030301420692356478218700042566146940345598488036019164944136859836172333034426475299360977773550746037781230355523685359896051245838911971087469266586191931907778679857463565972955053# e_2 = 79529912185727957854696598539340243519754783720481234589808002665134740533984846798408244547517529674239903959400216641821295959596895413579323465593465830465480139546555530097368569245288033553150779307023833488210096219439360271707710591508276783814809197507754362030663819911878417169437723245134949158879# n_2 = 129884915453563769925617783280424054377155108084275359132533095588688005688782127459458645185506079867020438362987468403256647102770553654162232890781552673147712836927912298560902655711987881754839768794787168125599139190546712270501013360266296615603202216855466243614243328596099717542864006193566337698107# c_2 = 45046520188230821139461613627667404949754182395531112466748475103653526026321780076835632789482008756547877684013753034233663379312517859344427404926219930531928639530079463417386563408726593602509407278834104957286532673590748489716544044445125128760577108367123150435970486466443524388142767285555053802498

这个题目中，攻击者可以通过已知的 $e_i$ 和 $N_i$ 来构造格 $\mathcal{B}_r$，然后直接使用 LLL 算法来求解出格 $\mathcal{L}$ 上的 $SVP$ 问题，从而得到$v_r$，最终获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import *from sage.all import *e_0 = 65273226782938365337746916273730336693400864987226527768629555154328678878476135267049386675622260483462220524488000354329161815186124642838496578365092125560635683645652071790968480727817124418736448310995681377289580390945033014829116595493634248909648715641159852982292802459935880193569900887152429411847n_0 = 68273324976926984651373562317651913900179693126653185371759797219277881642295726703952462364177190633417720186224603741096752660090376579503727572378024303201815180519953050892027877371422177476434135471869132077433509929481856863664414488106874978031117040155569240599125372440850335176938915089228631971431c_0 = 16463194277385538006493566728001486227786740657948067325252587295940494532065739047726911635855222798083564798297575745875829939089155104617971353187283800644588271503369243499488369408980732160648403981697621858247469275317713246150930367274375918283239982926149575828206494609703891781265641859935914641074e_1 = 53183464145552802360531688680606198853528727337569529128017476892680955108627614437658132384170885260306496461692012374021037184681776910963904643763330840441120876734164247981352314520467566316707955441110480325303720433156607378590168931447833282902975068598066007058786049095275193605661581759764776542387n_1 = 90833211551873588270723217667845249495678823850090802136881865517157637454704099665876807553866070458443591809771270518186644833084553243489440868805023263983493252562278743540874001449613551511883028751718014192333516201168480774970739015419610164062537605779410456513031793199999777014894788382706200020757c_1 = 22230407808384569931627303117203531383384351503543847426279650122016349747727471353664420880494793722905388983532487901293245030301420692356478218700042566146940345598488036019164944136859836172333034426475299360977773550746037781230355523685359896051245838911971087469266586191931907778679857463565972955053e_2 = 79529912185727957854696598539340243519754783720481234589808002665134740533984846798408244547517529674239903959400216641821295959596895413579323465593465830465480139546555530097368569245288033553150779307023833488210096219439360271707710591508276783814809197507754362030663819911878417169437723245134949158879n_2 = 129884915453563769925617783280424054377155108084275359132533095588688005688782127459458645185506079867020438362987468403256647102770553654162232890781552673147712836927912298560902655711987881754839768794787168125599139190546712270501013360266296615603202216855466243614243328596099717542864006193566337698107c_2 = 45046520188230821139461613627667404949754182395531112466748475103653526026321780076835632789482008756547877684013753034233663379312517859344427404926219930531928639530079463417386563408726593602509407278834104957286532673590748489716544044445125128760577108367123150435970486466443524388142767285555053802498M = floor(isqrt(n_2))Mat = Matrix(ZZ,[    [M,e_0,e_1,e_2],    [0,-n_0,0,0],    [0,0,-n_1,0],    [0,0,0,-n_2]])Mat_LLL=Mat.LLL()d = int(abs(Mat_LLL[0][0])/M)m = pow(c_0, d, n_0)print(long_to_bytes(m))# b'flag{u_gain_deep_insights_into_LLL!!!}'

上一章：RSA加解密专题 - 公钥指数相关攻击 👈
下一章：RSA加解密专题 - 公私钥格式相关攻击 👈
回到开始：关于我 👈

相关链接：
密码学数学基础 - 二次剩余 👈
密码学算法 - Wiener算法 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4003.html 2026-03-02T13:58:00.000Z

在RSA加解密算法中，私钥是一个非常重要的参数，它与公钥指数和模数之间存在着密切的关系。如果私钥的选择不当，或者在某些特定情况下，攻击者可能会利用这些关系来破解RSA加密算法，从而获取到原始消息或者分解出模数。

本文将介绍一些与RSA私钥 $d$ 相关的攻击方]]>

2026-03-16T07:30:16.623Z Dorange 在实际应用中，攻击者可能会利用一些特定的攻击方法来破解RSA加密，尤其是当公钥指数选择不当时。

本文将介绍一些与 RSA 公钥指数相关的攻击方法，包括常见的攻击手段如小公钥攻击、共模攻击等。

共模攻击 😝

对于同一个模数 $n$，用于加密同一个 $m$，但是用不同 $e$ 加密两次

$$\begin{align*}m^{e_1} \equiv c_1 \mod n \\m^{e_2} \equiv c_2 \mod n\end{align*}$$

使用裴蜀定理可以破解,构造

$$r e_1 + s e_2 = gcd(e_1,e_2)$$

则由

$$c_{1}^r \cdot c_{2}^s \equiv m^{er_1 + se_2} \mod n$$

从而绕过私钥d解密

共模攻击例题

共模攻击例题下载

from Crypto.Util.number import *from secret import mn=22708078815885011462462049064339185898712439277226831073457888403129378547350292420267016551819052430779004755846649044001024141485283286483130702616057274698473611149508798869706347501931583117632710700787228016480127677393649929530416598686027354216422565934459015161927613607902831542857977859612596282353679327773303727004407262197231586324599181983572622404590354084541788062262164510140605868122410388090174420147752408554129789760902300898046273909007852818474030770699647647363015102118956737673941354217692696044969695308506436573142565573487583507037356944848039864382339216266670673567488871508925311154801e1=11187289e2=9647291c1=pow(bytes_to_long(m.encode()),e1,n)c2=pow(bytes_to_long(m.encode()),e2,n)print("c1=",c1)print("c2=",c2)# c1= 790366317276917716093037100691893212049197503039073730961711955448039864232657167573766790435902489218987416033345432295535434340907830576059653129588389135233836704959763784732603854307280897825796829293821089699244606589550689905999360752865586633248545571069424718536350480397506708904105353777714019847026603704906940973023655873113053577161389905208578179532007836298832828616932855035573669965730367452024031424244549158099754154915714597044930116500701707880040556392334392040167123504591683227247869389138456426790241330370554371099743080796833926937422959498423437908845573739316285898375909700396674766321# c2= 4478228437147112241330288727207043414653440426045870497003424494438532257351016896075282127540792673410751595389118015588892772311255950462483402965089986383679582710285977427903307418218183817805264826906460262820854269348325404657900131315817318564877009830557176260073108040099242211702768455039629577625595469833810558303709929093235956775183074705448641710348260784158331497639337250366911970600020203747263235354753699686026666826062329129036821935202924925003686947876422542100428131746969352587613145920594297604370505030268652906467071393237088678927582520826567309207877633272146060026832148078270532393467

在这个例题中，两个加密使用了同一个模数 $n$，但是使用了不同的公钥指数 $e_1$ 和 $e_2$，攻击者可以通过构造裴蜀定理中的线性组合来破解，获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import *import gmpy2 as gpn=22708078815885011462462049064339185898712439277226831073457888403129378547350292420267016551819052430779004755846649044001024141485283286483130702616057274698473611149508798869706347501931583117632710700787228016480127677393649929530416598686027354216422565934459015161927613607902831542857977859612596282353679327773303727004407262197231586324599181983572622404590354084541788062262164510140605868122410388090174420147752408554129789760902300898046273909007852818474030770699647647363015102118956737673941354217692696044969695308506436573142565573487583507037356944848039864382339216266670673567488871508925311154801e1=11187289e2=9647291c1= 790366317276917716093037100691893212049197503039073730961711955448039864232657167573766790435902489218987416033345432295535434340907830576059653129588389135233836704959763784732603854307280897825796829293821089699244606589550689905999360752865586633248545571069424718536350480397506708904105353777714019847026603704906940973023655873113053577161389905208578179532007836298832828616932855035573669965730367452024031424244549158099754154915714597044930116500701707880040556392334392040167123504591683227247869389138456426790241330370554371099743080796833926937422959498423437908845573739316285898375909700396674766321c2= 4478228437147112241330288727207043414653440426045870497003424494438532257351016896075282127540792673410751595389118015588892772311255950462483402965089986383679582710285977427903307418218183817805264826906460262820854269348325404657900131315817318564877009830557176260073108040099242211702768455039629577625595469833810558303709929093235956775183074705448641710348260784158331497639337250366911970600020203747263235354753699686026666826062329129036821935202924925003686947876422542100428131746969352587613145920594297604370505030268652906467071393237088678927582520826567309207877633272146060026832148078270532393467g,r,s = gp.gcdext(e1, e2)m_g = pow(c1, r, n) * pow(c2, s, n) % nm, ok = gp.iroot(m_g,g)assert okprint(long_to_bytes(m))# flag{use_the_same_n_is_dangerous}

小公钥攻击 🤠

如果公钥指数 $e$ 选择得过小（如 $e=3$），攻击者可以直接爆破出正确的结果，获取到原始消息 $m$。

$$C \equiv M^e \mod n$$

如果 $e$ 较小，则 $C = M^e$，攻击者可以直接计算

$$M = \sqrt[e]{C + k n}$$

来获取到原始消息 $m$。

小公钥攻击例题

小公钥攻击例题下载

from Crypto.Util.number import getPrime, bytes_to_longfrom secret import mp = getPrime(512)q = getPrime(512)e = 5n = p * qprint("n = ",n)c = pow(bytes_to_long(m.encode()), e, n)print("c = ",c)# n =  151884658354743631395724585360507748159987284748681837528758493598171633984152168593482231461426893458183687924535172757062309062690802891891728554675548497092710048532926098530490127945685611807130560943577105993562003866576646552381530174936590879602799062588680515873294508600878401809375729119964496068873# c =  68358389983146861908514174327099913729389440802950325638324116448687159665872062912200362098390297202380605609237336130498725419673621377108679738418963796009518478977346741380680301178771968725758445389936586626869076720616127612057058701

在这个例题中，公钥指数 $e$ 选择得过小（$e=5$），攻击者可以直接计算 $M = \sqrt[5]{C + k n}$ 来获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import  long_to_bytesimport gmpy2n =  151884658354743631395724585360507748159987284748681837528758493598171633984152168593482231461426893458183687924535172757062309062690802891891728554675548497092710048532926098530490127945685611807130560943577105993562003866576646552381530174936590879602799062588680515873294508600878401809375729119964496068873c =  68358389983146861908514174327099913729389440802950325638324116448687159665872062912200362098390297202380605609237336130498725419673621377108679738418963796009518478977346741380680301178771968725758445389936586626869076720616127612057058701e = 5for k in range(0,10000000):    temp = c + k * n    m, ok = gmpy2.iroot(temp, e)    print(f"Trying k={k}...", end="\r")    if ok:        print(long_to_bytes(m))        break# flag{small_e_is_bad}

实际上，对于这种小根攻击，我们使用 Coppersmith 攻击会更快一些，这里我们只是为了演示小公钥攻击的原理，所以使用了暴力破解的方法。当然，仅限于这个明文较小的例题，如果明文较大，破解的方法就不太适用了。
这里我附上一个使用Coppersmith攻击的解题代码示例，供大家参考：

from sage.all import *from Crypto.Util.number import *n =  151884658354743631395724585360507748159987284748681837528758493598171633984152168593482231461426893458183687924535172757062309062690802891891728554675548497092710048532926098530490127945685611807130560943577105993562003866576646552381530174936590879602799062588680515873294508600878401809375729119964496068873c =  68358389983146861908514174327099913729389440802950325638324116448687159665872062912200362098390297202380605609237336130498725419673621377108679738418963796009518478977346741380680301178771968725758445389936586626869076720616127612057058701e = 5R = Zmod(n)P.<x> = PolynomialRing(R)f = x^e - croots = f.small_roots(bound=2**512,epsilon=1/32)for m in roots:    flag = long_to_bytes(int(m))    print(flag)

Håstad 广播攻击 🧐

如果同一个消息 $M$ 被加密成多个密文 $C_i$，并且使用了相同的公钥指数 $e$，但是不同的模数 $n_i$，攻击者可以通过中国剩余定理（CRT）来破解，获取到原始消息 $M$。

我们以 $e=3$ 为例，同时，我们假设 $m < n_i$，对于每个 $n_i$，我们都有 $m < n_i, \quad 1 \leq i \leq 3$。如果这个条件不满足的话，就会使得情况变得比较复杂，这里我们暂不讨论。

$$\begin{align*}C_1 &\equiv M^3 \mod n_1 \\C_2 &\equiv M^3 \mod n_2 \\C_3 &\equiv M^3 \mod n_3\end{align*}$$

既然他们互素，那么我们可以根据中国剩余定理，可得

$$C \equiv M^3 \mod n_1 n_2 n_3$$

此外，既然 $m < n_i, \quad 1 \leq i \leq 3$，那么我们知道 $m^3 < n_1 n_2 n_3$，因此 $C < m^3 < n_1 n_2 n_3$，所以 $C = M^3$，我们可以直接开三次根来获取到原始消息 $M$。

对于较大的 $e$ 来说，我们只是需要更多的明密文对。

Håstad 广播攻击例题

Håstad 广播攻击例题下载

from Crypto.Util.number import getPrime, bytes_to_longfrom secret import mp1 = getPrime(1024)p2 = getPrime(1024)p3 = getPrime(1024)q1 = getPrime(1024)q2 = getPrime(1024)q3 = getPrime(1024)n1 = p1 * q1n2 = p2 * q2n3 = p3 * q3e = 3c1 = pow(bytes_to_long(m.encode()), e, n1)c2 = pow(bytes_to_long(m.encode()), e, n2)c3 = pow(bytes_to_long(m.encode()), e, n3)print(f"n1 = {n1}")print(f"n2 = {n2}")print(f"n3 = {n3}")print(f"c1 = {c1}")print(f"c2 = {c2}")print(f"c3 = {c3}")# n1 = 21180112366275308792707198865461302488559205693127557021721507567406658951027484893183971746874386346549344017657780496423609870191100125206162930591509951158158895313786384410078334087373942711313704671415169591259711219172542673857746853640129378392407801833076846765791915529766486673221298820251490327058865256315102761890119503763324479969189120347374788296228439421010724923476231379022998720352792854596487066187715900286865855673410192615524429078338954151715726776929439932040633058951481065598837709559391701919303564132940137424657515472160189726163543109080323384612138592271850712993603287137677507275371# n2 = 26298692870046419603854209107106438626626364322119633807665057835205077716901148443766353934040185822955892086743845239542911306720672775951179579233523497436530727494678487971265695182505161985229279355999100651830529513900383767281291762278091913698101895553459847468191806086109066122848275034046679346214591398371960794960928446173802863362768056449148080873128801237014636371466461105802242018480278524831090013751334363547633971239825548849102143384730044030187903043701396605393326607857727105149463605439271849673250355049751794904386124840390758363224179076896253944395507179538229841566514339776966378699671# n3 = 12869245342475181303320296924755202819753541797517717539596064095556108493576385999354161121731642352002540447701060344408122911146469189736765677092104255335613300039538354090648284374737637720058242853559989339600163385950025982705089661378793053705329618987830223564779324941385061454586426419929951975212520146873738260085179715217979995535362995225493010874118526395325025302743041973441408932644128476440939321271157322933582064335494518736514896863501417816715050783307592053908471995029904208083874643331646961543050595330178883620466733870718886642963399595471133909399884799882277656325390344541700992326753# c1 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125# c2 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125# c3 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125

这个例题中，同一个消息 $M$ 被加密成了三个密文 $C_1$、$C_2$ 和 $C_3$，并且使用了相同的公钥指数 $e=3$，但是不同的模数 $n_1$、$n_2$ 和 $n_3$，攻击者可以通过中国剩余定理来破解，获取到原始消息 $M$。

解题代码示例：

from sage.all import *import gmpy2 as gpn1 = 21180112366275308792707198865461302488559205693127557021721507567406658951027484893183971746874386346549344017657780496423609870191100125206162930591509951158158895313786384410078334087373942711313704671415169591259711219172542673857746853640129378392407801833076846765791915529766486673221298820251490327058865256315102761890119503763324479969189120347374788296228439421010724923476231379022998720352792854596487066187715900286865855673410192615524429078338954151715726776929439932040633058951481065598837709559391701919303564132940137424657515472160189726163543109080323384612138592271850712993603287137677507275371n2 = 26298692870046419603854209107106438626626364322119633807665057835205077716901148443766353934040185822955892086743845239542911306720672775951179579233523497436530727494678487971265695182505161985229279355999100651830529513900383767281291762278091913698101895553459847468191806086109066122848275034046679346214591398371960794960928446173802863362768056449148080873128801237014636371466461105802242018480278524831090013751334363547633971239825548849102143384730044030187903043701396605393326607857727105149463605439271849673250355049751794904386124840390758363224179076896253944395507179538229841566514339776966378699671n3 = 12869245342475181303320296924755202819753541797517717539596064095556108493576385999354161121731642352002540447701060344408122911146469189736765677092104255335613300039538354090648284374737637720058242853559989339600163385950025982705089661378793053705329618987830223564779324941385061454586426419929951975212520146873738260085179715217979995535362995225493010874118526395325025302743041973441408932644128476440939321271157322933582064335494518736514896863501417816715050783307592053908471995029904208083874643331646961543050595330178883620466733870718886642963399595471133909399884799882277656325390344541700992326753c1 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125c2 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125c3 = 27986825396866988547862724357202658730691167333564612684951165687800210126707967163602150013745798355893557986277872052045351674932828898392362316022217536592578822801708792807726846802836702174268667149603691471355321662500021629469435803425125C = crt([c1, c2, c3], [n1, n2, n3])flag = int(gp.iroot(C, e)[0])print(long_to_bytes(flag).decode())# flag{e_quals_3_has_been_abandoned}

Rabin 加密算法 😎

Rabin 加密算法是 RSA 加密算法的一个变种，它使用了平方运算来加密消息。Rabin 加密算法的安全性基于大数分解的困难性，与 RSA 加密算法类似。可以直接将他看作 RSA 加密算法中 $e=2$ 的特殊情况。

Rabin 加密算法 😎

Rabin 加密算法是 RSA 加密算法的一个变种，它使用了平方运算来加密消息。Rabin 加密算法的安全性基于大数分解的困难性，与 RSA 加密算法类似。可以直接将他看作 RSA 加密算法中 $e=2$ 的特殊情况。

Rabin 解密过程：

加密:

$$C \equiv M^2 \mod n$$

解密:
计算出模 $p$ 和模 $q$ 下的平方根，得到4个候选值，然后用 CRT 合并这4个候选值，最终还原出正确的明文。

$$\begin{cases}m_{p_1} \equiv \sqrt{C} \mod p \\m_{p_2} \equiv -\sqrt{C} \mod p \\m_{q_1} \equiv \sqrt{C} \mod q \\m_{q_2} \equiv -\sqrt{C} \mod q \\\end{cases}$$

扩展欧几里得算法计算出 $q$ 在模 $p$ 下的逆元 $q^{-1}$ 和 $p$ 在模 $q$ 下的逆元 $p^{-1}$，然后用 CRT 合并这4个候选值，得到4个明文候选值：

$$\begin{cases}m_1 \equiv m_{p_1} \cdot q \cdot q^{-1} + m_{q_1} \cdot p \cdot p^{-1} \mod n \\m_2 \equiv m_{p_1} \cdot q \cdot q^{-1} + m_{q_2} \cdot p \cdot p^{-1} \mod n \\m_3 \equiv m_{p_2} \cdot q \cdot q^{-1} + m_{q_1} \cdot p \cdot p^{-1} \mod n \\m_4 \equiv m_{p_2} \cdot q \cdot q^{-1} + m_{q_2} \cdot p \cdot p^{-1} \mod n \\\end{cases}$$

然后遍历这4个候选值，尝试解码，成功解码的那个就是正确的明文。

Rabin 加密算法例题

Rabin 加密算法例题下载

from Crypto.Util.number import getPrime, bytes_to_longfrom secret import mp = getPrime(256)while p % 4 != 3:    p = getPrime(256)q = getPrime(256)while q % 4 != 3 or q == p:    q = getPrime(256)n = p * qe = 2c = pow(bytes_to_long(m.encode()), e, n)print("n =", n)print("c =", c)# p = 85456561857487541706156138220614376877735385707364349049681146831137409802611# q = 75122157510403898788703795042660745097752300792713827867823026882894316079263# c = 1468508928651076555882997390203921809955789362208256690325971247724971060869686807252565486180911155882249

这个例题中，模数 $n$ 是由两个满足 $p \equiv 3 \mod 4$ 和 $q \equiv 3 \mod 4$ 的素数 $p$ 和 $q$ 组成的，攻击者可以通过计算模 $p$ 和模 $q$ 下的平方根来获取到原始消息 $m$。

解题代码示例：

from Crypto.Util.number import long_to_bytes, inversemp1 = pow(c, (p + 1) // 4, p)mp2 = (p - mp1) % pmq1 = pow(c, (q + 1) // 4, q)mq2 = (q - mq1) % qinv_q_mod_p = inverse(q, p)  # q在模p下的逆元inv_p_mod_q = inverse(p, q)  # p在模q下的逆元candidates = [    (mp1 * q * inv_q_mod_p + mq1 * p * inv_p_mod_q) % n,    (mp1 * q * inv_q_mod_p + mq2 * p * inv_p_mod_q) % n,    (mp2 * q * inv_q_mod_p + mq1 * p * inv_p_mod_q) % n,    (mp2 * q * inv_q_mod_p + mq2 * p * inv_p_mod_q) % n,]# 遍历候选值，还原出正确的明文flag = None  # 初始化flagfor idx, candidate in enumerate(candidates):    try:        # 尝试解码        decoded_str = long_to_bytes(candidate).decode()        # 只有成功解码的才赋值给flag        flag = decoded_str        print(flag)    except (UnicodeDecodeError, ValueError):        continue# flag{u_know_the_rabin}

Rabin 算法也可以进一步扩展，不一定要 $e = 2$，我们也可以选择 $e = 4$，甚至更大的偶数 $e$，我们的思路也是一样的，计算出模 $p$ 和模 $q$ 下的 $e$ 次根，然后用 CRT 合并这些根，最终还原出正确的明文。不过难度就变成了怎么计算出模 $p$ 和模 $q$ 下的 $e$ 次根了，这个时候我们就可以使用 Adleman-Manders-Miller 算法来计算出模 $p$ 和模 $q$ 下的 $e$ 次根了。

相关密文攻击 🫠

相关明文意思是我们用同一个模数 $n$ 和同一个公钥指数 $e$ 加密了两个不同的明文 $m_1$ 和 $m_2$，得到两个密文 $c_1$ 和 $c_2$，而且这两个明文之间存在某种关系，比如 $m_2 = m_1 + k$，其中 $k$ 是一个已知的常数。

这个时候攻击者就可以利用这个关系来破解，获取到原始消息 $m_1$ 和 $m_2$。当然这种情况一般用于 $e$ 较小的情况，如果 $e$ 较大，这种攻击就不太适用了。

相关明文攻击例题

相关明文攻击例题下载

from Crypto.Util.number import *from secret import me = 5n = 0xf2e5339236455e2bc1b1bd12e45b9341a3b223ddb02dec11c880fa4aa8835df9e463e4c446292cd5a2fe19b10017856654b6d6c3f3a94a95807712329f7dae2e1e6506094d5d2f9c8a05c35cbf3366330996db9bff930fe566016d5e850e232057d419292ce30df9c135d56ef1bb72c38838d4b127aa577ceb4aba94d4e0d55c1 = pow(2*m + 1, e, n)c2 = pow(3*m + 2 , e, n)print("c1 =", c1)print("c2 =", c2)# c1 = 7641445753073898116827007164793381913392637757517918471003493172096039864745138859395162416166331018059670821487306307100317707328139395788231065689104033478291350670060313374875050515453520864469812221890996287381307066698453475729302664778430397377134780758018837387332598584435841888914421644231089685984# c2 = 167093247921785025551869982469106575631142864056525551417902883782425700355834225006036652059228820657628419198963259510127624586265812555108445743014018325690532163094506166009746619463293864352220499567472463409933060040516110759121216801644457250422763864380123004793281546395406406223721828567329161640

首先这一题我们可以将已知的信息转换一下，我们有

$$2m_1 + 1= 3m_2 + 2 \mod n$$

再变换一下

$$m_1 = 3 \cdot 2^{-1} \cdot m_2 + 2^{-1} \mod n$$

设 $M1 = x$，那么 $M2 = 3 \cdot 2^{-1} \cdot x + 2^{-1}$
如果我们有映射关系 $f(x) = ax + b$,，那么就有 $M_2 = f(M_1)$，因此题面

$$\begin{align*}(2m + 1)^e - c_1 &= 0 \mod n \\(3m + 2)^e - c_2 &= 0 \mod n\end{align*}$$

可以变成求解一个方程组：

$$\begin{align*}X^e - c_1 = 0 \mod n \ ① \\f(X)^e - c2=0 \mod n \ ②\end{align*}$$

显然对于这两个多项式有一个公共解：$M_1$，因此两条式子都可以化简：

$$\begin{align*}(X - M_1) \cdot K_1 = 0 \mod n \\(X - M_1) \cdot K_2 = 0 \mod n\end{align*}$$

$K_i$ 时是多项式方程，由①、②的单调性可知，两式在实数域下仅由唯一解，因此 $K_1$、$K_2$ 两式均不可再因式分解，因此其彼此互素。

从而我们对这两个多项式求一个 $gcd$ 就可以得到 $(X - M_1)$,但由于在模 $n$ 下,得到的将是 $X+M’$的形式（$M’ = -M_1 \mod n$）,所以最终

$$M_1 = -M' \mod n$$

最后我们就可以通过 $M_1$ 来计算出 $m$ 的值了。最后补充，这种攻击方法也被称为 Franklin-Reiter 攻击。

解题代码示例：

from Crypto.Util.number import *from sage.all import *def franklin_reiter(n,e,a,b,c1,c2):    R.<X> = Zmod(n)[]    f1 = X^e - c1    f2 = (a*X + b)^e - c2    m_ = GCD(f1,f2).coefficients()[0] # 返回的是首一多项式，coefficients()返回多项式各项式的系数，项式次数递增，所以第0项是常数    return Integer(n - m_) # 由于tmp其实是 -m % n,所以这里给他转换回去。def GCD(a, b):    if(b == 0):        return a.monic()# 返回首一多项式，即多项式最高次的项式系数为1    else:        return GCD(b, a % b)e = 5n = 0xf2e5339236455e2bc1b1bd12e45b9341a3b223ddb02dec11c880fa4aa8835df9e463e4c446292cd5a2fe19b10017856654b6d6c3f3a94a95807712329f7dae2e1e6506094d5d2f9c8a05c35cbf3366330996db9bff930fe566016d5e850e232057d419292ce30df9c135d56ef1bb72c38838d4b127aa577ceb4aba94d4e0d55b = 1 * pow(2, -1, n)a = 3 * pow(2, -1, n)c1 = 7641445753073898116827007164793381913392637757517918471003493172096039864745138859395162416166331018059670821487306307100317707328139395788231065689104033478291350670060313374875050515453520864469812221890996287381307066698453475729302664778430397377134780758018837387332598584435841888914421644231089685984c2 = 167093247921785025551869982469106575631142864056525551417902883782425700355834225006036652059228820657628419198963259510127624586265812555108445743014018325690532163094506166009746619463293864352220499567472463409933060040516110759121216801644457250422763864380123004793281546395406406223721828567329161640M1 = franklin_reiter(n,e,a,b,c1,c2)print("M1 =", M1)m = (M1 - 1) // 2print("m =", m)flag = long_to_bytes(int(m))print(flag)# b'flag{u_know_the_franklin_reiter!}'

我们按照这个思路扩展一下，实际上可以不将其中一条式子归一化处理也行，我们直接对两条式子求 $gcd$ 就可以了，得到的结果也是 $X - M_1$ 的形式，最终我们还是可以通过这个结果来计算出 $m$ 的值的。

from Crypto.Util.number import *from sage.all import *def franklinReiter(n,e1,e2,c1,c2,noise1,noise2,a,b):    # 在模n的多项式环上定义变量x    R.<x> = PolynomialRing(Zmod(n))    # 构造两个多项式：    # g1 = (a * x + noise1)^e1 - c1    # g2 = (b * x + noise2)^e2 - c2    # 当x = q时，这两个多项式都等于0    g1 = (a * x + noise1)^e1 - c1    g2 = (b * x + noise2)^e2 - c2    def gcd(g1, g2):        # 计算两个多项式的最大公因式        while g2:            g1, g2 = g2, g1 % g2        return g1.monic() # 返回首一多项式    # 最大公因式应该是(x - q)，所以取常数项的相反数就得到q    return -gcd(g1, g2)[0]e = 5n = 0xf2e5339236455e2bc1b1bd12e45b9341a3b223ddb02dec11c880fa4aa8835df9e463e4c446292cd5a2fe19b10017856654b6d6c3f3a94a95807712329f7dae2e1e6506094d5d2f9c8a05c35cbf3366330996db9bff930fe566016d5e850e232057d419292ce30df9c135d56ef1bb72c38838d4b127aa577ceb4aba94d4e0d55b = 3noise2 = 2a = 2noise1 = 1c1 = 7641445753073898116827007164793381913392637757517918471003493172096039864745138859395162416166331018059670821487306307100317707328139395788231065689104033478291350670060313374875050515453520864469812221890996287381307066698453475729302664778430397377134780758018837387332598584435841888914421644231089685984c2 = 167093247921785025551869982469106575631142864056525551417902883782425700355834225006036652059228820657628419198963259510127624586265812555108445743014018325690532163094506166009746619463293864352220499567472463409933060040516110759121216801644457250422763864380123004793281546395406406223721828567329161640M = franklinReiter(n,e,e,c1,c2,noise1,noise2,a,b)print("M =", M)flag = long_to_bytes(int(M))print("Flag =", flag)# Flag = b'flag{u_know_the_franklin_reiter!}'

上一章：RSA加解密专题 - 模数相关攻击 👈
下一章：RSA加解密专题 - 私钥 d 相关攻击 👈
回到开始：关于我 👈

相关链接：
密码学算法 - 欧几里得算法 👈
加解密模式分析 - Rabin 加密算法 👈
密码学算法 - AMM 算法 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4002.html 2026-03-02T13:08:00.000Z

在实际应用中，攻击者可能会利用一些特定的攻击方法来破解RSA加密，尤其是当公钥指数选择不当时。

本文将介绍一些与 RSA 公钥指数相关的攻击方法，包括常见的攻击手段如小公钥攻击、共模攻击等。

共模攻击 😝

2026-03-14T12:27:40.039Z Dorange 当你在 CTF 赛场遇到 RSA 题型时，模数相关的攻击手法⚔️往往是破解的关键。无论是共模攻击、模重复攻击，还是模数分解的相关漏洞，这些都是 RSA 加解密中常见且高频出现的题型。掌握这些攻击手法，不仅能让你在 CTF 赛场上如鱼得水，还能加深你对 RSA 加解密原理的理解。

暴力分解模数 🥳

在 $N$ 的比特位数小于 512 的时候，可以采用大整数分解的策略获取 $p$ 和 $q$。一般来说，使用一些高效的分解工具（如 YAFU、msieve、CADO-NFS 等）可以在合理的时间内完成分解，获取 $p$ 和 $q$。

暴力分解模数例题

暴力分解模数例题下载

from Crypto.Util.number import *from secret import Mp = getPrime(56)q = getPrime(56)e = 65537 n = p * qlong_M = long_to_bytes(M.encode())C = pow(long_M, e, n) print(C)print(n)#n: 3211733906383171840011432827424907#C: 1251845031704156126184126788111750

在这个例题中，模数 $n$ 的比特位数为 112 位，使用暴力分解的方式可以在几秒钟内获取到 $p$ 和 $q$，从而计算出私钥 $d$，最终解密出原始消息 $M$。

解题代码示例：

from Crypto.Util.number import *from sage.all import factorn = 3211733906383171840011432827424907C = 1251845031704156126184126788111750result = factor(n)p = result[0][0]q = result[1][0]phi = (p-1)*(q-1)e = 65537d = inverse(e, phi)m = pow(C, d, n)print(long_to_bytes(m))# b'flag{factor}'

模数过大攻击 😇

由于 RSA 的安全性依赖于大整数分解的困难性，因此理论上如果模数 $N$ 的比特位数过大，攻击者可能无法在合理的时间内完成分解，从而无法获取到 $p$ 和 $q$，最终无法破解 RSA 加密。

但是，有时候模数过大，达到因子 $p$ 或者 $q$ 可以直接当加解密的模数时，我们拿到 $p$ 时，是可以直接解密的。

模数过大攻击例题

模数过大攻击例题下载

from Crypto.Util.number import *from secret import flagm=bytes_to_long(flag)p=getPrime(512)q=getPrime(512)print('p=',p)print('q=',q)n=p*qe=65537c=pow(m,e,n)print('c=',c)# p= 12408795636519868275579286477747181009018504169827579387457997229774738126230652970860811085539129972962189443268046963335610845404214331426857155412988073# q= 12190036856294802286447270376342375357864587534233715766210874702670724440751066267168907565322961270655972226761426182258587581206888580394726683112820379# c= 21336045298142901291286840871587672865162787095337602832807363508232388776491914969338774738649382963457992989937263476335226789823301148587701912487928423012379208808206490825708386587184421011578572210993850461087767328588898076582321561621227540126149951300387265955685592427820272752547313291074696393753

这个题如果直接解密会发现无法解密，因为实际上构造时出了问题， $e$ 和 $q - 1$ 不是互素的，所以无法计算出私钥 $d$，但是我们拿到 $p$ 时，由于这个 $p$ 是远大于明文的，是可以直接解密的。

解题代码示例：

from sage.all import *from Crypto.Util.number import *e=65537p= 12408795636519868275579286477747181009018504169827579387457997229774738126230652970860811085539129972962189443268046963335610845404214331426857155412988073q= 12190036856294802286447270376342375357864587534233715766210874702670724440751066267168907565322961270655972226761426182258587581206888580394726683112820379c= 21336045298142901291286840871587672865162787095337602832807363508232388776491914969338774738649382963457992989937263476335226789823301148587701912487928423012379208808206490825708386587184421011578572210993850461087767328588898076582321561621227540126149951300387265955685592427820272752547313291074696393753g1 = gcd(p-1,e) g2 = gcd(q-1,e)print(g1) # 1print(g2) # 65537dp = inverse(e,(p-1))mp = pow(c,dp,p)print(long_to_bytes(mp))# b'flag{too_short_flag_is_not_secure}'

$p$ 和 $q$ 选取不当 😎

如果 $p$ 和 $q$ 选取不当，例如它们之间的差值过小，或者它们的比特位数相差过大，那么攻击者可以利用这些弱点进行攻击。

如果 $p$ 和 $q$ 的差值较小，可以使用 Fermat 分解法快速分解出 $n$，从而获取到 $p$ 和 $q$。

Fermat 分解法：
依据公式

$$\frac{(p+q)^2}{4} - n = \frac{(p+q)^2}{4} - pq = \frac{(p-q)^2}{4}$$

$|p-q|$ 比较小,那么 $\frac{(p-q)^2}{4}$ 也小，所以 $\frac{(p+q)^2}{4}$ 接近于n，可以通过不断增加 $\frac{(p+q)}{2}$ 的值，直到 $\frac{(p-q)^2}{4}$ 为完全平方数。

设 $x = \frac{(p+q)}{2}$, $y = \frac{(p-q)}{2}$
当满足 $x^2 - n = y^2$ 时即可求出方程

如果 $p$ 和 $q$ 的比特位数相差过大，那么攻击者可以尝试直接分解较小的素数，获取到其中一个素数后，再通过除法计算出另一个素数，从而获取到 $p$ 和 $q$。

$p$ 和 $q$ 选取不当例题一

选取不当例题一下载

from Crypto.Util.number import bytes_to_long, getPrimefrom sercet import mp = getPrime(1024)q = getPrime(25)n = p * qe = 65537c = pow(bytes_to_long(m.encode()), e, n)print(f"n = {n}")print(f"c = {c}")# n = 1906011750017368771307796117673461157817901033778025473698320639347279300698085835647703350923834808686618760795173855605538695556283974551407384296775817454538392743419582983483423430619884117509611946945420798868634216459855241900807180705272425022537879022082812277121832800892726814372715231802506905483235703703   # c = 549077691873070738038063799394443169955042904352211214070197952774248103687795272253319938425527517181518258210963581835901145261931143229164695429262477411771050634538709862613793004339395308836706979967103332910059842307878824556049956059889500094079522390808561349617771222185714804173669464216698326999828372795

在这个例题中，$p$ 和 $q$ 的比特位数相差过大，攻击者可以直接分解较小的素数 $q$，获取到 $q$ 后，再通过除法计算出 $p$，从而获取到 $p$ 和 $q$。

解题代码示例：

from Crypto.Util.number import long_to_bytes, inversefor p in range (2**24,2**25):    if n % p == 0:        q = n // p        print(f"Found factors:\np = {p}\nq = {q}")        breake = 65537m = pow(c, inverse(e, (p-1)*(q-1)), n)print(f"Decrypted message:\n{long_to_bytes(m)}")# flag{u_had_to_chose_pq_very_carefully}

$p$ 和 $q$ 选取不当例题二

选取不当例题二下载

import gmpy2from Crypto.Util.number import * from secret import mp = getPrime(2048) q = gmpy2.next_prime(p)for i in range(3600):    if i%100 ==0:        print(i)    q = gmpy2.next_prime(q)n = p * qe = 0x10001m = bytes_to_long(m)c = pow(m,e,n)print(c)print(n)# c = 62348462953990088934443336160656676256379196401827670581893451052313356600633156941411475073416038229710206387318746963512184736996831716413075320743814866642932860845362219164316326327314284158359209179674094486144680764515105492217458520575237366185272695957361214915406136484746226387883188256560994222709908095180408898696125963039783417587557949172960800557890764169451380255783986305118036512216986529314746084028860213669584595890037896692321861109269594521684968556512950683264437797627221443003439607555292132467628624371973634298128744397311157396100677819983319642517810760039637209759076927554454366134319010242392632132662642903994785600982132993886312621423872136988427063684972059758439594825762030726134443850618714647064586081678339263001700234301845400889943777913130192236281852096864533037602716295223417658798760710279949225248192831610982416617462182909627962556922338248721205926228772344215985646960602952014798520975237358594200048919941619698843434175749789671602254848991688128862206939872826391163844030010778464360088750386438734967569871044926861579066115140189872433762447450824103620809994330813092392551615553658883561091626338360944606525952944254241058687279915857632310080059282018449507613305332# n = 359336501271521532887656688609295042672434709877081900753462802000755944104448697042366747461395534728915053035475459015263877654779607712559439958640046447246795492613180033737648218742508752449971055824413830268089448680617248179389657713305429663149548581330682010843775095659107771083498691437964118187909080096258126217389687367383301166809926191321584757387431941409060744328371424948988833446651828309230245313487641590365198484255142967088588384318797132203546546629955996480505149111166600546126192029751124771571918693276230154597894534213860659972166774036644473508159923466417979740342453286817394016723536509392328304731594460395586984216646043768390806512181233642534151692135644819066105646943194201485395325911256860832603278670900133367627500162513041761043011626948699652168654976313717938901597808754267996648935745100287531478172712432058146052903388546565632174028182472012197791653306648067962114207504888841853254752313822184342829344043028253285087763176816976839219602985900752633788798421802365156777163724743521780060375607506242692718315299078104710983637353515944430437712607451078303509530539260657291973611896675785100483218112781144038004807688281170137433780853291933873671533348523292439854954465561

在这个例题中，$p$ 和 $q$ 的差值过小，攻击者可以使用 Fermat 分解法快速分解出 $n$，从而获取到 $p$ 和 $q$。

解题代码示例：

from Crypto.Util.number import *import gmpy2 as gpc = 62348462953990088934443336160656676256379196401827670581893451052313356600633156941411475073416038229710206387318746963512184736996831716413075320743814866642932860845362219164316326327314284158359209179674094486144680764515105492217458520575237366185272695957361214915406136484746226387883188256560994222709908095180408898696125963039783417587557949172960800557890764169451380255783986305118036512216986529314746084028860213669584595890037896692321861109269594521684968556512950683264437797627221443003439607555292132467628624371973634298128744397311157396100677819983319642517810760039637209759076927554454366134319010242392632132662642903994785600982132993886312621423872136988427063684972059758439594825762030726134443850618714647064586081678339263001700234301845400889943777913130192236281852096864533037602716295223417658798760710279949225248192831610982416617462182909627962556922338248721205926228772344215985646960602952014798520975237358594200048919941619698843434175749789671602254848991688128862206939872826391163844030010778464360088750386438734967569871044926861579066115140189872433762447450824103620809994330813092392551615553658883561091626338360944606525952944254241058687279915857632310080059282018449507613305332n = 359336501271521532887656688609295042672434709877081900753462802000755944104448697042366747461395534728915053035475459015263877654779607712559439958640046447246795492613180033737648218742508752449971055824413830268089448680617248179389657713305429663149548581330682010843775095659107771083498691437964118187909080096258126217389687367383301166809926191321584757387431941409060744328371424948988833446651828309230245313487641590365198484255142967088588384318797132203546546629955996480505149111166600546126192029751124771571918693276230154597894534213860659972166774036644473508159923466417979740342453286817394016723536509392328304731594460395586984216646043768390806512181233642534151692135644819066105646943194201485395325911256860832603278670900133367627500162513041761043011626948699652168654976313717938901597808754267996648935745100287531478172712432058146052903388546565632174028182472012197791653306648067962114207504888841853254752313822184342829344043028253285087763176816976839219602985900752633788798421802365156777163724743521780060375607506242692718315299078104710983637353515944430437712607451078303509530539260657291973611896675785100483218112781144038004807688281170137433780853291933873671533348523292439854954465561e = 65537a = gp.iroot(4*n,2)[0] + 1while 1:    if gp.iroot(a*a - 4 * n,2)[1]:        break    a = a + 1b = gp.iroot(a*a - 4 * n,2)[0]p = (a+b)//2q = (a-b)//2print(p)print(q)phi = (p-1)*(q-1)d = inverse(e,phi)m = pow(c,d,n)print(long_to_bytes(m))# b'flag{u_know_the_fermat_factor!}'

模不互素

如果两个 RSA 公钥的模数 $N_1$ 和 $N_2$ 不是互素的，即它们有一个公共的素因子，那么攻击者可以通过计算它们的最大公约数（GCD）来获取到这个公共的素因子，从而分解出两个模数，获取到 $p$ 和 $q$。

当然，如果复杂一点，也可以是有多个模数之间存在公共的素因子，那么攻击者可以通过计算它们之间的 GCD 来获取到这个公共的素因子，从而分解出多个模数，获取到多个 $p$ 和 $q$。

模不互素例题

模不互素例题下载

from Crypto.Util.number import *from secret import m1, m2e = 65537c1 = pow(bytes_to_long(m1.encode()), e, n1)c2 = pow(bytes_to_long(m2.encode()), e, n2)print(f"c1 = {c1}")print(f"c2 = {c2}")#n1 = 108895617879498519202012987242867653325279569011932848975855816698747912070665498376685393333717683240456930313786558144149400824750715586448894259226955671919120642624030060495951818893447378750288121119385599097111470518763491413669500398960687373958595273557114005654480025508336323302952322683369530980107#n2 = 92629502961791811672543248549202232353258702786741743055932183827495468369794305903601634793096476966443748199284199451053350116924505444008940619603683242386320802539761036526333916507865522071840234750951837168343853321642508612600344263266261925281998163722124602125092198291300471453120330544931376631613#c1 = 61235742166601682407600603003185668421611519337914948325202303574908037131452140001004081261277556291983868494754678213440816904181133566193839896694643634357526170240634104009464312693976654292785764598780495479072122249149103810491522930818342063044200307840151530874059848631341258068315918907694244629521#c2 = 50837238937861806304599627769544061465095296860582855610664744497211980029955384757173623065990262445808162369513719809531991409013899575630438092515903564752263986071475906232663711236691132660232092717966742157839890484764660045346149600612477895717855763187735898010895553739962656299222384523235710729405

在这个例题中，两个模数 $N_1$ 和 $N_2$ 不是互素的，它们有一个公共的素因子，攻击者可以通过计算它们的 GCD 来获取到这个公共的素因子，从而分解出两个模数，获取到 $p$ 和 $q$。

解题代码示例：

from Crypto.Util.number import *p = gcd(n1, n2)q1 = n1 // pq2 = n2 // pphi1 = (p-1)*(q1-1)phi2 = (p-1)*(q2-1)d1 = inverse_mod(e, phi1)d2 = inverse_mod(e, phi2)m1 = pow(c1, d1, n1)m2 = pow(c2, d2, n2)flag = long_to_bytes(m1) + long_to_bytes(m2)print(flag.decode())# flag{u_know_that_the_same_prime_is_dangerous}

光滑模数 😝

由于 $N$ 是由两个大素数 $p$ 和 $q$ 组成的，如果 $p-1$ 或 $q-1$ 是光滑数（即它们的质因数都比较小），那么攻击者可以利用 Pollard 的 p-1 算法来分解出 $N$，从而获取到 $p$ 和 $q$。

如果 $p+1$ 或 $q+1$ 是光滑数，那么攻击者可以利用 Williams 的 p+1 算法来分解出 $N$，从而获取到 $p$ 和 $q$。

光滑模数例题

光滑模数例题下载

from Crypto.Util.number import *from secret import mn = 149767527975084886970446073530848114556615616489502613024958495602726912268566044330103850191720149622479290535294679429142532379851252608925587476670908668848275349192719279981470382501117310509432417895412013324758865071052169170753552224766744798369054498758364258656141800253652826603727552918575175830897e = 65537c = pow(bytes_to_long(m.encode()), e, n)print("c =", c)#c = 43990054306025482446722327591812617378270114979666211260906092677157557305353209885519658615131923119123915114818456042307622384696570346974045212401273302638527074498582589588420265753013768960836315458711255307430199646105955701939961071797607203329554440687624048258855706057753535085388735489880883291030

在这个例题中，模数 $n$ 的 $p-1$ 或 $q-1$ 是光滑数，攻击者可以利用 Pollard 的 p-1 算法来分解出 $N$，从而获取到 $p$ 和 $q$。当然，$p+1$ 或 $q+1$ 也是光滑数，那么攻击者也可以利用 Williams 的 p+1 算法来分解出 $N$，从而获取到 $p$ 和 $q$。

解题代码示例：

from sage.all import *from Crypto.Util.number import *from itertools import countfrom sympy import primerange# williams's p+1 factorizationdef mlucas(v, a, n):    v1, v2 = v, (v ** 2 - 2) % n    for bit in bin(a)[3:]:        if bit == "0":            v1, v2 = (v1 ** 2 - 2) % n, (v1 * v2 - v) % n        else:            v1, v2 = (v1 * v2 - v) % n, (v2 ** 2 - 2) % n    return v1# 素数生成器def primegen():    yield from primerange(2, 10**6)  # 生成到 10^6 的素数，够用了# 整数对数：ilog(x, b) = 最大整数 l，使得 b^l <= xdef ilog(x, b):    l = 0    while x >= b:        x //= b        l += 1    return l# Williams p+1 分解攻击def Williams_p_plus_1_attack(n):    for v in count(1):  # 不断尝试新的 v        for p in primegen():            e = ilog(isqrt(n), p)            if e == 0:                break            for _ in range(e):                v = mlucas(v, p, n)            g = gcd(v - 2, n)            if 1 < g < n:                return int(g), int(n // g)            if g == n:                break# 开始攻击p1, q1 = Williams_p_plus_1_attack(n)if p1 and q1:    print("williams's p+1 factorization successful!")    print(f"p = {p1}")    print(f"q = {q1}")# pollard's p-1 factorizationdef pollard_p_minus_1(n, B=10**5): # B为素数表的上限,可以根据实际往上调    a = 2  # 通常选2作为基    for p in primerange(2, B):        e = int(isqrt(n).bit_length() / p.bit_length())        a = pow(a, pow(p, e), n)    g = gcd(a - 1, n)    if 1 < g < n:        return g, n // g    else:        return Nonep2, q2 = pollard_p_minus_1(n)if p2 and q2:    print("pollard's p-1 factorization successful!")    print(f"p = {p2}")    print(f"q = {q2}")phi = (p1 - 1) * (q1 - 1)d = inverse(e, phi)m = pow(c, d, n)print(long_to_bytes(m))# flag{smoothness_is_important}

上一章：RSA加解密专题 - 前言 👈
下一章：RSA加解密专题 - 公钥指数相关攻击 👈
回到开始：关于我 👈

相关链接：
密码学数学基础 - 整数关系 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/4001.html 2026-03-02T08:08:00.000Z

当你在 CTF 赛场遇到 RSA 题型时，模数相关的攻击手法⚔️往往是破解的关键。无论是共模攻击、模重复攻击，还是模数分解的相关漏洞，这些都是 RSA 加解密中常见且高频出现的题型。掌握这些攻击手法，不仅能让你在 CTF 赛场上如鱼得水，还能加深你对 RSA 加解密原理的理]]>

2026-03-17T15:07:15.411Z Dorange ECC（Elliptic Curve Cryptography）加密算法，作为非对称加密的现代方案之一，基于椭圆曲线上的离散对数问题的困难性，为数据加密和数字签名提供了高效且安全的解决方案。它在实际应用中被广泛采用，尤其是在资源受限的环境中，如移动设备和物联网设备。

在本章中，我们将深入分析 ECC 加密算法的核心原理和实现细节。我们将从 ECC 的数学基础开始，逐步揭示其加密和解密过程中的关键步骤。通过对 ECC 算法的详细解析，你将能够理解它是如何利用椭圆曲线上的离散对数问题的困难性来确保数据安全的。

ECC 加密数学原理 😇

ECC 加密算法的安全性基于椭圆曲线上的离散对数问题的困难性。

椭圆曲线介绍

首先，ECC 定义了一个椭圆曲线 $E_p$，通常采用 Weierstrass 形式的曲线，满足方程 $y^2 = x^3 + ax + b \mod p$，其中 $\Delta = -16(4a^3 + 27b^2) \neq 0$。

这个曲线的数学公式有点复杂，不过可以通过图像来理解。可以进入下面这个链接，改变参数来进行观察椭圆曲线的图像：

椭圆曲线图像

接下来我们介绍一下 ECC 中的群运算。对于椭圆曲线上的点 $A$ 和 $B$，我们定义了点加法和点乘法运算。

点加法是指将两个点 $A$ 和 $B$ 相加得到一个新的点 $C$，即 $C = A + B$。如图所示，点加法的几何意义是：如果 $A$ 和 $B$ 是曲线上的两个点，那么连接 $A$ 和 $B$ 的直线会与曲线相交于第三个点 $C’$，然后以 $C’$ 关于 x 轴的对称点 $C$ 作为结果。

如果 $A$ 和 $B$ 是同一个点，那么点加法的结果是 $2A$，即 $C = A + A$。如图所示，点加法的几何意义是：如果 $A$ 和 $B$ 是同一个点，那么连接 $A$ 和 $B$ 的切线会与曲线相交于另一个点 $C’$，然后以 $C’$ 关于 x 轴的对称点 $C$ 作为结果。

当然，这个运算是我们定义的，并不是真实存在的运算。我们可以通过一些算法来实现这个运算，比如使用斜率公式来计算点加法的结果。

曲线上的非对称点 $P(x_p,y_p)$ 和 $Q(x_q,y_q)$ 的点加法 $P + Q = R$ 可以通过以下公式计算：

$$\begin{align*}\lambda = \frac{y_q - y_p}{x_q - x_p} \mod p \\x_r = \lambda^2 - x_p - x_q \mod p \\y_r = \lambda(x_p - x_r) - y_p \mod p\end{align*}$$

曲线上的同一点 $P(x_p,y_p)$ 的点加法 $P + P = 2P$ 可以通过以下公式计算：

$$\begin{align*}\lambda = \frac{3x_p^2 + a}{2y_p} \mod p \\x_{2P} = \lambda^2 - 2x_p \mod p \\y_{2P} = \lambda(x_p - x_{2P}) - y_p \mod p\end{align*}$$

本质上就是计算斜率 $\lambda$，然后根据斜率计算出新的点的坐标。

标量积与倍加算法

在 ECC 中，我们还定义了标量积运算，即将一个点 $P$ 与一个整数 $k$ 相乘，得到一个新的点 $Q$，即 $Q = kP$。这个运算可以理解为将点 $P$ 自身相加 $k$ 次。

倍加算法是一种高效计算标量积的方法，它通过将 $k$ 表示为二进制形式来减少计算次数。具体来说，倍加算法的步骤如下：

1. 将 $k$ 转换为二进制表示。
2. 初始化结果点 $Q$ 为无穷远点。
3. 从二进制表示的最高位开始，依次处理每一位：
   • 如果当前位为 1，则将 $Q$ 加上 $P$。
   • 将 $P$ 加倍，即 $P = 2P$。
   • 继续处理下一位，直到处理完所有位。

倍加算法的时间复杂度为 $O(\log k)$，相较于直接相加的 $O(k)$，大大提高了计算效率。

举个例子，如果我们要计算 $kP$，其中 $k = 151$，如果直接暴力运算，我们要进行 $151$ 次点加法但是，我们可以将 $151$ 转换为二进制表示为 $10010111$。

将 $151$ 转化为二进制：

$$151 =1 \cdot 2^0 + 1 \cdot 2^1 + 1 \cdot 2^2 + 0 \cdot 2^3 + 1 \cdot 2^4 + 0 \cdot 2^5 + 0 \cdot 2^6 + 1 \cdot 2^7$$

所以我们可以通过倍加算法来计算

$$151P = 2^7 P + 2^4 P + 2^2 P + 2^1 P + 2^0 P$$

倍加算法告诉我们的是：

• 取一个 $P$
• 倍乘，我们得到 $2^1 P$
• $2^1 P$ 加 $P$（为了得到 $2^1P + 2^0P$）
• $2*2P$，我们得到 $2^2P$
• $2^2P$ 加到结果上，（$2^2P + 2^1P + 2^0P$）
• $2*2^2P$，得到 $2^3P$
• 扔掉，$2^3P$ 不参加任何加法运算
• $2*2^3P$，得到 $2^4P$
• 加到结果上，（$2^4P + 2^2P + 2^1P + 2^0P$）
• …

最后，我们计算151P只用了7次倍乘和4次加法，极大简化了运算速度。

离散化

现在，我们将这个椭圆曲线放入模 $p$ 的有限域中，这样我们就得到了一个有限的点集。对于这个点集，我们定义了一个特殊的点，称为无穷远点，记作 $O$，它是群的单位元。

这样，我们就得到了一个有限的群，群中的元素是椭圆曲线上的点，群运算是我们之前定义的点加法和标量积。而且，我们发现可视化的曲线变成了一个离散的点集，如下图所示：

我们之前提到的，ECC 的安全性基于椭圆曲线上的离散对数问题的困难性。对于一个足够大的 $p$ 和一个生成元 $P$，计算 $Q = kP$ 的离散对数 $k$ 是非常困难的。这意味着攻击者无法轻易地从公钥 $Q$ 中推断出私钥 $k$，从而无法解密密文。

就像打台球，知道球的起点和终点，但是由于中途碰了几次边，所以球的路径是非常复杂的，无法通过简单的计算来推断出球的路径。以此，我们可以理解为什么 ECC 的安全性是基于离散对数问题的困难性。

ECC 加密过程 😁

一天，Alice 想要向 Bob 发送一条秘密消息。为了确保消息的安全性，Alice 决定使用 ECC 加密算法。

首先通信双方先共享一个椭圆曲线 $E_p$ 和一个基点 $P$，然后构建椭圆曲线上的群，定义群运算（注意和我们平时的运算不同）。

Alice本地随机生成一个私钥 $k$，并计算公钥 $Q = k P$，将 $Q$ 作为公钥发送给 Bob。

Bob收到 $Q$ 后，选择一个随机数 $r$，计算临时公钥 $C_1 = r P$。然后，计算共享密钥 $K = r Q = r k P$。
选取明文 $M$，将其映射到椭圆曲线上的一个点（如果 $M$ 过大，可以分段加密），计算 $C_2 = M + K$。
Bob将密文对 $(C_1, C_2)$ 发送给 Alice。

Alice收到密文对 $(C_1, C_2)$ 后，计算共享密钥 $K = k C_1 = k r P$。使用共享密钥 $K$ 对 $C_2$ 进行解密，计算 $M = C_2 - K$,，从而恢复出明文 $M$。

ECC 加密算法实现 🥰

下面是一个简单的 ECC 加密算法的 Python 实现示例：

from sage.all import EllipticCurve, GF, randint, random_prime# 1. 初始化 ECC 参数# 选取足够大的 p 以容纳消息编码后的整数# 消息"hello_Alice"约88位，编码需要额外空间，故选取 160 位以上素数bits = 160p = random_prime(2^bits, lbound=2^(bits-1))# 随机选取参数 a, b 保证判别式不为 0while True:    a = randint(1, p-1)    b = randint(1, p-1)    if (4*a**3 + 27*b**2) % p != 0:        break# 定义椭圆曲线 y^2 = x^3 + ax + b mod pE = EllipticCurve(GF(p), [a, b])print(f"模数 p (前20位): {str(p)[:20]}...")print(f"椭圆曲线方程参数 a={a}, b={b}")G = E.gens()[0] # 基点n = G.order()   # 基点的阶print(f"基点 G: {G.xy()}")# 2. Key Generation (Alice)# Alice 生成私钥 kk_private = randint(1, n-1)# Alice 计算公钥 Q = k * GQ_public = k_private * Gprint(f"Alice 私钥: {k_private}")print(f"Alice 公钥: {Q_public.xy()}")# 3. Encryption (Bob)msg_str = "hello_Alice"# 辅助函数：将消息映射到椭圆曲线上的点 Mdef encode_message(msg, curve):    m = int.from_bytes(msg.encode(), 'big')    scale = 100 # 辅助系数    # 检查消息是否过大导致 x 坐标超过 p    if m * scale >= int(curve.base_ring().order()):        raise ValueError(f"消息过大 (数值={m*scale})，超过了模数 p")    for j in range(scale):        x = m * scale + j        try:            # lift_x 会尝试找到对应的 y，如果 x^3+ax+b 是二次剩余则成功            P = curve.lift_x(x)            return P        except ValueError:            continue    raise ValueError("无法将消息编码为曲线上的点")def decode_message(point, scale=100):    if point.is_zero():        raise ValueError("解密得到无穷远点")    x = int(point[0])    m = x // scale    byte_len = (m.bit_length() + 7) // 8    return m.to_bytes(byte_len, 'big').decode()M = encode_message(msg_str, E)print(f"消息 '{msg_str}' 编码后的点 x坐标: {M[0]}")# Bob 选择随机数 rr = randint(1, n-1)# 计算 C1 = r * GC1 = r * G# 计算共享密钥 K = r * QK_shared = r * Q_public# 计算密文 C2 = M + KC2 = M + K_sharedprint(f"密文 C1 x坐标: {C1[0]}")print(f"密文 C2 x坐标: {C2[0]}")# 4. Decryption (Alice)# Alice 计算共享密钥 K = k * C1K_alice = k_private * C1# 恢复消息点 M = C2 - KM_decrypted = C2 - K_alice# 解码消息decrypted_str = decode_message(M_decrypted)print(f"解密结果: {decrypted_str}")

简单说明一下辅助系数的意义，椭圆曲线的点必须满足方程 $y^2 = x^3 + ax + b \mod p$，这就意味着：不是所有的 $x$ 都能找到对应的 $y$，只有当 $x^3 + ax + b$ 是模 $p$ 的二次剩余时，才存在对应的点。

这个时候，把整数 $m$ 乘以一个辅助系数（比如 100），然后在这个基础上加上一个小的偏移量 $j$，形成一个区间，我们在这个区间内寻找一个 $x$，使得 $x^3 + ax + b$ 是二次剩余，从而找到一个对应的点。这种方法可以增加找到对应点的概率，同时也能确保消息能够被正确编码为曲线上的点。

举个例子：

• 假设消息 “hi” 转化成整数 $m$ 是 12345。
• scale 设为 100，那么我们会尝试 $x$ 从 $1234500$ 开始，依次增加 $j$（0, 1, 2, …），直到找到一个 $x$ 使得 $x^3 + ax + b$ 是二次剩余。
• 假设 $x = 1234507$ 满足条件，那么我们就将消息 “hi” 编码为点 $(1234507, y)$，其中 $y$ 是通过方程计算得到的。
• 解密时， $x = 1234507$，我们通过 $x // scale$ 就能得到原始消息的整数形式 $m = 12345$，然后再转回字符串 “hi”。

上一章：加解密模式分析 - ElGamal 加密算法 👈
下一章：加解密模式分析 - 背包加密算法 👈
回到开始：关于我 👈

相关链接：
密码学数学基础 - 群论基础 👈
密码学算法 - BSGS算法二 👈

]]> https://lr2006-robot.github.io/myblog.github.io/post/2006.html 2026-03-02T03:30:00.000Z

ECC（Elliptic Curve Cryptography）加密算法，作为非对称加密的现代方案之一，基于椭圆曲线上的离散对数问题的困难性，为数据加密和数字签名提供了高效且安全的解决方案。它在实际应用中被广泛采用，尤其是在资源受限的环境中，如移动设备和物联网设备。

]]>

2026-03-16T07:26:23.182Z