Rorkアプリを不正購入・リクエスト偽装から守る — App Attest / Play Integrity でAPI入口を固めるサーバーサイド検証の設計

// src/lib/appAttest.ts — iOS 側の Rork クライアントコード
import { NativeModules, Platform } from 'react-native';
 
const { AppAttestModule } = NativeModules;
 
interface AttestationResult {
  keyId: string;
  attestation: string; // Base64
}
 
// 初回のみ: App Attest 鍵ペアをデバイス Secure Enclave に生成
export async function generateAttestKey(): Promise<string> {
  if (Platform.OS \!== 'ios') throw new Error('iOS only');
 
  // Secure Enclave が使えない端末（シミュレーター等）は事前にチェック
  const isSupported = await AppAttestModule.isSupported();
  if (\!isSupported) throw new Error('App Attest not supported on this device');
 
  const keyId = await AppAttestModule.generateKey();
  return keyId; // 端末ローカルの SecureStore に保存しておく
}
 
// サーバーから渡された challenge (nonce) を鍵で署名
export async function attestKey(
  keyId: string,
  challenge: string,
): Promise<AttestationResult> {
  // challenge は SHA-256 でハッシュ化してから Apple に渡す
  const attestation = await AppAttestModule.attestKey(keyId, challenge);
  return { keyId, attestation };
}

// workers/src/attest.ts — Cloudflare Workers での検証
import { decodeCBOR, verifyCertificateChain } from './utils';
 
const APPLE_APP_ATTEST_ROOT_CERT = `-----BEGIN CERTIFICATE-----
YOUR_APPLE_ROOT_CERT_HERE
-----END CERTIFICATE-----`;
 
export async function verifyAttestation(
  keyId: string,
  attestationBase64: string,
  challenge: string,
  appIdHash: string, // "{TEAM_ID}.{BUNDLE_ID}" を SHA-256 にしたもの
  env: Env,
): Promise<{ valid: boolean; publicKey?: string; reason?: string }> {
  try {
    const attestation = atob(attestationBase64);
    const cbor = decodeCBOR(attestation);
 
    // 1. Apple 証明書チェーンの検証
    const chainValid = await verifyCertificateChain(
      cbor.attStmt.x5c,
      APPLE_APP_ATTEST_ROOT_CERT,
    );
    if (\!chainValid) return { valid: false, reason: 'cert_chain_invalid' };
 
    // 2. authData の nonce に challenge の SHA-256 が含まれているか
    const expectedNonce = await sha256(challenge);
    if (\!cbor.authData.nonce.equals(expectedNonce)) {
      return { valid: false, reason: 'nonce_mismatch' };
    }
 
    // 3. App ID ハッシュの一致確認
    if (\!cbor.authData.rpIdHash.equals(appIdHash)) {
      return { valid: false, reason: 'app_id_mismatch' };
    }
 
    // 4. keyId と公開鍵をハッシュで照合
    const publicKey = extractPublicKey(cbor.attStmt.x5c[0]);
    const keyIdCheck = await sha256(publicKey);
    if (\!keyIdCheck.equals(keyId)) {
      return { valid: false, reason: 'key_id_mismatch' };
    }
 
    // 5. 検証済みキーを KV に保存（公開鍵は以降のアサーション検証で使う）
    await env.ATTEST_KV.put(`attest:ios:${keyId}`, publicKey, {
      expirationTtl: 60 * 60 * 24 * 90, // 90日
    });
 
    return { valid: true, publicKey };
  } catch (err) {
    return { valid: false, reason: `parse_error:${(err as Error).message}` };
  }
}

// src/lib/playIntegrity.ts — Android 側の Rork クライアントコード
import { NativeModules, Platform } from 'react-native';
 
const { PlayIntegrityModule } = NativeModules;
 
export async function getIntegrityToken(nonce: string): Promise<string> {
  if (Platform.OS \!== 'android') throw new Error('Android only');
  // Play Integrity API は nonce を使って再生攻撃を防止する
  const token = await PlayIntegrityModule.requestToken(nonce);
  return token;
}

// workers/src/playIntegrity.ts
import { jwtDecrypt, importJWK } from 'jose';
 
export async function verifyPlayIntegrityToken(
  token: string,
  expectedPackageName: string,
  expectedNonce: string,
  env: Env,
): Promise<{ valid: boolean; reason?: string }> {
  try {
    // 1. Google の公開鍵で JWE を復号（環境変数で管理）
    const decryptKey = await importJWK(JSON.parse(env.PLAY_INTEGRITY_DECRYPT_KEY));
    const { payload } = await jwtDecrypt(token, decryptKey);
 
    // 2. nonce の一致確認（リクエストで渡した値と同じか）
    if (payload.nonce \!== expectedNonce) {
      return { valid: false, reason: 'nonce_mismatch' };
    }
 
    // 3. パッケージ名の一致確認
    const pkgName = (payload.requestDetails as any)?.requestPackageName;
    if (pkgName \!== expectedPackageName) {
      return { valid: false, reason: 'package_mismatch' };
    }
 
    // 4. アプリインテグリティ判定
    const appIntegrity = (payload.appIntegrity as any)?.appRecognitionVerdict;
    if (appIntegrity \!== 'PLAY_RECOGNIZED') {
      return { valid: false, reason: `app_integrity:${appIntegrity}` };
    }
 
    // 5. 端末インテグリティ判定（MEETS_DEVICE_INTEGRITY 以上を要求）
    const deviceIntegrity = (payload.deviceIntegrity as any)?.deviceRecognitionVerdict || [];
    if (\!deviceIntegrity.includes('MEETS_DEVICE_INTEGRITY')) {
      return { valid: false, reason: 'device_integrity_low' };
    }
 
    return { valid: true };
  } catch (err) {
    return { valid: false, reason: `decrypt_error:${(err as Error).message}` };
  }
}

// workers/src/storekit.ts
import { importX509, jwtVerify } from 'jose';
 
const APPLE_ROOT_CA_G3 = `-----BEGIN CERTIFICATE-----
YOUR_APPLE_ROOT_CA_G3_HERE
-----END CERTIFICATE-----`;
 
export async function verifyStoreKitTransaction(
  signedTransaction: string,
  expectedBundleId: string,
  expectedProductId: string,
): Promise<{ valid: boolean; transaction?: any; reason?: string }> {
  try {
    // JWS ヘッダーから x5c（証明書チェーン）を抽出
    const [headerB64] = signedTransaction.split('.');
    const header = JSON.parse(atob(headerB64));
    const certs = header.x5c as string[];
 
    // Apple のルート証明書までチェーンを検証
    const leafCertPem = `-----BEGIN CERTIFICATE-----\n${certs[0]}\n-----END CERTIFICATE-----`;
    const leafKey = await importX509(leafCertPem, 'ES256');
 
    const { payload } = await jwtVerify(signedTransaction, leafKey, {
      algorithms: ['ES256'],
    });
 
    // バンドル ID と商品 ID の一致確認
    if (payload.bundleId \!== expectedBundleId) {
      return { valid: false, reason: 'bundle_id_mismatch' };
    }
    if (payload.productId \!== expectedProductId) {
      return { valid: false, reason: 'product_id_mismatch' };
    }
 
    // 期限切れ・返金済みチェック
    if (payload.revocationDate) {
      return { valid: false, reason: 'revoked' };
    }
 
    return { valid: true, transaction: payload };
  } catch (err) {
    return { valid: false, reason: `verify_error:${(err as Error).message}` };
  }
}

// workers/src/index.ts — 3層検証を束ねるゲート
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
 
    // 1. レート制限チェック（キーIDベース）
    const keyId = request.headers.get('X-Attest-Key-Id');
    if (\!keyId) return new Response('missing_key', { status: 401 });
 
    const rateLimitOk = await checkRateLimit(keyId, env);
    if (\!rateLimitOk) return new Response('rate_limited', { status: 429 });
 
    // 2. アサーション検証（API 呼び出しの認証）
    if (url.pathname.startsWith('/api/ai/')) {
      const assertion = request.headers.get('X-Attest-Assertion');
      const valid = await verifyAssertion(keyId, assertion, request, env);
      if (\!valid) return new Response('invalid_assertion', { status: 401 });
    }
 
    // 3. 購入検証（課金系のみ）
    if (url.pathname === '/api/purchase/verify') {
      const body = await request.json<{ signedTransaction: string }>();
      const result = await verifyStoreKitTransaction(
        body.signedTransaction,
        env.BUNDLE_ID,
        env.PRODUCT_ID_PREMIUM,
      );
      if (\!result.valid) return Response.json(result, { status: 400 });
 
      // エンタイトルメントを KV に書き込み
      await env.ENTITLEMENT_KV.put(
        `user:${result.transaction.appAccountToken}:premium`,
        JSON.stringify({ transactionId: result.transaction.transactionId }),
        { expirationTtl: 60 * 60 * 24 * 365 },
      );
      return Response.json({ ok: true });
    }
 
    // 4. 実処理へのプロキシ
    return fetch(url.toString(), request);
  },
};

// workers/src/assertion.ts — リクエストごとのアサーション検証
import { importSPKI, verify } from './crypto-utils';
 
export async function verifyAssertion(
  keyId: string,
  assertionBase64: string | null,
  request: Request,
  env: Env,
): Promise<boolean> {
  if (\!assertionBase64) return false;
 
  // アテステーション時に保存した公開鍵を KV から取得
  const publicKey = await env.ATTEST_KV.get(`attest:ios:${keyId}`);
  if (\!publicKey) return false;
 
  try {
    const cbor = decodeCBOR(atob(assertionBase64));
    const clientData = await request.clone().text();
    const clientDataHash = await sha256(clientData);
 
    // authData + clientDataHash が署名と一致するか
    const message = new Uint8Array([...cbor.authData, ...clientDataHash]);
    const signatureValid = await verifyEcdsaSignature(
      publicKey,
      message,
      cbor.signature,
    );
    if (\!signatureValid) return false;
 
    // カウンターが単調増加していることを確認 — リプレイ攻撃対策
    const lastCounter = parseInt(
      (await env.ATTEST_KV.get(`counter:${keyId}`)) || '0',
      10,
    );
    if (cbor.authData.counter <= lastCounter) return false;
 
    await env.ATTEST_KV.put(
      `counter:${keyId}`,
      cbor.authData.counter.toString(),
    );
 
    return true;
  } catch {
    return false;
  }
}

// workers/src/nonce.ts
export async function issueNonce(env: Env): Promise<string> {
  // 暗号学的に強い32バイトをhex化
  const bytes = crypto.getRandomValues(new Uint8Array(32));
  const nonce = Array.from(bytes)
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
 
  // 30秒TTLで保留中として保存
  await env.NONCE_KV.put(`nonce:pending:${nonce}`, '1', {
    expirationTtl: 30,
  });
  return nonce;
}
 
export async function consumeNonce(nonce: string, env: Env): Promise<boolean> {
  // get-then-delete で原子的に消費
  const pending = await env.NONCE_KV.get(`nonce:pending:${nonce}`);
  if (\!pending) return false;
 
  await env.NONCE_KV.delete(`nonce:pending:${nonce}`);
  // 使用済みマーカーで二重消費を防ぐ
  await env.NONCE_KV.put(`nonce:used:${nonce}`, '1', {
    expirationTtl: 120,
  });
  return true;
}

interface AttestEvent {
  timestamp: number;
  platform: 'ios' | 'android';
  outcome: 'success' | 'failure';
  reason?: string;          // cert_chain_invalid 等
  endpoint: string;         // 呼ばれた API
  keyId: string;            // フル ID ではなく SHA-256 プレフィックスのみ
  country?: string;         // Cloudflare cf-ipcountry から
}