서버리스 게임 백엔드의 Spectre 부채널 공격: 탐지 및 대응 런북

서버리스 게임 백엔드는 플레이어 인증 토큰, 인벤토리 업데이트, 매치메이킹 요청을 수십 개의 다른 테넌트와 공유하는 하드웨어에서 처리합니다. 동일한 물리적 CPU에 공격자가 함께 위치하면 코드가 아닌 실리콘 자체를 통해 민감한 데이터를 추출할 수 있습니다. Cloudflare의 최근 공개 자료는 이것이 이론에 그치지 않음을 확인했습니다: 연구원들은 프로덕션 환경의 Cloudflare Workers에서 초당 12비트를 99% 정확도로 안정적으로 유출했습니다.

서버리스 또는 멀티 테넌트 플랫폼에서 게임 로직을 실행한다면, 이 런북은 무엇이 문제인지, 어떻게 탐지하는지, 어떻게 수정하는지, 그리고 재발을 방지하기 위한 아키텍처 설계 방법을 다룹니다.

무엇이 문제인가: 서버리스 게임 백엔드의 Spectre

공격 표면

Spectre는 최신 CPU의 추측 실행(speculative execution)을 악용합니다. 프로세서가 조건부 분기를 만나면 조건이 확정되기 전에 두 경로를 모두 추측적으로 실행합니다. 추측이 틀리면 CPU는 롤백하지만, CPU 캐시에는 흔적이 남습니다. 공격자는 캐시 타이밍을 측정하여 추측 실행 중에 접근된 데이터를 유추할 수 있습니다.

서버리스 환경에서 이는 다음과 같은 이유로 위험합니다:

• 공유 하드웨어: 게임 백엔드 함수는 다른 테넌트의 코드와 동일한 물리적 CPU 코어에서 (서로 다른 시점에) 실행됩니다
• 고해상도 타이머: JavaScript의 performance.now()와 SharedArrayBuffer 기반 타이머는 공격자에게 나노초 단위 정밀도의 캐시 측정 수단을 제공합니다
• 예측 가능한 메모리 레이아웃: V8의 JIT 컴파일러는 호출 간에 일관된 메모리 레이아웃을 생성하여 gadget 체인을 안정적으로 구성할 수 있게 합니다

Cloudflare Workers PoC(개념 증명)

TU Graz의 연구팀은 Cloudflare와 협력하여 실질적인 공격 체인을 시연했습니다:

1. Gadget 식별: 비밀 데이터를 기반으로 공격자가 제어하는 메모리에 접근하는 V8 런타임의 추측 실행 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. 캐시 타이밍 패턴 분석

메모리 집약적 작업 후 정밀한 타이밍 측정이 반복되는 패턴을 모니터링하세요. 애플리케이션 레벨에서 탐지하기는 어렵지만, 인프라 레벨 모니터링으로 다음을 플래그할 수 있습니다:

• 할당된 CPU 시간의 90% 이상을 지속적으로 사용하는 함수
• 비정상적인 Atomics.load() 및 Atomics.store() 호출 패턴
• 명확한 애플리케이션 목적 없이 대규모 연속 메모리 영역에 접근하는 함수

인프라 레벨 탐지

인프라 레벨에서는 다음을 관찰하세요:

• 동일 위치(co-location) 패턴: 동일한 공격자 제어 함수가 게임 백엔드와 동일한 물리적 하드웨어에 반복적으로 배치된다면 위험 신호입니다
• 리소스 소비 이상: Spectre PoC는 일반적으로 측정 중에 대상 코어의 CPU를 100% 소비합니다
• 네트워크 유출: 추출된 비트는 결국 시스템 외부로 나가야 합니다 — 서버리스 함수의 비정상적인 아웃바운드 데이터 패턴을 모니터링하세요

대응 방법

즉시 조치 (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(`Operation ${operationName} not in sensitive list`);
  }
  
  const worker = await getIsolatedWorker(isolationConfig.processPool);
  
  try {
    const result = await worker.execute(operationName, payload);
    return result;
  } finally {
    // 항상 워커를 풀에 반환 — 작업 간 재사용 금지
    await worker.terminate(); // 다음에는 새 프로세스 사용
  }
}

3단계: 메모리 접근 패턴 강화

비밀 의존 메모리 접근을 상수 시간(constant-time) 연산으로 만들어 추측 실행 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 = [];
  
  // 실제 JWT 토큰처럼 보이는 10개의 가짜 토큰 생성
  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 limit exceeded');
    }
    workerCount++;
    return new OriginalWorker(...args);
  };
}

서버리스 게임 백엔드 보안 모범 사례

1. 동일 위치(co-location) 가정: 공격자가 하드웨어를 공유한다고 가정하고 시스템을 설계하세요. 메모리의 모든 비밀은 부채널을 통해 읽힐 수 있습니다. 특정 시점에 메모리에 존재하는 데이터를 최소화하세요.

2. 적극적인 순환: 최대 5분 토큰 만료를 사용하세요. 암호화 키는 매시간 순환하세요. 취약점 창은 비밀이 메모리에 존재하는 시간에 정비례합니다.

3. 타이머 접근 패턴 모니터링: 게임 백엔드가 서브 밀리초 타이밍을 필요로 하지 않는다면(대부분의 경우), 고해상도 타이머를 완전히 비활성화하세요. 게임플레이에 필요하다면 타이밍 민감 코드와 비밀 처리 코드를 격리하세요.

4. Spectre PoC로 테스트: 스테이징 환경에서 개념 증명 Spectre 공격을 실행하세요. Cloudflare 연구 논문에는 적용 가능한 방법론이 포함되어 있습니다. 자신의 비밀을 유출할 수 있다면 공격자도 할 수 있습니다.

5. 방어 계층화: 단일 완화 조치로는 충분하지 않습니다. 타이머 강화, 프로세스 격리, 상수 시간 코드, 단기 토큰, 카나리 탐지를 결합하세요. 각 계층은 공격 비용을 기하급수적으로 증가시킵니다.

horizOn의 서버리스 보안 접근 방식

horizOn에서는 이러한 보안 문제를 플랫폼 레벨에서 처리하여 모든 완화 조치를 직접 구현할 필요가 없도록 합니다. 당사의 서버리스 게임 백엔드 인프라에는 타이머 강화, 민감 작업에 대한 프로세스 격리, 자동 토큰 순환이 기본적으로 구성되어 있습니다.

horizOn을 통해 인증을 처리하면 토큰이 격리된 프로세스에서 상수 시간 비교로 검증되며, 암호화 키는 함수 메모리에 저장되지 않고 키 볼트 레이어를 통해 관리됩니다. 따라서 사용자 지정 보안 코드를 작성하지 않고도 Spectre 공격 표면이 최소화됩니다.

침해에서 살아남는 아키텍처를 구축하는 게임 개발자에게도 원칙은 동일합니다: 침해를 가정하고, 폭발 반경을 최소화하며, 조기에 탐지하세요.

다음 단계

오늘 서버리스 게임 백엔드를 감사하세요. 다음 세 가지 작업부터 시작하십시오:

1. 비밀 인벤토리 작성: 일반적인 게임 세션 동안 서버리스 함수 메모리에 존재하는 모든 민감 데이터를 나열하세요
2. 타이머 해상도 측정: 플랫폼이 고해상도 타이머를 노출하는지 확인하세요 (performance.now()를 루프로 실행하고 최소 델타를 측정)
3. 상수 시간 준수 테스트: 인증 및 암호화 코드에서 비밀 의존 분기를 검토하세요

Spectre 계열 공격은 사라지지 않습니다 — 이는 현대 CPU의 작동 방식에 내재되어 있습니다. 문제는 서버리스 백엔드가 이론적으로 취약한지 여부가 아니라, 공격자가 다른 곳을 찾도록 충분히 비용을 높였는지입니다.

---

출처: A revisit of remote Spectre attacks on Cloudflare Workers