2020 工业信息安全技能大赛-石家庄站 WriteUp

比赛情况：已知成都安美勤信息技术股份有限公司曾参加该站比赛并获得了前三名的优异成绩

Misc

TJ 协议（TCP 协议）

打开流量包，全是 TCP 协议，主要发生在：

1
2
192.168.99.145 -> 192.168.99.102:8080
192.168.99.145 -> 192.168.99.102:8081

快速搜索十六进制拿到 flag

1
2
3
strings -a 11.pcap | grep -i "666c61677b"

flag{dalaoafddaa}

不安全的组件（HTTP 协议 + Moudbus 协议）

这个 flag 是假的

有 HTTP 直接过滤，看到只对 modus3.pacpng 有一次请求

导出这个文件

打开可以看到基本上都是写入寄存器操作

将写入的数据拼接起来得到 flag

1
2
3
34330928433800018445622871195029877774318527404492633948321508979

flag{St0p_al1_machine_exp1osi0ns}

黑客的 Fuzz（S7comm 协议）

打开流量包过滤 s7comm，全是写入和读取变量

题目说的是 FUZZ，所以重点应该看读取的流量，功能码为 0x04

FUZZ 的参数每次请求肯定都是不一样的

最后比对发现就 Address 字段的最后一个字节每次不一样

编写脚本提取

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

# 打开 pcapng 文件并读取全部内容
pcap = "s7.pcapng"
raw = open(pcap, "rb").read()

# 默认使用小端字节序
endian = "<"
# 当前读取偏移
off = 0
# 存放提取出的隐藏数据
hidden = bytearray()

def parse_tcp(pkt):
    """解析以太网帧中的 TCP 报文，返回 (src_ip, dst_ip, src_port, dst_port, payload)"""
    # 以太网帧最小长度 14 字节（目的 MAC + 源 MAC + 类型）
    if len(pkt) < 14:
        return None

    # 以太类型字段（大端）
    eth_type = int.from_bytes(pkt[12:14], "big")
    pos = 14

    # 若存在 802.1Q VLAN 标签（0x8100），再读取内层类型
    if eth_type == 0x8100:
        eth_type = int.from_bytes(pkt[16:18], "big")
        pos = 18

    # 只处理 IPv4（0x0800）
    if eth_type != 0x0800:
        return None

    # IP 头部长度（ihl * 4 字节）
    ihl = (pkt[pos] & 0x0f) * 4
    # IP 协议字段（6 = TCP）
    proto = pkt[pos + 9]

    if proto != 6:
        return None

    # 源 IP 和目标 IP（点分十进制）
    src = ".".join(map(str, pkt[pos + 12:pos + 16]))
    dst = ".".join(map(str, pkt[pos + 16:pos + 20]))

    # TCP 首部起始位置
    tcp = pos + ihl
    # 源端口、目的端口
    sport = int.from_bytes(pkt[tcp:tcp + 2], "big")
    dport = int.from_bytes(pkt[tcp + 2:tcp + 4], "big")
    # TCP 数据偏移（4 位，单位 4 字节）
    doff = (pkt[tcp + 12] >> 4) * 4

    # TCP 有效载荷
    payload = pkt[tcp + doff:]
    return src, dst, sport, dport, payload

# 解析 pcapng 文件：逐块读取
while off + 12 <= len(raw):
    # 块类型和块长度（使用当前字节序）
    block_type, block_len = struct.unpack(endian + "II", raw[off:off + 8])

    # 块长度不合理则退出
    if block_len < 12 or off + block_len > len(raw):
        break

    # 块体（去除头部类型/长度和尾部重复长度）
    body = raw[off + 8:off + block_len - 4]

    # 块类型 0x0A0D0D0A 是 Section Header Block（SHB），用于判断字节序
    if block_type == 0x0A0D0D0A:
        # 魔术数字判断大小端：b"\x4d\x3c\x2b\x1a" 表示小端，否则大端
        endian = "<" if body[:4] == b"\x4d\x3c\x2b\x1a" else ">"

    # 块类型 6 是 Enhanced Packet Block（EPB），包含数据包
    elif block_type == 6:
        if len(body) >= 20:
            # 块选项中的捕获长度（caplen）在固定字段的第三个 int 里
            caplen = struct.unpack(endian + "IIIII", body[:20])[3]
            # 提取数据包字节
            pkt = body[20:20 + caplen]

            # 解析 TCP 报文
            parsed = parse_tcp(pkt)
            if parsed:
                src, dst, sport, dport, payload = parsed

                # 只取攻击者发往 PLC 102 端口的数据
                if dport == 102 and payload.startswith(b"\x03\x00"):
                    # S7Comm Job 包，Read Var 功能，固定长度 31
                    if (
                        len(payload) == 31
                        and payload[7] == 0x32   # 功能码：Read Var
                        and payload[8] == 0x01   # 读取变量数量：1
                        and payload[17] == 0x04  # 数据长度：4 字节
                    ):
                        # 提取最后一个字节（读取到的数据）
                        hidden.append(payload[-1])

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

# 将隐藏数据写入文件
open("hidden", "wb").write(hidden)

# 打印恢复信息
print("hidden length:", len(hidden))
print("file header:", hidden[:10].hex())

# 搜索 flag 并输出
flags = re.findall(rb"flag\{[^}]+\}", hidden)
for f in flags:
    print(f.decode())

最后得到 flag：flag{50f84daf3a6dfd6a9f20c9f8ef428942}

Reverse

ICS TRITON（Python 反编译 + .pyz 恢复 + RC4 + 协议逆向）

分析 triton.exe 发现它是 PyInstaller 打包的 Python 2.7 程序

1
2
3
4
5
6
strings triton.exe | grep -i "py"

_MEIPASS
PyMarshal_ReadObjectFromString
python27.dll
PYZ-00.pyz

使用 pyinstxtractor.py 提取

在目录找到 PYZ-00.pyz，它本身是一个 Python 模块压缩包

PyInstaller 将 Python 依赖模块的字节码 .pyc（去掉 8~16 字节头部）进行 zlib 压缩，然后打包成一个 PYZ 存档，其物理结构如下

1
2
3
4
5
6
7
+--------+----------+----------+-----------------------------+
| 标识   | 魔数     | TOC偏移  |  压缩模块数据 (顺序存放)    |
| "PYZ\0"| Py magic | (big end)|                             |
| 4字节  | 4字节    | 4字节    |                             |
+--------+----------+----------+-----------------------------+
                                     ↑
                            TOC 指向这里 → [TOC 区域]

TOC（Table of Contents，目录表） 是一个 Python 对象的序列化形式，位于 TOC 偏移指定的位置，一直延伸到文件末尾

TOC 描述了每个模块的名称、存储位置、长度以及是否为包

  • ispkg：表示模块是否为一个包（package），1 则为包

  • pos：该模块的压缩数据在 PYZ 文件中的起始偏移

  • length：压缩数据占用的字节数

编写脚本通过读取 TOC 获得所有模块的压缩数据所在位置，然后逐个提取

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
import os                        # 操作系统接口，用于路径操作和创建目录
import zlib                      # zlib 压缩库，用于解压字节码
import marshal                   # Python 内部序列化，用于解析 TOC 数据
import struct                    # 二进制数据处理，用于读取大端整数

PYZ_FILE = "PYZ-00.pyz"         # 要提取的 PYZ 压缩包文件名
OUT_DIR = "manual_pyz_extract"  # 解压输出目录

# Python 2.7 pyc 文件头部魔数（含时间戳占位）
PY27_MAGIC = b"\x03\xf3\x0d\x0a\x00\x00\x00\x00"

os.makedirs(OUT_DIR, exist_ok=True)   # 创建输出目录，若已存在则忽略

data = open(PYZ_FILE, "rb").read()    # 以二进制方式读入整个 PYZ 文件

# PYZ 头部结构：
# 0x00: "PYZ\0" 标识
# 0x04: Python 版本魔数
# 0x08: TOC 偏移量（大端字节序）
toc_offset = struct.unpack("!I", data[8:12])[0]  # 读取大端 4 字节作为 TOC 偏移量

toc = marshal.loads(data[toc_offset:])   # 从偏移位置反序列化 TOC 对象

# 兼容不同版本 PyInstaller 的 TOC 格式（字典或列表）
if isinstance(toc, dict):
    items = toc.items()                  # 字典则取出所有键值对
else:
    items = toc                          # 列表则直接使用

for item in items:                       # 遍历每一个模块条目
    name, info = item                    # 解包模块名和元信息

    # 常见格式：(ispkg, pos, length)
    if len(info) == 3:
        ispkg, pos, length = info
    # 少数版本：(typecode, ispkg, pos, length)
    elif len(info) == 4:
        _, ispkg, pos, length = info
    else:
        print("[-] unknown TOC item:", name, info)  # 未知格式，打印并跳过
        continue

    comp = data[pos:pos + length]        # 根据 TOC 中的偏移和长度截取压缩数据

    try:
        raw = zlib.decompress(comp)      # 尝试 zlib 解压
    except Exception as e:
        print("[-] zlib failed:", name, e)   # 解压失败则打印错误并跳过该模块
        continue

    out_name = name.replace(".", os.sep) + ".pyc"   # 将模块名中的 "." 替换为路径分隔符，并加上 .pyc 后缀
    out_path = os.path.join(OUT_DIR, out_name)      # 生成最终输出文件路径

    parent = os.path.dirname(out_path)   # 获取文件所在目录
    if parent:
        os.makedirs(parent, exist_ok=True)   # 如果目录不存在则递归创建

    with open(out_path, "wb") as f:      # 以二进制写入模式打开文件
        f.write(PY27_MAGIC)              # 先写入 Python 2.7 的 pyc 头部
        f.write(raw)                     # 再写入解压后的字节码

    print("[+] extracted:", out_path)    # 输出提取成功信息

这里报错是因为 Python 导入模块时会优先搜索当前工作目录

脚本第一行 import struct 本来想导入标准库的 struct，但实际上却找到了目录下的 struct.pyc

这个 struct.pyc 是用 Python 2.7 编译的（magic 为 b'\x03\xf3\r\n'），而当前的 Python 环境是 3，两者不兼容，于是抛出 bad magic number 错误

直接删除这个文件就好了

重点反编译下面四个文件

1
2
3
4
TsHi.pyc
TsBase.pyc
aes.pyc
sh.pyc

首先是 TsHi.py，定义了一个 TsHi 类（继承自 TsBase.TsBase），用于与某工业控制系统（ICS）设备进行交互

它实现了程序/函数的上传下载、内存任意读写、代码执行，以及一个基于文本模式匹配的远程许可证校验

重点是下面三个函数

1
2
3
RemoteLicenseCheck()
TransDummyData()
UpdateDataFormat()
1
2
def TransDummyData(self, s):
    return ''.join([ '{:08b}'.format(ord(c)) for c in s ])

  • 功能：将字符串 s 的每个字符转换为 8 位二进制字符串（带前导零），并全部拼接

  • 示例：s = "AB" → ord('A') = 65 → "01000001"，ord('B') = 66 → "01000010"，结果 "0100000101000010"

  • 用途：将变换后的中间密钥字符串展开为一串 '0'/'1' 字符，作为控制空格替换的掩码

1
2
3
4
5
6
def UpdateDataFormat(self, string, p, c):
    new = []
    for s in string:
        new.append(s)
    new[p] = c
    return ''.join(new)

  • 功能：将字符串 string 位置 p 的字符替换为 c，返回新字符串

  • 注意：Python 字符串不可变，所以采用列表转换方式实现单字符替换

  • 用途：在 License 文本的指定空格位置，将空格改为制表符 \t

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
def RemoteLicenseCheck(self, remoteLicenseKey):
    # 1. 生成变换后的中间字符串
    raw_bytes = binascii.unhexlify(remoteLicenseKey)
    b64_str = base64.b64encode(raw_bytes)
    transformed = ''.join([ chr(ord(b64_str[i]) ^ ((i * 3 + 7) % 11)) 
                            for i in range(len(b64_str)) ])
    # 2. 转换为二进制掩码序列
    dummyData = self.TransDummyData(transformed)  # 由'0'和'1'组成的字符串

    # 3. 收集 License 文本中所有空格的位置
    connectIONumber = [i for i, ch in enumerate(License) if ch == ' ']

    # 4. 长度检查（原代码错误：应确保掩码足够长）
    if len(dummyData) < len(connectIONumber):
        raise AssertionError  # 实际应为 len(dummyData) >= len(connectIONumber)

    # 5. 固定随机种子（用于反调试/混淆，但最终不影响结果）
    random.seed(os.stat(sys.executable).st_mtime)

    # 6. 根据掩码替换空格
    for i in range(len(connectIONumber)):
        # 如果掩码对应位为'1'，则将该空格替换为制表符
        if i < len(dummyData) and dummyData[i] == '1':
            License = self.UpdateDataFormat(License, connectIONumber[i], '\t')
        # 原代码中的随机替换很可能是反编译错误或混淆代码，应忽略
        # if random.randint(0,1) == 1: ...  # 此句会导致无法通过校验，不参与真实逻辑

    # 7. 比较修改后的文本与预设模板
    return License == LicenseInLaw

完整流程如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
remoteLicenseKey (hex)
    │
    ▼
binascii.unhexlify → 原始字节
    │
    ▼
base64.b64encode → Base64 字符串
    │
    ▼
逐字符异或变换: ord(c) ^ ((i*3+7)%11) → transformed 字符串
    │
    ▼
TransDummyData → 二进制掩码序列 (dummyData)
    │
    ▼
遍历 License 文本中的每个空格位置 i：
    if dummyData[i] == '1': 替换为 '\t'
    else: 保留空格
    │
    ▼
得到修改后的 License 文本
    │
    ▼
与预设模板 LicenseInLaw 逐字比较 → 相等则通过

恢复 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
35
36
37
38
39
import base64                           # Base64 编解码库
import binascii                         # 二进制与 ASCII 互转库

License = r"""License"""
LicenseInLaw = r"""LicenseInLaw"""

bits = []                               # 用于存储掩码位序列

# 逐字符对比两个文本，提取空格对应的掩码位
for a, b in zip(License, LicenseInLaw):
    if a == " ":                        # 仅在遇到原始空格时记录
        if b == "\t":                   # 若模板中为制表符，说明此位应置 1
            bits.append("1")
        else:                           # 若模板中仍为空格，此位为 0
            bits.append("0")

bitstream = "".join(bits)               # 拼接成二进制字符串

dummy = ""                              # 存储逆 TransDummyData 结果（中间变换字符串）

# 每 8 位二进制转换为一个字符
for i in range(0, len(bitstream) // 8 * 8, 8):
    dummy += chr(int(bitstream[i:i+8], 2))

b64 = ""                                # 存储还原出的 Base64 字符串

# 逆向异或变换，恢复 Base64 字符
for i, c in enumerate(dummy):
    b64 += chr(ord(c) ^ ((i * 3 + 7) % 11))

# Base64 编码可能带有额外填充后的垃圾字节，截取到第一个 "==" 为止
end = b64.find("==")
if end != -1:
    b64 = b64[:end + 2]                 # 保留有效 Base64 数据（包含末尾 ==）

key = base64.b64decode(b64)             # Base64 解码得到原始密钥字节

print("[+] key bytes:", key)            # 输出密钥的字节形式
print("[+] key hex:", binascii.hexlify(key).decode())  # 输出密钥的十六进制表示

最后得到 77d975244bf3e642eac8b56aebed97595920a08b5a194eeb055d72cea621819329bf3863f9565a2529713f7d3e7412f59b31d94c481863ba14bc7d425a715334

接着反编译 aes.pyc，结果是 RC4 加密算法

最后是 sh.pyc

1
2
3
4
5
def chend(data):
    out = b""
    for i in range(0, len(data), 4):
        out += data[i:i+4][::-1]
    return out

  • 每 4 字节为一组，反转组内字节顺序

  • 等价于小端序 ↔ 大端序转换（对 32 位整数而言）

反编译最后的 TsBase.pyc，在 TsBase 类中，所有通信都通过 self.ts_exec() 发送，其第一个参数是一个元组，即协议命令标识。例如

1
2
3
4
def AllocateProgram(self, id, next, full_chunks=0, offset=0, data=''):
    request = struct.pack('<HHHHH', id, next, full_chunks, offset, len(data)/4) + data
    result = self.ts_exec((55, 153), request)   # 注意这里
    return result[0] == 0

  • (55, 153) → 55 即 0x37，153 是 0x99（可能是子命令或校验和参数）

  • 这正是 AllocateProgram 函数使用的命令字

AllocateProgram 的功能是向设备分配（或覆盖）一个程序条目，参数包括：

  • id：程序 ID

  • next：下一个程序的 ID（链表指针）

  • full_chunks：总数据块数（每块 4 字节）

  • offset：写入偏移块号

  • data：实际写入的字节码数据

功能 命令元组 说明
GetCpStatus (19, 108) 获取项目状态
UploadProgram (65, 162) 上传程序数据
AllocateProgram (55, 153) 分配/写入程序 (0x37)
StartDownloadChange (1, 102) 开始下载修改
EndDownloadChange (11, 103) 结束下载修改
CancelDownload (12, 104) 取消下载
RunProgram (20, 109) 运行程序
HaltProgram (21, 110) 暂停程序
ExecuteExploit (29, 150) 漏洞利用接口
GetModuleVersions (54, 151) 获取模块版本
UploadFunction (66, 163) 上传函数数据
AllocateFunction (56, 154) 分配/写入函数
StartDownloadAll (59, 101) 开始全部下载
EndDownloadAll (10, 105) 结束全部下载

打开流量包发现大量 UDP 协议的目标端口都是 1502

观察数据发现主要以 05003400000037 开头，推测是 AllocateProgram 函数

编写脚本提取流量

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
import struct                           # 用于解析二进制数据
from collections import Counter         # 用于统计频次

PCAP = "captured.pcapng"               # 待分析的 pcapng 抓包文件

def read_pcapng_packets(path):          # 按块读取 pcapng 文件，生成每个 Enhanced Packet 的原始字节
    data = open(path, "rb").read()      # 读取整个文件
    pos = 0                             # 当前解析偏移
    frame_no = 0                        # 帧序号计数器

    while pos + 12 <= len(data):        # 确保至少能读块类型和长度
        block_type, block_len = struct.unpack("<II", data[pos:pos+8])  # 解析块类型和长度（小端）

        if block_len < 12:              # 块长度非法则退出
            break

        block = data[pos:pos+block_len]  # 提取整个块

        # 0x00000006 = Enhanced Packet Block
        if block_type == 0x00000006:     # 仅处理增强包块
            cap_len = struct.unpack("<I", block[20:24])[0]  # 捕获的数据长度
            pkt = block[28:28+cap_len]   # 提取实际数据包
            frame_no += 1                # 帧计数
            yield frame_no, pkt          # 生成帧

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

def extract_udp1502_payloads(path):      # 从 pcapng 中提取目标端口 1502 的 UDP 载荷
    for frame_no, pkt in read_pcapng_packets(path):  # 遍历每个数据包
        # 这个包是 loopback/null 链路层
        # 前 4 字节不是以太网头，跳过
        ip_off = 4                       # IP 头起始偏移

        if len(pkt) < ip_off + 20:       # 不足最小 IP 头长度则跳过
            continue

        # IPv4
        if pkt[ip_off] >> 4 != 4:        # 检查 IP 版本（4 为 IPv4）
            continue

        ihl = (pkt[ip_off] & 0x0f) * 4   # IP 头长度（字节）
        proto = pkt[ip_off + 9]           # 传输层协议号

        # UDP = 17
        if proto != 17:                   # 非 UDP 则跳过
            continue

        udp_off = ip_off + ihl            # UDP 头起始

        if len(pkt) < udp_off + 8:        # 不足 UDP 头长度则跳过
            continue

        sport, dport, udp_len, checksum = struct.unpack(
            "!HHHH",
            pkt[udp_off:udp_off+8]        # 解析 UDP 首部
        )

        if dport != 1502:                 # 仅保留目标端口 1502 的包
            continue

        udp_payload = pkt[udp_off+8:udp_off+udp_len]  # 提取 UDP 数据

        yield frame_no, sport, dport, udp_payload     # 返回帧号、源/目的端口、载荷

counter = Counter()                      # 用于统计各 total_words 出现次数

for frame_no, sport, dport, payload in extract_udp1502_payloads(PCAP):  # 遍历提取的 UDP 载荷
    if len(payload) <= 14:               # 载荷过短则忽略
        continue

    cmd = payload[6]                     # 第 7 字节（偏移 6）为命令字

    if cmd != 0x37:                      # 仅处理 0x37 命令
        continue

    request = payload[14:-2]             # 去除头部和尾部（可能是校验）得到请求体

    if len(request) < 10:                # 请求体不足最小长度则忽略
        continue

    program_id, next_id, total_words, offset_words, chunk_words = struct.unpack(
        "<HHHHH",
        request[:10]                     # 解析五个 uint16 字段
    )

    chunk = request[10:]                 # 剩余部分为代码数据块

    counter[total_words] += 1            # 统计 total_words

    print(
        "frame=%-4d cmd=0x%02x total_words=%-4d offset_words=%-4d chunk_words=%-2d chunk_len=%d" %
        (frame_no, cmd, total_words, offset_words, chunk_words, len(chunk))
    )

print("\n[+] total_words counter:")      # 输出统计结果
for k, v in counter.items():
    print("total_words =", k, "count =", v)

接下来只要获取 total_words == 1003 的数据即可

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
import struct                           # 用于解析二进制数据

PCAP = "captured.pcapng"               # 待分析的 pcapng 抓包文件

def read_pcapng_packets(path):          # 读取 pcapng 文件，生成每个 Enhanced Packet 的原始字节
    data = open(path, "rb").read()      # 以二进制方式读入整个文件
    pos = 0                             # 当前解析偏移
    frame_no = 0                        # 帧序号计数器

    while pos + 12 <= len(data):        # 确保至少能读块类型和长度
        block_type, block_len = struct.unpack("<II", data[pos:pos+8])  # 读取块类型和块长度（小端）

        if block_len < 12:              # 块长度非法则退出
            break

        block = data[pos:pos+block_len]  # 提取整个块

        if block_type == 0x00000006:     # Enhanced Packet Block 类型值为 0x00000006
            cap_len = struct.unpack("<I", block[20:24])[0]  # 捕获的数据包长度
            pkt = block[28:28+cap_len]   # 提取实际数据包
            frame_no += 1                # 帧计数加一
            yield frame_no, pkt          # 生成帧序号和数据包

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

def extract_udp1502_payloads(path):      # 从 pcapng 中提取目标端口 1502 的 UDP 载荷
    for frame_no, pkt in read_pcapng_packets(path):  # 遍历每个数据包
        ip_off = 4                       # loopback/null 链路层头为 4 字节，跳过

        if len(pkt) < ip_off + 20:       # 不足最小 IP 头长度则跳过
            continue

        if pkt[ip_off] >> 4 != 4:        # 检查 IP 版本，4 表示 IPv4
            continue

        ihl = (pkt[ip_off] & 0x0f) * 4   # IP 头长度（字节）
        proto = pkt[ip_off + 9]           # 传输层协议号

        if proto != 17:                   # 17 表示 UDP，非 UDP 跳过
            continue

        udp_off = ip_off + ihl            # UDP 头起始偏移

        sport, dport, udp_len, checksum = struct.unpack(
            "!HHHH",
            pkt[udp_off:udp_off+8]        # 解析 UDP 首部（源端口、目的端口、长度、校验和）
        )

        if dport != 1502:                 # 仅保留目的端口为 1502 的包
            continue

        udp_payload = pkt[udp_off+8:udp_off+udp_len]  # 提取 UDP 数据
        yield frame_no, udp_payload       # 返回帧序号和 UDP 载荷

chunks = []                               # 用于存储 (offset, chunk) 元组

for frame_no, payload in extract_udp1502_payloads(PCAP):  # 遍历每个 UDP 载荷
    if len(payload) <= 14:               # 载荷过短则忽略
        continue

    if payload[6] != 0x37:               # 仅处理命令字 0x37（AllocateProgram）
        continue

    request = payload[14:-2]             # 去除头部和尾部（可能是校验和）得到请求体

    if len(request) < 10:                # 请求体不足最小长度则忽略
        continue

    program_id, next_id, total_words, offset_words, chunk_words = struct.unpack(
        "<HHHHH",
        request[:10]                     # 解析五个 uint16 字段
    )

    chunk = request[10:]                 # 剩余部分为代码数据块

    if total_words == 1003:              # 只收集总块数为 1003 的程序
        chunks.append((offset_words, chunk))  # 记录偏移和对应数据块

print("[+] chunk count:", len(chunks))   # 打印收集到的块数量

raw = bytearray(1003 * 4)                # 分配 4012 字节的缓冲区（1003 块 × 4 字节/块）

for offset_words, chunk in chunks:       # 按偏移填充数据
    start = offset_words * 4             # 计算字节起始位置
    raw[start:start+len(chunk)] = chunk  # 写入块数据

raw = bytes(raw)                         # 转为不可变字节串

print("[+] raw length:", len(raw))       # 打印重组后的数据长度

open("uploaded_raw.bin", "wb").write(raw)  # 保存重组后的原始程序到文件

# 验证重组是否正确
marker = struct.pack("<I", 0x56789a)      # 已知的特征标记（小端格式）
pos = raw.find(marker)                    # 在重组数据中搜索标记

print("[+] marker offset:", pos)          # 打印标记偏移
print("[+] marker bytes:", raw[pos:pos+4].hex() if pos != -1 else None)  # 打印标记位置的字节

if pos != -1:                             # 如果找到了标记
    payload_len = struct.unpack("<I", raw[pos+4:pos+8])[0]  # 读取紧随标记的 4 字节作为长度
    print("[+] payload_len:", payload_len)

    footer = raw[pos+8+payload_len-8:pos+8+payload_len]     # 提取尾部 8 字节
    print("[+] footer:", footer.hex())
    print("[+] footer parsed:", struct.unpack("<II", footer))  # 解析尾部为两个 uint32

它的结构是

1
2
3
4
5
6
uploaded_raw.bin
├── 第一段加密数据：inject_enc_chend
├── 0x56789a
├── 第二段 payload 长度
├── 第二段加密数据：imain_enc_chend
└── footer: payload_len + 0x1234

程序上传前做了两步

1
2
3
4
5
6
7
原始数据
    ↓
aes.encrypt 加密
    ↓
sh.chend 做 4 字节大小端转换
    ↓
发送到流量里

解密脚本

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
import struct                           # 用于二进制数据打包/解包
import hashlib                          # 用于计算文件 MD5 校验

# 硬编码的 RC4 密钥（十六进制字符串）
KEY_HEX = (
    "77d975244bf3e642eac8b56aebed97595920a08b5a194eeb055d72cea6218193"
    "29bf3863f9565a2529713f7d3e7412f59b31d94c481863ba14bc7d425a715334"
)

key = bytes.fromhex(KEY_HEX)            # 将十六进制密钥转换为字节串

def chend(data):
    """
    对应 sh.py 里的 chend:
    每 4 字节做一次小端 -> 大端转换。
    这个函数做两次就能还原。
    """
    if len(data) % 4 != 0:              # 长度必须是 4 的倍数
        raise ValueError("data length must be multiple of 4")

    out = b""                            # 初始化输出

    for i in range(0, len(data), 4):     # 每 4 字节处理一次
        temp = struct.unpack("<I", data[i:i + 4])[0]  # 按小端解码为整数
        out += struct.pack(">I", temp)   # 按大端重新编码

    return out

def rc4(key, data):
    """
    对应 aes.py 里的 encrypt。
    名字叫 aes，但实际是 RC4 类流加密。
    """
    key = list(key)                      # 转为整数列表
    S = list(range(256))                 # 初始化 S 盒
    j = 0

    # KSA（密钥调度算法）
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]

    # PRGA（伪随机生成算法）
    i = 0
    j = 0
    out = bytearray()                    # 使用 bytearray 累积结果

    for c in data:                       # 逐字节处理
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]

        k = S[(S[i] + S[j]) % 256]       # 生成密钥流字节
        out.append(c ^ k)                # 异或解密

    return bytes(out)                    # 返回解密后字节串

raw = open("uploaded_raw.bin", "rb").read()  # 读取重组后的原始加密数据

print("[+] uploaded_raw length:", len(raw))          # 打印原始数据长度
print("[+] uploaded_raw md5:", hashlib.md5(raw).hexdigest())  # 打印原始数据 MD5

# 1. 找分隔符 0x56789a
marker = struct.pack("<I", 0x56789a)                 # 打包特征标记
pos = raw.find(marker)                               # 查找标记在数据中的位置

if pos == -1:
    raise Exception("marker 0x56789a not found")      # 未找到则抛出异常

print("[+] marker offset:", pos)                      # 打印标记偏移

# 2. 拆第一段：inject 部分（加密+字节序转换后）
inject_enc_chend = raw[:pos]

# 3. 拆第二段：imain 部分（含长度和尾部）
payload_len = struct.unpack("<I", raw[pos + 4:pos + 8])[0]  # 紧随标记的 4 字节为 payload 长度
payload = raw[pos + 8:pos + 8 + payload_len]                 # 提取 payload

footer = payload[-8:]                                        # payload 最后 8 字节为尾部
footer_len, footer_magic = struct.unpack("<II", footer)      # 解析为两个 uint32

print("[+] payload_len:", payload_len)
print("[+] footer_len:", footer_len)
print("[+] footer_magic:", hex(footer_magic))

if footer_magic != 0x1234:                                   # 校验尾部魔数
    raise Exception("footer magic mismatch")

imain_enc_chend = payload[:-8]                               # imain 加密数据（去除尾部）

print("[+] inject_enc_chend length:", len(inject_enc_chend))
print("[+] imain_enc_chend length:", len(imain_enc_chend))

# 4. 逆向还原：
# 原逻辑：cipher = chend(rc4(key, plain))
# 逆逻辑：plain = rc4(key, chend(cipher))

inject_plain = rc4(key, chend(inject_enc_chend))  # 解密 inject
imain_plain = rc4(key, chend(imain_enc_chend))    # 解密 imain

open("inject_decrypted.bin", "wb").write(inject_plain)   # 保存 inject 明文
open("imain_decrypted.bin", "wb").write(imain_plain)     # 保存 imain 明文

print("[+] inject_decrypted.bin length:", len(inject_plain))
print("[+] inject_decrypted.bin md5:", hashlib.md5(inject_plain).hexdigest())

print("[+] imain_decrypted.bin length:", len(imain_plain))
print("[+] imain_decrypted.bin md5:", hashlib.md5(imain_plain).hexdigest())

# 可以同时保存合并后的明文，方便后续分析
combined = inject_plain + imain_plain                     # 合并两个部分
open("combined_decrypted.bin", "wb").write(combined)     # 保存合并明文

print("[+] combined_decrypted.bin md5:", hashlib.md5(combined).hexdigest())  # 打印合并文件 MD5

inject_decrypted.bin 文件是一个缺了文件头的 GIF 图片

它少了前 4 个字节 GIF89a，修补后拿到 flag