StoreKit 2 の署名付きトランザクションを Cloudflare Worker で検証する

import StoreKit
 
/// 指定商品の最新トランザクションの「署名付き文字列」を取り出す。
/// 返すのは検証済みの Transaction ではなく、生の JWS 文字列である点が重要。
func latestSignedTransaction(for productID: String) async -> String? {
    // Transaction.latest は VerificationResult<Transaction> を返す
    guard let result = await Transaction.latest(for: productID) else {
        return nil
    }
    // .verified / .unverified いずれの場合も、生の JWS はここから取れる
    // 端末側の verified 判定は「参考」に留め、正本はサーバー検証に委ねる
    return result.jwsRepresentation
}
 
/// 取り出した JWS を Cloudflare Worker の検証エンドポイントへ送る
func syncEntitlement(productID: String) async throws -> Bool {
    guard let jws = await latestSignedTransaction(for: productID) else {
        return false
    }
    var request = URLRequest(url: URL(string: "https://api.example.com/verify")!)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try JSONEncoder().encode(["signedTransaction": jws])
 
    let (data, response) = try await URLSession.shared.data(for: request)
    guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
        return false
    }
    struct VerifyResponse: Decodable { let entitled: Bool }
    // サーバーが検証した結果だけを信じる
    return try JSONDecoder().decode(VerifyResponse.self, from: data).entitled
}

import { compactVerify, importX509 } from "jose";
 
// base64（標準）を base64url ではなく DER として扱うためのヘルパー
function derToPem(derBase64: string): string {
  const lines = derBase64.match(/.{1,64}/g)?.join("\n") ?? derBase64;
  return `-----BEGIN CERTIFICATE-----\n${lines}\n-----END CERTIFICATE-----`;
}
 
function decodeJwsHeader(jws: string): { alg: string; x5c: string[] } {
  const headerSegment = jws.split(".")[0];
  const json = atob(headerSegment.replace(/-/g, "+").replace(/_/g, "/"));
  return JSON.parse(json);
}
 
/// JWS の署名をリーフ証明書の公開鍵で検証し、ペイロードを返す
async function verifySignature(jws: string): Promise<Record<string, unknown>> {
  const header = decodeJwsHeader(jws);
  if (header.alg !== "ES256") {
    throw new Error(`unexpected alg: ${header.alg}`);
  }
  // x5c[0] が実際に署名したリーフ証明書
  const leafPem = derToPem(header.x5c[0]);
  const leafKey = await importX509(leafPem, "ES256");
 
  // compactVerify は署名が壊れていれば例外を投げる
  const { payload } = await compactVerify(jws, leafKey);
  return JSON.parse(new TextDecoder().decode(payload));
}

// あらかじめ Apple 公式配布の Apple Root CA - G3 を DER(base64) で埋め込んでおく
// 参照元: https://www.apple.com/certificateauthority/
const APPLE_ROOT_CA_G3_DER =
  "MIICQzCCAcmgAwIBAgIILc..."; // 実際の証明書全体をここに固定する
 
function assertAppleRoot(x5c: string[]): void {
  const presentedRoot = x5c[x5c.length - 1];
  if (presentedRoot !== APPLE_ROOT_CA_G3_DER) {
    // 送られてきたチェーンの根が、私たちが信頼する Apple ルートと違う
    throw new Error("root certificate is not the pinned Apple Root CA - G3");
  }
}
 
// ペイロードが自分のアプリの正しい商品・正しい環境を指しているかを確かめる
interface TransactionPayload {
  bundleId: string;
  productId: string;
  transactionId: string;
  environment: "Production" | "Sandbox";
}
 
function assertPayload(
  payload: TransactionPayload,
  expected: { bundleId: string; env: "Production" | "Sandbox" },
): void {
  if (payload.bundleId !== expected.bundleId) {
    throw new Error("bundleId mismatch");
  }
  if (payload.environment !== expected.env) {
    // Sandbox のトランザクションを本番の権利付与に使わせない
    throw new Error(`environment mismatch: ${payload.environment}`);
  }
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    try {
      const { signedTransaction } = await request.json<{ signedTransaction: string }>();
 
      // 1. 署名検証（リーフ鍵で JWS を確認）
      const payload = (await verifySignature(signedTransaction)) as unknown as TransactionPayload;
 
      // 2. ルート証明書の固定照合
      assertAppleRoot(decodeJwsHeader(signedTransaction).x5c);
 
      // 3. 中身の照合（bundleId / 環境）
      assertPayload(payload, { bundleId: "net.example.app", env: "Production" });
 
      // 4. リプレイ対策：transactionId の初出のみ受理
      const seenKey = `txn:${payload.transactionId}`;
      const already = await env.ENTITLEMENTS.get(seenKey);
      if (already) {
        // 既知のトランザクション。冪等に「付与済み」を返すだけにする
        return Response.json({ entitled: true, replay: true });
      }
      await env.ENTITLEMENTS.put(seenKey, "1", { expirationTtl: 60 * 60 * 24 * 400 });
 
      return Response.json({ entitled: true, productId: payload.productId });
    } catch (err) {
      // 検証に落ちたものは一律で権利なしとして扱う（deny by default）
      return Response.json({ entitled: false, reason: String(err) }, { status: 400 });
    }
  },
};
 
interface Env {
  ENTITLEMENTS: KVNamespace;
}