JWT安全攻防 - 元素码农

发布时间: 2025-03-23 12:59

↑

# JWT安全攻防

## JWT概述

JSON Web Token (JWT) 是一种基于JSON的开放标准，用于在网络应用间安全地传输信息。本文将详细介绍JWT的安全风险和防护措施，帮助开发者构建更安全的JWT实现。

## JWT结构

### 1. 基本组成

```javascript
// JWT的三个部分：Header.Payload.Signature
const jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.' +
            'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.' +
            'SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';

// 解码示例
const [header, payload, signature] = jwt.split('.');
const decodedHeader = JSON.parse(atob(header));
const decodedPayload = JSON.parse(atob(payload));
```

### 2. 签名验证

```python
# Python示例：JWT签名验证
import jwt
from datetime import datetime, timedelta

class JWTManager:
    def __init__(self, secret_key):
        self.secret_key = secret_key
    
    def generate_token(self, user_id, expires_delta=None):
        payload = {
            'user_id': user_id,
            'iat': datetime.utcnow(),
            'exp': datetime.utcnow() + (expires_delta or timedelta(minutes=30))
        }
        
        return jwt.encode(
            payload,
            self.secret_key,
            algorithm='HS256'
        )
    
    def verify_token(self, token):
        try:
            payload = jwt.decode(
                token,
                self.secret_key,
                algorithms=['HS256']
            )
            return payload
        except jwt.ExpiredSignatureError:
            raise Exception('Token已过期')
        except jwt.InvalidTokenError:
            raise Exception('无效的Token')
```

## 常见攻击方式

### 1. 算法篡改攻击

```python
# Python示例：防止算法篡改
class SecureJWTManager:
    def __init__(self, secret_key, public_key=None):
        self.secret_key = secret_key
        self.public_key = public_key
    
    def verify_token(self, token):
        # 获取未验证的header
        unverified_header = jwt.get_unverified_header(token)
        
        # 检查算法
        if unverified_header['alg'] not in ['HS256', 'RS256']:
            raise Exception('不支持的算法')
        
        # 根据算法选择密钥
        key = self.public_key if unverified_header['alg'] == 'RS256' else self.secret_key
        
        try:
            return jwt.decode(
                token,
                key,
                algorithms=[unverified_header['alg']]
            )
        except jwt.InvalidAlgorithmError:
            raise Exception('算法不匹配')
```

### 2. 无签名攻击

```javascript
// Node.js示例：强制验证签名
const jwt = require('jsonwebtoken');

class JWTValidator {
    constructor(config) {
        this.secretKey = config.secretKey;
        this.allowedAlgorithms = ['HS256', 'RS256'];
    }
    
    verifyToken(token) {
        // 检查token格式
        if (!token || token.split('.').length !== 3) {
            throw new Error('Invalid token format');
        }
        
        return new Promise((resolve, reject) => {
            jwt.verify(token, this.secretKey, {
                algorithms: this.allowedAlgorithms,
                ignoreExpiration: false
            }, (err, decoded) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(decoded);
                }
            });
        });
    }
}
```

### 3. 密钥泄露防护

```java
// Java示例：密钥轮换机制
public class KeyRotationManager {
    private Map<String, SecretKey> keys;
    private String currentKeyId;
    
    public KeyRotationManager() {
        this.keys = new ConcurrentHashMap<>();
        this.rotateKey(); // 初始化第一个密钥
    }
    
    public void rotateKey() {
        String keyId = UUID.randomUUID().toString();
        SecretKey key = generateKey();
        keys.put(keyId, key);
        currentKeyId = keyId;
        
        // 清理过期密钥
        cleanupOldKeys();
    }
    
    private SecretKey generateKey() {
        KeyGenerator keyGen = KeyGenerator.getInstance("HmacSHA256");
        keyGen.init(256);
        return keyGen.generateKey();
    }
    
    public String signToken(String payload) {
        SecretKey key = keys.get(currentKeyId);
        String token = Jwts.builder()
            .setHeaderParam("kid", currentKeyId)
            .setPayload(payload)
            .signWith(key)
            .compact();
        return token;
    }
    
    public boolean verifyToken(String token) {
        try {
            String kid = extractKeyId(token);
            SecretKey key = keys.get(kid);
            if (key == null) {
                return false;
            }
            
            Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}
```

## 安全最佳实践

### 1. Token管理

```typescript
// TypeScript示例：Token管理器
interface TokenConfig {
    expiresIn: number;
    refreshExpiresIn: number;
    algorithm: string;
    issuer: string;
}

class TokenManager {
    private readonly config: TokenConfig;
    private readonly blacklist: Set<string>;
    
    constructor(config: TokenConfig) {
        this.config = config;
        this.blacklist = new Set();
    }
    
    async createTokenPair(userId: string): Promise<{
        accessToken: string;
        refreshToken: string;
    }> {
        const accessToken = jwt.sign(
            { userId, type: 'access' },
            process.env.JWT_SECRET!,
            {
                expiresIn: this.config.expiresIn,
                algorithm: this.config.algorithm,
                issuer: this.config.issuer
            }
        );
        
        const refreshToken = jwt.sign(
            { userId, type: 'refresh' },
            process.env.JWT_REFRESH_SECRET!,
            {
                expiresIn: this.config.refreshExpiresIn,
                algorithm: this.config.algorithm,
                issuer: this.config.issuer
            }
        );
        
        return { accessToken, refreshToken };
    }
    
    invalidateToken(token: string): void {
        this.blacklist.add(token);
    }
    
    isTokenBlacklisted(token: string): boolean {
        return this.blacklist.has(token);
    }
}
```

### 2. 安全配置

```yaml
# JWT安全配置示例
jwt:
  # 签名配置
  signing:
    algorithm: RS256
    private_key_path: /path/to/private.key
    public_key_path: /path/to/public.key
    key_rotation_interval: 24h
  
  # Token配置
  token:
    access_token_expiry: 15m
    refresh_token_expiry: 7d
    issuer: "your-service-name"
    audience: "your-app"
  
  # 安全选项
  security:
    validate_issuer: true
    validate_audience: true
    require_exp: true
    clock_skew: 30s
    max_age: 1h
```

### 3. 错误处理

```python
# Python示例：JWT错误处理
class JWTErrorHandler:
    def handle_jwt_error(self, error):
        if isinstance(error, jwt.ExpiredSignatureError):
            return {
                'status': 401,
                'error': 'token_expired',
                'message': 'Token已过期'
            }
        elif isinstance(error, jwt.InvalidAlgorithmError):
            return {
                'status': 401,
                'error': 'invalid_algorithm',
                'message': '不支持的算法'
            }
        elif isinstance(error, jwt.InvalidTokenError):
            return {
                'status': 401,
                'error': 'invalid_token',
                'message': '无效的Token'
            }
        else:
            return {
                'status': 500,
                'error': 'jwt_error',
                'message': '处理Token时发生错误'
            }
```

## 最佳实践

1. 算法安全
   - 使用强密码学算法（如RS256）
   - 避免使用none算法
   - 显式指定允许的算法

2. 密钥管理
   - 使用足够长度的密钥
   - 定期轮换密钥
   - 安全存储密钥
   - 使用非对称加密算法

3. Token安全
   - 设置合理的过期时间
   - 实现Token撤销机制
   - 使用刷新Token
   - 验证所有必要的声明

4. 传输安全
   - 使用HTTPS传输
   - 设置安全的Cookie属性
   - 实现CSRF防护

5. 错误处理
   - 实现完善的错误处理
   - 避免泄露敏感信息
   - 记录安全事件

## 总结

JWT安全涉及多个方面，需要综合考虑：

1. 正确实现JWT规范
2. 选择安全的算法和密钥
3. 实施完善的Token管理
4. 采取必要的安全防护措施
5. 定期审计和更新安全策略

通过遵循本文介绍的最佳实践，可以显著提高JWT实现的安全性，有效防止各种潜在的安全威胁。同时要注意，安全是一个持续的过程，需要定期评估和更新安全措施。