无服务器游戏后端上的 Spectre 侧信道攻击：检测与修复手册

你的无服务器游戏后端与数十个其他租户共享物理硬件，处理玩家身份验证令牌、库存更新和匹配请求。攻击者只要与你的代码位于同一物理 CPU 上，就能提取敏感数据——不是通过你的代码，而是通过硅片本身。Cloudflare 最近披露的研究证实这并非理论上的威胁：研究人员在生产环境的 Cloudflare Workers 上以 99% 的准确率稳定泄漏了每秒 12 比特的数据。

如果你在任何无服务器或多租户平台上运行游戏逻辑，本手册将涵盖哪些环节会出问题、如何检测、如何修复，以及如何从架构层面防止问题再次发生。

什么会出问题：无服务器游戏后端中的 Spectre

攻击面

Spectre 利用了现代 CPU 中的推测执行机制。当处理器遇到条件分支时，会在条件解析之前推测性地执行两条路径。如果推测错误，CPU 会回滚——但痕迹会留在 CPU 缓存中。攻击者通过测量缓存时序，就能推断出推测执行期间访问了哪些数据。

在无服务器环境中，这种攻击变得尤为危险，因为：

• 共享硬件：你的游戏后端函数与其他租户的代码运行在同一物理 CPU 核心上（不同时间片）
• 高精度定时器：JavaScript 的 performance.now() 和基于 SharedArrayBuffer 的定时器为攻击者提供了纳秒级的缓存测量能力
• 可预测的内存布局：V8 的 JIT 编译器在多次调用之间创建一致的内存布局，使 gadget 链变得可靠

Cloudflare Workers 概念验证

格拉茨技术大学的研究团队与 Cloudflare 合作，演示了一条实际的攻击链：

1. Gadget 识别：在 V8 运行时中找到一个推测执行 gadget，该 gadget 根据秘密数据访问攻击者控制的内存
2. 定时器设置：使用 SharedArrayBuffer 创建高精度定时器（亚纳秒精度）
3. 缓存预置：刷新相关缓存行，触发 gadget，然后测量重新加载时间
4. 数据提取：从时序测量中重建秘密比特，速度为每秒 12 比特，准确率 99%

泄漏的数据包括认证令牌、加密密钥以及共置 Workers 处理的其他秘密。

为什么游戏后端尤其容易受到攻击

游戏后端持续处理高价值秘密：

• 用于玩家认证的 JWT 令牌（通常为 300-1000 字节的 base64 编码数据）
• 用于实时多人游戏状态的会话加密密钥
• 用于应用内购买的支付处理令牌
• 必须保密才能有效的反作弊签名

12 比特/秒的泄漏速率听起来很慢，但提取一个 256 比特的 AES 密钥只需约 21 秒。提取一个 512 比特的 JWT 令牌约需 43 秒。在持续 20 分钟以上的游戏会话中，攻击者可以提取大量秘密材料。

如何检测

监控侧信道活动

你无法通过应用程序日志直接观察到 Spectre 攻击。相反，应监控攻击的前提条件和行为特征：

1. 定时器分辨率滥用检测

// 检测脚本：监控高频率定时器访问模式
// 作为中间件或包装器部署在你的无服务器函数周围

const TIMER_ACCESS_THRESHOLD = 1000; // 每秒访问次数
const timerAccessLog = new Map();

function monitorTimerAccess(sessionId) {
  const now = Date.now();
  const entry = timerAccessLog.get(sessionId) || { count: 0, windowStart: now };
  
  if (now - entry.windowStart > 1000) {
    // 重置窗口
    entry.count = 1;
    entry.windowStart = now;
  } else {
    entry.count++;
  }
  
  timerAccessLog.set(sessionId, entry);
  
  if (entry.count > TIMER_ACCESS_THRESHOLD) {
    // 警报：可能在进行侧信道侦察
    logSecurityEvent({
      type: 'TIMER_ABUSE_SUSPECTED',
      sessionId,
      accessCount: entry.count,
      timestamp: now,
      severity: 'HIGH'
    });
    return true; // 标记以进一步检查
  }
  return false;
}

2. SharedArrayBuffer 使用监控

如果你的游戏后端不需要合法使用 SharedArrayBuffer（大多数都不需要），请监控其创建：

// 包装 SharedArrayBuffer 构造函数以检测未授权使用
const OriginalSAB = globalThis.SharedArrayBuffer;
let sabCreationCount = 0;

globalThis.SharedArrayBuffer = function(...args) {
  sabCreationCount++;
  
  if (sabCreationCount > 5) { // 合法的游戏代码很少创建多个
    logSecurityEvent({
      type: 'SAB_CREATION_ANOMALY',
      count: sabCreationCount,
      stackTrace: new Error().stack,
      severity: 'CRITICAL'
    });
  }
  
  return new OriginalSAB(...args);
};

3. 缓存时序模式分析

监控内存密集型操作后跟精确时序测量的重复模式。这在应用层较难检测，但基础设施级监控可以标记：

• 持续使用超过 90% 分配 CPU 时间的函数
• 异常的 Atomics.load() 和 Atomics.store() 调用模式
• 访问大块连续内存区域但无明显应用目的的函数

基础设施级检测

在基础设施层面，注意以下迹象：

• 共置模式：如果同一个受攻击者控制的函数反复落在与你的游戏后端相同的物理硬件上，这是一个危险信号
• 资源消耗异常：Spectre 概念验证攻击在测量时通常会在目标核心上消耗 100% 的 CPU
• 网络外泄：提取的比特必须通过某种方式离开系统——监控无服务器函数是否有异常的出站数据模式

如何修复

立即行动（24 小时内部署）

步骤 1：禁用高精度定时器

最有效的缓解措施是消除攻击者精确测量缓存时序的能力：

// serverless-security-hardening.js
// 应用于所有游戏后端无服务器函数

// 1. 将定时器分辨率降低到 100 微秒（降低 10,000 倍）
if (typeof performance !== 'undefined') {
  const originalNow = performance.now.bind(performance);
  const TIMER_GRANULARITY = 0.1; // 100 微秒
  
  performance.now = function() {
    const precise = originalNow();
    return Math.round(precise / TIMER_GRANULARITY) * TIMER_GRANULARITY;
  };
}

// 2. 如果不需要，完全禁用 SharedArrayBuffer
// （大多数游戏后端在服务端不需要它）
delete globalThis.SharedArrayBuffer;
delete globalThis.Atomics;

// 3. 为所有异步操作添加时序抖动
const originalSetTimeout = globalThis.setTimeout;
globalThis.setTimeout = function(callback, delay, ...args) {
  // 添加 0-5ms 的随机抖动以防止时序同步
  const jitter = Math.random() * 5;
  return originalSetTimeout(callback, delay + jitter, ...args);
};

步骤 2：对敏感操作实施进程隔离

将处理秘密的操作隔离到具有加固内存布局的独立进程中：

// process-isolation-config.js
// 隔离敏感游戏后端操作的配置

const isolationConfig = {
  // 必须在隔离进程中运行的操作
  sensitiveOperations: [
    'auth.token.verify',
    'auth.token.generate',
    'payment.process',
    'crypto.encrypt',
    'crypto.decrypt',
    'anticheat.signature.validate'
  ],
  
  // 进程池配置
  processPool: {
    minProcesses: 2,
    maxProcesses: 8,
    // 每个进程拥有独立的内存空间——无跨进程缓存共享
    memoryIsolation: true,
    // 随机化进程分配以防止共置攻击
    randomAssignment: true,
    // 每 N 个请求轮换进程以破坏长时间运行的攻击
    rotationInterval: 1000
  }
};

// 实现：将敏感操作路由到隔离进程
async function executeSensitiveOperation(operationName, payload) {
  if (!isolationConfig.sensitiveOperations.includes(operationName)) {
    throw new Error(`操作 ${operationName} 不在敏感列表中`);
  }
  
  const worker = await getIsolatedWorker(isolationConfig.processPool);
  
  try {
    const result = await worker.execute(operationName, payload);
    return result;
  } finally {
    // 始终将 worker 返回池中——绝不跨操作复用
    await worker.terminate(); // 下次使用全新进程
  }
}

步骤 3：加固内存访问模式

使秘密相关的内存访问变为恒定时间，以消除推测执行 gadget：

// constant-time-comparison.js
// 用恒定时间操作替换所有秘密相关的分支

// 有漏洞：分支依赖秘密数据
function verifyTokenVulnerable(token, expectedHash) {
  const hash = computeHash(token);
  if (hash === expectedHash) { // 分支通过缓存泄漏信息
    return true;
  }
  return false;
}

// 安全：恒定时间比较——没有分支依赖秘密
function verifyTokenSecure(token, expectedHash) {
  const hash = computeHash(token);
  
  if (hash.length !== expectedHash.length) {
    return false; // 长度不匹配不依赖秘密
  }
  
  let result = 0;
  for (let i = 0; i < hash.length; i++) {
    // XOR 累积差异而不分支
    result |= hash.charCodeAt(i) ^ expectedHash.charCodeAt(i);
  }
  
  // 最终比较：0 表示所有字节匹配
  return result === 0;
}

// 恒定时间数组查找（防止索引的缓存时序泄漏）
function constantTimeLookup(table, index) {
  // 访问所有条目，但只使用我们需要的那个
  // 这防止缓存行暴露访问了哪个索引
  let result = null;
  for (let i = 0; i < table.length; i++) {
    const match = (i === index) ? 0xFF : 0x00;
    // 无分支的条件选择
    result = (table[i] & match) | (result & ~match);
  }
  return result;
}

短期行动（1 周内部署）

步骤 4：实施纵深防御令牌架构

通过最小化内存中存在的秘密来降低泄漏数据的价值：

// token-architecture.js
// 最小化无服务器函数内存中的秘密材料

class SecureTokenHandler {
  constructor() {
    // 绝不存储完整令牌——分块处理
    this.CHUNK_SIZE = 32; // 字节
  }
  
  async verifyTokenChunked(token) {
    const chunks = this.splitIntoChunks(token);
    const expectedChunks = await this.getExpectedChunks(token.id);
    
    let isValid = true;
    for (let i = 0; i < chunks.length; i++) {
      // 每个块的验证是独立的
      // 攻击者必须泄漏所有块才能重建令牌
      const chunkValid = await this.verifyChunk(chunks[i], expectedChunks[i]);
      isValid = isValid && chunkValid;
      
      // 立即覆盖内存中的块
      chunks[i].fill(0);
    }
    
    return isValid;
  }
  
  splitIntoChunks(token) {
    const buffer = Buffer.from(token, 'base64');
    const chunks = [];
    for (let i = 0; i < buffer.length; i += this.CHUNK_SIZE) {
      chunks.push(buffer.slice(i, i + this.CHUNK_SIZE));
    }
    return chunks;
  }
}

步骤 5：部署蜜罐令牌

植入假秘密，在访问时触发警报：

// canary-tokens.js
// 部署检测未经授权内存读取的假秘密

const CANARY_PREFIX = 'CANARY_';

function deployCanaryTokens() {
  const canaries = [];
  
  // 生成 10 个看起来像真实 JWT 令牌的假令牌
  for (let i = 0; i < 10; i++) {
    const canary = {
      id: `${CANARY_PREFIX}${generateUUID()}`,
      value: generateFakeJWT(), // 看起来真实但已被追踪
      deployedAt: Date.now(),
      location: `memory_region_${i}`
    };
    canaries.push(canary);
  }
  
  // 存储在可预测的内存位置
  // 如果这些值出现在网络流量中，说明内存已被读取
  globalThis.__SECURITY_CANARIES__ = canaries;
  
  return canaries;
}

function checkCanaryIntegrity() {
  const canaries = globalThis.__SECURITY_CANARIES__ || [];
  
  // 通过检查蜜罐是否出现在任何出站网络请求中
  // 来验证蜜罐未被外传
  // （需要网络监控集成）
  
  return canaries.every(c => {
    const age = Date.now() - c.deployedAt;
    return age < 3600000; // 每小时轮换蜜罐
  });
}

如何防止再次发生

抗 Spectre 游戏后端的架构模式

模式 1：秘密最小化

防御 Spectre 的最佳方式是减少可泄漏的秘密：

• 使用短期令牌（5 分钟过期）而非长期会话令牌
• 实现令牌绑定到客户端 IP/指纹，使泄漏的令牌在其他地方无法使用
• 将加密密钥存储在**硬件安全模块（HSM）**中，而不是无服务器函数内存中
• 使用无状态认证（带短过期的签名 JWT）避免服务端会话存储

模式 2：分层隔离

┌─────────────────────────────────────────────────┐
│                  负载均衡器                       │
│         （随机分配到区域）                     │
├─────────────────────────────────────────────────┤
│           无服务器函数层                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │ 函数 A   │  │ 函数 B   │  │ 函数 C   │      │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘      │
│       │              │              │            │
├───────┼──────────────┼──────────────┼────────────┤
│       ↓              ↓              ↓            │
│           进程隔离层                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │ 隔离进程 │  │ 隔离进程 │  │ 隔离进程 │      │
│  │（秘密）  │  │（秘密）  │  │（秘密）  │      │
│  └──────────┘  └──────────┘  └──────────┘      │
│       每次调用随机化内存布局                     │
├─────────────────────────────────────────────────┤
│              HSM / 密钥库层               │
│         （加密密钥永不驻留内存）               │
└─────────────────────────────────────────────────┘

模式 3：定时器加固

在平台层面部署这些缓解措施，而不是每个函数单独部署：

// platform-timer-hardening.js
// 在无服务器平台初始化层应用

function hardenTimers() {
  // 1. 降低 performance.now() 分辨率
  const perfNow = performance.now;
  performance.now = () => Math.round(perfNow() / 100) * 100;
  
  // 2. 降低 Date.now() 分辨率
  const dateNow = Date.now;
  Date.now = () => Math.round(dateNow() / 10) * 10;
  
  // 3. 禁用 SharedArrayBuffer
  globalThis.SharedArrayBuffer = undefined;
  
  // 4. 为所有定时器源添加噪声
  const noise = () => Math.random() * 0.05; // 50 微秒噪声
  const originalPerfNow = performance.now;
  performance.now = () => originalPerfNow() + noise();
  
  // 5. 限制 Worker 线程创建
  const OriginalWorker = globalThis.Worker;
  let workerCount = 0;
  globalThis.Worker = function(...args) {
    if (workerCount >= 2) {
      throw new Error('超出 Worker 限制');
    }
    workerCount++;
    return new OriginalWorker(...args);
  };
}

无服务器游戏后端安全最佳实践

1. 假设共置：设计系统时假设攻击者与你共享硬件。内存中的每个秘密都可能通过侧信道被读取。尽量减少任何时刻内存中存在的秘密。

2. 激进轮换：令牌过期时间最长 5 分钟。加密密钥每小时轮换。漏洞窗口与秘密在内存中存留的时间成正比。

3. 监控定时器访问模式：如果游戏后端不需要亚毫秒级定时（大多数不需要），完全禁用高分辨率定时器。如果游戏玩法需要，将定时敏感代码与秘密处理代码隔离。

4. 使用 Spectre 概念验证进行测试：在暂存环境中运行概念验证 Spectre 攻击。Cloudflare 研究论文 包含可适配的方法论。如果你能泄漏自己的秘密，攻击者也能。

5. 分层防御：没有单一的缓解措施是足够的。结合定时器加固、进程隔离、恒定时间代码、短期令牌和蜜罐检测。每一层都会指数级提高攻击成本。

horizOn 的无服务器安全方案

在 horizOn，我们在平台层面处理这些安全问题，这样你就不必自己实现所有缓解措施。我们的无服务器游戏后端基础设施包括定时器加固、敏感操作进程隔离和自动令牌轮换——全部默认配置。

当你通过 horizOn 处理认证时，令牌在隔离进程中通过恒定时间比较进行验证，加密密钥通过我们的密钥库层管理，而不是存储在函数内存中。这意味着 Spectre 攻击面被最小化，无需编写自定义安全代码。

对于构建能够抵御入侵的架构的游戏开发者来说，原则是相同的：假设被入侵，最小化爆炸半径，尽早检测。

你的下一步

立即审计你的无服务器游戏后端。从这三个行动开始：

1. 盘点你的秘密：列出典型游戏会话期间存在于无服务器函数内存中的每一条敏感数据
2. 测量定时器分辨率：检查你的平台是否暴露了高精度定时器（循环运行 performance.now() 并测量最小增量）
3. 测试恒定时间合规性：审查你的认证和加密代码是否存在秘密相关的分支

Spectre 类攻击不会消失——它已内置于现代 CPU 的工作方式中。问题不在于你的无服务器后端是否理论上容易受到攻击，而在于你是否已让攻击者付出足够高的成本，使其转向其他目标。

---

来源：重新审视针对 Cloudflare Workers 的远程 Spectre 攻击