Next.js 中间件拦截失效：Edge Runtime 中的全局状态共享问题深度剖析

let userSessions = new Map();

/**
 * 中间件函数，用于验证用户身份认证状态
 * @param {Object} request - HTTP请求对象，包含cookies等信息
 * @returns {Object} NextResponse对象，可能是重定向到登录页或继续处理
 */
export function middleware(request) {
  const token = request.cookies.get('auth-token')?.value;

  if (!token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  const userId = verifyToken(token);
  if (!userId) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // 检查会话是否仍然有效
  const session = userSessions.get(userId);
  if (!session || session.token !== token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  return NextResponse.next();
}

/**
 * 验证JWT token的有效性
 * @param {string} token - JWT token字符串
 * @returns {string|null} 验证成功返回用户ID，验证失败返回null
 */
function verifyToken(token) {
  // token 验证逻辑
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    return payload.userId;
  } catch (error) {
    return null;
  }
}

[10:23:45] 请求来自IP: 192.168.1.100，路径: /dashboard，token对应userA，globalUser设置为userA
[10:23:47] 请求来自IP: 192.168.1.101，路径: /dashboard，token对应userB，globalUser设置为userB
[10:23:48] 请求来自IP: 192.168.1.100，路径: /reports，token对应userA，读取globalUser为userB → 触发"异地登录"检测

// 增加调试日志
let userSessions = new Map();

/**
 * 中间件函数，用于处理请求的身份验证和会话检查
 * @param {Object} request - HTTP请求对象，包含URL、cookies等信息
 * @returns {NextResponse} 重定向响应或继续处理的响应
 */
export function middleware(request) {
  console.log('Middleware execution start', {
    url: request.url,
    timestamp: new Date().toISOString(),
  });

  const token = request.cookies.get('auth-token')?.value;
  console.log('Token from request:', token);

  // 验证令牌是否存在，不存在则重定向到登录页面
  if (!token) {
    console.log('No token found, redirecting to login');
    return NextResponse.redirect(new URL('/login', request.url));
  }

  const userId = verifyToken(token);
  console.log('Verified userId:', userId);

  // 验证令牌是否有效，无效则重定向到登录页面
  if (!userId) {
    console.log('Invalid token, redirecting to login');
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // 检查会话是否仍然有效
  const session = userSessions.get(userId);
  console.log('Current session in store:', session);
  console.log('Expected token:', token);

  // 验证会话中的令牌与请求令牌是否匹配，不匹配则重定向到登录页面
  if (!session || session.token !== token) {
    console.log('Session mismatch, redirecting to login');
    return NextResponse.redirect(new URL('/login', request.url));
  }

  console.log('Authentication successful');
  return NextResponse.next();
}

export default {
  experimental: {
    runtime: 'edge' // 或 'nodejs'
  }
}

async function simulateConcurrentRequests() {
  const users = [
    { id: 'user1', token: 'token1' },
    { id: 'user2', token: 'token2' },
    { id: 'user3', token: 'token3' },
  ];

  // 并发发送请求
  const promises = users.map(user =>
    fetch('http://localhost:3000/api/protected', {
      headers: {
        Cookie: `auth-token=${user.token}`,
      },
    }),
  );

  const responses = await Promise.all(promises);
  responses.forEach((res, index) => {
    console.log(`User ${index + 1} status:`, res.status);
  });
}

// 重构版本
import { NextResponse } from 'next/server';

/**
 * 中间件函数，用于验证用户身份认证状态
 * 检查请求中的认证令牌，验证用户会话有效性
 * @param {Request} request - Next.js 请求对象，包含cookies和其他请求信息
 * @returns {NextResponse} 重定向响应或继续处理的响应
 */
export function middleware(request) {
  const token = request.cookies.get('auth-token')?.value;

  if (!token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  const userId = verifyToken(token);
  if (!userId) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // 不再依赖全局状态，直接验证 token 的有效性
  if (!isValidSession(token, userId)) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  return NextResponse.next();
}

/**
 * 验证JWT令牌并提取用户ID
 * @param {string} token - JWT认证令牌
 * @returns {string|null} 解析出的用户ID，如果验证失败则返回null
 */
function verifyToken(token) {
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    return payload.userId;
  } catch (error) {
    return null;
  }
}

/**
 * 验证会话的有效性
 * 通过外部存储验证会话状态，确保令牌未被撤销
 * @param {string} token - JWT认证令牌
 * @param {string} userId - 用户ID
 * @returns {boolean} 会话是否有效
 */
function isValidSession(token, userId) {
  // 通过外部存储（如 Redis）验证会话有效性
  // 这里简化为直接验证 token
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    return payload.userId === userId && payload.exp > Date.now() / 1000;
  } catch (error) {
    return false;
  }
}

/**
 * 中间件配置对象
 * 定义需要应用此中间件的路由匹配规则
 */
export const config = {
  matcher: ['/dashboard/:path*', '/profile/:path*'],
};

// 使用 Redis 存储会话
import { NextResponse } from 'next/server';
import Redis from 'ioredis';

// 注意：在 Edge Runtime 中需要使用兼容的 Redis 客户端
const redis = new Redis(process.env.REDIS_URL);

/**
 * 中间件函数，用于验证用户身份和会话状态
 * @param {Request} request - HTTP 请求对象，包含 cookies 和 URL 信息
 * @returns {NextResponse} 重定向响应或继续处理的响应
 */
export async function middleware(request) {
  const token = request.cookies.get('auth-token')?.value;

  if (!token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  const userId = verifyToken(token);
  if (!userId) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // 从 Redis 获取会话信息
  const sessionData = await redis.get(`session:${userId}`);
  if (!sessionData) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  const session = JSON.parse(sessionData);
  if (session.token !== token) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  return NextResponse.next();
}

/**
 * 验证 JWT token 并提取用户 ID
 * @param {string} token - JWT token 字符串
 * @returns {string|null} 验证成功时返回用户 ID，失败时返回 null
 */
function verifyToken(token) {
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    return payload.userId;
  } catch (error) {
    return null;
  }
}

/**
 * Session管理器类
 * 负责管理用户会话数据，提供缓存机制以提高访问性能
 */
class SessionManager {
  constructor() {
    this.cache = new Map();
    this.cacheExpiry = new Map();
    this.cacheTTL = 5 * 60 * 1000; // 5分钟缓存
  }

  /**
   * 获取用户会话数据
   * 首先检查内存缓存，如果缓存未命中或已过期，则从Redis获取数据并更新缓存
   * @param {string} userId - 用户ID
   * @returns {Promise<Object|null>} 用户会话数据对象，如果不存在则返回null
   */
  async getSession(userId) {
    // 检查缓存
    const now = Date.now();
    if (this.cache.has(userId)) {
      const expiry = this.cacheExpiry.get(userId);
      if (now < expiry) {
        return this.cache.get(userId);
      } else {
        // 缓存过期，清理
        this.cache.delete(userId);
        this.cacheExpiry.delete(userId);
      }
    }

    // 从 Redis 获取并缓存
    const sessionData = await redis.get(`session:${userId}`);
    if (sessionData) {
      const session = JSON.parse(sessionData);
      this.cache.set(userId, session);
      this.cacheExpiry.set(userId, now + this.cacheTTL);
      return session;
    }

    return null;
  }

  /**
   * 使指定用户的缓存失效
   * @param {string} userId - 用户ID
   */
  invalidateCache(userId) {
    this.cache.delete(userId);
    this.cacheExpiry.delete(userId);
  }
}

const sessionManager = new SessionManager();

/**
 * 安全管理器类
 * 负责处理令牌黑名单、会话管理和用户登出等安全相关功能
 */
class SecurityManager {
  /**
   * 将令牌添加到黑名单中
   * @param {string} token - 需要加入黑名单的令牌
   * @param {number} expiry - 令牌过期时间（秒）
   * @returns {Promise<void>}
   */
  async addToBlacklist(token, expiry) {
    const tokenHash = createHash('sha256').update(token).digest('hex');
    await redis.setex(`blacklist:${tokenHash}`, expiry, '1');
  }

  /**
   * 检查令牌是否在黑名单中
   * @param {string} token - 需要检查的令牌
   * @returns {Promise<boolean>} 令牌是否在黑名单中
   */
  async isTokenBlacklisted(token) {
    const tokenHash = createHash('sha256').update(token).digest('hex');
    const result = await redis.get(`blacklist:${tokenHash}`);
    return result === '1';
  }

  /**
   * 用户登出操作，将用户所有会话令牌加入黑名单并删除会话
   * @param {string} userId - 用户ID
   * @param {string} currentToken - 当前令牌
   * @returns {Promise<void>}
   */
  async logoutUser(userId, currentToken) {
    // 获取用户所有会话
    const userSessions = await redis.keys(`session:${userId}*`);

    // 将所有 token 加入黑名单
    for (const sessionKey of userSessions) {
      const sessionData = await redis.get(sessionKey);
      if (sessionData) {
        const session = JSON.parse(sessionData);
        const ttl = await redis.ttl(sessionKey);
        await this.addToBlacklist(session.token, ttl);
      }
    }

    // 删除所有会话
    if (userSessions.length > 0) {
      await redis.del(...userSessions);
    }
  }
}

const securityManager = new SecurityManager();