Day-067-API 安全进阶

# Day 65: API 安全进阶

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

---

## 清单 目录

1. [API 安全进阶概述](#api 安全进阶概述)
2. [GraphQL 安全深入](#graphql 安全深入)
3. [gRPC 安全](#grpc 安全)
4. [WebSocket 安全](#websocket 安全)
5. [REST API 高级漏洞](#rest-api 高级漏洞)
6. [API 认证进阶](#api 认证进阶)
7. [API 速率限制绕过](#api 速率限制绕过)
8. [API 安全防护进阶](#api 安全防护进阶)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## API 安全进阶概述

### API 演进趋势

**传统 API**：
```
REST API:
- 资源导向
- HTTP 方法
- 状态码
- JSON/XML 格式

SOAP API:
- XML 格式
- WSDL 描述
- 严格规范
- 企业级使用
```

**现代 API**：
```
GraphQL:
- 查询语言
- 单一端点
- 客户端定义
- 灵活查询

gRPC:
- Protocol Buffers
- HTTP/2
- 双向流
- 高性能

WebSocket:
- 持久连接
- 双向通信
- 实时推送
- 低延迟
```

### API 安全挑战

**新攻击面**：
```
GraphQL:
- 深度查询攻击
- 批量查询攻击
- 内省查询泄露
- 注入攻击

gRPC:
- 协议理解困难
- 工具支持不足
- 认证授权复杂
- 流量加密

WebSocket:
- 连接劫持
- 消息注入
- 状态管理
- 重放攻击
```

**防护挑战**：
```
1. 传统 WAF 限制
   - 不理解新协议
   - 无法深度检查
   - 误报率高

2. 监控困难
   - 加密流量
   - 二进制协议
   - 动态查询

3. 速率限制复杂
   - 查询复杂度
   - 批量操作
   - 资源消耗
```

---

## GraphQL 安全深入

### GraphQL 基础

**什么是 GraphQL**：
```
GraphQL 是 Facebook 开发的查询语言和运行时。

特点：
- 单一端点（通常是 /graphql）
- 客户端定义数据结构
- 强类型系统
- 内省查询
- 实时订阅
```

**基本查询**：
```graphql
# 查询用户信息
query {
  user(id: "123") {
    name
    email
    posts {
      title
      content
    }
  }
}

# 响应
{
  "data": {
    "user": {
      "name": "John",
      "email": "john@example.com",
      "posts": [
        {
          "title": "Post 1",
          "content": "..."
        }
      ]
    }
  }
}
```

**变异操作**：
```graphql
# 创建用户
mutation {
  createUser(input: {
    name: "John"
    email: "john@example.com"
  }) {
    id
    name
    email
  }
}
```

### GraphQL 漏洞

**内省查询风险**：
```graphql
# 内省查询
{
  __schema {
    types {
      name
      description
      fields {
        name
        description
        type {
          name
          kind
        }
      }
    }
  }
}

# 风险：
# - 暴露完整 API 结构
# - 帮助攻击者了解 API
# - 敏感字段暴露
```

**深度查询攻击**：
```graphql
# 恶意深度查询
{
  user(id: "1") {
    friends {
      friends {
        friends {
          friends {
            # ... 20 层
          }
        }
      }
    }
  }
}

# 影响：
# - 指数级资源消耗
# - 数据库查询爆炸
# - 服务不可用
```

**批量查询攻击**：
```graphql
# 批量查询
[
  { "query": "{ user(id: 1) { name } }" },
  { "query": "{ user(id: 2) { name } }" },
  # ... 1000 次
]

# 影响：
# - 绕过速率限制
# - 资源耗尽
# - 数据爬取
```

**注入攻击**：
```graphql
# SQL 注入
{
  user(id: "1 OR 1=1 --") {
    name
    email
  }
}

# NoSQL 注入
{
  user(filter: {id: {$gt: 0}}) {
    name
  }
}

# 命令注入
{
  execute(command: "ls -la; cat /etc/passwd") {
    output
  }
}
```

### GraphQL 防护

**查询深度限制**：
```javascript
// Apollo Server 配置
const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(5)]
});

// 自定义深度限制
function depthLimit(maxDepth) {
  return function(context) {
    return {
      Field(node, key, parent, path, ancestors) {
        if (path.length > maxDepth) {
          context.reportError(
            new GraphQLError(`Query depth ${path.length} exceeds maximum ${maxDepth}`)
          );
        }
      }
    };
  };
}
```

**查询复杂度限制**：
```javascript
// 定义字段复杂度
const typeDefs = gql`
  type Query {
    user(id: ID!): User @complexity(value: 1)
    posts(limit: Int!): [Post] @complexity(multiplier: "limit")
  }
`;

// 配置复杂度限制
const server = new ApolloServer({
  typeDefs,
  resolvers,
  introspection: false,  // 生产环境禁用内省
  formatError: (error) => {
    // 隐藏详细错误
    return { message: 'Internal server error' };
  }
});
```

**速率限制**：
```javascript
// 基于查询复杂度
const costAnalysis = {
  maximumCost: 1000,
  defaultCost: 1,
  variables: {},
  createError: (max, actual) => {
    return new Error(`Query cost ${actual} exceeds maximum ${max}`);
  }
};

// 批量查询限制
const batchLimit = {
  maxBatchSize: 10,
  createError: (max, actual) => {
    return new Error(`Batch size ${actual} exceeds maximum ${max}`);
  }
};
```

---

## gRPC 安全

### gRPC 基础

**什么是 gRPC**：
```
gRPC 是 Google 开发的高性能 RPC 框架。

特点：
- Protocol Buffers 序列化
- HTTP/2 传输
- 双向流
- 多语言支持
- 内置认证
```

**服务定义**：
```protobuf
// service.proto
syntax = "proto3";

service UserService {
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
  rpc StreamUsers(StreamUsersRequest) returns (stream User);
}

message GetUserRequest {
  string user_id = 1;
}

message GetUserResponse {
  User user = 1;
}

message User {
  string id = 1;
  string name = 2;
  string email = 3;
}
```

### gRPC 安全问题

**认证问题**：
```
1. 未启用 TLS
   - 明文传输
   - 凭证泄露
   - 中间人攻击

2. 认证缺失
   - 未实现认证
   - 认证绕过
   - 令牌验证缺失

3. 令牌管理
   - 令牌泄露
   - 令牌重用
   - 令牌过期
```

**授权问题**：
```
1. 方法级授权
   - 未检查权限
   - 越权访问
   - 权限提升

2. 消息级授权
   - 未验证字段
   - 字段篡改
   - 数据泄露

3. 流式授权
   - 流控制缺失
   - 资源耗尽
   - 未授权订阅
```

**注入攻击**：
```protobuf
// Protobuf 注入
message SearchRequest {
  string query = 1;
  // 如果直接拼接到 SQL
  // SELECT * FROM users WHERE name = 'query'
}

// 命令注入
message ExecuteRequest {
  string command = 1;
  // 如果直接执行
  // system(command)
}
```

### gRPC 防护

**TLS 配置**：
```javascript
// Node.js gRPC 服务器
const credentials = grpc.ServerCredentials.createSsl(
  fs.readFileSync('ca.pem'),
  [{
    cert_chain: fs.readFileSync('server.pem'),
    private_key: fs.readFileSync('server-key.pem')
  }],
  true  // 强制客户端认证
);

server.bindAsync('0.0.0.0:50051', credentials, () => {
  server.start();
});
```

**认证中间件**：
```javascript
// 认证拦截器
function authInterceptor(options, nextCall) {
  return new InterceptingCall(nextCall(options), {
    start: function(metadata, listener, next) {
      const token = metadata.get('authorization')[0];
      
      if (!token || !verifyToken(token)) {
        const error = {
          code: grpc.status.UNAUTHENTICATED,
          details: 'Invalid token'
        };
        listener.onReceiveStatus(error);
        return;
      }
      
      next(metadata, listener, next);
    }
  });
}

// 注册拦截器
server.addInterceptor(authInterceptor);
```

**授权检查**：
```javascript
// 方法级授权
async function getUser(call, callback) {
  const user = call.metadata.get('user')[0];
  
  if (!hasPermission(user, 'get_user')) {
    callback({
      code: grpc.status.PERMISSION_DENIED,
      details: 'No permission'
    });
    return;
  }
  
  // 执行操作
  const result = await db.getUser(call.request.userId);
  callback(null, result);
}
```

---

## WebSocket 安全

### WebSocket 基础

**什么是 WebSocket**：
```
WebSocket 是一种双向通信协议。

特点：
- 持久连接
- 双向通信
- 低延迟
- 实时推送
- 跨域支持
```

**连接建立**：
```javascript
// 客户端
const ws = new WebSocket('ws://example.com/socket');

ws.onopen = () => {
  console.log('Connected');
  ws.send(JSON.stringify({type: 'subscribe', channel: 'news'}));
};

ws.onmessage = (event) => {
  console.log('Received:', event.data);
};

ws.onerror = (error) => {
  console.error('Error:', error);
};

ws.onclose = () => {
  console.log('Disconnected');
};
```

### WebSocket 漏洞

**连接劫持**：
```
场景：
- WebSocket 未验证 Origin
- CSRF 攻击
- 跨站 WebSocket

利用：
1. 诱导用户访问恶意网站
2. 恶意网站建立 WebSocket 连接
3. 以用户身份执行操作

防护：
- 验证 Origin 头
- 使用 CSRF Token
- 认证检查
```

**消息注入**：
```javascript
// 服务端未验证消息
ws.on('message', function(data) {
  const msg = JSON.parse(data);
  
  // 直接使用用户输入
  db.query('SELECT * FROM users WHERE id = ' + msg.id);
  
  // 直接执行
  eval(msg.code);
});

// 防护
ws.on('message', function(data) {
  const msg = JSON.parse(data);
  
  // 验证输入
  if (!isValidId(msg.id)) {
    return;
  }
  
  // 参数化查询
  db.query('SELECT * FROM users WHERE id = ?', [msg.id]);
});
```

**状态管理问题**：
```
场景：
- 未验证连接状态
- 未授权消息
- 重放攻击

利用：
1. 重放旧消息
2. 未授权操作
3. 状态混乱

防护：
- 消息序列号
- 时间戳验证
- 状态检查
```

### WebSocket 防护

**Origin 验证**：
```javascript
const http = require('http');
const WebSocket = require('ws');

const server = http.createServer();
const wss = new WebSocket.Server({ server });

wss.on('connection', function connection(ws, req) {
  const origin = req.headers.origin;
  
  // 验证 Origin
  const allowedOrigins = ['https://example.com', 'https://app.example.com'];
  
  if (!allowedOrigins.includes(origin)) {
    ws.close(1008, 'Invalid origin');
    return;
  }
  
  // 继续处理连接
});
```

**消息验证**：
```javascript
// 消息 schema 验证
const Ajv = require('ajv');
const ajv = new Ajv();

const messageSchema = {
  type: 'object',
  properties: {
    type: {type: 'string'},
    data: {type: 'object'}
  },
  required: ['type', 'data']
};

const validate = ajv.compile(messageSchema);

ws.on('message', function(data) {
  const msg = JSON.parse(data);
  
  if (!validate(msg)) {
    ws.send(JSON.stringify({error: 'Invalid message'}));
    return;
  }
  
  // 处理有效消息
});
```

**认证授权**：
```javascript
// 连接时认证
wss.on('connection', function connection(ws, req) {
  const token = getCookie(req, 'token');
  
  if (!token || !verifyToken(token)) {
    ws.close(1008, 'Invalid token');
    return;
  }
  
  ws.user = decodeToken(token);
});

// 消息级授权
ws.on('message', function(data) {
  const msg = JSON.parse(data);
  
  if (!hasPermission(ws.user, msg.action)) {
    ws.send(JSON.stringify({error: 'No permission'}));
    return;
  }
  
  // 处理消息
});
```

---

## REST API 高级漏洞

### BOLA/IDOR 进阶

**复杂 IDOR**：
```
场景 1: UUID 预测
- 使用有序 UUID
- 时间戳 + 序列号
- 可预测生成

场景 2: 复合 ID
- 多个字段组合
- 部分可控
- 绕过检查

场景 3: 间接引用
- 映射表
- 别名引用
- 枚举攻击
```

**批量 IDOR**：
```http
# 批量获取资源
POST /api/users/bulk
{
  "ids": [1, 2, 3, 4, 5]
}

# 响应所有用户数据
# 即使无权访问
```

**防护**：
```javascript
// 使用随机 UUID
const { v4: uuidv4 } = require('uuid');
const id = uuidv4();

// 检查所有权
async function getUser(userId, currentUserId) {
  const user = await db.user.findUnique({
    where: { id: userId }
  });
  
  if (user.ownerId !== currentUserId) {
    throw new Error('No permission');
  }
  
  return user;
}

// 批量检查
async function getUsers(ids, currentUserId) {
  const users = await db.user.findMany({
    where: {
      id: { in: ids },
      ownerId: currentUserId  // 自动过滤
    }
  });
  
  return users;
}
```

### 批量赋值进阶

**嵌套对象**：
```javascript
// 更新用户
PATCH /api/users/123
{
  "profile": {
    "bio": "New bio",
    "role": "admin"  // 越权字段
  }
}
```

**数组操作**：
```javascript
// 批量更新
POST /api/users/bulk-update
{
  "updates": [
    {"id": 1, "role": "admin"},
    {"id": 2, "role": "admin"}
  ]
}
```

**防护**：
```javascript
// 白名单过滤
const allowedFields = ['name', 'email', 'bio'];
const updates = {};

for (const key of allowedFields) {
  if (req.body[key] !== undefined) {
    updates[key] = req.body[key];
  }
}

// 深度白名单
function filterObject(obj, allowed) {
  const result = {};
  
  for (const key of Object.keys(obj)) {
    if (allowed.includes(key)) {
      result[key] = obj[key];
    } else if (typeof obj[key] === 'object' && allowed[key]) {
      result[key] = filterObject(obj[key], allowed[key]);
    }
  }
  
  return result;
}
```

### 高级注入

**NoSQL 注入**：
```javascript
// MongoDB 查询
db.users.find({
  username: req.body.username,
  password: req.body.password
});

// 注入
{
  "username": {"$ne": null},
  "password": {"$ne": null}
}

// 防护
db.users.find({
  username: {$eq: req.body.username},
  password: {$eq: req.body.password}
});
```

**LDAP 注入**：
```javascript
// LDAP 查询
const filter = `(uid=${username})`;

// 注入
username = "*)(uid=*))(|(uid=*";

// 防护
const escaped = ldap.escapeFilter(username);
const filter = `(uid=${escaped})`;
```

**XPath 注入**：
```javascript
// XPath 查询
const query = `//user[@name='${username}']`;

// 注入
username = "' or '1'='1";

// 防护
const escaped = username.replace(/['&<>]/g, '');
const query = `//user[@name='${escaped}']`;
```

---

## API 认证进阶

### OAuth 2.0 进阶

**PKCE 流程**：
```
1. 客户端生成 code_verifier
2. 生成 code_challenge = SHA256(code_verifier)
3. 请求授权
   GET /authorize?
     response_type=code&
     code_challenge=xxx&
     code_challenge_method=S256
4. 换取 Token
   POST /token
   code_verifier=xxx
```

**客户端凭证**：
```
场景：
- 服务间通信
- 无用户上下文
- 机器对机器

流程：
1. 客户端认证
   POST /token
   grant_type=client_credentials
   client_id=xxx
   client_secret=xxx

2. 获取 Token
   {
     "access_token": "xxx",
     "token_type": "Bearer"
   }
```

**设备授权**：
```
场景：
- TV/游戏机
- 命令行工具
- IoT 设备

流程：
1. 请求设备码
   POST /device/code

2. 用户授权
   访问 verification_uri
   输入 user_code

3. 轮询 Token
   POST /token
   grant_type=urn:ietf:params:oauth:grant-type:device_code
```

### JWT 进阶

**令牌绑定**：
```
DPoP (Demonstration of Proof-of-Possession):
- 绑定密钥对
- 防止令牌重用
- 请求签名

mTLS:
- 客户端证书
- 双向认证
- 令牌绑定
```

**令牌轮换**：
```javascript
// 刷新令牌轮换
async function refreshToken(refreshToken) {
  // 验证刷新令牌
  const payload = verifyToken(refreshToken);
  
  // 使旧令牌失效
  await blacklistToken(refreshToken);
  
  // 生成新令牌
  const newAccessToken = generateAccessToken(payload);
  const newRefreshToken = generateRefreshToken(payload);
  
  return {
    access_token: newAccessToken,
    refresh_token: newRefreshToken
  };
}
```

**细粒度权限**：
```javascript
// JWT 包含权限
const token = jwt.sign({
  sub: userId,
  permissions: ['read:users', 'write:posts'],
  resources: ['user:123', 'post:456']
}, secret);

// 权限检查
function checkPermission(required, token) {
  const [action, resource] = required.split(':');
  
  return token.permissions.some(p => {
    const [pAction, pResource] = p.split(':');
    return pAction === action || pAction === '*';
  });
}
```

---

## API 速率限制绕过

### 绕过技术

**IP 轮换**：
```
方法：
- 代理池
- Tor 网络
- 云函数
- CDN 边缘

检测：
- IP 信誉
- 行为分析
- 指纹识别
```

**用户代理轮换**：
```javascript
// 轮换 User-Agent
const userAgents = [
  'Mozilla/5.0 ...',
  'curl/7.68.0',
  'PostmanRuntime/7.28.0'
];

headers['User-Agent'] = userAgents[Math.floor(Math.random() * userAgents.length)];
```

**参数变异**：
```http
# 原始请求
POST /api/transfer
amount=100

# 参数变异
POST /api/transfer
amount[0]=100
POST /api/transfer
amount[]=100
POST /api/transfer
{"amount":100}
```

### 防护进阶

**指纹识别**：
```javascript
// 设备指纹
function generateFingerprint(req) {
  const hash = crypto.createHash('sha256');
  
  hash.update(req.headers['user-agent']);
  hash.update(req.headers['accept-language']);
  hash.update(req.headers['accept-encoding']);
  hash.update(req.ip);
  
  return hash.digest('hex');
}

// 基于指纹限流
const fingerprint = generateFingerprint(req);
const count = await redis.incr(`rate_limit:${fingerprint}`);

if (count > 100) {
  throw new Error('Rate limit exceeded');
}
```

**行为分析**：
```javascript
// 异常检测
function detectAnomaly(requests) {
  // 请求频率
  const frequency = requests.length / timeWindow;
  
  // 请求模式
  const patterns = analyzePatterns(requests);
  
  // 异常评分
  const score = calculateScore(frequency, patterns);
  
  return score > threshold;
}

// 动态限流
if (detectAnomaly(requests)) {
  applyStrictLimit();
} else {
  applyNormalLimit();
}
```

**挑战响应**：
```javascript
// CAPTCHA 挑战
if (suspiciousActivity(req)) {
  return {
    challenge: generateCaptcha(),
    required: true
  };
}

// JavaScript 挑战
if (firstTimeUser(req)) {
  return {
    challenge: generateJsChallenge(),
    required: true
  };
}
```

---

## API 安全防护进阶

### API 网关安全

**认证卸载**：
```yaml
# Kong 配置
plugins:
  - name: jwt
    config:
      key_claim_name: iss
      secret_is_base64: false
      claims_to_verify:
        - exp
  
  - name: rate-limiting
    config:
      minute: 100
      policy: redis
  
  - name: cors
    config:
      origins:
        - https://example.com
      methods:
        - GET
        - POST
```

**请求验证**：
```yaml
# API Gateway 配置
request_validation:
  enabled: true
  schema:
    type: object
    properties:
      userId:
        type: string
        pattern: '^[a-f0-9]{32}$'
      action:
        type: string
        enum: ['create', 'update', 'delete']
```

**响应保护**：
```yaml
# 敏感数据脱敏
response_transformation:
  masks:
    - field: credit_card
      pattern: '.*'
      replacement: '****'
    - field: ssn
      pattern: '.*'
      replacement: '***-**-****'
```

### 零信任 API

**持续验证**：
```
原则：
- 从不信任，始终验证
- 最小权限
- 假设已沦陷

实施：
- 每次请求认证
- 动态授权
- 持续监控
```

**微隔离**：
```
API 分段：
- 按功能分段
- 按数据敏感度
- 按用户类型

网络策略：
- 服务间认证
- 流量加密
- 访问控制
```

**动态授权**：
```javascript
// 基于上下文的授权
async function authorize(request) {
  const context = {
    user: request.user,
    action: request.action,
    resource: request.resource,
    time: new Date(),
    location: request.ip,
    device: request.device
  };
  
  const decision = await policyEngine.evaluate(context);
  
  return decision.allowed;
}
```

---

## 总结与思考

### 核心要点回顾

1. **新协议安全**
   - GraphQL 深度/复杂度限制
   - gRPC 认证授权
   - WebSocket 连接验证

2. **高级漏洞**
   - 复杂 IDOR
   - 批量赋值
   - 高级注入

3. **防护进阶**
   - API 网关
   - 零信任
   - 行为分析

### 深入思考问题

1. **API 安全未来**？
   - AI 辅助检测
   - 自动化修复
   - 自适应防护

2. **量子计算影响**？
   - 加密算法
   - 签名算法
   - 密钥管理

3. **边缘计算安全**？
   - 边缘 API
   - 分布式认证
   - 延迟与安全平衡

### 实战建议

**API 开发人员**：
1. 安全设计
2. 输入验证
3. 认证授权
4. 速率限制

**安全人员**：
1. API 测试
2. 漏洞扫描
3. 监控告警
4. 事件响应

**架构师**：
1. API 网关
2. 零信任架构
3. 微隔离
4. 持续监控

---

## 参考资料

### 学习资源
- [OWASP API Security](https://owasp.org/www-project-api-security/)
- [GraphQL Security](https://graphql.org/learn/security/)
- [gRPC Security](https://grpc.io/docs/guides/security/)

### 工具资源
- [Postman](https://www.postman.com/)
- [Insomnia](https://insomnia.rest/)
- [GraphQL Playground](https://github.com/graphql/graphql-playground)

### 书籍推荐
- 《API 安全实战》
- 《Web API 设计与安全》
- 《API Security in Action》
- 《GraphQL Security》

### 在线资源
- [OWASP API Top 10](https://owasp.org/www-project-api-security/)
- [API Security Checklist](https://github.com/shieldfy/API-Security-Checklist)
- [Awesome API Security](https://github.com/arainho/awesome-api-security)

---

**标记 明日预告**：Day 66 - 服务端请求伪造（SSRF）深入

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

---

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