2019 工业信息安全技能大赛-哈尔滨站 WriteUp

📝 赛事概况

  • 参赛规模：比赛共吸引了来自全国的 24 支队伍参加

  • 比赛项目：大赛设有 PLC 漏洞挖掘和 SCADA 漏洞挖掘两个比赛项目

🏛️ 组织架构

  • 指导单位：国家工业信息安全发展研究中心、黑龙江省工业和信息化厅

  • 主办单位：黑龙江省电子技术研究所、哈尔滨工程大学

🏆 比赛结果

  • 第一名：冀信安队

Misc

异常的 S7 数据（S7comm 协议）

大概看了一下，全是 0x05 功能码

绝大多数写入数据都以 ffff 开头

右键作为过滤器应用

WireShark 生成的语法是 s7comm.resp.data == ff:ff:96:e7:8f:51:c4:d0:3a:2b

我们更改为 s7comm.resp.data[0:2] != ff:ff，筛选出数据包

所以 flag 是 flag{FFAD28A0CE69DB34751F}

神奇的数据（S7 符号访问服务）

查看文本文件是一大堆 ASCII 码（十进制），用 | 间隔

搜索 flag 66|6c|61|67|，有两段结果

分析第一段是请求包

以太网帧

字段 值
目标 MAC 08:ac:7d:01:e1:83
源 MAC 00:05:b7:da:72:57
EtherType 0x0800 (IPv4)

IPv4 首部

字段 值
版本 / IHL 4 / 5 (20 字节)
DSCP / ECN 0x00
总长度 91 (0x005b)
标识 0x987e
标志 / 片偏移 DF (不分片), 0
TTL 64
协议 6 (TCP)
校验和 0x10a1
源 IP 100.100.100.21
目的 IP 100.100.100.160

TCP 首部

字段 值
源端口 57632 (0xe120)
目的端口 102 (ISO-TSAP)
序列号 0xbdcc6ad5
确认号 0x86f7846e
数据偏移 32 字节 (8)
标志 ACK + PSH (0x18)
窗口 501 (0x01f5)
校验和 0x5744
紧急指针 0
选项 NOP, NOP, Timestamp (TSval=0x7d8a8100, TSecr=0x09ad3958)
负载长度 39 字节

TPKT (RFC1006)

字段 值
版本 3
保留 0
长度 39 (0x0027)

COTP (ISO 8073)

字段 值
头长度 2 字节
PDU 类型 DT (0x0f)
EOT / TPDU-NR 0x80 (EOT, NR=0)

S7 符号访问服务（请求）

字段 值
固定头 01 00 01 00
应用构造标签 0x61 (Application 1)
长度 26 (0x1a)
SEQUENCE 长度 24 (0x18)
协议版本 (INTEGER) 3
Context[0] 长度 19 (0x13)
Context[0] 内容长度 17 (0x11)
符号 ID (INTEGER) 0x666c6167 (“flag”)
Context[1] 长度 9
↳ Context[0] (参数1) 80 01 09 (原始, 值 0x09)
↳ Context[1] (参数2) 80 00 (原始, 空)

很明显，目的端口 102 → 典型的西门子 PLC ISO-TSAP 端口

接下来再来看响应包

以太网帧 (802.1Q)

字段 值
目标 MAC 00:05:b7:da:72:57
源 MAC 08:ac:7d:01:e1:83
802.1Q TPID 0x8100
优先级 / CFI / VLAN ID 0 / 0 / 1
EtherType 0x0800 (IPv4)

IPv4 首部

字段 值
版本 / IHL 4 / 5
总长度 145 (0x0091)
标识 0x15f4
标志 / 片偏移 DF, 0
TTL 64
协议 6 (TCP)
校验和 0x92f5
源 IP 100.100.100.160
目的 IP 100.100.100.21

TCP 首部

字段 值
源端口 102
目的端口 57632
序列号 0x86f7846e
确认号 0xbdcc6afc (确认增加 39)
数据偏移 32 字节
标志 ACK + PSH (0x18)
窗口 15000 (0x3a98)
校验和 0x56e2
紧急指针 0
选项 NOP, NOP, Timestamp (TSval=0x09ad3958, TSecr=0x7d8a8100)
负载长度 93 字节

TPKT (RFC1006)

字段 值
版本 3
保留 0
长度 93 (0x005d)

COTP (ISO 8073)

字段 值
头长度 2 字节
PDU 类型 DT
EOT / TPDU-NR 0x80

S7 符号访问服务（响应）

字段 值
固定头 01 00 01 00
应用构造标签 0x61
长度 80 (0x50)
SEQUENCE 长度 78 (0x4e)
协议版本 3
Context[0] 长度 73 (0x49)
Context[1] 长度 71 (0x47)
Invoke ID (符号 ID) 0x666c6167 (“flag”)
变量列表容器 Context[1] (长度 63)
返回状态 0x00 (成功)

变量列表（VisibleString）

序号 变量符号名
1 PL1012{ROT
2 PL1012CTRL
3 PL1012LD0
4 PL1012MEAS
5 PL1012RC

看上面的变量列表结构，删除掉 PL1012，flag 就出来了

1
flag{ROTCTRLLD0MEASRC}

智能变电站设备异常诊断（SCD 文件）

010 打开发现文件头被颠倒了

改回来后打开就是一个 dcs.dcs 文件

初步查看文件类型

1
2
file dcs.dcs
strings -a dcs.dcs | head

可以看到文件不是普通 XML

1
dcs.dcs: data

但文件头附近有明显标识

1
$KEMOV-SCD-FILE$

继续查看十六进制

1
2
3
od -Ax -tx1z -N 128 dcs.dcs

ff ff 24 4b 45 4d 4f 56 2d 53 43 44 2d 46 49 4c 45 24

对应了 $KEMOV-SCD-FILE$

同时后面出现了类似

1
20 31 20 31 20 30 20 6b 20 76 20 2e 20 73 20 63 20 64

这种结构解出来是

1
110kv.scd

说明这个文件本质上保存的是一个变电站 SCD 配置信息，只是被厂商工具二进制化了

观察文件里的 ASCII 字符串会发现它不是正常连续保存的

1
20 49 20 4c 20 31 20 31 20 30 20 31

这不是普通 ASCII，而是类似

1
0x20 + ASCII 字符

所以

1
2
3
4
5
6
20 49 -> I
20 4c -> L
20 31 -> 1
20 31 -> 1
20 30 -> 0
20 31 -> 1

解出来是

1
IL1101

中文部分则基本可以按 UTF-16BE 理解

也就是说，文件里的大量字段是 1 字节长度 + 2 字节字符序列

编写脚本来恢复

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

b = Path("dcs.dcs").read_bytes()

print("[+] header:", b[2:18].decode())

def dec(pos):
    if pos >= len(b):
        return None

    L = b[pos]

    # 字符串长度一般为偶数，每个字符 2 字节
    if L < 2 or L > 200 or L % 2:
        return None

    data = b[pos + 1:pos + 1 + L]
    if len(data) != L:
        return None

    out = []

    for hi, lo in zip(data[0::2], data[1::2]):
        # ASCII 字符：20 xx
        if hi == 0x20 and 0x20 <= lo <= 0x7e:
            out.append(chr(lo))
        else:
            try:
                ch = bytes([hi, lo]).decode("utf-16be")
            except Exception:
                return None

            # 本题需要的非 ASCII 基本都是中文，严格过滤误判
            if not (0x4e00 <= ord(ch) <= 0x9fff):
                return None

            out.append(ch)

    s = "".join(out)

    if not re.search(r"[A-Za-z0-9\u4e00-\u9fff]", s):
        return None

    return s, pos + 1 + L


def strs(start=0, end=None):
    p = start
    end = len(b) if end is None else min(end, len(b))
    out = []

    while p < end:
        r = dec(p)
        if r:
            s, p2 = r
            out.append((p, s))
            p = p2
        else:
            p += 1

    return out


allstr = strs()

print("[+] decoded strings:", len(allstr))
print("[+] first strings:")
for off, s in allstr[:8]:
    print(hex(off), repr(s))


print("\n[+] 110kV line intelligent terminals:")
for idx, (off, s) in enumerate(allstr):
    if "110kV" in s and "线路智能终端" in s:
        print("---")
        for o, t in allstr[max(0, idx - 3):idx + 2]:
            print(hex(o), t)


print("\n[+] duplicated IED_GOCB:")

records = []

for m in re.finditer(b"IED_GOCB", b):
    vals = [s for _, s in strs(m.end(), m.end() + 700)]

    gocb = next((x for x in vals if re.fullmatch(r"gocb\d+", x)), None)
    ref = next((x for x in vals if "/LLN0" in x), "")

    mi = re.search(r"0?([A-Z]{1,4}\d{3,4})(?=[A-Z]+/LLN0)", ref)

    if gocb and mi:
        ied = mi.group(1)
        records.append((m.start(), ied, gocb, vals[:6]))

cnt = Counter((ied, gocb) for _, ied, gocb, _ in records)

for (ied, gocb), c in sorted(cnt.items()):
    if c > 1:
        print(ied, gocb, "count =", c)

        for off, ied2, gocb2, vals in records:
            if (ied2, gocb2) == (ied, gocb):
                print("   ", hex(off), vals[:5])

脚本首先能恢复出原始 SCD 文件名

1
2
3
4
5
6
7
8
[+] header: $KEMOV-SCD-FILE$
[+] decoded strings: 8174
[+] first strings:
0x21 '九曲110kv.scd'
0x3b 'version'
0x4d 'reversion'
0x63 'template'
0x77 'toolID'

接着筛选 110kV 线路智能终端，可以看到

1
2
3
4
5
6
7
[+] 110kV line intelligent terminals:
---
0x2525d IL1101
0x2526d 110kV1#线路智能终端
---
0x30a87 IL1102
0x30a97 110kV2#线路智能终端

题目说问题可能来源于线路智能终端，所以重点检查

1
2
IL1101
IL1102

然后分析 IED_GOCB 记录，即 GOOSE Control Block 配置，异常输出为

1
2
3
4
5
6
[+] duplicated IED_GOCB:
IL1101 gocb5 count = 10
    0x28756 ['gocb5', '0IL1101RPIT/LLN0', 'GOOSE采样', '0IL1101RPIT/LLN0', 'GO$gocb5 0IL1101RP']
    0x2953e ['gocb5', '0IL1101RPIT/LLN0', 'GOOSE采样', '0IL1101RPIT/LLN0', 'GO$gocb5 0IL1101RP']
    0x2a24e ['gocb5', '0IL1101RPIT/LLN0', 'GOOSE采样', '0IL1101RPIT/LLN0', 'GO$gocb5 0IL1101RP']
    ...

这里的异常点非常明确：

1
IL1101 / RPIT / LLN0 / gocb5

被重复配置了 10 次

在 IEC 61850/SCD 配置里，同一个 IED、同一个逻辑节点下的 GOOSE 控制块名称应该唯一。重复的 gocb5 会导致控制块引用冲突、GOOSE 配置异常，从而引发运行异常

题目问的是 “分析存在问题根源”

真正的问题是 “变电站基础配置文件 SCD 存在错误”

所以 flag 是 flag{scdisbad}

黑客的大意（信息收集）

识别出是 PNG 图片，修改后缀再打开

GitHub 上搜索到源码，里面就有邮箱

窃取数据的黑客（MMS 协议）

查看会话可以看到一直在跟 192.168.51.34:102 通信

所以 192.168.51.34 就是服务器

按照长度排列，第 3096 包没有 info 信息有点可疑（3022、3059 也一样）

展开后可以看到 flag.7z 以及 flag.txt

按照最先发包顺序，从 3022 之后看攻击者 IP 192.168.51.33 请求操作

在 3066 包中可以看到访问了 flag.7z

编写脚本去响应中找到这个压缩文件

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

pcap = "tmflag(1).pcapng"               # 要解析的 pcapng 文件
data = open(pcap, "rb").read()           # 一次性读取全部二进制内容

endian = "<"                             # 默认小端字节序，后续可根据块类型修正
pos = 0                                  # 当前解析位置（字节偏移）
packets = []                             # 存储提取的原始数据包内容

# 逐块解析 pcapng 文件
while pos + 12 <= len(data):            # 至少需要类型(4) + 块长(4) + 尾部块长(4)
    block_type, block_len = struct.unpack(endian + "II", data[pos:pos+8])
    if block_len < 12 or pos + block_len > len(data):  # 非法块长度则停止解析
        break

    body = data[pos+8:pos+block_len-4]  # 块体，去掉头和尾的块长度字段

    if block_type == 0x0A0D0D0A:        # Section Header Block：决定字节序
        bom = struct.unpack("<I", body[:4])[0]  # 读取字节序标记
        endian = "<" if bom == 0x1A2B3C4D else ">"  # 根据标记设置端序
    elif block_type == 6:               # Enhanced Packet Block
        if len(body) >= 20:
            # 接口ID、时间戳高/低、捕获长度、原始长度（只关注 caplen）
            _, _, _, caplen, _ = struct.unpack(endian + "IIIII", body[:20])
            packets.append(body[20:20+caplen])  # 保存捕获到的数据包

    pos += block_len                     # 移动到下一个块

# 分析提取的以太网数据包
for idx, pkt in enumerate(packets, 1):
    if len(pkt) < 14:
        continue                         # 不够以太网帧头长度，跳过

    eth_type = struct.unpack("!H", pkt[12:14])[0]  # 以太网类型字段
    if eth_type != 0x0800:
        continue                         # 非 IPv4 包则跳过

    ip = pkt[14:]                        # IP 头部起始
    ihl = (ip[0] & 0x0f) * 4            # IP 头长度（字节）
    proto = ip[9]                        # 传输层协议号
    if proto != 6:
        continue                         # 非 TCP 则跳过

    total_len = struct.unpack("!H", ip[2:4])[0]  # IP 总长度
    tcp = ip[ihl:total_len]              # TCP 段（头部+数据）
    sport, dport = struct.unpack("!HH", tcp[:4])  # 源端口、目的端口
    tcp_hlen = (tcp[12] >> 4) * 4        # TCP 头长度（字节）
    payload = tcp[tcp_hlen:]             # TCP 有效载荷（应用层数据）

    # 7z 文件魔数签名
    sig = b"7z\xbc\xaf\x27\x1c"
    off = payload.find(sig)              # 在载荷中查找该签名

    if off != -1:                        # 找到 7z 文件头
        # 提取从签名开始的一段数据（长度 0x8f 字节）
        filedata = payload[off:off + 0x8f]
        open("flag.7z", "wb").write(filedata)  # 写出文件
        print(f"[+] frame {idx}: extracted flag.7z, size={len(filedata)} bytes")

解压后拿到 flag 值

flag 在哪（文件附件隐写 + 像素隐写）

使用 foremost 分离出一个 PNG 图片和压缩包

图片发现存在残缺的条形码图文

使用 PS 工具将其修复完整，发现熊猫的颜色颠倒过来，因此对图片进行反相处理

扫描可得到字符串：This_n0t_fl4g

使用该字符串解压刚才的压缩包，得到 3.jpg 文件，使用 binwalk 查看依旧存在 ZIP 文件，于是继续分离出来

最终得到两个一模一样的图片，使用 Stegsolve 工具进行图片对比

发现出现很多像素点，确定是像素隐写，保存该图片为：solved.bmp，发现和原图对比数据杂乱因此尝试使用像素隐写解密工具进行解密

GitHub 搜索尝试几个工具后，最终发现此工具可以成功解密：https://github.com/HFO4/HideByPixel

md5 解密拿到 flag：flag{this_is_fl4g_icsc-^_^}

协议分析又来了（LSIS-XGT 工控协议）

pasted_1787814734574_1v4z48.png

统计会话中的主要端口是 2004

pasted_1787817753184_vzzb00.png

过滤 tcp.port == 2004，发现明显特征

pasted_1787818296125_pzae5x.png

过滤器直接搜 tcp contains "LSIS-XGT"

pasted_1787818752223_c769p6.png

使用 tshark 提取上面这些数据出来

1
tshark -r .\capture.pcapng -Y "tcp.port == 2004 && tcp.len > 0" -T fields -e tcp.payload > xgt_payloads.txt

编写脚本解析

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

input_file = "xgt_payloads.txt"

# 用于存放未匹配响应的请求队列，每个元素为 (地址, 请求读取长度)
pending = []

# 以 UTF-16 编码打开输入文件
with open(input_file, "r", encoding="utf-16") as f:
    # enumerate 从 1 开始计数行号，便于定位
    for line_no, line in enumerate(f, 1):
        # 去除行首尾空白字符（包括换行符）
        line = line.strip()
        # 跳过空行
        if not line:
            continue

        # 将十六进制字符串转换为字节序列（例如 "AA BB" -> b'\xAA\xBB'）
        payload = bytes.fromhex(line)

        # LSIS-XGT 协议报文固定以 "LSIS-XGT" 开头（ASCII 字符串）
        if not payload.startswith(b"LSIS-XGT"):
            continue

        # 报文长度至少需要 0x20 字节才包含完整头部，否则跳过
        if len(payload) < 0x20:
            continue

        # 命令码位于偏移 0x14，占 2 字节，小端序
        # 0x54 = 读请求，0x55 = 读响应
        cmd = int.from_bytes(payload[0x14:0x16], "little")

        # ---------- 处理读请求 (cmd == 0x54) ----------
        if cmd == 0x54:
            # 在报文中搜索 "%PB" 后跟一个或多个数字的模式（变量名）
            # 例如 "%PB100" 表示 PB 区地址 100
            m = re.search(rb"%PB(\d+)", payload)
            if not m:
                # 未找到变量名，无法解析，跳过
                continue

            # 提取地址数字（从匹配组中获取）
            addr = int(m.group(1))

            # 变量名字符串后面紧接 2 字节，表示本次读取的长度（小端序）
            # m.end() 是匹配结束的位置，其后 2 字节即为长度字段
            size = int.from_bytes(payload[m.end():m.end() + 2], "little")

            # 将该请求加入待匹配队列（先进先出，用于与后续响应配对）
            pending.append((addr, size))

            # 打印请求信息，方便追踪
            print(f"[请求] line={line_no}, %PB{addr}, size={size}")

        # ---------- 处理读响应 (cmd == 0x55) ----------
        elif cmd == 0x55:
            # 如果 pending 为空，说明收到一个没有对应请求的响应
            if not pending:
                print(f"[响应] line={line_no}, 但是找不到对应请求")
                continue

            # 从队列头部取出最早的请求（假定响应顺序与请求一致）
            addr, req_size = pending.pop(0)

            # 响应数据长度位于偏移 0x1e，占 2 字节，小端序
            data_len = int.from_bytes(payload[0x1e:0x20], "little")

            # 实际数据从偏移 0x20 开始，长度为 data_len
            data = payload[0x20:0x20 + data_len]

            # 打印响应信息，包括请求的地址、请求长度、实际数据长度和十六进制数据
            print(
                f"[响应] line={line_no}, %PB{addr}, "
                f"req_size={req_size}, data_len={data_len}, "
                f"data={data.hex()}"
            )

pasted_1787819515408_gv73do.png

总结出规律地址

1
2
3
4
5
6
%PB100
%PB200
%PB300
%PB400
%PB500
...

修改脚本，按照这些顺序拼接数据得到

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
# 1. 新增字典，用于存储符合条件的数据块（地址 -> 响应数据）
chunks = {}

# 2. 在原有的读响应处理分支（cmd == 0x55）中，替换掉了直接打印，改为收集数据：

        # ...（前面的响应解析代码与第一个脚本相同）
        data_len = int.from_bytes(payload[0x1e:0x20], "little")
        data = payload[0x20:0x20 + data_len]

        # 新增：检查请求长度与实际数据长度是否一致，不一致则警告并跳过
        if data_len != req_size:
            print(f"[!] 长度不一致: %PB{addr}, req={req_size}, resp={data_len}")
            continue

        # 新增：只收集地址为100的整数倍，且在100~29900范围内的“主线”数据块
        if addr % 100 == 0 and 100 <= addr <= 29900:
            # 避免重复覆盖（每个地址只保存第一次收到的数据）
            if addr not in chunks:
                chunks[addr] = data
                print(f"[+] 收集 %PB{addr}, len={len(data)}")

# 3. 新增文件读取循环结束后，进行数据块拼接和输出：

# 按地址顺序拼接，预期地址范围：100, 200, 300, ... , 29900（步长100）
buf = bytearray()

for addr in range(100, 30000, 100):
    # 检查是否所有预期地址都已收集到，否则抛出异常
    if addr not in chunks:
        raise Exception(f"缺少数据块: %PB{addr}")

    data = chunks[addr]

    # 检查每个数据块长度是否为100字节（根据协议固定长度），否则异常
    if len(data) != 100:
        raise Exception(f"数据块长度异常: %PB{addr}, len={len(data)}")

    # 按顺序追加到缓冲区
    buf.extend(data)

# 将拼接好的二进制数据写入文件
with open("raw_pb.bin", "wb") as f:
    f.write(buf)

# 输出统计信息
print("[+] 拼接完成")
print("[+] 数据块数量:", len(chunks))
print("[+] raw_pb.bin size:", len(buf))
print("[+] raw_pb.bin 前16字节:", buf[:16].hex())

文件开头是 b2 a5 6f ff fc ff ff ff fb ff ff ff 00 00 ff ff，对其异或 0xff 得到 4d 5a 90 00 ...

4d 5a 就是 Windows EXE 的 MZ 文件头

1
2
3
4
5
6
7
8
9
raw = open("raw_pb.bin", "rb").read()

decoded = bytes(b ^ 0xff for b in raw)

open("flag.exe", "wb").write(decoded)

print("raw size:", len(raw))
print("decoded size:", len(decoded))
print("magic:", decoded[:16].hex())

从字符串中识别出它是一个 .NET / WPF 程序

pasted_1787850579639_wvmihi.png

IDA 反编译发现一堆数值

pasted_1787880198410_w1vrch.png

这种格式在 WPF 里非常像 Margin="62,62,0,0"

1
strings -a flag.exe | grep -E "[0-9]+,[0-9]+,0,0"

提取出来类似于 UI 布局

pasted_1787880962395_4srksr.png

编写脚本绘图拿到 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
import re

data = open("flag.exe", "rb").read()

# 用于存储筛选后的有效坐标点
points = []

# 使用正则表达式在二进制数据中查找形如 "数字,数字,0,0" 的片段
# \d{1,4} 匹配1到4位数字，逗号分隔，后面紧跟 ",0,0"
for x, y in re.findall(rb"(\d{1,4}),(\d{1,4}),0,0", data):
    # 将匹配到的字节串转为整数
    x = int(x)
    y = int(y)

    # 过滤有效坐标范围：x 在 [40, 760]，y 在 [50, 160]
    # 这个范围可能是根据原图或屏幕区域设定的可见区域
    if 40 <= x <= 760 and 50 <= y <= 160:
        points.append((x, y))

print("valid points:", len(points))

# 计算所有有效点的最小/最大坐标，用于确定 SVG 画布尺寸
min_x = min(x for x, y in points)
min_y = min(y for x, y in points)
max_x = max(x for x, y in points)
max_y = max(y for x, y in points)

# 准备构建SVG图片
svg = []

# SVG 头部，设置命名空间，宽度和高度留出 40 像素边距（各边 20 像素）
svg.append(
    f'<svg xmlns="http://www.w3.org/2000/svg" '
    f'width="{max_x - min_x + 80}" height="{max_y - min_y + 80}">'
)

# 添加白色背景矩形，占满整个画布
svg.append('<rect width="100%" height="100%" fill="white"/>')

# 遍历所有有效坐标点，在SVG中绘制黑色小方块（16x16）
# 坐标偏移 (min_x, min_y) 并额外增加20像素边距，使得图形居中
for x, y in points:
    svg.append(
        f'<rect x="{x - min_x + 20}" '
        f'y="{y - min_y + 20}" '
        f'width="16" height="16" fill="black"/>'
    )

# SVG闭合标签
svg.append("</svg>")

# 将生成的SVG内容写入文件 "flag.svg"
open("flag.svg", "w", encoding="utf-8").write("\n".join(svg))

print("[+] 已生成 flag.svg")

pasted_1787881066484_oiydbm.png

Reverse

简单的 APK 分析（签到）

解包 APK 得到 multiprotocol.tesla.scada 文件

反编译该文件通过对比正版软件，很容易得到 flag（为混淆前的类名）

Tesla 工业 APP 分析（DEX 脱壳 + so 层逆向 + 控制流平坦化混淆 + SM4 + Brainfuck + 摩斯密码 + 变种 Base91 + Base85）

pasted_1788592920683_paycgd.png

解压附件中的 APK

pasted_1788592971406_exijax.png

在字体库中发现某个字体文件异常过大

pasted_1788593853715_2ba29k.png

检查发现原本是 APK 文件

pasted_1788590362103_loj5y3.png

修改后缀后再次解压缩

pasted_1788590483241_9p2mpq.png

jadx 反编译 classes.dex

这段代码是一个 Android 加固脱壳的代理 Application，通过反射替换系统 Application 为真实的目标 Application 并调用其生命周期，同时加载 native 库执行初始化

在 onCreate() 方法中，代码大量使用 ReflectUtils 对 ActivityThread 和 LoadedApk 这些系统核心类进行反射操作：

  • 将 LoadedApk 中的 mApplication 设为 null，并从系统的 mAllApplications 列表中移除旧的 Application 对象

  • 强行将 ApplicationInfo 中的 className 修改为 "com.targetapk.MyApplication"

在系统感知之前，用真实的业务 Application 替换掉这个临时的代理入口

代码通过反射调用 LoadedApk.makeApplication 动态创建了一个新的 Application 实例，并将其赋值给系统的 mInitialApplication，最后直接调用了 app.onCreate()

这一步证明了该代理类的存在意义——它并不自己承担业务逻辑，而是充当 “启动器”，负责找到、构造并启动被加固保护的原始 Application，确保原始 App 的代码能够正常跑起来

pasted_1788591347937_8zynf8.png

010 分析中 DEX 头里有两个关键字段：data_size 和 data_off

pasted_1788592674324_yfbnk1.png

所以 DEX 的数据区结束位置是 data_end = data_off + data_size = 0x938 + 0x1948 = 0x2280

也就是说，壳 dex 的正常数据到 0x2280 就结束了，但这个 classes.dex 的总长度是 0xf83f

壳 dex 尾部 4 字节是 payload 长度：00 00 d5 bb

pasted_1788592380184_ps6im1.png

然后我们算一下：

1
2
3
总长度 - DEX 正常结束位置 - 4 字节长度字段
= 0xf83f - 0x2280 - 4
= 0xd5bb

刚好等于最后 4 字节表示的数值，所以可以确认 00 00 d5 bb 就是前面那段附加 payload 的长度

然后对 payload 每个字节异或 0xff，就能还原 zip，开头会变成 PK 03 04

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

p = Path("./classes.dex")
b = p.read_bytes()

payload_len = int.from_bytes(b[-4:], "big")
start = len(b) - 4 - payload_len

payload = bytes(x ^ 0xff for x in b[start:-4])

Path("TargetApk.zip").write_bytes(payload)

解压缩后拿到真正的 DEX

pasted_1788593251207_wwk3xb.png

public static String O00o00O00o00O00o00O00o00O00o00O00o00O00o00O00o00OO(String str) 中虽然传入 String str

但是完全没用，最终进入 native 的永远是 Your Flag!

pasted_1788594060191_gmfrry.png

进入 O00o00O00o00O00o00O00o00O00o00O00o00O00o00O00o00OO 内部

pasted_1788594328762_7nvszj.png

其中

1
2
3
4
5
6
7
static int[] = {
1,
85,
7225,
614125,
52200625
}

这个就是

1
2
3
4
5
85^0
85^1
85^2
85^3
85^4

这个类里面有三个函数，大概率是 encode()，decode()，check()

所以推测为 Base85 编码，Java 层如下

1
2
3
4
5
6
7
Your Flag!
       |
       |
    Base85
       |
       |
stringFromJNI()

接下来去逆向 so 层

pasted_1788594715859_lvk1fc.png

找到了这个 JNI 函数，分析 sub_2E74 函数

pasted_1788594903007_6g3e0p.png

这几百行 while 混淆就是典型的控制流平坦化混淆

pasted_1788595275343_09hw8t.png

扔给 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
sub_2E74(JNIEnv *env, char *input)
{

    // 1
    strcpy(v36, input);


    // 2
    sub_1228(v34, v37);


    // 3
    sub_1720(v34, key, 32, v36, v35);


    // 4
    sub_D58(v31);


    // 5
    v22 = sub_DA4(
            v31,
            v16,
            32,
            v21
          );


    // 6
    sub_106C(v31,v32);


}

继续分析 sub_1228 函数，同样也被混淆了

这里 0x20 = 32，对应着 SM4 的 32 轮加密，32 个轮密钥 rk[0~31]

1
2
if ( v2 < 0x20 )
    j = 550605733;

A3B1BAC6 是 SM4 固定参数

1
2
3
v47[0] = 
v29 & 0x5C4E4539 |
~v29 & 0xA3B1BAC6;

标准 SM4：

1
2
3
4
FK0 = A3B1BAC6
FK1 = 56AA3350
FK2 = 677D9197
FK3 = B27022DC

pasted_1788595817175_m1q7ws.png

但是这个函数里面是没有 Key 的，回头看调用时传的参数 sub_1228(v34,v37);

a2 才是 16 字节密钥，可以在开头的定义变量中按 X 看引用的代码段

pasted_1788596862826_3hmi9j.png

所以回到 sub_2E74 看 v37 在哪里初始化

pasted_1788596862826_3hmi9j.png

IDA 没有识别到，那么密钥在哪呢？

回到隐藏 APK，里面有一个资源文件 r/D.aac，它内容是一串十六进制

1
D4E8E5A0EBE5F9A0E9F3A0D9EFF5F2E5DFF6E5F2F9DFF3EDE1F2F4ACC3E9F0E8E5F2F4E5F8F4A0E3EFEEF3E9F3F4F3A0EFE6A0F4E8F2E5E5A0F0E1F2F4F3ACC3EFEDE5A0EFEEA1

这段每个字节减去 0x80，就会得到明文

1
The key is Youre_very_smart,Ciphertext consists of three parts,Come on!

其中 Youre_very_smart 就是 Key，接下来去找密文

在最外层的 APK 中，functions_fr.properties 文件的其中一个值很奇怪

1
hide=....................../-//.-......................-.-/.-.... ../.-............./-//.-////////////-.-/.-///////////.-..... ..../-//.-........-.-/.-................/.-........./-//.-// //////-.-/.-/.-........./-//.-////////-.-/.-/////////.-..... ../-//.-......-.-/.-......../.-........./-//.-////////-.-/.- /////////.-........./-//.-////////-.-/.-///////////.-....... ....../-//.-............-.-/.-......................../.-... ....../-//.-........-.-/.-../.-............./-//.-////////// //-.-/.-/////.-.........../-//.-..........-.-/.-......../.-. ............/-//.-////////////-.-/.-/////////////////////.-. ....../-//.-//////-.-/.-///.../.-.........../-//.-.......... -.-/.-............../.-............./-//.-////////////-.-/.- ///////.-............./-//.-............-.-/.-.............. /./////////.-.

这段看起来像摩尔斯，其实是 Brainfuck 变体，替换规则

1
2
/  -> !
-  -> ?

然后按照 Ook 规则转 Brainfuck 得到 |Sk[GT@+[lFc5+,L%PL

第二段密文在最开始的 APK 中，这段看起来像 Brainfuck，其实是 Morse，替换规则：

1
2
! -> -
? -> /

替换后变成 ...--/-.--/.-/.-.-.-/-.-./-.-.-./...--/--/.-.-./--..--/--../....，解码得到 3ya.c;3m+,zh

pasted_1788599534771_u6kry6.png

第三段在 /android/support/v7/internal/view/menu/ActionMenuItemView 中，这一段是真 Brainfuck 变体，但是 ! 和 ? 被交换了，替换规则：

1
2
! -> ?
? -> !

得到 jR1"KTb?:

pasted_1788599658450_l19zcf.png

但是题目没有告诉顺序，所以需要枚举 6 种排列

继续回到 IDA 中，在字符串窗口发现了一串字符

pasted_1788600312241_z96cac.png

AI 分析出这个 sub_DA4 函数是变种 Base91

pasted_1788601173183_tups6u.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
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
from itertools import permutations
import base64


# 三段密文：前面 Brainfuck / Morse / Brainfuck 解出来的结果
PARTS = [
    '|Sk[GT@+[lFc5+,L%PL',
    '3ya.c;3m+,zh',
    'jR1"KTb?:',
]


# libnative-lib.so 里的变异 Base91 表
B91_TABLE = ',./:;%&()*+<={|}~>?@[]^_`"fghiabcdejklmGHIJABCDEFKLMwxyznopqrstuvNOPQRSTUVWXYZ789!0123456#$'


# r/D.aac 解出来的 SM4 key
KEY = b'Youre_very_smart'


# libnative-lib.so 里的变异 SM4 CK 表
SM4_CK = [
    0x00070e15, 0x383f464d, 0x1c232a31, 0x545b6269,
    0xbcc3cad1, 0xa0a7aeb5, 0xd8dfe6ed, 0xf4fb0209,
    0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
    0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
    0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
    0xdce3eaf1, 0xc0c7ced5, 0xf8ff060d, 0x141b2229,
    0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
    0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279,
]


# sub_1228 里 FK1 / FK2 被调换后的 FK
SM4_FK = [
    0xa3b1bac6,
    0x677d9197,
    0x56aa3350,
    0xb27022dc,
]


# libnative-lib.so 里的变异 Sbox，按内存字节序取
SM4_SBOX = bytes.fromhex(
    'c3aa4413262b679a762abe04498606999c7a33540b43ed4250f491ef98cfac62'
    'e4a9c9df94fa7508e89580b31c8f3fa64707a7fcf37317ba83593c19e6854fa8'
    '0a7bbd2d74d012b8c13188a5cde5b4b0897e65b9f169974a0c967709c56ec684'
    '686b81b27164da8bf8eb0f4b70569d35d6b716b614c22890e9fecce13dfb2c05'
    '1ea225227c3b0121240e5e6358d17887d40046579fd327524c3602e7a0c4c89e'
    'eabf8ad240c738b5a3f7f2cef96115a1e0ae5da49b341a55ad933230f58cb1e3'
    '1dca60c02923f6e22e8266ab0d534e6fd5db3745defd8e2f03ff6a726d6c5b51'
    '8d7f11d95c411f101baf92bbddbc5ad8184d2079ee5f3ed7cbf07dec3adc3948'
)


def rol32(x, n):
    x &= 0xffffffff
    return ((x << n) & 0xffffffff) | (x >> (32 - n))


def sm4_tau(x):
    return (
        (SM4_SBOX[(x >> 24) & 0xff] << 24)
        | (SM4_SBOX[(x >> 16) & 0xff] << 16)
        | (SM4_SBOX[(x >> 8) & 0xff] << 8)
        | SM4_SBOX[x & 0xff]
    )


def sm4_key_schedule(key):
    """
    对应 sub_1228：生成 32 个轮密钥
    """
    if len(key) != 16:
        raise ValueError("SM4 key must be 16 bytes")

    mk = [
        int.from_bytes(key[0:4], "big"),
        int.from_bytes(key[4:8], "big"),
        int.from_bytes(key[8:12], "big"),
        int.from_bytes(key[12:16], "big"),
    ]

    k = [mk[i] ^ SM4_FK[i] for i in range(4)]
    rk = []

    for i in range(32):
        tmp = k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ SM4_CK[i]
        b = sm4_tau(tmp)

        # SM4 key schedule 的 L' 变换
        rki = k[i] ^ b ^ rol32(b, 13) ^ rol32(b, 23)
        rki &= 0xffffffff

        rk.append(rki)
        k.append(rki)

    return rk


def sm4_one_block(block, round_keys):
    if len(block) != 16:
        raise ValueError("SM4 block must be 16 bytes")

    x = [
        int.from_bytes(block[0:4], "big"),
        int.from_bytes(block[4:8], "big"),
        int.from_bytes(block[8:12], "big"),
        int.from_bytes(block[12:16], "big"),
    ]

    for i in range(32):
        tmp = x[i + 1] ^ x[i + 2] ^ x[i + 3] ^ round_keys[i]
        b = sm4_tau(tmp)

        # SM4 加密轮函数的 L 变换
        xi = (
            x[i]
            ^ b
            ^ rol32(b, 2)
            ^ rol32(b, 10)
            ^ rol32(b, 18)
            ^ rol32(b, 24)
        )
        xi &= 0xffffffff
        x.append(xi)

    return b"".join(v.to_bytes(4, "big") for v in x[35:31:-1])


def sm4_ecb_decrypt(ciphertext, key):
    if len(ciphertext) % 16 != 0:
        raise ValueError("ciphertext length must be a multiple of 16")

    rk = sm4_key_schedule(key)[::-1]

    out = b""
    for i in range(0, len(ciphertext), 16):
        out += sm4_one_block(ciphertext[i:i + 16], rk)

    return out


def base91_decode(data):
    """
    对应 sub_DA4 的反向：使用变异表做 Base91 解码
    """
    decode_table = {ch: idx for idx, ch in enumerate(B91_TABLE)}

    v = -1
    b = 0
    n = 0
    out = bytearray()

    for ch in data:
        if ch not in decode_table:
            raise ValueError(f"invalid base91 char: {ch!r}")

        c = decode_table[ch]

        if v < 0:
            v = c
        else:
            v += c * 91
            b |= v << n

            if (v & 8191) > 88:
                n += 13
            else:
                n += 14

            while n >= 8:
                out.append(b & 0xff)
                b >>= 8
                n -= 8

            v = -1

    if v >= 0:
        out.append((b | (v << n)) & 0xff)

    return bytes(out)


def main():
    assert len(B91_TABLE) == 91
    assert len(SM4_SBOX) == 256

    for order in permutations(PARTS):
        joined = "".join(order)

        try:
            # 1. 变异 Base91 解码
            sm4_cipher = base91_decode(joined)

            # 2. 变异 SM4-ECB 解密
            sm4_plain = sm4_ecb_decrypt(sm4_cipher, KEY)

            # 3. 去掉 \x00 填充，得到 Java 层 Base85 字符串
            b85_text = sm4_plain.rstrip(b"\x00")

            # 4. Base85 解码得到 flag
            flag = base64.a85decode(b85_text)

            print("[+] order:", order)
            print("[+] base91 decoded:", sm4_cipher.hex())
            print("[+] SM4 plaintext/Base85:", b85_text.decode())
            print("[+] flag:", flag.decode())
            return

        except Exception:
            pass

    print("[-] failed")


if __name__ == "__main__":
    main()