Python

Python 逆向是指对 Python 编写的程序（包括脚本、.pyc 字节码、打包的可执行文件等）进行分析，以理解其逻辑、提取算法、恢复源码或寻找漏洞

Python 程序的编译与运行机制

源码 .py 被编译为 字节码 .pyc，存储在 __pycache__ 目录（Python 3.2+）

.pyc 文件结构：

  • 前 4 字节：magic number（标识 Python 版本，如 Python 3.8 为 550D）

  • 后 4 或 12 字节：时间戳 + 源码大小（可选）

  • 剩余部分：marshal 序列化后的 code object

逆向的核心就是：获取 .pyc → 反编译为近似源码或直接分析字节码

实战案例

pydis2ctf（Python 反汇编）

C1cipher.txt 里面核心反汇编是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
LOAD_CONST               1 ('')
STORE_FAST               1 (ret_text)

FOR_ITER
STORE_FAST               2 (i)

LOAD_FAST                1 (ret_text)
LOAD_GLOBAL              2 (chr)
LOAD_CONST               2 (2)
LOAD_GLOBAL              3 (ord)
LOAD_FAST                2 (i)
CALL_FUNCTION            1
BINARY_MULTIPLY
LOAD_GLOBAL              4 (len)
LOAD_FAST                0 (text)
CALL_FUNCTION            1
BINARY_SUBTRACT
CALL_FUNCTION            1
INPLACE_ADD
STORE_FAST               1 (ret_text)

翻译成看的 Python 代码就是

1
2
3
4
5
6
def C1(text):
    ret_text = ""
    for i in list(text):
        counter = text.count(i)  # 这个变量其实没用
        ret_text += chr(2 * ord(i) - len(text))
    return ret_text

所以 C1 的加密公式是

1
cipher_char = chr(2 * ord(plain_char) - len(text))

反过来就是

1
plain_char = chr((ord(cipher_char) + len(text)) / 2)

C2cipher.txt 还原出来是

1
2
3
4
5
6
7
8
9
10
11
12
def C2(inpString):
    xorKey = "S"
    length = len(inpString)

    for i in range(length):
        inpString = (
            inpString[:i]
            + chr(ord(inpString[i]) ^ ord(xorKey))
            + inpString[i + 1:]
        )

    return inpString

也就是每个字符和 'S' 异或

但是实际解题时，对 encodedflag.txt 直接反 C1 就能得到 flag；C2 更像是干扰项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import ast

with open("encodedflag.txt", "r", encoding="utf-8") as f:
    data = f.read().strip()

cipher = ast.literal_eval(data)

n = len(cipher)

flag = ""
for c in cipher:
    v = ord(c) + n

    # 正常情况下 v 应该能被 2 整除
    if v % 2 != 0:
        print("[-] Invalid character:", repr(c))

    flag += chr(v // 2)

print(flag)

得到 flag：csictf{T#a+_wA5_g0oD_d155aSe^^bLy}

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

最好的语言（Python 字节码）

pasted_1784357937528_0wa08t.png

下载附加识别字符串发现是 Python2 字节码文件

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
su2es2@Suc2es2:/mnt/d/CTF/213_79e9610e96eb501c77b8d1cae8536dfcc64f58c0/最好的语言$ strings re
magic 03f30d0a
moddate 6d4a695b (Tue Aug  7 15:29:49 2018)
<code>
   <argcount> 0 </argcount>
   <nlocals> 0</nlocals>
   <stacksize> 5</stacksize>
   <flags> 0040</flags>
   <code>
      6400006401006c00005a00006400006402006c01006d02005a0200016400
      006401006c03005a03006400006401006c04005a04006403005a05006404
      008400005a06006405008400005a07006506006505006406002083010065
      070065050064060064070021830100176506006505006407001f83010017
      5a08006500006a090065080083010047486408005a080064010053
   </code>
   <names> ('base64', 'hashlib', 'md5', 'random', 'string', 'f', '_', '____', 'e', 'b64encode')</names>
   <varnames> ()</varnames>
   <freevars> ()</freevars>
   <cellvars> ()</cellvars>
   <filename> 're2.py'</filename>
   <name> '<module>'</name>
   <firstlineno> 1</firstlineno>
   <consts>
      -1
      None
      ('md5',)
      'flag{*******}'
      <code>
         <argcount> 1 </argcount>
         <nlocals> 4</nlocals>
         <stacksize> 8</stacksize>
         <flags> 0043</flags>
         <code>
            6401006a00007401006a02007403006a04006402008302008301007d0100
            6401007d02007846007405007406007c0000830100830100445d32007d03
            007c02007407007408007c00007c0300198301007408007c01007c030064
            0200161983010041830100377d0200713700577c020053
         </code>
         <names> ('join', 'random', 'sample', 'string', 'digits', 'range', 'len', 'chr', 'ord')</names>
         <varnames> ('b', '__', '___', 'i')</varnames>
         <freevars> ()</freevars>
         <cellvars> ()</cellvars>
         <filename> 're2.py'</filename>
         <name> '_'</name>
         <firstlineno> 7</firstlineno>
         <consts>
            None
            ''
            4
         </consts>
         <lnotab> 00011e01060119013001</lnotab>
      </code>
      <code>
         <argcount> 1 </argcount>
         <nlocals> 2</nlocals>
         <stacksize> 2</stacksize>
         <flags> 0043</flags>
         <code>
            7400008300007d01007c01006a01007c0000830100017c01006a02008300
            0053
         </code>
         <names> ('md5', 'update', 'digest')</names>
         <varnames> ('a', '___')</varnames>
         <freevars> ()</freevars>
         <cellvars> ()</cellvars>
         <filename> 're2.py'</filename>
         <name> '____'</name>
         <firstlineno> 14</firstlineno>
         <consts>
            None
         </consts>
         <lnotab> 000109010d01</lnotab>
      </code>
      12
      19
      'U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU='
   </consts>
   <lnotab> 0c0110010c010c020601090709052f010e01</lnotab>
</code>

根据字节码还原脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import base64
from hashlib import md5
import random
import string

f = 'flag{*******}'

def _(b):
    key = ''.join(random.sample(string.digits, 4))
    res = ''
    for i in range(len(b)):
        res += chr(ord(b[i]) ^ ord(key[i % 4]))
    return res

def ____(a):
    m = md5()
    m.update(a)
    return m.digest()

e = _(f[:12]) + ____(f[12:19]) + _(f[19:])
print base64.b64encode(e)

e = 'U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU='

程序把 flag 分成三段

1
2
3
4
5
6
7
f[:12]
f[12:19]
f[19:]

第 1 段：前 12 字符
第 2 段：第 12 到 18 位，共 7 字符
第 3 段：第 19 位到结尾

加密方式为

1
e = _(f[:12]) + ____(f[12:19]) + _(f[19:])

其中 _() 是 XOR 加密

key 是 4 位互不重复的数字

1
key = ''.join(random.sample(string.digits, 4))

然后循环异或

1
cipher[i] = plain[i] ^ key[i % 4]

而 ____() 是 MD5

1
md5(flag[12:19]).digest()

所以密文结构为

1
2
3
4
5
Base64(
    XOR(flag[:12], 4位数字key1)
  + MD5(flag[12:19])
  + XOR(flag[19:], 4位数字key2)
)

先解码目标字符串结果长度为 38

因为中间 MD5 digest 固定是 16 字节，所以可以切成

1
2
3
c1 = data[:12]
h  = data[12:28]
c3 = data[28:]

分别是

1
2
3
c1 长度：12
h  长度：16
c3 长度：10

这说明原始 flag 长度为 12 + 7 + 10 = 29

第一段是 XOR(flag[:12], key1)，而 flag 开头固定为 flag{，密文是 535550534e6948776a08426b

计算

1
2
3
4
5
key[0] = c1[0] ^ ord('f')
key[1] = c1[1] ^ ord('l')
key[2] = c1[2] ^ ord('a')
key[3] = c1[3] ^ ord('g')
key[0] = c1[4] ^ ord('{')

得到结果 59145，第 5 位再次得到 5，说明 key 是循环的四位随机数

解密第一段密文得到 flag{PyC_1s_

爆破第二段密文 MD5 得到 613u21i

最后第三段密文的 Key 可以直接爆破，因为最后一位一定是 }

密钥是 4813，最后得到 _N0t_Hard}

所以 flag 就是 flag{PyC_1s_613u21i_N0t_Hard}

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
import base64
import itertools
import string

# Base64 编码的密文，内部结构为：加密前缀(12字节) + MD5哈希(16字节) + 加密后缀
target = "U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU="
data = base64.b64decode(target)

# 拆分三段
c1 = data[:12]       # 前12字节：flag 前缀部分的密文
md5_part = data[12:28]  # 中间16字节：flag 中间部分的 MD5 哈希
c3 = data[28:]        # 剩余字节：flag 后缀部分的密文

def xor(c, k):
    """循环异或解密：c 为密文字节串，k 为密钥字符串"""
    kb = k.encode()
    return bytes(c[i] ^ kb[i % len(kb)] for i in range(len(c)))

# ---------- 第一部分：恢复 flag 前缀 ----------
# 已知 flag 以 "flag{" 开头，与密文前5字节异或得到密钥流
# 题目使用的异或密钥长度为 4，因此取密钥流前 0 4字节作为 key1
key1 = bytes(c1[i] ^ b"flag{"[i] for i in range(5))[:4].decode()
part1 = xor(c1, key1).decode()   # 解密出完整的第一部分

# ---------- 第二部分：中间字符串 ----------
middle = "613u21i"

# ---------- 第三部分：爆破后缀 ----------
charset = string.ascii_letters + string.digits + "_{}"  # 合法字符集
# 密钥是4位不重复的数字，对 0-9 的所有排列进行尝试
for digits in itertools.permutations(string.digits, 4):
    k = ''.join(digits)
    try:
        text = xor(c3, k).decode()
        # 检查解密结果是否符合 flag 后缀的特征
        if text.startswith("_") and text.endswith("}") and all(c in charset for c in text):
            part3 = text
            break
    except UnicodeDecodeError:
        continue

# 拼接得到完整 flag
flag = part1 + middle + part3

signin（Python 反编译 + .pyz 恢复 + 线性变换）

pasted_1784919043337_dxfgmw.png

提出可识别字符串发现是有 Python 写出来的

1
2
3
4
main
mydata
signin
PYZ-00.pyz

使用 pyinstxtractor.py 反编译出 .pyc 文件

pasted_1785419964564_3z2wl0.png

main.pyc 反编译如下：

  • AccountChecker.__init__ 释放 tmp.dll，加载 DLL 并获取 enc 函数

  • self.accounts 仅存一个用户：b'SCTFer'，对应一个 Base64 解码后的 33 字节密文

  • check 比较 buffer 与预设密文，相等即返回 True，界面显示 Succeeded! Flag is your password

从 tmp.dll 的导出表可以看到只有一个导出函数 enc

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
int enc(char *username, char *password, char *out, int out_len)
{
    // 如果密码长度（不含结尾 \0）已经大于输出缓冲区的长度，直接返回 1 表示失败
    int pwd_len = strlen(password);
    int user_len = strlen(username);

    if (pwd_len > out_len)
        return 1;

    // 将 password 字符串从当前长度开始，用 0（即 \0）填充，直到长度为 32 字节
    while (pwd_len < 32) {
        password[pwd_len] = 0;
        pwd_len++;
    }

    // 将密码的 32 字节视为 4 个 64 位无符号整数
    // 每个 8 字节块调用 transform(block) 进行变换，变换后的结果依次写入 out 的前 32 字节
    for (int i = 0; i < 4; i++) {
        uint64_t block = *(uint64_t *)(password + i * 8);
        block = transform(block);
        *(uint64_t *)(out + i * 8) = block;
    }

    // 将上一步得到的 out 中 32 字节，每个字节与用户名对应位置的字节异或
    for (int i = 0; i < 32; i++) {
        out[i] ^= username[i % user_len];
    }

    // 在 out 的第 33 字节（索引 32）写入一个空字符 \0，使其成为一个可打印的 C 字符串
    out[32] = 0;
    return 0;
}

其中 transform() 是 64 轮类似 LFSR 的变换

1
2
3
4
5
6
7
8
9
10
11
12
13
uint64_t transform(uint64_t x)
{
    for (int i = 0; i < 64; i++) {
        // 每次循环检查 x 的最高位（第 63 位）
        if (x & 0x8000000000000000)
            // 若最高位为 1，左移 1 位后再与常数 0xb0004b7679fa26b3 异或
            x = (x << 1) ^ 0xb0004b7679fa26b3;
        else
            // 若最高位为 0，只左移 1 位
            x <<= 1;
    }
    return x;
}

由于这是 GF(2) 上的线性变换，可以对 64 位块求逆

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

# 64 位掩码，用于模拟 C 语言中的 uint64_t 溢出
# Python 的整数不会自然溢出，所以每次左移后都需要 & MASK
MASK = (1 << 64) - 1

# DLL 中 transform 函数使用的异或常量
# 当最高位为 1 时，左移后会异或该多项式常量
POLY = 0xb0004b7679fa26b3

# Python 主程序中写死的用户名
# 后续加密结果会与 username 循环异或
username = b"SCTFer"

# Python 主程序中写死的目标密文：
# b64decode("PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA")
#
# 解码后长度为 33 字节：
#   前 32 字节是真正的密文
#   最后 1 字节是 \x00 字符串结束符
cipher = base64.b64decode(
    b"PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA"
)[:32]


def transform(x):
    """
    还原 DLL 中的核心加密变换。

    输入：
        x: 一个 64 位整数，对应 password 的 8 字节小端块

    输出：
        经过 64 轮线性变换后的 64 位整数

    DLL 逻辑大致如下：

        for i in range(64):
            if x & 0x8000000000000000:
                x = (x << 1) ^ 0xb0004b7679fa26b3
            else:
                x <<= 1

    该操作本质上是 GF(2) 上的线性变换，类似 LFSR
    """
    for _ in range(64):
        # 判断最高位 bit63 是否为 1
        if x & (1 << 63):
            # 左移一位，模拟 uint64_t 溢出，然后异或 POLY
            x = ((x << 1) & MASK) ^ POLY
        else:
            # 最高位不是 1 时，只左移一位
            x = (x << 1) & MASK

    return x


def build_inverse():
    """
    构造 transform 的逆矩阵。

    因为 transform 是 64 位到 64 位的线性变换：

        y = transform(x)

    所以可以把它看成一个 64x64 的二进制矩阵 M：

        y = M * x

    只要矩阵 M 可逆，就可以求出：

        x = M^-1 * y

    构造方法：

    1. 依次计算 transform(1 << i)
       这相当于得到矩阵 M 的第 i 列

    2. 把列形式转换为行形式

    3. 对增广矩阵 [M | I] 做高斯消元

    4. 消元结束后得到 [I | M^-1]
    """

    # cols[i] 表示矩阵 M 的第 i 列
    # 因为输入只有第 i 位为 1，其输出就是第 i 个基向量经过变换后的结果
    cols = [transform(1 << i) for i in range(64)]

    rows = []

    # 将列表示转换为行表示
    for r in range(64):
        row = 0

        # 检查每一列在第 r 行是否为 1
        for c, col in enumerate(cols):
            if (col >> r) & 1:
                row |= 1 << c

        # 构造增广矩阵 [M | I]
        #
        # 低 64 位：原矩阵 M 的一行
        # 高 64 位：单位矩阵 I 的一行
        row |= 1 << (64 + r)

        rows.append(row)

    # 对 64x128 的增广矩阵做 GF(2) 高斯消元
    for c in range(64):
        pivot = None

        # 从当前行往下找一个第 c 列为 1 的主元行
        for r in range(c, 64):
            if (rows[r] >> c) & 1:
                pivot = r
                break

        # 如果找不到主元，说明矩阵不可逆
        # 本题中 transform 是可逆的，所以不会触发
        if pivot is None:
            raise RuntimeError("matrix is singular")

        # 把主元行交换到当前第 c 行
        rows[c], rows[pivot] = rows[pivot], rows[c]

        # 消去其他所有行的第 c 列
        #
        # GF(2) 中：
        #   加法等价于异或
        #   减法也等价于异或
        for r in range(64):
            if r != c and ((rows[r] >> c) & 1):
                rows[r] ^= rows[c]

    # 消元完成后：
    #   低 64 位应该是单位矩阵 I
    #   高 64 位就是逆矩阵 M^-1
    inv_rows = [(rows[i] >> 64) & MASK for i in range(64)]

    return inv_rows


# 预先计算 transform 的逆矩阵
INV_ROWS = build_inverse()


def inv_transform(y):
    """
    使用逆矩阵计算 transform 的逆运算

    输入：
        y = transform(x)

    输出：
        原始 x

    这里 INV_ROWS[i] 表示逆矩阵的第 i 行
    对 y 和该行做按位与后，统计 1 的个数
    如果 1 的个数为奇数，则结果第 i 位为 1；
    如果为偶数，则结果第 i 位为 0

    这就是 GF(2) 矩阵乘法
    """
    x = 0

    for i, row in enumerate(INV_ROWS):
        # 计算逆矩阵第 i 行和 y 的点积
        #
        # 在 GF(2) 中：
        #   点积结果 = 所有相与 bit 的异或和
        #   等价于 bit_count() 的奇偶性
        if (row & y).bit_count() & 1:
            x |= 1 << i

    return x


# ============================================================
# 开始逆向还原密码
# ============================================================

# DLL 加密的最后一步是：
#
#   out[i] ^= username[i % len(username)]
#
# 所以解密时需要先把这一步异或回去。
#
# 由于 XOR 的自反性：
#
#   a ^ b ^ b = a
#
# 因此再次异或同样的 username 即可恢复 transform 后的中间值。
middle = bytes(
    c ^ username[i % len(username)]
    for i, c in enumerate(cipher)
)

# 用于拼接还原出的明文密码
plain = b""

# DLL 将 password 按 8 字节一组分成 4 个 uint64_t 小端整数
#
# password[0:8]   -> block 0
# password[8:16]  -> block 1
# password[16:24] -> block 2
# password[24:32] -> block 3
#
# 每个 block 独立经过 transform。
# 因此这里也按 8 字节一组分别逆变换。
for i in range(0, 32, 8):
    # 取出 8 字节密文块
    block = middle[i:i + 8]

    # DLL 中是 uint64_t 小端读取
    # 所以这里也要按 little-endian 转成整数
    y = int.from_bytes(block, "little")

    # 对 transform 求逆，得到原始 password 的 8 字节块
    x = inv_transform(y)

    # 再按 little-endian 转回字节
    plain += x.to_bytes(8, "little")

# DLL 会把不足 32 字节的密码用 \x00 补齐
# 所以最终去掉末尾的 \x00 即可得到真正密码
flag = plain.rstrip(b"\x00").decode()

print(flag)

最后得到 flag：SCTF{We1c0m3_To_Sctf_2020_re_!!}