2020 SCTF WriteUp

🏛️ 组织架构

  • 主办方：XCTF 联赛

  • 组织方：成都信息工程大学 Syclover（三叶草）战队

  • 技术支持：赛宁网安

📝 赛事概况

  • 比赛时间：2020 年 7 月 4 日 09:00 至 7 月 6 日 09:00，共 48 小时

  • 比赛形式：在线 CTF（Capture The Flag）夺旗挑战赛

  • 题目类别：涵盖 Web、IOT、Reverse、Pwn、Misc 五大方向

奖金（美元）：

  • 一等奖：1500 美元

  • 二等奖：800 美元

  • 三等奖：500 美元

晋级资格：冠军队伍可直接晋级第六届 XCTF 总决赛

Misc

Can you hear（SSTV 无线电）

pasted_1784206249961_sxqds2.png

使用软件直接解密即可

pasted_1784206278695_fy5vop.png

EasyMisc（十六进制倒序 + 文件头篡改 + RC4）

pasted_1788001621144_00sujh.png

附件名 galf_si_erehw 提示了倒序，where_is_flag

对附件同样进行倒序

1
2
3
4
5
6
7
8
9
10
11
12
from binascii import hexlify, unhexlify

infile = "galf_si_erehw.jpg"
outfile = "where_is_flag.jpg"

raw = open(infile, "rb").read()

# 整个十六进制字符串倒序
fixed = unhexlify(hexlify(raw)[::-1])

open(outfile, "wb").write(fixed)
print("saved:", outfile)

倒序后打不开文件，发现缺少了 JPG 头 ffd8ff，补充上去后打开是个假的 flag

pasted_1788001995396_u7jtdx.png

继续用 WinHex 查看时找到可疑字符串并提示 RC4

1
xoBTuw36SfH4hicvCzFD9ESj

pasted_1788002267793_kuwwzr.png

套板子解密拿到 flag：SCTF{St@Y_@T_H0Me}

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
import base64

def rc4(data: bytes, key: bytes) -> bytes:
    s = list(range(256))
    j = 0

    # KSA
    for i in range(256):
        j = (j + s[i] + key[i % len(key)]) & 0xff
        s[i], s[j] = s[j], s[i]

    # PRGA
    i = 0
    j = 0
    out = bytearray()

    for b in data:
        i = (i + 1) & 0xff
        j = (j + s[i]) & 0xff
        s[i], s[j] = s[j], s[i]
        k = s[(s[i] + s[j]) & 0xff]
        out.append(b ^ k)

    return bytes(out)


cipher_b64 = "xoBTuw36SfH4hicvCzFD9ESj"
key = b"that_is_not_right_man"

cipher = base64.b64decode(cipher_b64)
plain = rc4(cipher, key)

print(plain.decode())

AndroidDisplayBridge（Android 无线 ADB + Scrcpy 投屏 + H.264 视频流）

pasted_1788003391673_sjdote.png

用 Wireshark 打开后发现大量 TCP 5555 流量，5555 很容易联想到 Android 的无线 ADB

继续看流量里还能发现 scrcpy-server.jar，说明这是用 scrcpy 在电脑上投屏/控制 Android 手机

scrcpy 的屏幕画面是以 H.264 视频流传输的

pasted_1788004338991_zn5c6e.png

H.264 的关键特征是流量中能搜到类似 00 00 00 01 67，这是 H.264 裸流里常见的 NAL 起始码加 SPS 数据

1
tcp.port == 5555 && frame contains 00:00:00:01:67

过滤后追踪长度最大的流量包，筛选一下选择 192.168.1.103:5555 --> 192.168.1.107:35316 方向，它的大学占了绝大部分，应该就是传输的内容，导出来

pasted_1788005643493_z2tfsp.png

在上面导出来的流量中，00 00 00 01 67 偏移位置是 968，直接截取出来

1
2
3
# offset 是 0-based 的 968
# tail -c 是 1-based，所以写 +969
tail -c +969 raw.h264 > out.h264

然后转 MP4

1
ffmpeg -err_detect ignore_err -f h264 -i out.h264 -c copy output.mp4

  • -err_detect ignore_err

    • 含义：设置错误检测/处理标志

    • 具体作用：ignore_err 告诉 FFmpeg 的解码器，在读取输入数据时如果遇到比特流错误，不要抛出致命错误或中断解码，而是尽可能 “将错就错” 地跳过损坏部分并继续解析后续数据

  • -f h264

    • 含义：强制指定输入文件的格式

  • -i out.h264

    • 含义：指定输入文件

  • -c copy

    • 含义：流拷贝模式

    • 具体作用：禁用重新编码。直接将输入的 H.264 视频流数据打包到输出容器中。这样做的好处是速度极快且画质无损。缺点是如果输入流有错误，错误也会被原样拷贝到输出文件中（除非被 -err_detect 截断）

视频的最后出现了 flag

pasted_1788009345855_x8qvpf.png

Reverse

signin（Python 反编译 + .pyz 恢复 + 线性变换）

pasted_1784919043337_dxfgmw.png

提出可识别字符串发现是有 Python 写出来的

1
2
3
4
main
mydata
signin
PYZ-00.pyz

使用 pyinstxtractor.py 反编译出 .pyc 文件

pasted_1785419964564_3z2wl0.png

main.pyc 反编译如下：

  • AccountChecker.__init__ 释放 tmp.dll，加载 DLL 并获取 enc 函数

  • self.accounts 仅存一个用户：b'SCTFer'，对应一个 Base64 解码后的 33 字节密文

  • check 比较 buffer 与预设密文，相等即返回 True，界面显示 Succeeded! Flag is your password

从 tmp.dll 的导出表可以看到只有一个导出函数 enc

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
int enc(char *username, char *password, char *out, int out_len)
{
    // 如果密码长度（不含结尾 \0）已经大于输出缓冲区的长度，直接返回 1 表示失败
    int pwd_len = strlen(password);
    int user_len = strlen(username);

    if (pwd_len > out_len)
        return 1;

    // 将 password 字符串从当前长度开始，用 0（即 \0）填充，直到长度为 32 字节
    while (pwd_len < 32) {
        password[pwd_len] = 0;
        pwd_len++;
    }

    // 将密码的 32 字节视为 4 个 64 位无符号整数
    // 每个 8 字节块调用 transform(block) 进行变换，变换后的结果依次写入 out 的前 32 字节
    for (int i = 0; i < 4; i++) {
        uint64_t block = *(uint64_t *)(password + i * 8);
        block = transform(block);
        *(uint64_t *)(out + i * 8) = block;
    }

    // 将上一步得到的 out 中 32 字节，每个字节与用户名对应位置的字节异或
    for (int i = 0; i < 32; i++) {
        out[i] ^= username[i % user_len];
    }

    // 在 out 的第 33 字节（索引 32）写入一个空字符 \0，使其成为一个可打印的 C 字符串
    out[32] = 0;
    return 0;
}

其中 transform() 是 64 轮类似 LFSR 的变换

1
2
3
4
5
6
7
8
9
10
11
12
13
uint64_t transform(uint64_t x)
{
    for (int i = 0; i < 64; i++) {
        // 每次循环检查 x 的最高位（第 63 位）
        if (x & 0x8000000000000000)
            // 若最高位为 1，左移 1 位后再与常数 0xb0004b7679fa26b3 异或
            x = (x << 1) ^ 0xb0004b7679fa26b3;
        else
            // 若最高位为 0，只左移 1 位
            x <<= 1;
    }
    return x;
}

由于这是 GF(2) 上的线性变换，可以对 64 位块求逆

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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
import base64

# 64 位掩码，用于模拟 C 语言中的 uint64_t 溢出
# Python 的整数不会自然溢出，所以每次左移后都需要 & MASK
MASK = (1 << 64) - 1

# DLL 中 transform 函数使用的异或常量
# 当最高位为 1 时，左移后会异或该多项式常量
POLY = 0xb0004b7679fa26b3

# Python 主程序中写死的用户名
# 后续加密结果会与 username 循环异或
username = b"SCTFer"

# Python 主程序中写死的目标密文：
# b64decode("PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA")
#
# 解码后长度为 33 字节：
#   前 32 字节是真正的密文
#   最后 1 字节是 \x00 字符串结束符
cipher = base64.b64decode(
    b"PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA"
)[:32]


def transform(x):
    """
    还原 DLL 中的核心加密变换。

    输入：
        x: 一个 64 位整数，对应 password 的 8 字节小端块

    输出：
        经过 64 轮线性变换后的 64 位整数

    DLL 逻辑大致如下：

        for i in range(64):
            if x & 0x8000000000000000:
                x = (x << 1) ^ 0xb0004b7679fa26b3
            else:
                x <<= 1

    该操作本质上是 GF(2) 上的线性变换，类似 LFSR
    """
    for _ in range(64):
        # 判断最高位 bit63 是否为 1
        if x & (1 << 63):
            # 左移一位，模拟 uint64_t 溢出，然后异或 POLY
            x = ((x << 1) & MASK) ^ POLY
        else:
            # 最高位不是 1 时，只左移一位
            x = (x << 1) & MASK

    return x


def build_inverse():
    """
    构造 transform 的逆矩阵。

    因为 transform 是 64 位到 64 位的线性变换：

        y = transform(x)

    所以可以把它看成一个 64x64 的二进制矩阵 M：

        y = M * x

    只要矩阵 M 可逆，就可以求出：

        x = M^-1 * y

    构造方法：

    1. 依次计算 transform(1 << i)
       这相当于得到矩阵 M 的第 i 列

    2. 把列形式转换为行形式

    3. 对增广矩阵 [M | I] 做高斯消元

    4. 消元结束后得到 [I | M^-1]
    """

    # cols[i] 表示矩阵 M 的第 i 列
    # 因为输入只有第 i 位为 1，其输出就是第 i 个基向量经过变换后的结果
    cols = [transform(1 << i) for i in range(64)]

    rows = []

    # 将列表示转换为行表示
    for r in range(64):
        row = 0

        # 检查每一列在第 r 行是否为 1
        for c, col in enumerate(cols):
            if (col >> r) & 1:
                row |= 1 << c

        # 构造增广矩阵 [M | I]
        #
        # 低 64 位：原矩阵 M 的一行
        # 高 64 位：单位矩阵 I 的一行
        row |= 1 << (64 + r)

        rows.append(row)

    # 对 64x128 的增广矩阵做 GF(2) 高斯消元
    for c in range(64):
        pivot = None

        # 从当前行往下找一个第 c 列为 1 的主元行
        for r in range(c, 64):
            if (rows[r] >> c) & 1:
                pivot = r
                break

        # 如果找不到主元，说明矩阵不可逆
        # 本题中 transform 是可逆的，所以不会触发
        if pivot is None:
            raise RuntimeError("matrix is singular")

        # 把主元行交换到当前第 c 行
        rows[c], rows[pivot] = rows[pivot], rows[c]

        # 消去其他所有行的第 c 列
        #
        # GF(2) 中：
        #   加法等价于异或
        #   减法也等价于异或
        for r in range(64):
            if r != c and ((rows[r] >> c) & 1):
                rows[r] ^= rows[c]

    # 消元完成后：
    #   低 64 位应该是单位矩阵 I
    #   高 64 位就是逆矩阵 M^-1
    inv_rows = [(rows[i] >> 64) & MASK for i in range(64)]

    return inv_rows


# 预先计算 transform 的逆矩阵
INV_ROWS = build_inverse()


def inv_transform(y):
    """
    使用逆矩阵计算 transform 的逆运算

    输入：
        y = transform(x)

    输出：
        原始 x

    这里 INV_ROWS[i] 表示逆矩阵的第 i 行
    对 y 和该行做按位与后，统计 1 的个数
    如果 1 的个数为奇数，则结果第 i 位为 1；
    如果为偶数，则结果第 i 位为 0

    这就是 GF(2) 矩阵乘法
    """
    x = 0

    for i, row in enumerate(INV_ROWS):
        # 计算逆矩阵第 i 行和 y 的点积
        #
        # 在 GF(2) 中：
        #   点积结果 = 所有相与 bit 的异或和
        #   等价于 bit_count() 的奇偶性
        if (row & y).bit_count() & 1:
            x |= 1 << i

    return x


# ============================================================
# 开始逆向还原密码
# ============================================================

# DLL 加密的最后一步是：
#
#   out[i] ^= username[i % len(username)]
#
# 所以解密时需要先把这一步异或回去。
#
# 由于 XOR 的自反性：
#
#   a ^ b ^ b = a
#
# 因此再次异或同样的 username 即可恢复 transform 后的中间值。
middle = bytes(
    c ^ username[i % len(username)]
    for i, c in enumerate(cipher)
)

# 用于拼接还原出的明文密码
plain = b""

# DLL 将 password 按 8 字节一组分成 4 个 uint64_t 小端整数
#
# password[0:8]   -> block 0
# password[8:16]  -> block 1
# password[16:24] -> block 2
# password[24:32] -> block 3
#
# 每个 block 独立经过 transform。
# 因此这里也按 8 字节一组分别逆变换。
for i in range(0, 32, 8):
    # 取出 8 字节密文块
    block = middle[i:i + 8]

    # DLL 中是 uint64_t 小端读取
    # 所以这里也要按 little-endian 转成整数
    y = int.from_bytes(block, "little")

    # 对 transform 求逆，得到原始 password 的 8 字节块
    x = inv_transform(y)

    # 再按 little-endian 转回字节
    plain += x.to_bytes(8, "little")

# DLL 会把不足 32 字节的密码用 \x00 补齐
# 所以最终去掉末尾的 \x00 即可得到真正密码
flag = plain.rstrip(b"\x00").decode()

print(flag)

最后得到 flag：SCTF{We1c0m3_To_Sctf_2020_re_!!}

get_up（RC4）

pasted_1787930586970_ynuyl3.png

IDA 反编译，首先是输入长度要小于等于 6，然后调用了 sub_401DF0() 函数

pasted_1787936725232_1hhk4h.png

查看这个函数发现是在做 MD5 对比

pasted_1787936830439_r1j85k.png

撞库得到 sycsyc，所以这是程序第一步所需要输入的

在 IDA 里查字符串发现了 worry 以及 right

跳转到被引用的地方

pasted_1787937035303_y49fye.png

一眼 RC4，伪代码上面就是定义的密文

pasted_1787937102833_ttag2t.png

动态调试拿到 Key 后编写解密脚本

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
def rc4(data: bytes, key: bytes) -> bytes:
    s = list(range(256))
    j = 0

    # KSA
    for i in range(256):
        j = (j + s[i] + key[i % len(key)]) & 0xff
        s[i], s[j] = s[j], s[i]

    # PRGA
    i = 0
    j = 0
    out = bytearray()

    for b in data:
        i = (i + 1) & 0xff
        j = (j + s[i]) & 0xff
        s[i], s[j] = s[j], s[i]
        t = (s[i] + s[j]) & 0xff
        out.append(b ^ s[t])

    return bytes(out)


cipher = bytes([
    128, 85, 126, 45, 209, 9, 37, 171, 60, 86,
    149, 196, 54, 19, 237, 114, 36, 147, 178, 200,
    69, 236, 22, 107, 103, 29, 249, 163, 150, 217
])

key = b"syclover"

flag = rc4(cipher, key)
print(flag.decode())

得到 flag：SCTF{zzz~(|3[___]_rc4_5o_e4sy}

Orz（LCG + DES）

pasted_1788758281194_ghmlip.png

在 IDA 或 Ghidra 中分析主函数时，可以看到程序大致执行以下步骤：

  • 读取用户输入；

  • 判断输入长度是否为 32；

  • 根据输入的第 7、16、30 个字符计算 seed；

  • 通过 seed 生成 33 个伪随机数；

  • 将输入和伪随机数做卷积式计算，生成 64 个 unsigned int；

  • 把这 64 个 unsigned int 视为 32 个 unsigned long long；

  • 每两个 uint64 为一组，分别作为 key 和 data；

  • 对每组执行 64 轮 DES 加密；

  • 将最终结果和内置 cmp_data 比较；

  • 如果全部相等，则输出成功。

pasted_1788758367203_x9tyvx.png

程序先检查输入长度为 32，然后用输入中特定位置的字符计算 seed：

1
seed = (~((input[6] + input[15] + input[29]) * 53)) & 0xfff;

由于最终 & 0xfff，所以 seed 的范围只有：0x000 ~ 0xfff

也就是最多 4096 种可能。这意味着 seed 可以直接爆破

程序通过线性同余方式生成 33 个随机数：

1
2
3
4
5
6
def gen_rand(seed):
    arr = []
    for _ in range(33):
        seed = (32310901 * seed + 1729) % 254
        arr.append(seed)
    return arr

这个生成器有几个特点：

  • 每个随机数范围在 0 ~ 253；

  • 只依赖初始 seed；

  • 初始 seed 范围很小，可以枚举；

  • 生成的是 33 个数，而 flag 长度是 32

程序将 32 字节输入和 33 个随机数做累加，得到 64 个 uint32

可以抽象为：

1
2
3
4
5
for (int i = 0; i < 32; i++) {
    for (int j = 0; j < 33; j++) {
        b[i + j] += input[i] ^ rand[j];
    }
}

由于 i 的范围是 0 ~ 31，j 的范围是 0 ~ 32

所以 i + j 的范围是 0 ~ 63，因此输出正好是 b[0] ~ b[63] 共 64 个 uint32

第一阶段得到的是：unsigned int b[64];

第二阶段会把它强制转换为：unsigned long long *tmp2 = (unsigned long long *)b;

也就是说，每两个 uint32 会被拼成一个 uint64。

在常见 x86/x64 小端环境下：

1
2
3
4
tmp2[0] = b[0] + (b[1] << 32)
tmp2[1] = b[2] + (b[3] << 32)
tmp2[2] = b[4] + (b[5] << 32)
...

逆向时也必须按小端拆分：

1
2
b[2*i]     = tmp2[i] & 0xffffffff
b[2*i + 1] = (tmp2[i] >> 32) & 0xffffffff

这个端序问题是本题非常容易出错的地方

正向每轮的 key 更新为：key = key * 2 mod 2^64

如果左移时发生溢出，程序会额外执行：key ^= 0x3FD99AEBAD576BA5

判断是否溢出的方式是：if (key < old_key)

因为无符号整数溢出后，左移结果会比原值小

这一题最重要的突破点是 key 的奇偶性

正向过程中：key * 2 一定是偶数

如果没有溢出：new_key = old_key * 2，那么 new_key 一定是偶数。

如果发生溢出：new_key = (old_key * 2 mod 2^64) ^ 0x3FD99AEBAD576BA5

而常量：0x3FD99AEBAD576BA5

最低位是 1，是奇数。所以：偶数 ^ 奇数 = 奇数

因此：

  • 当前 key 是偶数 → 上一轮没有溢出 → 上一轮走 DES-ECB

  • 当前 key 是奇数 → 上一轮发生溢出 → 上一轮走 DES-CBC

这就让我们能够从最终 key 一轮一轮倒推回去

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
from Crypto.Cipher import DES

MASK = (1 << 64) - 1
C = 0x3FD99AEBAD576BA5
IV = b"syclover"

# 这里需要从程序中提取完整的 32 个 uint64 常量
cmp_data = [
    2153387829194836539, 4968037865209379450,
    8168265158727502467, 7752938936513403525,
    # ... 中间省略
    4953583337191211260, 6316604661095411857
]


def des_dec(data64, key64, mode):
    """对一个 uint64 数据块执行 DES 解密。"""
    key = key64.to_bytes(8, "little")
    data = data64.to_bytes(8, "little")

    if mode == "ECB":
        plain = DES.new(key, DES.MODE_ECB).decrypt(data)
    elif mode == "CBC":
        plain = DES.new(key, DES.MODE_CBC, IV).decrypt(data)
    else:
        raise ValueError("unknown DES mode")

    return int.from_bytes(plain, "little")


def reverse_pair(final_key, final_data):
    """逆推一组 key/data，恢复加密前的 key/data。"""
    key = final_key
    data = final_data

    for _ in range(64):
        if key & 1:
            # 当前 key 为奇数，说明正向上一轮发生了溢出，并走 CBC
            data = des_dec(data, key, "CBC")
            key = ((key ^ C) >> 1) | (1 << 63)
        else:
            # 当前 key 为偶数，说明正向上一轮没有溢出，并走 ECB
            data = des_dec(data, key, "ECB")
            key >>= 1

        key &= MASK

    return key, data


def recover_tmp2_from_cmp(cmp_data):
    """从 cmp_data 逆第二阶段，恢复 tmp2[32]。"""
    tmp2 = []

    for i in range(0, 32, 2):
        key, data = reverse_pair(cmp_data[i], cmp_data[i + 1])
        tmp2.append(key)
        tmp2.append(data)

    return tmp2


def split_tmp2_to_b(tmp2):
    """把 uint64 tmp2[32] 按小端拆成 uint32 b[64]。"""
    b = []

    for x in tmp2:
        b.append(x & 0xffffffff)
        b.append((x >> 32) & 0xffffffff)

    return b


def gen_rand(seed):
    """根据 seed 生成 33 个伪随机数。"""
    arr = []

    for _ in range(33):
        seed = (32310901 * seed + 1729) % 254
        arr.append(seed)

    return arr


def recover_flag_from_b(b, rand):
    """在 rand 已知的情况下，从 b[64] 递推恢复 32 字节 flag。"""
    flag = []

    for i in range(32):
        t = b[i]

        # 减去已经恢复出的 flag[0..i-1] 对 b[i] 的贡献
        for j in range(i):
            t -= flag[j] ^ rand[i - j]

        # 剩下的是 flag[i] ^ rand[0]
        flag.append(t ^ rand[0])

    return bytes(flag)


def main():
    tmp2 = recover_tmp2_from_cmp(cmp_data)
    b = split_tmp2_to_b(tmp2)

    for seed in range(0x1000):
        rand = gen_rand(seed)
        flag = recover_flag_from_b(b, rand)

        # 过滤不可打印字符
        if not all(32 <= x < 128 for x in flag):
            continue

        # 检查 seed 是否和 flag 本身一致
        real_seed = (~((flag[6] + flag[15] + flag[29]) * 53)) & 0xfff
        if real_seed != seed:
            continue

        # 检查 flag 格式
        try:
            s = flag.decode()
        except UnicodeDecodeError:
            continue

        if s.startswith("SCTF{") and s.endswith("}"):
            print("[+] flag:", s)


if __name__ == "__main__":
    main()

最后得到 SCTF{b5c0b187fe309af0f4d35982fd}

Password Lock（STM32 固件）

pasted_1788771978982_n4lgck.png

打开附件可以看到这个典型的 Intel HEX 格式

pasted_1788773923720_q7wlf1.png

第一行 :020000040800F2 含义是扩展线性地址，高 16 位是 0x0800，所以后面的数据加载基址是 0x08000000

这非常关键。因为 STM32F103 的 Flash 默认就是从 0x08000000 开始执行的

把 HEX 解析成二进制后，开头几个 4 字节小端整数是

1
2
3
4
0x08000000: 0x20000440
0x08000004: 0x08000101
0x08000008: 0x08000109
0x0800000C: 0x0800010B

其中第一个值 0x20000440 是初始栈指针，位于 0x20000000 SRAM 区域

第二个值 0x08000101 是 Reset_Handler 地址，注意这里末尾是 1，这是 ARM Cortex-M 的特点，表示 Thumb 模式。真实函数地址要去掉最低位

1
0x08000101 -> 0x08000100

所以可以确定这是 ARM Cortex-M / STM32 固件，IDA 中选择 ARM little endian 反编译

pasted_1788774722486_rijg0l.png

假的 flag

pasted_1788774645371_qyh8y1.png

定位到关键函数

pasted_1788775366925_ni8on6.png

真正决定答案的是下面这段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
unk_40010410 |= 2u;
sub_80003F0(1);

unk_40010410 |= 0x10u;
sub_80003F0(1);

unk_40010410 |= 0x10u;
sub_80003F0(1);

unk_40010410 |= 4u;
sub_80003F0(1);

unk_40010410 |= 0x10u;
sub_80003F0(1);

unk_40010410 |= 2u;
sub_80003F0(1);

unk_40010410 |= 8u;
sub_80003F0(1);

这里的 0x40010410 对应着软件中断事件寄存器，它的作用是不用真的按物理按键，也可以通过软件写寄存器来触发 EXTI 中断

EXTI_SWIER 是一个按 bit 控制的寄存器

数值 二进制 置位的是哪一位 对应 EXTI
0x02 0000 0010 bit1 EXTI1
0x04 0000 0100 bit2 EXTI2
0x08 0000 1000 bit3 EXTI3
0x10 0001 0000 bit4 EXTI4

所以逐个转换

1
2
3
4
5
6
7
0x02 -> EXTI1 -> 按键 1
0x10 -> EXTI4 -> 按键 4
0x10 -> EXTI4 -> 按键 4
0x04 -> EXTI2 -> 按键 2
0x10 -> EXTI4 -> 按键 4
0x02 -> EXTI1 -> 按键 1
0x08 -> EXTI3 -> 按键 3

拿到 flag：SCTF{1442413}