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}