2020 工业信息安全技能大赛-济南站 WriteUp

Misc

COTP（COTP 协议）

一眼过去全是 COTP 协议，过滤下

COTP 协议默认端口是 102，所以 192.168.99.22 是工控设备

再新增 ip.src == 192.168.99.22 过滤下，查看工控响应的内容有没有什么异常

第 217 个包长度突然不一样，是之前的两倍

Payload 中还能看到明显的设备信息字符串

1
6ES7 211-1BE51-0XB0 ;V3.0

这说明攻击者/扫描方正在读取设备型号、版本等信息

因此，这个响应包就是题目要找的 “遭到攻击的数据包”

最后的 flag 如下

1
flag{31312D31424535312D30584230203B56332E308240001505323B32383882410003000300A20000000072010000}

工控大楼的道闸怎么坏了（1527 芯片）

EM1527 是常见的 433MHz/315MHz 无线遥控编码芯片协议，经常用于道闸、卷帘门、遥控开关等设备

协议数据一般为 24 bit，也就是 6 个十六进制字符

它通常使用 OOK/ASK 调制，也就是：

1
2
有载波 = 高电平
无载波 = 低电平

题目附件给的是某种原始无线 IQ 采样数据

常见 SDR 原始采样格式是：

1
I, Q, I, Q, I, Q ...

用 Python 读取后，将相邻两个字节作为一组 I/Q

1
2
3
4
raw = np.fromfile(path, dtype=np.int8)

I = raw[0::2]
Q = raw[1::2]

为了把 OOK 信号还原成高低电平，需要计算幅度

1
2
# mag2 大时，表示有载波，即高电平；当 mag2 接近 0 时，表示无载波，即低电平
mag2 = I * I + Q * Q

对幅度做一个简单平滑，然后设置阈值

1
2
env = np.convolve(mag2, np.ones(100) / 100, mode="same")
level = env > 1000

这样可以得到类似逻辑分析仪中的高低电平序列

1
高电平  低电平  高电平  低电平 ...

本题中观察到的编码方式有点不同

1
2
1 = 长高电平 + 短低电平
0 = 短高电平 + 长低电平

也就是

1
2
bit 1: HHH + L
bit 0: H + LLL

从信号中截取一帧，统计高低电平长度后，可以得到类似下面的脉冲序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
高 2324 低  853
高  728 低 2416
高 2329 低  854
高  727 低 2416
高 2329 低  854
高  726 低 2414
高 2331 低  861
高 2326 低  857
高  724 低 2417
高  721 低 2414
高 2331 低  860
高  721 低 2415
高 2330 低  857
高 2330 低  859
高  722 低 2413
高  725 低 2412
高 2333 低  859
高  722 低 2411
高  728 低 2415
高  723 低 2420
高  719 低 2413
高  724 低 2414
高  725 低 2412
高 2333 低  857

按规则解码得到 24 位二进制

1
101010110010110010000001

转 ASCII 码是 AB2C81

所以 flag 就是 flag{ab2c81}

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
import numpy as np

path = "iiiiicccccssssshhhhheeeeexxxxx"

# 1. 按 signed int8 IQ 读取
raw = np.fromfile(path, dtype=np.int8)

I = raw[0::2].astype(np.int16)
Q = raw[1::2].astype(np.int16)

# 2. 计算幅度平方，OOK 中幅度高表示有载波
mag2 = I * I + Q * Q

# 3. 平滑包络
win = 100
env = np.convolve(mag2, np.ones(win) / win, mode="same")

# 4. 二值化
level = env > 1000

# 5. 统计高低电平 run length
runs = []
cur = level[0]
start = 0

for i, v in enumerate(level[1:], 1):
    if v != cur:
        runs.append((int(cur), start, i - start))
        cur = v
        start = i

runs.append((int(cur), start, len(level) - start))

# 过滤掉很短的噪声毛刺
runs = [(v, s, l) for v, s, l in runs if l > 300]


def classify_len(l):
    if 500 <= l <= 1100:
        return "S"   # short
    if 1900 <= l <= 2800:
        return "L"   # long
    return "?"


frames = []

# EM1527 一帧 24 bit，每 bit 由 高电平 + 低电平 组成
for i in range(len(runs) - 48):
    if runs[i][0] != 1:
        continue

    bits = []
    ok = True

    for k in range(24):
        vh, sh, lh = runs[i + 2 * k]
        vl, sl, ll = runs[i + 2 * k + 1]

        if vh != 1 or vl != 0:
            ok = False
            break

        h = classify_len(lh)
        l = classify_len(ll)

        if h == "L" and l == "S":
            bits.append("1")
        elif h == "S" and l == "L":
            bits.append("0")
        else:
            ok = False
            break

    if ok:
        bitstr = "".join(bits)
        code = f"{int(bitstr, 2):06X}"
        frames.append((runs[i][1], bitstr, code))

# 去重输出
seen = set()

for start, bitstr, code in frames:
    if code in seen:
        continue

    seen.add(code)

    print("[+] bits:", bitstr)
    print("[+] code:", code)
    print("[+] flag:", f"flag{{{code.lower()}}}")

泄露的信号（无线 IQ 信号分析 + 频谱图隐写）

文件名没有后缀，看十六进制

1
2
3
4
od -Ax -tx1z -N 64 ppt

1c 00 fd ff fd ff e4 ff e4 ff 03 00 04 00 1c 00
1c 00 fc ff fc ff e4 ff e4 ff 04 00 04 00 1c 00

按小端 int16 解释

1
28, -3, -3, -28, -28, 3, 4, 28 ...

如果把它两两分组

1
I, Q, I, Q, I, Q ...

会发现它很像复数 IQ 采样

1
(28, -3), (-3, -28), (-28, 3), (4, 28) ...

也就是说，这个文件大概率是 IQ 原始无线采样

可以用 Python 对 IQ 数据做 STFT，生成频谱瀑布图

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

# 文件路径（二进制 IQ 数据）
path = "ppt"

# 按 little-endian int16 读取，转为 float32
raw = np.fromfile(path, dtype="<i2").astype(np.float32)

# 交错提取 I/Q 分量，合成复数信号
iq = raw[0::2] + 1j * raw[1::2]

print("[+] complex samples:", len(iq))

# ---------- STFT 参数 ----------
nfft = 4096                     # FFT 点数
hop = 64                        # 帧移（采样点）
win = np.hanning(nfft).astype(np.float32)   # 汉宁窗

# 总帧数
N = (len(iq) - nfft) // hop + 1

# 使用 stride trick 生成重叠的帧矩阵（避免循环拷贝）
frames = np.lib.stride_tricks.as_strided(
    iq,
    shape=(N, nfft),
    strides=(iq.strides[0] * hop, iq.strides[0])
)

# 加窗 → FFT → fftshift（直流居中）
spec = np.fft.fftshift(
    np.fft.fft(frames * win, axis=1),
    axes=1
)

# 转置为 (频率, 时间) 并转换为 dB 幅度谱
S = 20 * np.log10(np.abs(spec).T + 1)

# ---------- 绘制瀑布图 ----------
plt.figure(figsize=(18, 8))
plt.imshow(
    S,
    aspect="auto",
    origin="lower",             # 低频在下
    cmap="gray",                # 灰度颜色映射
    vmin=np.percentile(S, 50),  # 动态范围下限（抑制背景）
    vmax=np.percentile(S, 99.5),# 上限取 99.5% 分位数，防止个别强点拉平
)
plt.axis("off")                 # 隐藏坐标轴
plt.tight_layout(pad=0)
plt.savefig("waterfall.png", dpi=200)

生成的 waterfall.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
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
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image, ImageOps

# ========== 1. 读取二进制 IQ 数据 ==========
path = "ppt"                                 # 输入文件路径

# 按 little-endian int16 读取，并转为 float32 便于后续计算
raw = np.fromfile(path, dtype="<i2").astype(np.float32)

# 交错提取 I（偶数索引）和 Q（奇数索引），合成复数信号
iq = raw[0::2] + 1j * raw[1::2]

# ========== 2. 短时傅里叶变换 (STFT) 参数 ==========
nfft = 4096                                  # FFT 点数（频率分辨率）
hop = 64                                     # 帧移（时间分辨率）
win = np.hanning(nfft).astype(np.float32)    # 汉宁窗，减少频谱泄漏

# 计算总帧数（滑动窗口能覆盖的帧数）
N = (len(iq) - nfft) // hop + 1

# 使用 stride_tricks 高效构建重叠帧矩阵（无拷贝，只改变视图）
frames = np.lib.stride_tricks.as_strided(
    iq,
    shape=(N, nfft),                         # 每行一帧
    strides=(iq.strides[0] * hop, iq.strides[0])  # 行步长 = hop 个样本
)

# 加窗并执行 FFT，再将零频移到频谱中心
spec = np.fft.fftshift(
    np.fft.fft(frames * win, axis=1),
    axes=1
)

# 转为 dB 幅度谱（转置后维度为 [频率, 时间]）
S = 20 * np.log10(np.abs(spec).T + 1)        # +1 避免 log(0)

# ========== 3. 裁剪目标区域（条码所在位置） ==========
# 不同 FFT 参数下，条码在频谱图中的位置会变化，这里根据实际数据手动调整
crop = S[900:3100, 900:4000]                 # 裁剪 [频率范围, 时间范围]

# 动态范围压缩：取裁剪区域的中位数和 99.5% 分位数作为映射边界
vmin = np.percentile(crop, 50)               # 抑制背景噪声
vmax = np.percentile(crop, 99.5)             # 防止个别强点拉平对比度

# ========== 4. 归一化并转为 8 位灰度图 ==========
img = (crop - vmin) / (vmax - vmin)          # 线性映射到 [0,1]
img = np.clip(img, 0, 1)                     # 截断超出范围的值
img = (img * 255).astype(np.uint8)           # 转为 0~255 整数

# ========== 5. 图像后处理：旋转与反色 ==========
im = Image.fromarray(img)                    # 创建 PIL 图像对象

# 将图像旋转 90°（使条码横向放置，便于识别器读取）
im = im.rotate(90, expand=True)

# 生成反色版本（黑条白底 → 白条黑底），某些 PDF417 解码器可能偏好
im_inv = ImageOps.invert(im)

# ========== 6. 保存结果 ==========
im.save("barcode_gray.png")
im_inv.save("barcode_invert.png")

print("[+] saved barcode_gray.png")
print("[+] saved barcode_invert.png")

翻转过来再颜色反转可以识别出 flag

所以最后 flag 就是

1
flag{1cbnz723x81il1812ss2}

被篡改的数据（S7comm 协议）

“被大量修改的数据” 对应的写入内容，也就是功能码 0x05

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
import struct
import socket
import re

# 读取 pcapng 文件
pcap = "/mnt/data/s702(1).pcapng"
data = open(pcap, "rb").read()

# -------- 解析 pcapng 块 --------
packets = []
off = 0
endian = "<"  # 默认小端

while off + 12 <= len(data):
    # 块类型和块总长度（含固定尾）
    block_type, block_len = struct.unpack(endian + "II", data[off:off+8])
    if block_len < 12 or off + block_len > len(data):
        break

    body = data[off+8:off+block_len-4]  # 排除尾部的块总长度字段

    # Section Header Block (SHB)
    if block_type == 0x0A0D0D0A:
        # 字节序标记：0x1A2B3C4D 表示大端
        endian = ">" if body[:4] == b"\x1a\x2b\x3c\x4d" else "<"

    # Enhanced Packet Block (EPB)
    elif block_type == 0x00000006 and len(body) >= 20:
        # 接口ID、时间戳高低位、捕获长度、原始长度
        iface, ts_high, ts_low, cap_len, orig_len = struct.unpack(
            endian + "IIIII", body[:20]
        )
        # 提取实际捕获的报文数据
        packets.append(body[20:20+cap_len])

    off += block_len


def get_tcp_payload(pkt):
    """从原始以太网帧中提取 TCP 载荷及四元组"""
    if len(pkt) < 54:  # 最小长度：以太网14 + IP20 + TCP20
        return None

    # 以太网类型必须为 IPv4 (0x0800)
    if pkt[12:14] != b"\x08\x00":
        return None

    # IP 协议字段必须为 TCP (6)
    if pkt[23] != 6:
        return None

    # IP 头长度（IHL）及偏移
    ihl = (pkt[14] & 0x0F) * 4
    ip_start = 14
    tcp_start = ip_start + ihl

    # 源IP、目的IP
    src = socket.inet_ntoa(pkt[ip_start+12:ip_start+16])
    dst = socket.inet_ntoa(pkt[ip_start+16:ip_start+20])

    tcp = pkt[tcp_start:]
    if len(tcp) < 20:
        return None

    # 源端口、目的端口
    sport, dport = struct.unpack("!HH", tcp[:4])
    # TCP 数据偏移
    data_offset = (tcp[12] >> 4) * 4
    payload = tcp[data_offset:]

    return src, sport, dst, dport, payload


def parse_s7_write_values(payload):
    """从 TCP 载荷中提取 S7 写变量操作的写入值（每次写1字节）"""
    values = []
    off = 0

    while off + 4 <= len(payload):
        # TPKT 头部：版本 0x03，保留 0x00，总长度
        if payload[off:off+2] != b"\x03\x00":
            break

        tpkt_len = int.from_bytes(payload[off+2:off+4], "big")
        tpkt = payload[off:off+tpkt_len]

        # COTP 数据 TPDU：DT Data (0x0f) 且最后字节 0x80 表示数据
        if len(tpkt) >= 17 and tpkt[4:7] == b"\x02\xf0\x80":
            s7 = tpkt[7:]

            # S7 协议标识 (0x32)
            if len(s7) >= 10 and s7[0] == 0x32:
                rosctr = s7[1]  # 报文类型

                # 0x01 = Job（请求）
                if rosctr == 0x01:
                    # 参数长度、数据长度
                    param_len = int.from_bytes(s7[6:8], "big")
                    data_len = int.from_bytes(s7[8:10], "big")

                    param = s7[10:10+param_len]
                    d = s7[10+param_len:10+param_len+data_len]

                    # 功能码 0x05 = 写变量
                    if param and param[0] == 0x05:
                        # 本题每次写入 1 字节，S7 写数据前 4 字节为：
                        # 保留/传输大小/位长度
                        if len(d) >= 5:
                            values.append(d[4:5])  # 提取写入值

        off += tpkt_len

    return values


# 累积所有写入值，拼接成字节序列
seq = b""

for pkt in packets:
    item = get_tcp_payload(pkt)
    if not item:
        continue

    src, sport, dst, dport, payload = item

    # 只看上位机 (192.168.88.2) 发给 PLC (192.168.88.23) 端口 102 的 S7 写入
    if src == "192.168.88.2" and dst == "192.168.88.23" and dport == 102:
        for v in parse_s7_write_values(payload):
            seq += v

print("extracted length:", len(seq))

# 在累积的序列中搜索 flag{...} 模式
m = re.search(rb"flag\{[^}]+\}", seq)
if m:
    print(m.group().decode())
else:
    print("not found")

得到 flag{931377ad4a}

工业物联网智能网关数据分析（MQTT 协议 + PNG 宽高篡改 + LSB 隐写）

先分析 MQTT PUBLISH 消息，过滤语法

1
mqtt.hdrflags == 0x30

可以看到这些关键字的长度有明显异常

1
2
3
4
5
f : ZIP 十六进制数据开头，payload 以 504B0304 开始
l : ZIP 中间碎片
a : ZIP 中间碎片
g : ZIP 十六进制数据结尾
d : ZIP 密码 pass_1s_ea4y

拼接 f + l + a + g 的 ZIP 数据得到压缩包

再用 d 的解压密码解压缩出图片

修改宽高拿到 flag{21png_

剩下的一半需要 LSB 隐写提取出来然后拼接再反转颜色即可

工控协议数据分析（ARP 协议）

重点看 ARP 报文，可以发现 192.168.1.55 这台设备多次发出异常 ARP

192.168.1.0/24 中的 192.168.1.0 是网络地址，正常不应该被配置为主机地址或网关地址

所以这里的异常点是 PLC / 工控设备可能配置了错误的网关、通信目标或网络参数，导致它不断尝试 ARP 解析 192.168.1.0 从而产生大量告警日志

司机的身份（JT/T808 车载终端通信协议）

pasted_1784030036432_94e7qb.png

打开流量包可以发现大量以 7e 开头、7e 结尾的 JT/T 808 帧

pasted_1784099243714_u78427.png

在 No.16 流量中，其中关键报文头

1
07 02 40 eb 01 00 00 00 00 01 77 70 64 12 11 00 72

解析

1
2
3
4
5
6
消息 ID：0x0702
消息体属性：0x40eb
协议版本：0x01
终端号：00000000017770641211
流水号：0x0072
消息体长度：0x00eb = 235

0x0702 正好是驾驶员身份信息采集上报，消息体开头为

1
2
3
4
01                  状态：IC 卡插入
20 06 27 09 48 56   时间：2020-06-27 09:48:56
00                  IC 卡读取成功
b4                  驾驶员姓名长度：0xb4 = 180 字节

取出这 180 字节发现是 UTF-16BE。每两个字节对应一个汉字

1
2
3
4
5
8a f8 -> 諸
96 b8 -> 隸
50 e7 -> 僧
96 4d -> 降
54 3d -> 吽

完整取出来得到

1
諸隸僧降吽諸陀摩隸僧缽薩願皤耨皤眾劫阿我皤慧阿亦皤我哆兜降嚤祗愍皤迦闍眾皤陀亦聞宣咤迦劫薩囉愍聞須皤塞迦皤諦亦劫亦皤闍願皤咤修闍薩嚤宣皤我菩菩皤迦聞諦婆亦聞皤阿薩所願如空如如囑皤囑

用 “新约佛论禅 / 新佛曰” 解密，得到一串 Base64

1
TVpXR0NaMzNJTlpIUzREWkdBWVhHUlRWSlo2UT09PT0=

连续 Base 解码得到 flag{Crypy01sFuN}

奇怪的声音（签到）

pasted_1784100116123_fchjm9.png

在识别过程中第一个摩斯码为

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

而倒数第二位的 --... 并没有这个莫斯码，所以要将音频文件倒放

倒放过来得到

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

经过转换得到 flag{43h63kd285m2}

Reverse

某嵌入式设备固件升级包（VxWorks 固件）

题目给出的是一个名为 UpgradePackage.bin 的固件升级包

首先需要理解固件升级包的常见结构：大多数升级包包含一个明文头部（记录设备型号、版本等信息），后面跟着压缩或加密的固件本体

用十六进制编辑器或 binwalk 查看文件，能发现开头有可读字符串：140-NOE-771-01 和 Quantum Ethernet Executive firmware Ver. 6.40

这告诉我们设备型号和固件版本，同时也提示固件可能是 VxWorks 操作系统

VxWorks 是一种嵌入式实时操作系统，广泛应用于工业控制、网络设备中，其固件镜像通常包含符号表用于调试

继续分析升级包，需要找到真正的固件数据在哪里

偏移 0x385 处存在 zlib 压缩数据，用 Python 直接从 0x385 开始 zlib 解压

1
2
3
4
5
6
7
8
9
import zlib
from pathlib import Path

pkg = Path("UpgradePackage.bin").read_bytes()

fw = zlib.decompress(pkg[0x385:])
Path("firmware.raw").write_bytes(fw)

print(hex(len(fw)))

在解压后的固件里可以看到 VxWorks 痕迹

1
2
# -a：全文件扫描（--all）
strings -a firmware.raw | grep "VxWorks"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 该固件使用 VxWorks 实时操作系统（RTOS），版本信息格式为 L8
UNIX Type: L8 Version: VxWorks

# 这是一个格式化字符串模板，用于打印 VxWorks 系统时间（年/月/日 时:分:秒）
VxWorks =%u, m/d/y h:m:s %.2d/%.2d/%.2d %.2d:%.2d:%.2d

# 一个命令行帮助信息，暗示系统可能存在一个 Shell 或调试控制台，输入 version 可打印版本和启动参数
version                        Print VxWorks version info, and boot line

# 另一个格式化输出模板，用于打印特定目标（%s）的版本号
VxWorks (for %s) version %s.

# 来自文件 dosVDirLib.c 的调试/错误信息，提示 VxWorks 的 DOS 兼容文件系统不支持长文件名（FAT 限制）
dosVDirLib.c : VxWorks proprietary long names not supported

# 登录提示符
<VxWorks login:

题目说要找 bsolute__C14SequenceNumber 函数所对应的文件偏移

1
2
# -t x  输出字符串所在的十六进制文件偏移
strings -a -t x firmware.raw | grep "bsolute__C14SequenceNumber"

得到偏移是 0x26634c，并且是 Absolute__C14SequenceNumber，题目可能给错了

固件里的符号表一般不会保存 “文件偏移”，而是保存运行时地址

1
运行时地址 = 文件偏移 + 加载基址

获取加载基址的思路如下

1
2
3
4
固件中有很多字符串文件偏移
固件中也有很多 4 字节大端整数
如果某个整数值 V 是字符串运行时地址
那么 V - 某个 base 应该刚好等于某个字符串文件偏移

所以我们枚举 base，看哪个 base 能解释最多的 “指向字符串的指针”

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
from pathlib import Path

fw = Path("firmware.raw").read_bytes()

# 1. 收集所有 ASCII 字符串的起始文件偏移
string_starts = set()

i = 0
while i < len(fw):
    if 32 <= fw[i] < 127:
        j = i
        while j < len(fw) and 32 <= fw[j] < 127:
            j += 1

        # 至少 4 字节，并且以 \x00 结尾，认为是一个字符串
        if j < len(fw) and fw[j] == 0 and j - i >= 4:
            string_starts.add(i)

        i = j + 1
    else:
        i += 1

# 2. 收集固件中所有 4 字节大端整数
words = []
for off in range(0, len(fw) - 4, 4):
    v = int.from_bytes(fw[off:off+4], "big")

    # 只保留看起来像固件内地址范围的值，减少噪声
    if 0 <= v <= len(fw) + 0x100000:
        words.append(v)

# 3. 枚举候选加载基址，看哪个 base 命中最多字符串起点
scores = []

for base in range(0, 0x400000, 0x1000):
    hit = 0

    for v in words:
        if v - base in string_starts:
            hit += 1

    if hit:
        scores.append((hit, base))

for hit, base in sorted(scores, reverse=True)[:10]:
    print(f"base={base:#x}, hit={hit}")

可以看到 0x10000 命中数遥遥领先，所以基址就是 0x10000

所以目标字符串运行地址 = 0x26634C + 0x10000 = 0x27634C

因为 PowerPC 是大端，所以 0x0027634C 在文件里的字节形式是 00 27 63 4C

接下来就是找到哪个符号表项引用了 Absolute__C14SequenceNumber 这个字符串

1
2
3
4
5
6
7
8
9
10
from pathlib import Path

fw = Path("firmware.raw").read_bytes()

target = bytes.fromhex("0027634c")
off = fw.find(target)

print("name_addr field offset:", hex(off))
print("symbol item start     :", hex(off - 4))
print("symbol item bytes     :", fw[off-4:off+12].hex(" "))

将 symbol item bytes 按 4 字节大端拆开

1
00 00 00 00   00 27 63 4C   00 11 FD 38   00 00 05 00

对应结构体

1
2
3
4
5
6
struct symbol_item {
    uint32_t unk;
    uint32_t name_addr;
    uint32_t value_addr;
    uint32_t type;
};

解析结果

1
2
3
4
unk        = 0x00000000
name_addr  = 0x0027634C
value_addr = 0x0011FD38
type       = 0x00000500

value_addr 就是 Absolute__C14SequenceNumber 的函数运行时地址

题目要的是 函数所对应的文件偏移，所以要减去基址

得到 flag 后半部分 0x0011FD38 - 0x00010000 = 0x0010FD38

symbol item start 是符号表项，值为 0x302010，那么整张符号表应该是一段连续的 16 字节结构数组

所以我们要做的是

1
2
3
4
5
6
7
从 0x302010 开始
每次向前减 0x10
检查前一个 16 字节结构是否仍然像符号表项

再从 0x302010 开始
每次向后加 0x10
检查后一个 16 字节结构是否仍然像符号表项

判断 “像符号表项” 的标准是：

  • 第 1 字段通常为 0
  • 第 2 字段 name_addr - 0x10000 后能指向一个合法字符串
  • 第 3 字段 value_addr 落在固件地址范围内
  • 第 4 字段 type 是少量重复的类型值，例如 0x500、0x700、0x900 等
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
from pathlib import Path
import struct

fw = Path("firmware.raw").read_bytes()

BASE = 0x10000
TARGET_ITEM = 0x302010

# 这些 type 是从目标附近和整段表里观察到的常见符号类型
TYPES = {
    0x100, 0x200, 0x300, 0x400,
    0x500, 0x600, 0x700, 0x800,
    0x900, 0x1500, 0x1700
}

def is_ascii_string_at(off):
    if off < 0 or off >= len(fw):
        return False

    end = fw.find(b"\x00", off)
    if end == -1:
        return False

    # 符号名一般不会太短，也不会特别长
    if end <= off or end - off > 256:
        return False

    s = fw[off:end]
    return all(32 <= c < 127 for c in s)

def is_symbol_item(pos):
    if pos < 0 or pos + 0x10 > len(fw):
        return False

    unk, name_addr, value_addr, typ = struct.unpack(">IIII", fw[pos:pos+0x10])

    name_off = name_addr - BASE

    return (
        unk == 0
        and is_ascii_string_at(name_off)
        and typ in TYPES
        and 0 <= value_addr - BASE < len(fw)
    )

# 向前找表头
start = TARGET_ITEM
while is_symbol_item(start - 0x10):
    start -= 0x10

# 向后找表尾
end = TARGET_ITEM
while is_symbol_item(end):
    end += 0x10

count_by_len = (end - start) // 0x10

print("symbol table start:", hex(start))
print("symbol table end  :", hex(end))
print("count by length   :", hex(count_by_len), count_by_len)

print("bytes at end      :", fw[end:end+0x10].hex(" "))
print("first dword at end:", hex(struct.unpack(">I", fw[end:end+4])[0]))

输出

1
2
3
4
5
symbol table start: 0x301e60
symbol table end  : 0x3293b0
count by length   : 0x2755 10069
bytes at end      : 00 00 27 55 00 03 c1 d8 00 03 eb 40 00 03 ff e4
first dword at end: 0x2755

symbol table end 说明 0x3293B0 起就不再是符号表项

手动观察表尾

1
2
3
4
# -g 4：改为 4 个字节一组
# -s 0x329380：跳过的偏移量
# -l 0x60：长度
xxd -g 4 -s 0x329380 -l 0x60 firmware.raw

回显

1
2
3
4
00329380: 00000000 00232b08 00367788 00000900
00329390: 00000000 00232afc 00339494 00000900
003293a0: 00000000 00232af4 00339a64 00000900
003293b0: 00002755 0003c1d8 0003eb40 0003ffe4

前三行仍然符合符号表项结构

1
00000000 [name_addr] [value_addr] [type]

但到了 0x3293B0，第一字段变成了 00002755。它不再是符号表项，而是表项数量

所以表尾就是 0x3293B0，第一部分 flag 已经确认为 00002755

最终 flag 为 flag{000027550010FD38}

ddddynamic（算法优化）

逆向分析代码，solve() 里面没有用动态规划，而是调用了 dfs() 枚举子序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void dfs(int target_len, int start, int depth) {
    tmp[depth] = str[start];

    if (depth == target_len) {
        check tmp[1..target_len] 是否非降序;
        if valid:
            flag = 1;
        return;
    }

    for (int i = start + 1; i <= n; i++) {
        dfs(target_len, i, depth + 1);
    }
}

检查逻辑是 if (tmp[i] < last) fail;

所以它找的是最长非降子序列

因为数组元素只在 0 ~ 10 之间，所以最长非降子序列可以用很简单的 DP 求

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
MOD = 2147483647

def glibc_rand(seed):
    """
    glibc random()/rand() 生成器
    验证：seed=1 时前几个输出应为：
    1804289383, 846930886, 1681692777...
    """
    if seed == 0:
        seed = 1

    r = [0] * 34
    r[0] = seed & 0xffffffff

    for i in range(1, 31):
        prev = r[i - 1]
        if prev >= 2**31:
            prev -= 2**32
        r[i] = (16807 * prev) % MOD

    for i in range(31, 34):
        r[i] = r[i - 31]

    i = 34
    while True:
        val = (r[i - 31] + r[i - 3]) & 0xffffffff
        r.append(val)

        if i >= 344:
            yield val >> 1

        i += 1


def lnds_len(seq):
    """
    最长非降子序列长度
    seq[i] 范围为 0~10
    """
    dp = [0] * 11

    for x in seq:
        best = max(dp[:x + 1]) + 1
        if best > dp[x]:
            dp[x] = best

    return max(dp)


seed = 0x666c6167
rng = glibc_rand(seed)

chars = []

for round_id in range(1, 11):
    arr = [next(rng) % 11 for _ in range(10000)]

    lis = lnds_len(arr)

    # solve() 里会把长度加 0x22，最后取低 8 位作为字符
    ch = (lis + 0x22) & 0xff
    chars.append(chr(ch))

    print(
        round_id,
        "LNDS =", lis,
        "value =", hex(lis + 0x22),
        "char =", chr(ch)
    )

middle = "".join(chars)
flag = f"flag{{{middle}}}"

print(flag)

IoT（RISC-V 架构 + XOR）

IDA 逆向，根据流程图一步一步来

main 函数用途：

  • 调用 scanf 从标准输入读取字符串到全局缓冲区 str

  • 调用 strlen 获取输入长度

  • 若长度等于 20，则跳转到 loc_1018E 进入处理逻辑；否则顺序执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
main:
var_s0   =  0
var_s8   =  8
var_s10  = 10h
arg_0    = 18h

addi    sp, sp, -30h          ; 分配栈空间 0x30 字节
sd      ra, 18h+var_s10(sp)   ; 保存返回地址到 sp+0x10
sd      s0, 18h+var_s8(sp)    ; 保存 s0 到 sp+0x8
sd      s1, 18h+var_s0(sp)    ; 保存 s1 到 sp+0x0
addi    s0, sp, 18h+arg_0     ; 设置帧指针 s0 = sp + 0x18
lui     a5, %hi(str)          ; 加载 str 地址高20位
addi    a1, a5, %lo(str)      ; a1 = str 完整地址（scanf 第二个参数）
lui     a5, %hi(unk_1F3D0)    ; 加载格式字符串高20位
addi    a0, a5, %lo(unk_1F3D0); a0 = 格式字符串（scanf 第一个参数）
jal     scanf                 ; 调用 scanf
lui     a5, %hi(str)          ; 重新加载 str 地址
addi    a0, a5, %lo(str)      ; a0 = str
jal     strlen                ; 调用 strlen，返回值在 a0
mv      a4, a0                ; a4 = 字符串长度
li      a5, 0x14              ; a5 = 20
beq     a4, a5, loc_1018E     ; 如果长度等于 20 则跳转到 loc_1018E

loc_1018E 函数用途：

  • 将局部变量 i 置零，然后跳到 loc_101F4
1
2
3
loc_1018E:
sw      zero, -24h(s0)       ; 将 0 存入 s0-0x24 处（局部变量初始化）
j       loc_101F4            ; 无条件跳转到 loc_101F4

loc_101F4 函数用途：

  • 从栈上重新加载 i，调用 strlen 获得长度 20，用 bltu 比较，若 i < 20 则跳回 loc_10194（循环体），否则退出循环

  • 实现一个 20 次迭代的 for 循环，用于逐字节处理输入字符串

1
2
3
4
5
6
7
8
loc_101F4:
lw      s1, -24h(s0)          ; s1 = i （从栈上局部变量加载）
lui     a5, %hi(str)          ; 加载 str 地址高 20 位
addi    a0, a5, %lo(str)      ; a0 = str （输入缓冲区）
jal     strlen                ; 调用 strlen(str)
mv      a5, a0                ; a5 = 字符串长度 (应为 20)
bltu    s1, a5, loc_10194     ; 如果 i < 长度则跳转到 loc_10194（循环体）
                              ; 否则顺序执行（退出循环）

该循环体对输入字符串 str 的每个字符 str[i] 进行如下操作：

  • 读取 str[i]

  • 从 xor 表中读取一个 32 位整数 xor[i]

  • 计算 xor[i] ^ str[i]

  • 从 __DATA_BEGIN__ 表中读取 expected[i]

  • 比较 xor[i] ^ str[i] 与 expected[i]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
loc_10194:
lui     a5, %hi(str)            ; a5 = str 的高 20 位地址
addi    a4, a5, %lo(str)        ; a4 = str 的完整地址
lw      a5, -24h(s0)            ; a5 = i （从栈上加载循环计数器）
add     a5, a5, a4              ; a5 = &str[i]
lbu     a5, 0(a5)               ; a5 = str[i]（无符号字节）
sext.w  a4, a5                  ; a4 = 将字节符号扩展为 32 位（实际仍为原值）
lui     a5, %hi(xor)            ; 加载 xor 表地址
addi    a3, a5, %lo(xor)        ; a3 = xor 表基址
lw      a5, -24h(s0)            ; a5 = i
slli    a5, a5, 2               ; a5 = i * 4 （因为 xor 表是 4 字节整数数组）
add     a5, a5, a3              ; a5 = &xor[i]
lw      a5, 0(a5)               ; a5 = xor[i] （32 位值）
xor     a5, a5, a4              ; a5 = xor[i] ^ str[i] （32 位异或，高 24 位为 0）
sext.w  a3, a5                  ; a3 = 异或结果（符号扩展，实际低位有效）
lui     a5, %hi(__DATA_BEGIN__) ; 加载 __DATA_BEGIN__ 表地址
addi    a4, a5, %lo(__DATA_BEGIN__) ; a4 = __DATA_BEGIN__ 基址
lw      a5, -24h(s0)            ; a5 = i
slli    a5, a5, 2               ; a5 = i * 4
add     a5, a5, a4              ; a5 = &__DATA_BEGIN__[i]
lw      a5, 0(a5)               ; a5 = __DATA_BEGIN__[i]
mv      a4, a3                  ; a4 = 异或结果
beq     a4, a5, loc_101EA       ; 如果 xor[i] ^ str[i] == __DATA_BEGIN__[i] 则跳转到 loc_101EA
                                 ; 否则顺序执行（可能走向失败路径）

提取 xor 表和 __DATA_BEGIN__ 的数据解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 已知的 xor 表与 expected 表（32 位整数数组）
xor_table = [
    159, 249, 383, 227, 56,
    326, 295, 468, 315, 321,
    364, 129, 236, 72, 444,
    141, 309, 392, 231, 377
]

expected = [
    249, 149, 286, 132, 67,
    286, 328, 390, 356, 264,
    345, 222, 191, 120, 483,
    200, 340, 507, 158, 260
]

# 计算密钥字节：低 8 位异或
key_bytes = [(x ^ e) & 0xFF for x, e in zip(xor_table, expected)]

# 转换为字节串并输出
key = bytes(key_bytes)
print("Key bytes:", key)

最后得到 flag{XoR_I5_S0_Easy}