Day-049-API认证与授权安全

# Day 47: API 认证与授权安全

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

---

## 清单 目录

1. [API 认证基础](#api 认证基础)
2. [JWT 深度解析](#jwt 深度解析)
3. [OAuth 2.0 详解](#oauth-20 详解)
4. [API 密钥管理](#api 密钥管理)
5. [API 授权模型](#api 授权模型)
6. [认证漏洞分析](#认证漏洞分析)
7. [授权漏洞分析](#授权漏洞分析)
8. [实战攻防演练](#实战攻防演练)
9. [防护策略与最佳实践](#防护策略与最佳实践)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## API 认证基础

### 认证 vs 授权

**认证（Authentication）**：
```
验证"你是谁"的过程。

方法：
- 用户名密码
- API Key
- JWT Token
- OAuth Token
- 生物识别
```

**授权（Authorization）**：
```
验证"你能做什么"的过程。

模型：
- RBAC（基于角色）
- ABAC（基于属性）
- ReBAC（基于关系）
- PBAC（基于策略）
```

**关系**：
```
先认证 → 后授权

用户登录（认证）→ 获取 Token → 访问资源（授权）
```

### 认证方式对比

**Session 认证**：
```
流程：
1. 用户登录
2. 服务器创建 Session
3. 返回 Session ID
4. 客户端携带 Session ID
5. 服务器验证 Session

优点：
✓ 服务器控制
✓ 可随时撤销
✓ 状态管理

缺点：
✗ 服务器存储
✗ 扩展困难
✗ CSRF 风险
```

**Token 认证**：
```
流程：
1. 用户登录
2. 服务器生成 Token
3. 返回 Token
4. 客户端携带 Token
5. 服务器验证 Token

优点：
✓ 无状态
✓ 易于扩展
✓ 跨域支持

缺点：
✗ Token 泄露风险
✗ 撤销困难
✗ 大小较大
```

**API Key 认证**：
```
流程：
1. 申请 API Key
2. 服务器存储 Key
3. 客户端携带 Key
4. 服务器验证 Key

优点：
✓ 简单易用
✓ 长期有效
✓ 适合服务器间

缺点：
✗ 泄露风险高
✗ 无用户上下文
✗ 难以撤销
```

---

## JWT 深度解析

### JWT 结构

**Header（头部）**：
```json
{
  "alg": "HS256",
  "typ": "JWT"
}

字段说明：
alg - 签名算法
typ - 令牌类型
```

**Payload（负载）**：
```json
{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022,
  "exp": 1516242622,
  "iss": "api.example.com",
  "aud": "web.example.com"
}

标准声明：
iss - 签发者
sub - 主题
aud - 受众
exp - 过期时间
nbf - 生效时间
iat - 签发时间
jti - JWT ID
```

**Signature（签名）**：
```
HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

或使用 RSA：
RS256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  private_key
)
```

### JWT 生成与验证

**生成 JWT（Python）**：
```python
import jwt
import datetime

def generate_token(user_id, secret):
    payload = {
        'user_id': user_id,
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1),
        'iat': datetime.datetime.utcnow(),
        'iss': 'api.example.com'
    }
    
    token = jwt.encode(payload, secret, algorithm='HS256')
    return token
```

**验证 JWT（Python）**：
```python
import jwt

def verify_token(token, secret):
    try:
        payload = jwt.decode(
            token,
            secret,
            algorithms=['HS256'],
            issuer='api.example.com',
            audience='web.example.com'
        )
        return payload
    except jwt.ExpiredSignatureError:
        return None  # Token 过期
    except jwt.InvalidTokenError:
        return None  # Token 无效
```

### JWT 安全问题

**密钥泄露**：
```
问题：
- 密钥硬编码在代码中
- 密钥提交到 Git
- 密钥泄露给攻击者

后果：
- 可伪造任意 Token
- 可提升权限
- 可冒充用户

修复：
- 使用环境变量
- 密钥管理系统
- 定期轮换密钥
```

**算法混淆攻击**：
```
攻击方式：
1. 服务器支持 HS256 和 RS256
2. 攻击者修改 Header 为 HS256
3. 使用公钥作为 HMAC 密钥
4. 伪造 Token

修复：
- 明确指定算法
- 不接受算法切换
- 验证算法类型
```

**None 算法攻击**：
```
攻击方式：
1. 修改 Header 为 {"alg": "none"}
2. 删除 Signature
3. 服务器接受无签名 Token

修复：
- 明确拒绝 none 算法
- 验证签名存在
- 严格算法检查
```

**Token 泄露**：
```
泄露途径：
- URL 参数
- 日志文件
- Referer 头
- 本地存储

修复：
- 使用 Authorization Header
- 不记录 Token
- 使用 HttpOnly Cookie
- 实施 Token 轮换
```

### JWT 最佳实践

**短期 Token + Refresh Token**：
```python
# Access Token（短期）
access_payload = {
    'user_id': user_id,
    'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=15),
    'type': 'access'
}

# Refresh Token（长期）
refresh_payload = {
    'user_id': user_id,
    'exp': datetime.datetime.utcnow() + datetime.timedelta(days=7),
    'type': 'refresh'
}
```

**Token 轮换**：
```
1. 每次使用 Refresh Token 时
2. 生成新的 Access Token 和 Refresh Token
3. 使旧 Refresh Token 失效
4. 防止 Token 重用
```

**Token 撤销**：
```
1. 维护 Token 黑名单
2. 存储已撤销的 Token ID
3. 验证时检查黑名单
4. 设置合理的过期时间
```

---

## OAuth 2.0 详解

### OAuth 2.0 流程

**授权码模式**：
```
1. 用户点击"使用 Google 登录"
2. 重定向到授权服务器
   GET /authorize?response_type=code&client_id=xxx&redirect_uri=xxx
3. 用户授权
4. 重定向回客户端，带授权码
   GET /callback?code=AUTH_CODE
5. 客户端用授权码换取 Token
   POST /token
   {
     "grant_type": "authorization_code",
     "code": "AUTH_CODE",
     "client_id": "xxx",
     "client_secret": "xxx",
     "redirect_uri": "xxx"
   }
6. 返回 Access Token 和 Refresh Token
```

**隐式模式**：
```
1. 重定向到授权服务器
   GET /authorize?response_type=token&client_id=xxx
2. 用户授权
3. 直接返回 Token（无授权码）
   GET /callback#access_token=TOKEN

注意：
- 不安全，Token 暴露在 URL
- 已不推荐使用
```

**客户端凭证模式**：
```
1. 客户端直接请求 Token
   POST /token
   {
     "grant_type": "client_credentials",
     "client_id": "xxx",
     "client_secret": "xxx"
   }
2. 返回 Access Token

适用：
- 服务器间通信
- 无用户上下文
```

**密码模式**：
```
1. 客户端收集用户凭证
   POST /token
   {
     "grant_type": "password",
     "username": "user",
     "password": "pass",
     "client_id": "xxx",
     "client_secret": "xxx"
   }
2. 返回 Access Token

注意：
- 客户端需高度信任
- 已不推荐使用
```

### OAuth 2.0 安全问题

**重定向 URI 验证**：
```
问题：
- 未严格验证 redirect_uri
- 攻击者控制重定向地址
- 窃取授权码

攻击：
GET /authorize?redirect_uri=http://attacker.com/steal

修复：
- 白名单验证 redirect_uri
- 精确匹配
- 不允许子域名通配
```

**授权码泄露**：
```
问题：
- 授权码通过 URL 传递
- Referer 泄露
- 日志记录

攻击：
- 截获授权码
- 换取 Access Token

修复：
- 短期有效（10 分钟）
- 一次性使用
- PKCE 扩展
```

**PKCE（Proof Key for Code Exchange）**：
```
流程：
1. 客户端生成 code_verifier
2. 生成 code_challenge = SHA256(code_verifier)
3. 请求授权时发送 code_challenge
4. 换取 Token 时发送 code_verifier
5. 服务器验证 code_challenge 匹配

修复：
- 防止授权码拦截
- 移动端必备
- 推荐使用
```

**Token 泄露**：
```
问题：
- Token 长期有效
- 无刷新机制
- 泄露后持续风险

修复：
- 短期 Access Token
- 使用 Refresh Token
- Token 轮换
- 撤销机制
```

---

## API 密钥管理

### API Key 生成

**安全生成**：
```python
import secrets
import hashlib

def generate_api_key():
    # 生成随机密钥
    raw_key = secrets.token_urlsafe(32)
    
    # 生成前缀（便于识别）
    prefix = 'sk_'
    
    # 生成哈希（存储用）
    key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
    
    return f"{prefix}{raw_key}", key_hash
```

### API Key 存储

**安全存储**：
```python
# - 错误做法
# 明文存储 API Key

# + 正确做法
# 存储哈希值
stored_key = hashlib.sha256(api_key.encode()).hexdigest()

# 验证时
def verify_key(provided_key, stored_hash):
    provided_hash = hashlib.sha256(provided_key.encode()).hexdigest()
    return secrets.compare_digest(provided_hash, stored_hash)
```

### API Key 轮换

**轮换策略**：
```
1. 定期轮换（90 天）
2. 泄露时立即轮换
3. 员工离职时轮换
4. 审计时轮换
```

**轮换流程**：
```
1. 生成新 Key
2. 同时接受新旧 Key（过渡期）
3. 通知用户更新
4. 过渡期后禁用旧 Key
5. 删除旧 Key
```

---

## API 授权模型

### RBAC 实现

**角色定义**：
```python
roles = {
    'admin': {
        'permissions': ['read', 'write', 'delete', 'admin']
    },
    'user': {
        'permissions': ['read', 'write']
    },
    'guest': {
        'permissions': ['read']
    }
}
```

**权限检查**：
```python
def check_permission(user, action, resource=None):
    user_role = get_user_role(user)
    role_permissions = roles[user_role]['permissions']
    
    if action not in role_permissions:
        return False
    
    # 资源级别检查
    if resource and not has_resource_access(user, resource):
        return False
    
    return True
```

### ABAC 实现

**属性定义**：
```python
# 用户属性
user_attributes = {
    'id': 123,
    'department': 'engineering',
    'level': 'senior',
    'clearance': 'secret'
}

# 资源属性
resource_attributes = {
    'id': 456,
    'owner': 123,
    'department': 'engineering',
    'classification': 'internal'
}

# 环境属性
environment_attributes = {
    'time': '09:00',
    'location': 'office',
    'ip': '192.168.1.1'
}
```

**策略引擎**：
```python
def evaluate_policy(user, resource, action, environment):
    # 策略 1: 资源所有者可执行任何操作
    if user['id'] == resource['owner']:
        return True
    
    # 策略 2: 同部门可读取
    if action == 'read' and user['department'] == resource['department']:
        return True
    
    # 策略 3: 工作时间可访问
    if is_work_hours(environment['time']):
        if user['clearance'] >= resource['classification']:
            return True
    
    return False
```

---

## 认证漏洞分析

### JWT 漏洞

**弱密钥攻击**：
```
问题：
- 使用弱密钥（短、简单）
- 可暴力破解

工具：
jwt-crack
hashcat

修复：
- 使用强密钥（32+ 字符）
- 定期轮换
- 使用 RSA/ECDSA
```

**Token 注入**：
```
问题：
- Token 拼接 SQL
- Token 包含恶意数据

攻击：
{
  "user_id": "1 OR 1=1 --"
}

修复：
- Token 数据不直接信任
- 二次验证
- 参数化查询
```

### OAuth 漏洞

**CSRF 攻击**：
```
问题：
- OAuth 流程无 CSRF 保护
- 攻击者诱导用户授权

攻击：
1. 攻击者发起 OAuth 请求
2. 诱导用户点击
3. 用户授权攻击者账户
4. 攻击者获得用户数据

修复：
- 使用 state 参数
- 验证 state 匹配
- 绑定用户会话
```

**账户劫持**：
```
问题：
- 同一邮箱多账户
- OAuth 登录覆盖

攻击：
1. 注册账户 A（user@example.com）
2. 用 Google 登录（user@example.com）
3. 系统关联账户
4. 攻击者访问账户 A

修复：
- 邮箱验证
- 明确账户绑定
- 二次确认
```

---

## 授权漏洞分析

### 对象级别授权漏洞

**ID 遍历**：
```
GET /api/users/1
GET /api/users/2
GET /api/users/3
...

问题：
- 未验证资源所有权
- 可访问所有资源

修复：
- 验证用户 ID 匹配
- 使用 UUID
- 速率限制
```

### 功能级别授权漏洞

**垂直权限提升**：
```
POST /api/users/1/role
{
  "role": "admin"
}

问题：
- 普通用户可修改角色
- 权限提升

修复：
- 验证操作权限
- 分离管理员接口
- 审计日志
```

### 上下文依赖授权漏洞

**工作流绕过**：
```
正常流程：
草稿 → 审核 → 发布

攻击：
直接发布（跳过审核）

修复：
- 状态机验证
- 流程检查
- 状态转换验证
```

---

## 实战攻防演练

### 攻击场景

**场景 1: JWT 密钥破解**：
```
1. 获取 JWT Token
2. 尝试弱密钥破解
3. 伪造管理员 Token
4. 访问管理员接口
```

**场景 2: OAuth 重定向攻击**：
```
1. 发现 OAuth 登录
2. 测试 redirect_uri 验证
3. 构造恶意重定向
4. 窃取授权码
5. 换取 Access Token
```

**场景 3: ID 遍历**：
```
1. 获取自己的用户 ID
2. 遍历相邻 ID
3. 访问他人数据
4. 批量爬取
```

### 防御演练

**实施 JWT 最佳实践**：
```python
# 强密钥
SECRET_KEY = os.environ.get('JWT_SECRET', secrets.token_urlsafe(32))

# 短期 Token
access_token = create_token(user_id, expires_in=15)
refresh_token = create_token(user_id, expires_in=7*24*60*60, type='refresh')

# 算法明确
token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')

# 验证算法
payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
```

**实施 OAuth 安全**：
```python
# State 参数
state = secrets.token_urlsafe(32)
session['oauth_state'] = state

# 重定向
redirect_uri = f"{authorization_url}&state={state}"

# 验证
if request.args.get('state') != session.pop('oauth_state'):
    abort(403)
```

**实施授权检查**：
```python
@app.route('/api/users/<user_id>')
@require_permission('read')
def get_user(user_id):
    # 验证资源所有权
    if not has_access(current_user.id, user_id):
        abort(403)
    
    return get_user_data(user_id)
```

---

## 防护策略与最佳实践

### 认证防护

**多因素认证**：
```
- 密码 + 短信验证码
- 密码 + 认证器 App
- 密码 + 生物识别
```

**会话管理**：
```
- 短期 Token
- Refresh Token 轮换
- 设备指纹
- 异常登录检测
```

**密码策略**：
```
- 最小长度 12 字符
- 复杂度要求
- 禁止常见密码
- 定期更换
```

### 授权防护

**最小权限**：
```
- 默认拒绝
- 按需授权
- 定期审查
- 及时回收
```

**审计日志**：
```
- 记录所有授权决策
- 记录权限变更
- 异常访问告警
- 定期审计
```

**持续验证**：
```
- 定期重新认证
- 权限变更时验证
- 异常行为检测
- 动态授权调整
```

---

## 总结与思考

### 核心要点回顾

1. **认证安全**
   - JWT 最佳实践
   - OAuth 2.0 流程
   - API Key 管理

2. **授权安全**
   - RBAC/ABAC 模型
   - 最小权限原则
   - 持续验证

3. **漏洞防护**
   - 认证漏洞分析
   - 授权漏洞分析
   - 实战攻防

### 深入思考问题

1. **无密码认证未来**？
   - WebAuthn
   - 生物识别
   - 设备认证

2. **零信任架构**？
   - 持续验证
   - 动态授权
   - 最小信任

3. **AI 辅助认证**？
   - 行为分析
   - 风险评分
   - 自适应认证

### 实战建议

**开发人员**：
1. 实施强认证
2. 细粒度授权
3. 审计日志
4. 定期审查

**安全人员**：
1. 认证授权测试
2. 渗透测试
3. 代码审计
4. 监控告警

**管理层**：
1. 安全策略
2. 开发规范
3. 安全培训
4. 合规要求

---

## 参考资料

### 学习资源
- [OWASP Authentication](https://owasp.org/www-community/Authentication_Cheat_Sheet)
- [JWT RFC 7519](https://tools.ietf.org/html/rfc7519)
- [OAuth 2.0 RFC 6749](https://tools.ietf.org/html/rfc6749)

### 工具资源
- [jwt.io](https://jwt.io/)
- [PyJWT](https://pyjwt.readthedocs.io/)
- [OAuth Playground](https://oauthplayground.appspot.com/)

### 书籍推荐
- 《OAuth 2.0 实战》
- 《Web API 认证与授权》
- 《白帽子讲 Web 安全》

---

**标记 明日预告**：Day 48 - API 漏洞挖掘实战

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

---

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