JWT vs Session：现代Web的身份验证战争

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.        # Header（头部）
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.  # Payload（负载）
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c  # Signature（签名）

{
  "alg": "HS256",     // 签名算法：HMAC SHA256
  "typ": "JWT"        // 类型：JWT
}

{
  "sub": "1234567890",      // 主题（用户ID）
  "name": "John Doe",       // 自定义声明
  "iat": 1516239022,        // 签发时间（issued at）
  "exp": 1516242622,        // 过期时间（expiration）
  "admin": true             // 角色/权限
}

HMACSHA256(
  base64UrlEncode(header) + "." + 
  base64UrlEncode(payload),
  secret_key
)

用户登录
    ▼
服务器验证凭证
    ▼
生成JWT（包含用户ID、过期时间等）
    ▼
返回给客户端（通常HTTP响应中）
    ▼
客户端存储（localStorage/Cookie/内存）
    ▼
后续请求：Authorization: Bearer <token>
    ▼
服务器验证签名、过期时间、声明
    ▼
通过 → 处理请求
拒绝 → 401 Unauthorized

# 现代Session存储示例（Redis + 安全增强）
class SecureSession:
    def create_session(self, user_id, request_metadata):
        session_id = generate_cryptographically_random_string(32)
    
        # 存储丰富信息
        session_data = {
            'user_id': user_id,
            'ip': request_metadata['ip'],
            'user_agent_hash': hash(request_metadata['ua']),
            'created_at': time.time(),
            'last_active': time.time(),
            'mfa_verified': False,  # 可逐步提升信任
            'device_fingerprint': generate_fingerprint(request_metadata)
        }
    
        # Redis存储，自动过期
        redis.setex(
            f"session:{session_id}", 
            timeout=3600,  # 1小时
            value=json.dumps(session_data)
        )
    
        # 安全的Cookie
        response.set_cookie(
            'session_id', 
            session_id,
            httponly=True,
            secure=True,
            samesite='Strict',
            max_age=3600
        )
    
        return session_id

JWT得分点：
  • 无状态，天生分布式友好
  • 服务扩容简单，无需Session共享
  • 适合微服务架构

Session得分点：
  • 状态集中，控制力强
  • 可存储复杂、大量的会话数据
  • 服务器完全掌控会话生命周期

平局提示：这实际是“中心化 vs 去中心化”的选择

# 模拟性能对比
import time

def verify_jwt(token):
    """JWT验证：解密+校验签名+检查过期"""
    start = time.time()
    # 1. 解码Base64（快）
    # 2. 验证签名（加密计算）
    # 3. 检查exp声明
    elapsed = time.time() - start
    return elapsed  # 通常<1ms

def verify_session(session_id):
    """Session验证：网络请求+数据反序列化"""
    start = time.time()
    # 1. 网络请求到Redis（0.5-2ms，网络依赖）
    # 2. 获取数据
    # 3. JSON反序列化
    # 4. 检查过期
    elapsed = time.time() - start
    return elapsed  # 通常1-5ms，依赖网络质量

# 但注意：Session可做优化！
# • 本地缓存热门Session
# • 批量验证
# • 使用更快的序列化（MessagePack）

# JWT撤销方案1：Token黑名单
def logout_with_jwt(token):
    # 提取过期时间
    payload = decode_without_verify(token)
    expiry = payload['exp']
  
    # 将未过期的Token加入黑名单
    if time.time() < expiry:
        redis.setex(
            f"jwt_blacklist:{token_hash}",
            timeout=expiry - time.time(),  # 只存到Token过期
            value=1
        )

# JWT撤销方案2：版本号/撤销ID
payload = {
    "sub": "user123",
    "jti": "revocable_id_001",  # JWT ID，可撤销
    "version": 2  # 用户改密码后递增
}

# 验证时检查
if redis.exists(f"revoked:{payload['jti']}"):
    return "Token已被撤销"

微服务架构 → JWT优势明显
  服务A验证Token后，可直接传递给服务B
  无需中央Session存储

单体应用 → Session更简单
  所有状态在同一个数据库/Redis

混合架构 → 需要权衡
  有的服务用Session，有的用JWT
  需要适配层或网关统一处理

移动原生App：
  JWT胜出 ✓
  • App没有Cookie概念
  • Token存Secure Storage
  • 简单明了

响应式Web：
  各有优势
  • JWT：localStorage + API调用
  • Session：Cookie自动管理（需要处理SameSite）

桌面应用：
  类似移动端，JWT更自然

// 前端开发者视角
// JWT方式：
const login = async () => {
  const res = await fetch('/api/login', {method: 'POST'});
  const {token} = await res.json();
  localStorage.setItem('token', token);  // 手动管理
  // 后续每个请求：
  fetch('/api/data', {
    headers: {Authorization: `Bearer ${token}`}
  });
};

// Session方式（现代SPA）：
const login = async () => {
  const res = await fetch('/api/login', {
    method: 'POST',
    credentials: 'include'  // 关键！
  });
  // Cookie自动管理，后续请求自动带上
  fetch('/api/data', {credentials: 'include'});
};

// 后端开发者视角
// JWT库（Python示例）：
import jwt

token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
# 验证
try:
    decoded = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
except jwt.ExpiredSignatureError:
    return "Token过期"
except jwt.InvalidTokenError:
    return "无效Token"

# Session库：
from flask import session
session['user_id'] = user.id  # 就这么简单

用户认证 → Session
  • 需要即时踢人（安全团队要求）
  • 绑定设备/IP防盗号

购物车 → Session + 本地存储
  • 未登录：localStorage存草稿
  • 已登录：同步到服务器Session

支付流程 → 独立短期Session
  • 高安全隔离
  • 15分钟超时

微服务间通信 → JWT
  • 服务A生成内部JWT
  • 服务B验证但不存状态
  
API给移动端 → JWT
  • App团队要求
  • 长期Token + 短期Refresh Token

class HybridAuth:
    def login(self, user_id):
        # 生成JWT
        token = jwt.encode({
            'sub': user_id,
            'jti': str(uuid.uuid4()),  # 唯一ID
            'iat': now(),
            'exp': now() + 3600  # 1小时
        }, SECRET_KEY)
    
        # 但同时也在服务端记录
        redis.setex(
            f"active_token:{user_id}:{token_hash}",
            timeout=3600,
            value=json.dumps({
                'issued_at': now(),
                'last_used': now(),
                'ip': request.ip
            })
        )
    
        return token
  
    def verify(self, token):
        # 1. 验证JWT签名和过期
        payload = jwt.decode(token, SECRET_KEY)
    
        # 2. 检查服务端是否已撤销
        if not redis.exists(f"active_token:{payload['sub']}:{token_hash}"):
            raise TokenRevokedError()
    
        # 3. 更新最后使用时间
        redis.expire(f"active_token:{payload['sub']}:{token_hash}", 3600)
    
        return payload

Access Token（JWT）：15分钟过期
Refresh Token（可撤销）：7天过期
服务器维护：Refresh Token白名单

访问流程：
1. 用Access Token访问（无状态）
2. 过期 → 用Refresh Token获取新Access Token
3. 服务器检查Refresh Token是否在白名单
4. 不在 → 拒绝（用户已被踢或Token被盗）