2019 RoarCTF WriteUp

🏛️ 组织架构与规模

  • 主办方：由国内知名信息安全媒体“嘶吼（4hou）”与 W&M 战队联合主办

  • 比赛时间：2019 年 10 月 12 日 10:00 至 10 月 14 日 10:00，共计 48 小时

  • 比赛赛制：线上 Jeopardy-style（ jeopardy 解题模式） CTF

  • 参赛规模：吸引了全球超过 2000 名选手参与

排名 队伍名称 解题数 得分
1 0ops 25 14407
2 whitzard 23 12931
3 星盟突击队 19 9151
4 Vidar 17 7507
5 pwn4fun 15 6598
6 Venom 15 6292
7 Lanc3t 13 5824
8 楼上请让路 14 5658
9 如果有人愿意带带我 13 5186
10 Kap0k 12 4566
11 C4M31 10 4366
12 天枢Dubhe 11 4318
13 CNSS 11 3917
14 Ginkgo 12 3892
15 K__K 11 3882
16 SUS2019 11 3768
17 0b1111 11 3720
18 C1sec 9 2994
19 sixstars 8 2972
20 or4nge 7 2780

Misc

黄金 6 年（数据附加隐写 + MP4 截取）

附件是一个 MP4 视频文件，通过 WinHex 打开，发现在末尾隐藏的 Base64

解码是一个 RAR 压缩文件

解码发现需要密码，通过 Free Video to JPG Converter，将视频中的图片提取出来

提取出含有二维码的四张图片，并对四张图片中的二维码单独截图出来，通过 QR Rearch 进行扫描，并获得四个 Key 的密码字符串

拼接得到解压密码 iwantplayctf

davinci_cipher（Unicode + Emoji AES + Wacom 数位板流量分析）

pasted_1787311249143_cx3xo6.png

flag.txt 中是 Unicode 编码

pasted_1787320254286_z145ir.png

解码得到 Emoji 表情包

pasted_1787321151876_yfnk6w.png

打开流量包有 USB 协议，直接过滤

pasted_1787323882790_ka6g9k.png

在第一次对设备请求的响应中找到关键线索，DEVICE 指定了索要的类型是 “设备描述符”

pasted_1787326130854_j4zo6w.png

查看会话统计发现与 1.9.1 接触的最多

pasted_1787328794562_x7hw0l.png

Wacom 就是数位板，题目提示达芬奇画画，所以我们需要提取数据出来绘图

从抓包文件 k3y.pcapng 中，提取出所有 USB 数据包中出现过的端点地址

1
2
3
4
5
6
# -Y usb：显示过滤器
# -T fields：设置输出格式为 "字段模式"，即只打印指定的字段内容
# -e usb.endpoint_address：指定要提取的字段是 USB 端点地址
# Sort-Object：对列表进行升序排序
# -Unique 参数去除重复项，只保留唯一值
tshark -r k3y.pcapng -Y usb -T fields -e usb.endpoint_address | Sort-Object -Unique

pasted_1787330510584_b396il.png

0x00 和 0x80：这是设备插上电脑时 “打招呼” 的握手包（识别设备型号），接下来只要查看 0x81 端点的数据

Endpoint 作用
0x00 控制输出
0x80 控制输入
0x81 Interrupt IN

USBPcap 结构 = Header + HID Report，其中 Header 占 27 字节，需要跳过

pcapng 是由多个 Block 组成的

1
2
3
4
5
6
7
8
9
10
11
12
13
pcapng file

+----------------+
| Section Header |
+----------------+
| Interface Desc |
+----------------+
| Enhanced Packet|
+----------------+
| Enhanced Packet|
+----------------+
| Enhanced Packet|
+----------------+

官方规定

Block Type
Section Header Block 0x0A0D0D0A
Interface Description Block 0x00000001
Enhanced Packet Block 0x00000006
Simple Packet Block 0x00000003

所以我们可以指定 ENHANCED_PACKET_BLOCK_TYPE = 6 从而直接抓取真正是数据包

再查看 USB 是走的哪个网络接口，在统计 –> 解析文件属性中

Interface 0 和 Interface 2 都是 WLAN，Interface 1 则是 USB

所以可以指定 TARGET_INTERFACE_ID = 1

pasted_1787331983835_aw77lu.png

USB 协议定义 4 种传输方式

类型 特点 典型设备
Control 控制传输 设备初始化、配置、查询 所有USB设备
Interrupt 中断传输 小数据、低延迟、人机输入 键盘、鼠标、Wacom
Bulk 批量传输 大量可靠数据 U盘、硬盘
Isochronous 同步传输 实时连续数据，不保证重传 摄像头、麦克风

在数据包结构中的位置如下

1
2
3
4
5
6
7
8
9
10
11
12
┌──────────────────────┐
│ USBPcap Header       │
│                      │
│ Device Address       │
│ Endpoint             │
│ Transfer Type  <─────┼── 我们说的这里
│ Direction            │
│                      │
├──────────────────────┤
│ HID Report Data      │
│                      │
└──────────────────────┘

所以 REPORT_TRANSFER = 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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import struct

# ========== 配置常量 ==========
PCAP_FILE = "k3y.pcapng"                 # 输入的 pcapng 文件名
ENHANCED_PACKET_BLOCK_TYPE = 6           # pcapng 文件格式规定，类型码为 6 的块里装的是真正的网络/USB 数据包
TARGET_INTERFACE_ID = 1                  # 网络接口 ID
REPORT_ENDPOINT = 0x81                   # HID 报告端点地址
REPORT_TRANSFER = 1                      # 传输类型（1 通常表示中断传输，或根据协议定义）
EXPECTED_REPORT_LEN = 27                 # 我们期望的 HID 报告长度（字节）

# ========== 块解析器（生成器） ==========
def blocks(buf):
    """
    解析 pcapng 文件中的块（block）
    pcapng 格式：每个块由 4 字节类型、4 字节总长度（含头部和尾部）构成，
    块体位于偏移 8 处，末尾有 4 字节 CRC（但此处我们跳过不校验）
    """
    off = 0
    while off < len(buf):
        # 读取块类型和总长度（小端无符号 32 位）
        typ, length = struct.unpack_from("<II", buf, off)
        # 块体数据：从头部后（偏移 8）到长度 -4（去掉尾部的 CRC）
        body = buf[off + 8: off + length - 4]
        yield typ, body
        off += length                      # 移动到下一个块


def main():
    # 读取整个 pcapng 文件
    with open(PCAP_FILE, "rb") as f:
        data = f.read()

    reports = []  # 用于存储所有符合条件的 HID 报告载荷

    # 遍历所有块
    for typ, body in blocks(data):
        # 只处理 Enhanced Packet Block
        if typ != ENHANCED_PACKET_BLOCK_TYPE:
            continue

        # 块体结构（简化）：前 4 字节为接口 ID
        iface = struct.unpack_from("<I", body, 0)[0]
        if iface != TARGET_INTERFACE_ID:
            continue

        # 偏移 12 处为捕获长度（caplen），即实际保存的数据包长度
        caplen = struct.unpack_from("<I", body, 12)[0]
        # 数据包内容从偏移 20 开始（前 16 字节为时间戳和长度等信息）
        pkt = body[20:20 + caplen]

        # 确保至少包含端点、传输类型和报告数据（最少 27 字节）
        if len(pkt) < 27:
            continue

        # USB 数据包格式（常见）：第 21 字节为端点地址，第 22 字节为传输类型
        endpoint = pkt[21]
        transfer = pkt[22]
        # HID 报告载荷从第 27 字节开始（前 27 字节为 USB 头部等）
        payload = pkt[27:]

        # 筛选：指定端点、传输类型，且载荷长度正好为 27 字节（即期望的 HID 报告）
        if endpoint == REPORT_ENDPOINT and transfer == REPORT_TRANSFER and len(payload) == EXPECTED_REPORT_LEN:
            reports.append(payload)

    # 输出统计信息
    print("HID reports:", len(reports))

    # 将所有报告按顺序写入一个二进制文件
    with open("wacom_hid.bin", "wb") as f:
        for r in reports:
            f.write(r)


if __name__ == "__main__":
    main()

编写脚本绘图

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
import matplotlib.pyplot as plt

# 读取提取出的二进制数据
data = open("wacom_hid.bin", "rb").read()

# 按 27 字节一组切分为报告
reports = [
    data[i:i + 27]
    for i in range(0, len(data), 27)
]

strokes = []      # 所有笔画
current = []      # 当前正在画的笔画点集

for r in reports:
    status = r[1]                         # 状态字节（第 2 字节）
    x = int.from_bytes(r[2:5], "little")  # X坐标（3~5 字节，小端）
    y = int.from_bytes(r[5:8], "little")  # Y坐标（6~8 字节，小端）

    if status & 0x20:                     # 笔尖按下（0x20 位为 1）
        current.append((x, -y))           # 存储点，Y取反以调整显示方向
    else:                                 # 笔尖抬起
        if current:                       # 结束当前笔画
            strokes.append(current)
            current = []                  # 清空，准备下一笔

# 文件末尾若还有未结束的笔画，一并保存
if current:
    strokes.append(current)

print("stroke:", len(strokes))

# 绘图
plt.figure(figsize=(12, 6))
for s in strokes:
    if len(s) > 2:                        # 至少3个点才画线
        plt.plot([p[0] for p in s], [p[1] for p in s], linewidth=0.8)

plt.axis("equal")                         # 等比例缩放
plt.axis("off")                           # 隐藏坐标轴
plt.show()

pasted_1787332988786_c5np2l.png

拼接完整得到 MONA_LISA_IS_A_MAN，Emoji AES 解密得到 flag

pasted_1787333568150_bmnydx.png

Reverse

TankGame（Unity）

pasted_1787311138752_wgs14b.png

附件目录名提示使用 Mono 反编译，直接用 dnSpy 反编译 /Managed/Assembly-CSharp.dll

找到了 WinGame() 函数

pasted_1787304152154_l7nq52.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
25
public static void WinGame()
{
    // 防止重复触发胜利，且只有摧毁数量为 4 或 5 时才允许胜利
    if (!MapManager.winGame && (MapManager.nDestroyNum == 4 || MapManager.nDestroyNum == 5))
    {
        // 构建地图状态字符串（21x17 的格子状态拼接）
        string text = "clearlove9";
        for (int i = 0; i < 21; i++)
        {
            for (int j = 0; j < 17; j++)
            {
                text += MapManager.MapState[i, j].ToString();
            }
        }
        // 计算地图状态的 SHA1 哈希值，与硬编码值比对
        string a = MapManager.Sha1(text);
        if (a == "3F649F708AAFA7A0A94138DC3022F6EA611E8D01")
        {
            // 哈希匹配，显示胜利 UI，并生成 Flag（格式：RoarCTF{wm- + MD5(地图状态) + }）
            FlagText._instance.gameObject.SetActive(true);
            FlagText.str = "RoarCTF{wm-" + MapManager.Md5(text) + "}";
            MapManager.winGame = true; // 标记胜利，防止再次触发
        }
    }
}

也就是说 flag 取决于地图状态，接下来去看初始地图

pasted_1787304581098_ix56h7.png

但是 WinGame() 检查的是游戏结束时的地图，两者可能不同，比如：坦克开炮，子弹撞墙

在代码中有这样一个条件 if(nDestroyNum == 4 || nDestroyNum == 5)

所以接下来的思路就是找可以被破坏的位置，查看 MapCreation.Initmap()

pasted_1787305357708_f4k9ls.png

这里唯一 100% 确定的是 if(num != 8)，当 MapState 的值为 8 时，不创建任何游戏物体。即空地

前面代码没有读取 MapState，而是直接 this.item[6] 生成一圈东西，总共四次，应该对应着边界

1
2
3
4
5
6
7
for (int i = -11; i < 12; i++)
{
    this.CreateItem(this.item[6],
        new Vector3((float)i,9f,0f),
        Quaternion.identity,
        6);
}

继续分析 CreateItem 虽然传入了 id，但是没用

pasted_1787305714227_gbkn5e.png

继续分析其他的类，在 Bullect 类中找到核心逻辑

1
2
3
4
5
6
7
8
9
10
11
12
// 当子弹击中墙壁时
if(tag=="Wall")
{
    // 在地图状态数组中标记该位置为已摧毁（值为 8）
    MapManager.MapState[num+10, num2+8] = 8;
    // 增加已摧毁墙壁数量
    MapManager.nDestroyNum++;

    // 销毁墙壁对象和子弹自身
    Destroy(collision.gameObject);
    Destroy(this.gameObject);
}

这里 MapManager.nDestroyNum++;，所以玩家需要摧毁 4 个墙或者摧毁 5 个墙

继续往后看

1
2
3
4
5
6
7
8
9
10
11
// 当子弹击中非墙壁物体（如敌人）时
else
{
    // 在地图状态数组中标记该位置为已处理（值为 9，可能表示敌人被击毁）
    MapManager.MapState[num+10, num2+8] = 9;
    // 增加已摧毁物体数量（与墙壁共享同一计数）
    MapManager.nDestroyNum++;

    // 发送 Die 消息给被击中的物体，触发其死亡逻辑
    collision.SendMessage("Die");
}

现在所有变化规则确定，打墙和打敌人都会增加已摧毁物体数量

解题思路就是将 21×17 的二维地图压缩成一维字符串，预先记录所有可破坏 Wall 的位置，通过枚举被摧毁的 4/5 个 Wall（以及 Heart+Wall组合），直接修改对应字符生成候选 MapState，计算 SHA1 与目标值比对，找到正确地图后再计算 MD5 生成 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
import hashlib
import itertools    # 用于生成组合
import time

target = "3F649F708AAFA7A0A94138DC3022F6EA611E8D01"

Map = [
    [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
    [8, 8, 4, 5, 8, 1, 1, 1, 1, 1, 1, 8, 8, 8, 8, 4, 8],
    [8, 2, 8, 1, 8, 8, 5, 1, 8, 8, 8, 1, 8, 1, 8, 4, 8],
    [8, 5, 8, 2, 8, 8, 8, 8, 1, 8, 8, 4, 8, 1, 1, 5, 8],
    [8, 8, 8, 8, 2, 4, 8, 1, 1, 8, 8, 1, 8, 5, 1, 5, 8],
    [8, 8, 8, 8, 5, 8, 8, 1, 5, 1, 8, 8, 8, 1, 8, 8, 8],
    [8, 8, 8, 1, 8, 8, 8, 8, 8, 8, 8, 8, 1, 8, 1, 5, 8],
    [8, 1, 8, 8, 1, 8, 8, 1, 1, 4, 8, 8, 8, 8, 8, 1, 8],
    [8, 4, 1, 8, 8, 5, 1, 8, 8, 8, 8, 8, 4, 2, 8, 8, 8],
    [1, 1, 8, 5, 8, 2, 8, 5, 1, 4, 8, 8, 8, 1, 5, 1, 8],
    [0, 1, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
    [1, 1, 8, 1, 8, 8, 2, 1, 8, 8, 5, 2, 1, 8, 8, 8, 8],
    [8, 8, 8, 8, 4, 8, 8, 2, 1, 1, 8, 2, 1, 8, 1, 8, 8],
    [8, 1, 1, 8, 8, 4, 4, 1, 8, 4, 2, 4, 8, 4, 8, 8, 8],
    [8, 4, 8, 8, 1, 2, 8, 8, 8, 8, 1, 8, 8, 1, 8, 1, 8],
    [8, 1, 1, 5, 8, 8, 8, 8, 8, 8, 8, 8, 1, 8, 8, 8, 8],
    [8, 8, 1, 1, 5, 2, 8, 8, 8, 8, 8, 8, 8, 8, 2, 8, 8],
    [8, 8, 4, 8, 1, 8, 2, 8, 1, 5, 8, 8, 4, 8, 8, 8, 8],
    [8, 8, 2, 8, 1, 8, 8, 1, 8, 8, 1, 8, 2, 2, 5, 8, 8],
    [8, 2, 1, 8, 8, 8, 8, 2, 8, 4, 5, 8, 1, 1, 2, 5, 8],
    [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
]

# ==========================================================================
# 构建基础字符串数组及索引信息（将地图展平为一维）
# 展平方式：按行优先，i 从 0 到 20，j 从 0 到 16，每个位置对应一维索引 idx = i*17 + j
# ==========================================================================

base = []          # 存储每个格子的原始数值（字符串形式），长度为 21*17 = 357
walls = []         # 记录所有墙壁（值为 1）的一维索引，用于后续组合枚举
heart = None       # 记录 Heart（值为 0）的一维索引，用于特殊组合

for i in range(21):
    for j in range(17):
        idx = i * 17 + j        # 计算一维索引
        v = Map[i][j]
        base.append(str(v))     # 将数值转为字符串存入 base

        if v == 1:
            walls.append(idx)   # 收集所有墙壁索引
        elif v == 0:
            heart = idx         # 记录心脏索引（唯一，此地图中只有一个 0）

def calc(change):
    # 复制基础字符串列表，避免修改原始数据
    s = base.copy()
    
    # 对每个被攻击的位置进行标记替换
    for idx in change:
        if idx == heart:
            s[idx] = '9'          # Heart 被攻击时改为 '9'
        else:
            s[idx] = '8'          # 墙壁被攻击时改为 '8'

    # 拼接固定前缀 "clearlove9" 和地图状态字符串（357个字符）
    text = "clearlove9" + "".join(s)

    # 计算 SHA1 并与目标比较（注意转换为大写）
    if hashlib.sha1(text.encode()).hexdigest().upper() == target:
        print("FOUND!")
        print("change:", change)
        # 计算 MD5 并取前 10 位作为 flag 的一部分
        md5 = hashlib.md5(text.encode()).hexdigest().upper()
        print("flag:", "RoarCTF{wm-" + md5[:10] + "}")
        exit()   # 找到后立即退出，不再继续搜索

start = time.time()

# ----------- 情况 1: 仅摧毁 4 个墙壁（无 Heart） -----------
# 对应游戏 nDestroyNum == 4，且未攻击 Heart
print("try 4 walls")
cnt = 0
for x in itertools.combinations(walls, 4):  # 生成从 walls 列表中选取任意 4 个元素的所有不重复组合（不考虑顺序）
    calc(x)          # change 为元组，calc 内部会迭代
    cnt += 1
print("done", cnt, time.time() - start)   # 输出尝试的组合数和耗时

# ----------- 情况 2: 仅摧毁 5 个墙壁（无 Heart） -----------
# 对应游戏 nDestroyNum == 5，且未攻击 Heart
print("try 5 walls")
for x in itertools.combinations(walls, 5):
    calc(x)

# ----------- 情况 3: 摧毁 Heart + 3 个墙壁 -----------
# 虽然游戏条件中不包含这种组合（仅判断墙壁数量，未单独处理 Heart），但作为备选
print("try heart + 3 walls")
for x in itertools.combinations(walls, 3):
    # 将墙壁组合转为列表，再添加 heart 索引，形成攻击集合
    calc(list(x) + [heart])

# ----------- 情况 4: 摧毁 Heart + 4 个墙壁 -----------
# 同上，作为备选枚举
print("try heart + 4 walls")
for x in itertools.combinations(walls, 4):
    calc(list(x) + [heart])

# 如果所有组合均未匹配，输出未找到信息
print("[-] not found")

pasted_1787307604223_evkxm9.png