Day-120-API 安全

# Day 117: API 安全

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

---

## 清单 目录

1. [API 安全概述](#api 安全概述)
2. [API 认证安全](#api 认证安全)
3. [API 授权安全](#api 授权安全)
4. [API 输入验证](#api 输入验证)
5. [API 速率限制](#api 速率限制)
6. [API 网关安全](#api 网关安全)
7. [API 监控安全](#api 监控安全)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## API 安全概述

### 为什么需要 API 安全

> ▎ API 是现代应用的核心。核心不安全，应用就不安全。

**API 安全重要性**：
```
1. 数据保护
   - 数据泄露防护
   - 数据完整性
   - 数据可用性

2. 访问控制
   - 身份验证
   - 授权控制
   - 访问审计

3. 攻击预防
   - API 攻击防护
   - 注入攻击防护
   - DDoS 防护
```

**API 安全原则**：
```
1. 认证
   - 强认证
   - 多因素认证
   - 令牌管理

2. 授权
   - 最小权限
   - 细粒度授权
   - 动态授权

3. 防护
   - 输入验证
   - 输出编码
   - 速率限制
```

### API 安全威胁

**API 安全威胁**：
```
1. OWASP API Top 10
   - API1: 对象级别授权失效
   - API2: 用户认证失效
   - API3: 过多数据暴露
   - API4: 资源限制缺失
   - API5: 对象级别授权失效
   - API6: 批量赋值
   - API7: 安全配置错误
   - API8: 注入攻击
   - API9: 资产管理不当
   - API10: 日志和监控不足

2. 常见攻击
   - SQL 注入
   - XSS 攻击
   - CSRF 攻击
   - 暴力破解
   - 会话劫持
```

---

## API 认证安全

### API 认证

> ▎ API 认证是 API 安全的第一道防线。防线不牢，API 就不安全。

**API 认证类型**：
```
1. API Key
   - 简单认证
   - 易于实现
   - 易于管理

2. OAuth 2.0
   - 授权框架
   - 令牌管理
   - 范围控制

3. JWT
   - 无状态认证
   - 自包含令牌
   - 签名验证

4. mTLS
   - 双向认证
   - 证书验证
   - 高安全性
```

### API Key 认证

**API Key 认证**：
```python
from functools import wraps
from flask import request, abort

def require_api_key(f):
    @wraps(f)
    def wrapped(*args, **kwargs):
        api_key = request.headers.get('X-API-Key')
        if not api_key or not is_valid_api_key(api_key):
            abort(401)
        return f(*args, **kwargs)
    return wrapped

# 使用示例
@app.route('/api/data')
@require_api_key
def get_data():
    return get_data_from_database()
```

### OAuth 2.0 认证

**OAuth 2.0 认证**：
```python
from authlib.integrations.flask_client import OAuth

oauth = OAuth(app)

oauth.register(
    'oauth_provider',
    client_id='client-id',
    client_secret='client-secret',
    server_metadata_url='https://provider/.well-known/openid-configuration',
    client_kwargs={
        'scope': 'openid email profile'
    }
)

@app.route('/login')
def login():
    redirect_uri = url_for('authorize', _external=True)
    return oauth.oauth_provider.authorize_redirect(redirect_uri)

@app.route('/authorize')
def authorize():
    token = oauth.oauth_provider.authorize_access_token()
    user = token.get('userinfo')
    # 处理用户信息
```

### JWT 认证

**JWT 认证**：
```python
import jwt
from functools import wraps
from flask import request, abort
from datetime import datetime, timedelta

def generate_jwt(user_id, secret_key):
    payload = {
        'user_id': user_id,
        'exp': datetime.utcnow() + timedelta(hours=1),
        'iat': datetime.utcnow()
    }
    return jwt.encode(payload, secret_key, algorithm='HS256')

def verify_jwt(token, secret_key):
    try:
        payload = jwt.decode(token, secret_key, algorithms=['HS256'])
        return payload
    except jwt.ExpiredSignatureError:
        return None
    except jwt.InvalidTokenError:
        return None

def require_jwt(f):
    @wraps(f)
    def wrapped(*args, **kwargs):
        token = request.headers.get('Authorization')
        if not token:
            abort(401)
        
        # 移除 Bearer 前缀
        if token.startswith('Bearer '):
            token = token[7:]
        
        payload = verify_jwt(token, app.config['SECRET_KEY'])
        if not payload:
            abort(401)
        
        request.current_user = payload
        return f(*args, **kwargs)
    return wrapped

# 使用示例
@app.route('/api/profile')
@require_jwt
def get_profile():
    return get_user_profile(request.current_user['user_id'])
```

---

## API 授权安全

### API 授权

> ▎ API 授权是 API 安全的核心。授权不严格，API 就不安全。

**API 授权类型**：
```
1. RBAC
   - 基于角色
   - 角色权限
   - 角色继承

2. ABAC
   - 基于属性
   - 动态策略
   - 动态授权

3. ReBAC
   - 基于关系
   - 关系权限
   - 关系继承
```

### RBAC 授权

**RBAC 授权**：
```python
from functools import wraps
from flask import abort

def require_role(role):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            if not current_user.has_role(role):
                abort(403)
            return f(*args, **kwargs)
        return wrapped
    return decorator

# 使用示例
@app.route('/api/admin')
@require_role('admin')
def admin_api():
    return get_admin_data()
```

### ABAC 授权

**ABAC 授权**：
```python
from functools import wraps
from flask import abort

def require_attributes(**required_attrs):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            for attr, value in required_attrs.items():
                if not current_user.has_attribute(attr, value):
                    abort(403)
            return f(*args, **kwargs)
        return wrapped
    return decorator

# 使用示例
@app.route('/api/sensitive')
@require_attributes(department='engineering', level='senior')
def sensitive_api():
    return get_sensitive_data()
```

---

## API 输入验证

### API 输入验证

> ▎ API 输入验证是 API 安全的基础。基础不验证，API 就不安全。

**输入验证**：
```python
from marshmallow import Schema, fields, validate, ValidationError

class APISchema(Schema):
    username = fields.Str(
        required=True,
        validate=[
            validate.Length(min=3, max=50),
            validate.Regexp(r'^[a-zA-Z0-9_]+$')
        ]
    )
    
    email = fields.Email(
        required=True,
        validate=validate.Length(max=100)
    )
    
    age = fields.Int(
        required=True,
        validate=validate.Range(min=0, max=150)
    )

# 使用示例
@app.route('/api/users', methods=['POST'])
def create_user():
    schema = APISchema()
    try:
        data = schema.load(request.json)
        create_user_in_database(data)
        return {'status': 'success'}, 201
    except ValidationError as e:
        return {'errors': e.messages}, 400
```

### 输入验证规则

**输入验证规则**：
```
1. 类型检查
   - 字符串
   - 整数
   - 浮点数
   - 布尔值

2. 长度限制
   - 最小长度
   - 最大长度
   - 固定长度

3. 格式验证
   - 正则表达式
   - 格式规范
   - 结构验证

4. 范围验证
   - 最小值
   - 最大值
   - 范围限制
```

---

## API 速率限制

### API 速率限制

> ▎ API 速率限制是 API 防护的重要手段。不限流，API 就被滥用。

**速率限制**：
```python
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app=app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route('/api/heavy')
@limiter.limit("1 per minute")
def heavy_task():
    return "Done"
```

### 速率限制策略

**速率限制策略**：
```
1. 全局限制
   - 所有请求
   - 统一限制
   - 简单实现

2. 用户限制
   - 每用户限制
   - 差异化限制
   - 灵活控制

3. IP 限制
   - 每 IP 限制
   - 防止滥用
   - 防止 DDoS

4. 端点限制
   - 重要端点
   - 严格限制
   - 重点防护
```

---

## API 网关安全

### API 网关

> ▎ API 网关是 API 安全的门户。门户不安全，API 就不安全。

**API 网关功能**：
```
1. 认证
   - API Key
   - OAuth 2.0
   - JWT

2. 授权
   - RBAC
   - ABAC
   - 权限验证

3. 限流
   - 速率限制
   - 配额管理
   - 熔断

4. 监控
   - 请求日志
   - 性能监控
   - 异常检测
```

### API 网关实现

**API 网关实现**：
```yaml
# Kong 配置
services:
  - name: api-service
    url: http://backend:8080
    routes:
      - name: api-route
        paths:
          - /api
        plugins:
          - name: jwt
          - name: rate-limiting
            config:
              minute: 100
          - name: cors
```

---

## API 监控安全

### API 监控

> ▎ API 监控是 API 安全的重要手段。不监控，API 就失控。

**API 监控**：
```
1. 请求监控
   - 请求量
   - 请求类型
   - 请求来源

2. 性能监控
   - 响应时间
   - 吞吐量
   - 错误率

3. 安全监控
   - 认证失败
   - 授权失败
   - 异常请求
```

### API 监控实现

**API 监控实现**：
```python
from flask import request, g
from datetime import datetime
import logging

logger = logging.getLogger('api')

@app.before_request
def log_request():
    g.start_time = datetime.utcnow()
    logger.info(f"Request: {request.method} {request.path}")

@app.after_request
def log_response(response):
    duration = (datetime.utcnow() - g.start_time).total_seconds()
    logger.info(f"Response: {response.status} {duration}s")
    return response

@app.after_request
def log_error(response):
    if response.status_code >= 400:
        logger.error(f"Error: {response.status} {request.path}")
    return response
```

---

## 实战案例分析

### 案例 1: API 未授权访问

**漏洞代码**：
```python
# 不安全 API
@app.route('/api/users/<user_id>')
def get_user(user_id):
    user = get_user_by_id(user_id)
    # 没有检查当前用户是否有权访问
    return jsonify(user.to_dict())

# 攻击
# GET /api/users/123
# 访问其他用户数据
```

**安全代码**：
```python
@app.route('/api/users/<user_id>')
@require_jwt
def get_user(user_id):
    user = get_user_by_id(user_id)
    
    # 水平越权检查
    if user.id != request.current_user['user_id'] and not is_admin(request.current_user['user_id']):
        abort(403)
    
    return jsonify(user.to_dict())
```

### 案例 2: API 未限流

**漏洞代码**：
```python
# 不安全 API
@app.route('/api/heavy')
def heavy_task():
    # 没有限流
    # 可以被滥用
    return do_heavy_task()

# 攻击
# 频繁调用
# 耗尽资源
```

**安全代码**：
```python
@app.route('/api/heavy')
@limiter.limit("1 per minute")
def heavy_task():
    return do_heavy_task()
```

---

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

---

## 总结与思考

### 核心要点回顾

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

**API 认证**：
```
1. API Key
   - 简单认证
   - 易于实现
   - 易于管理

2. OAuth 2.0
   - 授权框架
   - 令牌管理
   - 范围控制

3. JWT
   - 无状态认证
   - 自包含令牌
   - 签名验证
```

**API 授权**：
```
1. RBAC
   - 基于角色
   - 角色权限
   - 角色继承

2. ABAC
   - 基于属性
   - 动态策略
   - 动态授权

3. 权限验证
   - 所有权检查
   - 权限检查
   - 访问控制
```

**API 防护**：
```
1. 输入验证
   - 类型检查
   - 长度限制
   - 格式验证

2. 速率限制
   - 全局限制
   - 用户限制
   - 端点限制

3. API 网关
   - 认证
   - 授权
   - 限流
```

### 深入思考问题

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

**零信任 API**：
```
1. 持续验证
   - 每次请求验证
   - 动态授权
   - 行为分析

2. 微隔离
   - 服务隔离
   - 网络隔离
   - 权限隔离

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

**自动化 API**：
```
1. 自动管理
   - 自动认证
   - 自动授权
   - 自动限流

2. 自动验证
   - 静态分析
   - 动态分析
   - 模糊测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

### 实战建议

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

**开发人员**：
```
1. API 实现
   - API 认证
   - API 授权
   - 输入验证

2. 框架使用
   - 使用框架 API
   - 自动管理
   - 自定义 API

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**安全人员**：
```
1. 安全审计
   - 代码审计
   - API 审计
   - 权限审计

2. 渗透测试
   - API 测试
   - 授权测试
   - 限流测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**架构师**：
```
1. API 架构
   - API 架构
   - 认证架构
   - 授权架构

2. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化

3. 工具链
   - API 工具
   - 管理工具
   - 监控工具
```

---

## 参考资料

### 学习资源
```
- OWASP API Security
  https://owasp.org/www-project-api-security/

- OWASP API Top 10
  https://owasp.org/www-project-api-top-10/

- OWASP API Security Cheat Sheet
  https://cheatsheetseries.owasp.org/cheatsheets/REST_Security_Cheat_Sheet.html
```

### 工具资源
```
- Kong
  https://konghq.com/

- Flask-Limiter
  https://flask-limiter.readthedocs.io/

- Authlib
  https://authlib.org/
```

### 书籍推荐
```
- 《API 安全技术》
- 《API Security》
- 《Secure API Design》
```

### 在线资源
```
- OWASP API Security
  https://owasp.org/www-project-api-security/

- OWASP API Top 10
  https://owasp.org/www-project-api-top-10/

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

---

**标记 明日预告**：Day 118 - 微服务安全

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

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

---

*本文是 365 天信息安全技术系列的第 117 篇，应用安全部分第 10 篇，精编版本*