HS256 と RS256 の違いを、仕様と実測で決着させる — JWT署名方式の選定・鍵ローテーション・無停止移行

Q1. そのトークンを検証する主体は、発行する権限を持ってよいか？
    ├─ NO  → RS256 / ES256（非対称）  ← ここで決着することが多い
    └─ YES → Q2 へ

Q2. 検証者は将来にわたって1つの信頼ドメインに閉じるか？
    （マイクロサービス分割・BFF追加・別チームへの提供予定はないか）
    ├─ NO  → RS256 / ES256
    └─ YES → Q3 へ

Q3. 32バイトの暗号論的乱数鍵を、シークレットマネージャで
    安全に配布・ローテーションできる運用があるか？
    ├─ NO  → RS256（公開鍵配布のほうが運用事故に強い）
    └─ YES → HS256 で十分。速く、短く、鍵管理も単純。

【HS256】共有鍵モデル — 鍵の配布先ぶんだけ「発行者」が増える
                    ┌──────────────┐
     ┌─────────────►│ 注文サービス  │ K を持つ → 偽造可能 ⚠
     │              └──────────────┘
┌────┴─────┐        ┌──────────────┐
│ 認証サーバ │───────►│ 在庫サービス  │ K を持つ → 偽造可能 ⚠
│  鍵 K     │        └──────────────┘
└────┬─────┘        ┌──────────────┐
     └─────────────►│ 通知サービス  │ K を持つ → 偽造可能 ⚠
                    └──────────────┘
     ※ 1サービスの侵害 = 認証基盤全体の侵害

【RS256】公開鍵モデル — 発行者はひとりだけ
                    ┌──────────────┐
     ┌─────────────►│ 注文サービス  │ 公開鍵のみ → 検証だけ ✅
     │  JWKS(公開鍵) └──────────────┘
┌────┴─────┐        ┌──────────────┐
│ 認証サーバ │───────►│ 在庫サービス  │ 公開鍵のみ → 検証だけ ✅
│ 秘密鍵 sk │        └──────────────┘
└────┬─────┘        ┌──────────────┐
     └─────────────►│ 通知サービス  │ 公開鍵のみ → 検証だけ ✅
                    └──────────────┘
     ※ 1サービスが侵害されても、トークンは偽造できない

# 32バイト（256ビット）の暗号論的乱数。これが最低ライン。
openssl rand -base64 32
# 出力例は44文字の base64。例示値をそのまま使い回さないこと

# Node.js なら
node -e "console.log(require('node:crypto').randomBytes(32).toString('base64url'))"

// ❌ 絶対にやってはいけない
const secret = new TextEncoder().encode("supersecret2026");

// ❌ これも同罪（env 経由でも、値が人間由来なら意味は同じ）
const secret = new TextEncoder().encode(process.env.JWT_SECRET!); // 値が "changeme" だったら？

// ✅ 起動時にエントロピー要件を検証して fail-fast させる
import { z } from "zod";

/**
 * JWT 署名鍵は base64url エンコードされた 32 バイト以上の乱数であることを起動時に強制する。
 * RFC 7518 3.2 は「ハッシュ出力長以上」を MUST とするが、実際の強度は鍵のエントロピーで
 * 決まる（NIST SP 800-57 Pt.1 Rev.5 Table 3 注記）。長さだけでなく由来も規約で縛る。
 */
const HmacSecretSchema = z
  .string()
  .min(43, "JWT_SIGNING_KEY must be >= 32 bytes (base64url). Generate with: openssl rand -base64 32")
  .transform((raw, ctx) => {
    // Node の base64 デコーダはアルファベット外の文字を黙って捨てる。素朴に復号するだけだと
    // "MyVeryLongButTotallyMemorablePassword..." のような人間由来の文字列も34バイトに
    // 「復号」できてしまうので、再エンコードして正準形であることを確かめる
    const normalized = raw.replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
    const bytes = Buffer.from(normalized, "base64");
    if (!/^[A-Za-z0-9+/]+$/.test(normalized) ||
        Buffer.from(bytes).toString("base64").replace(/=+$/, "") !== normalized) {
      ctx.addIssue({ code: "custom", message: "key must be canonical base64/base64url from a CSPRNG" });
      return z.NEVER;
    }
    if (bytes.byteLength < 32) {
      ctx.addIssue({ code: "custom", message: "decoded key must be >= 256 bits" });
      return z.NEVER;
    }
    return new Uint8Array(bytes);
  });

// モジュール読み込み時に評価 → 弱い鍵ではプロセスが起動しない
export const HMAC_SECRET = HmacSecretSchema.parse(process.env.JWT_SIGNING_KEY);

// bench.mjs — HS256 / RS256 / ES256 / EdDSA の署名・検証コストを測る
import {
  createSign, createVerify, createHmac, generateKeyPairSync,
  timingSafeEqual, sign as nodeSign, verify as nodeVerify,
} from "node:crypto";

const N = 2000;
const data = Buffer.from("eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1XzAxIn0");

/** ウォームアップ1回のあと N 回計測し、1回あたりのマイクロ秒とスループットを返す */
const bench = (label, fn) => {
  fn();
  const start = process.hrtime.bigint();
  for (let i = 0; i < N; i++) fn();
  const ms = Number(process.hrtime.bigint() - start) / 1e6;
  return { label, opsPerSec: Math.round(N / (ms / 1000)), usPerOp: +((ms * 1000) / N).toFixed(1) };
};

const rows = [];
const secret = Buffer.alloc(32, 7);
const mac = createHmac("sha256", secret).update(data).digest();
rows.push(bench("HS256 sign", () => createHmac("sha256", secret).update(data).digest()));
rows.push(bench("HS256 verify", () =>
  timingSafeEqual(createHmac("sha256", secret).update(data).digest(), mac)));

for (const bits of [2048, 4096]) {
  const { privateKey, publicKey } = generateKeyPairSync("rsa", { modulusLength: bits });
  const sig = createSign("sha256").update(data).sign(privateKey);
  rows.push(bench(`RS256 sign (RSA-${bits})`, () => createSign("sha256").update(data).sign(privateKey)));
  rows.push(bench(`RS256 verify (RSA-${bits})`, () => createVerify("sha256").update(data).verify(publicKey, sig)));
}

const ec = generateKeyPairSync("ec", { namedCurve: "P-256" });
const ecSig = createSign("sha256").update(data).sign(ec.privateKey);
rows.push(bench("ES256 sign (P-256)", () => createSign("sha256").update(data).sign(ec.privateKey)));
rows.push(bench("ES256 verify (P-256)", () => createVerify("sha256").update(data).verify(ec.publicKey, ecSig)));

const ed = generateKeyPairSync("ed25519");
const edSig = nodeSign(null, data, ed.privateKey);
rows.push(bench("EdDSA sign (Ed25519)", () => nodeSign(null, data, ed.privateKey)));
rows.push(bench("EdDSA verify (Ed25519)", () => nodeVerify(null, data, ed.publicKey, edSig)));

console.log(process.version, process.arch, process.platform);
console.table(rows);

1. GET https://auth.example.com/.well-known/jwks.json  → 公開鍵 pub を入手
2. 正規ログインでトークンを1つ入手し、payload の "role":"user" を "role":"admin" に書き換え
3. header の "alg":"RS256" を "alg":"HS256" に書き換え
4. HMAC-SHA256(key = pub のバイト列, header.payload) で署名を計算
5. サーバは alg を見て HMAC 検証を選び、鍵として pub を使う → 検証成功 → 権限昇格

// ❌ ライブラリのデフォルトに任せる（alg を検証していない）
await jwtVerify(token, key);

// ✅ アプリが alg を決める。トークンの申告は判断材料にしない。
await jwtVerify(token, key, { algorithms: ["RS256"] });

// src/auth/claims.ts
import { z } from "zod";

/**
 * アプリが受理するアクセストークンのクレーム契約。
 * jose は iss/aud/exp/nbf/iat の「存在と一致」を検証するが、
 * アプリ固有クレーム（scope / tenant）の形までは知らない。ここが最後の砦。
 */
export const AccessTokenClaimsSchema = z.object({
  iss: z.url(),
  sub: z.string().min(1),
  aud: z.union([z.string(), z.array(z.string()).nonempty()]),
  exp: z.number().int().positive(),
  iat: z.number().int().positive(),
  jti: z.string().min(1),
  /** RFC 6749 のスペース区切り scope。配列へ正規化して扱う */
  scope: z
    .string()
    .transform((s) => s.split(" ").filter(Boolean))
    .pipe(z.array(z.string()).nonempty()),
  /** マルチテナントの所属。RLS などデータ層の認可キーになるため必須 */
  tenant_id: z.uuid(),
});

export type AccessTokenClaims = z.infer<typeof AccessTokenClaimsSchema>;

/** 認証失敗の分類。メトリクスの次元になるので、増やすときは意味を1つに保つ */
export type AuthFailureReason =
  | "malformed"        // JWT の形をしていない
  | "alg_not_allowed"  // 許可していない alg（＝混同攻撃の疑い）
  | "signature"        // 署名不一致
  | "expired"          // exp 超過
  | "claim"            // iss/aud/typ/sub などの不一致
  | "schema"           // 署名は正しいがクレームの形が契約違反
  | "unknown_kid"      // kid に対応する鍵がない（kid は攻撃者が任意に指定できる入力）
  | "key_unavailable"; // JWKS の取得自体に失敗＝こちらの障害（≠ トークンが不正）

export type AuthResult =
  | { readonly ok: true; readonly claims: AccessTokenClaims }
  | { readonly ok: false; readonly reason: AuthFailureReason };

// src/auth/verify-rs256.ts
import { createRemoteJWKSet, jwtVerify } from "jose";
// jose v6 はエラークラスをルートから export しない。サブパス "jose/errors" から取る
import {
  JOSEAlgNotAllowed,
  JWKSNoMatchingKey,
  JWKSTimeout,
  JWSSignatureVerificationFailed,
  JWTExpired,
  JWTClaimValidationFailed,
  JWTInvalid,
} from "jose/errors";
import { AccessTokenClaimsSchema, type AuthFailureReason, type AuthResult } from "./claims";

/**
 * JWKS リゾルバはモジュールスコープで1つだけ持つ。
 * - cacheMaxAge: 鍵をキャッシュする上限時間（既定10分）
 * - cooldownDuration: 連続再取得の抑制（既定30秒）。未知の kid が来ても
 *   この間隔より頻繁には再取得しないため、JWKS エンドポイントへの DoS 踏み台化を防ぐ
 * - timeoutDuration: 取得のタイムアウト（jose の既定は5秒。ここでは3秒に短縮している）。長すぎるとリクエストを道連れにする
 */
export const jwks = createRemoteJWKSet(new URL(process.env.JWKS_URI!), {
  cacheMaxAge: 10 * 60_000,
  cooldownDuration: 30_000,
  timeoutDuration: 3_000,
});

const ISSUER = process.env.TOKEN_ISSUER!;
const AUDIENCE = process.env.TOKEN_AUDIENCE!;

export async function verifyAccessToken(
  token: string,
  // 鍵リゾルバは差し替え可能にする。既定は本番の JWKS、テストからはローカル JWKS を注入できる
  keys: Parameters<typeof jwtVerify>[1] = jwks,
): Promise<AuthResult> {
  try {
    const { payload } = await jwtVerify(token, keys, {
      // ① アプリが alg を決める。トークンの申告は信用しない（RFC 8725 §3.1）
      algorithms: ["RS256"],
      // ② トークン種別を固定してクロス JWT 混同を防ぐ（RFC 9068 §4 / RFC 8725 §3.11）
      typ: "at+jwt",
      // ③ 発行者と対象を固定（RFC 8725 §3.8 / §3.9）
      issuer: ISSUER,
      audience: AUDIENCE,
      // ④ 時計ずれの許容は「秒」単位に留める。分単位はトークン失効を無意味にする
      clockTolerance: 5,
      // ⑤ 発行から時間が経ちすぎたトークンを弾く（exp とは独立の防御）
      maxTokenAge: "1 hour",
      // ⑥ 欠けていたら即失敗させるクレーム。既定では検証されないものを明示する
      requiredClaims: ["exp", "sub", "jti", "tenant_id", "scope"],
    });

    // ⑦ 署名が正しいことと、中身が契約通りであることは別。ここで形を確定させる
    const parsed = AccessTokenClaimsSchema.safeParse(payload);
    if (!parsed.success) return { ok: false, reason: "schema" };

    return { ok: true, claims: parsed.data };
  } catch (error) {
    return { ok: false, reason: classify(error) };
  }
}

/** jose のエラークラスを、観測可能な有限の理由コードに落とす */
function classify(error: unknown): AuthFailureReason {
  if (error instanceof JWTExpired) return "expired";
  if (error instanceof JOSEAlgNotAllowed) return "alg_not_allowed";
  if (error instanceof JWSSignatureVerificationFailed) return "signature";
  if (error instanceof JWTClaimValidationFailed) return "claim";
  if (error instanceof JWTInvalid) return "malformed";
  // kid は攻撃者が任意に指定できる入力。「その kid の鍵が無い」はトークン側の問題として 401 に落とす
  if (error instanceof JWKSNoMatchingKey) return "unknown_kid";
  // 取得そのものの失敗＝サーバ側の障害。トークンが不正だとは限らないので別扱いにする
  if (error instanceof JWKSTimeout) return "key_unavailable";
  return "signature"; // 未知の失敗は最も保守的な扱い（fail-closed）
}

// src/auth/verify-hs256.ts
import { jwtVerify } from "jose";
import { HMAC_SECRET } from "./env";
import { AccessTokenClaimsSchema, type AuthResult } from "./claims";

export async function verifySessionToken(token: string): Promise<AuthResult> {
  try {
    const { payload } = await jwtVerify(token, HMAC_SECRET, {
      // 対称鍵しか渡していなくても明示する。将来 key が JWKS に変わったとき、
      // この1行がアルゴリズム混同を防ぐ最後の防壁になる
      algorithms: ["HS256"],
      typ: "at+jwt",
      issuer: process.env.TOKEN_ISSUER!,
      audience: process.env.TOKEN_AUDIENCE!,
      clockTolerance: 5,
      requiredClaims: ["exp", "sub", "jti", "tenant_id", "scope"],
    });
    const parsed = AccessTokenClaimsSchema.safeParse(payload);
    return parsed.success ? { ok: true, claims: parsed.data } : { ok: false, reason: "schema" };
  } catch {
    return { ok: false, reason: "signature" };
  }
}

// src/auth/issue.ts
import { SignJWT, importPKCS8 } from "jose";
import { randomUUID } from "node:crypto";

/** 秘密鍵は起動時に1度だけ import する。毎回パースするとRSA署名より重くなる */
const signingKey = await importPKCS8(process.env.SIGNING_PRIVATE_KEY_PEM!, "RS256");
const SIGNING_KID = process.env.SIGNING_KEY_ID!; // 例: "2026-08-a"

export async function issueAccessToken(input: {
  subject: string;
  tenantId: string;
  scope: readonly string[];
}): Promise<string> {
  return new SignJWT({ tenant_id: input.tenantId, scope: input.scope.join(" ") })
    // kid はローテーションの生命線。これが無いと鍵を2本並行運用できない（RFC 7515 §4.1.4）
    .setProtectedHeader({ alg: "RS256", kid: SIGNING_KID, typ: "at+jwt" })
    .setIssuer(process.env.TOKEN_ISSUER!)
    .setAudience(process.env.TOKEN_AUDIENCE!)
    .setSubject(input.subject)
    .setJti(randomUUID())      // 失効リスト／再生検知のキー
    .setIssuedAt()
    .setExpirationTime("15m")  // アクセストークンは短命に。失効はリフレッシュ側で担う
    .sign(signingKey);
}

// src/auth/middleware.ts
import { verifyAccessToken } from "./verify-rs256";

/**
 * 記録してよいもの: 失敗理由コード、alg（ヘッダから読める）、kid、経過時間
 * 記録してはいけないもの: トークン本体、payload、sub、メールアドレス等の PII
 *   → トークンをログに書くと、ログ閲覧権限がそのまま成りすまし権限になる
 */
export async function authenticate(req: Request): Promise<Response | AuthContext> {
  const header = req.headers.get("authorization");
  if (!header?.startsWith("Bearer ")) {
    metrics.increment("auth.failure", { reason: "malformed" });
    return unauthorized();
  }

  const result = await verifyAccessToken(header.slice(7));

  if (!result.ok) {
    metrics.increment("auth.failure", { reason: result.reason });

    // 混同攻撃の試行は「珍しいイベント」なので、必ず単独でアラートを張る。
    // 平常時ゼロのはずの系列が立ち上がったら、それは攻撃かクライアントの重大なバグ。
    if (result.reason === "alg_not_allowed") {
      logger.warn("jwt.alg_rejected", { path: new URL(req.url).pathname });
    }
    // 鍵が引けないのは IdP 側の障害。攻撃と混ぜないよう 503 で返す
    if (result.reason === "key_unavailable") return serviceUnavailable();

    return unauthorized();
  }

  metrics.increment("auth.success");
  return { userId: result.claims.sub, tenantId: result.claims.tenant_id, scope: result.claims.scope };
}

Phase 1 (T+0)  新鍵ペア B を生成。JWKS に B の公開鍵を「追加」する（A も残す）
               → 検証側は kid で A/B どちらも引ける。署名はまだ A
               ★ cacheMaxAge（既定10分）ぶん待ち、全検証者が B を認識するまで進まない

Phase 2 (T+1h) 発行側の署名鍵を B に切り替える（SIGNING_KEY_ID = "2026-08-b"）
               → 新規トークンは kid=B。既存の kid=A トークンも有効期限まで通る

Phase 3 (T+1h + アクセストークンTTL + 余裕)
               A で署名されたトークンが全て期限切れになったことをメトリクスで確認
               （auth.success{kid="2026-08-a"} が 0 になる）

Phase 4        JWKS から A の公開鍵を削除。秘密鍵 A を破棄

// .well-known/jwks.json — Phase 1〜3 の状態（RFC 7517）
{
  "keys": [
    { "kty": "RSA", "use": "sig", "alg": "RS256", "kid": "2026-08-a", "n": "...", "e": "AQAB" },
    { "kty": "RSA", "use": "sig", "alg": "RS256", "kid": "2026-08-b", "n": "...", "e": "AQAB" }
  ]
}

Phase 1  新鍵 K2 を生成し、全検証者に「検証用の追加鍵」として配布
         → 検証側は K1 と K2 の両方を試す（同時受理ウィンドウの開始）
         ★ 全検証者への配布完了を確認するまで Phase 2 に進めない
Phase 2  発行側の署名鍵を K2 に切替
Phase 3  K1 署名のトークンが全て失効するまで待つ
Phase 4  全検証者から K1 を削除

// HS256 のローテーション対応。kid で鍵を引けるようにしておくと総当たりを避けられる
import { decodeProtectedHeader } from "jose";

// KEY_A / KEY_B は 2.3 の HmacSecretSchema で検証済みの Uint8Array
const HMAC_KEYS: ReadonlyMap<string, Uint8Array> = new Map([
  ["2026-08-a", KEY_A],
  ["2026-08-b", KEY_B],
]);

export async function verifyWithRotation(token: string): Promise<AuthResult> {
  // kid を見て鍵を1本に絞る。総当たりは検証コストが鍵数に比例し、
  // かつ「どの鍵で通ったか」の観測を難しくする
  const kid = decodeProtectedHeader(token).kid;
  const key = kid ? HMAC_KEYS.get(kid) : undefined;
  // kid はトークン側の申告。解決できないのは障害ではなく、トークンの問題として扱う
  if (!key) return { ok: false, reason: "unknown_kid" };
  // 以下は 5.3 と同じ：algorithms: ["HS256"] を必ず指定して jwtVerify する
  return verifyHs256(token, key);
}

              発行 alg      検証で受理する alg      ユーザー影響
Phase 0       HS256         HS256                   —（現状）
Phase 1       HS256         HS256 + RS256           なし ★全検証者のデプロイ完了を待つ
Phase 2       RS256         HS256 + RS256           なし（既存トークンは期限まで有効）
Phase 3       RS256         RS256                   なし（HS256 トークンは既に全失効）

// ❌ 危険：RS256 の公開鍵を HS256 の鍵として使われる余地を作ってしまう
await jwtVerify(token, someKeyResolver, { algorithms: ["HS256", "RS256"] });

// ✅ 正しい：ヘッダの alg で「鍵とアルゴリズムのペア」を排他的に選び、
//    選んだ後は 1 アルゴリズムに固定して検証する（RFC 8725 §3.1「各鍵はちょうど1つのアルゴリズム」）
import { decodeProtectedHeader, jwtVerify, type JWTVerifyOptions } from "jose";
import { jwks } from "./verify-rs256";      // 5.2 の createRemoteJWKSet
import { HMAC_SECRET } from "./env";        // 2.3 の Zod で検証済みの対称鍵
import { AccessTokenClaimsSchema, type AuthResult } from "./claims";

/** alg 以外の検証条件は 1 か所に集約する（DRY）。経路ごとに差があるのは alg と鍵だけ */
const COMMON: JWTVerifyOptions = {
  typ: "at+jwt",
  issuer: process.env.TOKEN_ISSUER!,
  audience: process.env.TOKEN_AUDIENCE!,
  clockTolerance: 5,
  requiredClaims: ["exp", "sub", "jti", "tenant_id", "scope"],
};

/** 鍵と検証オプションの組を受け取り、クレーム契約の検証まで通して Result を返す */
async function verifyWith(
  token: string,
  key: Parameters<typeof jwtVerify>[1],
  options: JWTVerifyOptions,
): Promise<AuthResult> {
  try {
    const { payload } = await jwtVerify(token, key, options);
    const parsed = AccessTokenClaimsSchema.safeParse(payload);
    return parsed.success ? { ok: true, claims: parsed.data } : { ok: false, reason: "schema" };
  } catch (error) {
    return { ok: false, reason: classify(error) }; // 5.2 の classify を再利用
  }
}

export async function verifyDuringMigration(token: string): Promise<AuthResult> {
  let alg: string | undefined;
  try {
    // ヘッダの読み取りは「どの検証経路を選ぶか」の分岐にのみ使う。
    // ここで読んだ値をそのまま検証パラメータに流さないことが肝。
    alg = decodeProtectedHeader(token).alg;
  } catch {
    return { ok: false, reason: "malformed" };
  }

  switch (alg) {
    case "RS256":
      // RS256 経路には JWKS しか渡らない → HMAC 鍵として使われようがない
      return verifyWith(token, jwks, { ...COMMON, algorithms: ["RS256"] });
    case "HS256":
      // HS256 経路には対称鍵しか渡らない → 公開鍵が紛れ込む経路が存在しない
      return verifyWith(token, HMAC_SECRET, { ...COMMON, algorithms: ["HS256"] });
    default:
      // none も、未知の alg も、ここで死ぬ。既定を「拒否」にするのが fail-closed
      return { ok: false, reason: "alg_not_allowed" };
  }
}

// Phase 3：HS256 経路を削除する。この差分を出して初めて Phase 3 に入ったと言える
  switch (alg) {
    case "RS256":
      return verifyWith(token, jwks, { ...COMMON, algorithms: ["RS256"] });
    default:
      // HS256 もここに落ちる。戻したいときは Phase 2 のビルドを再デプロイする
      return { ok: false, reason: "alg_not_allowed" };
  }

// src/auth/verify.test.ts — vitest
import { describe, expect, it, beforeAll } from "vitest";
import { SignJWT, createLocalJWKSet, exportJWK, exportSPKI, generateKeyPair } from "jose";
import { createHmac } from "node:crypto";
import { verifyAccessToken } from "./verify-rs256";

let privateKey: CryptoKey;
let publicKeyPem: string;
let localJwks: ReturnType<typeof createLocalJWKSet>;

beforeAll(async () => {
  const pair = await generateKeyPair("RS256", { extractable: true });
  privateKey = pair.privateKey;
  publicKeyPem = await exportSPKI(pair.publicKey);
  // 本番の createRemoteJWKSet を差し替える。ネットワークにも JWKS_URI にも依存させない
  localJwks = createLocalJWKSet({
    keys: [{ ...(await exportJWK(pair.publicKey)), kid: "2026-08-a", alg: "RS256" }],
  });
});

const base = () =>
  new SignJWT({ tenant_id: "3f1b7c8e-0000-4000-8000-000000000000", scope: "orders:read" })
    .setIssuer("https://auth.example.com")
    .setAudience("https://api.example.com")
    .setSubject("u_01")
    .setJti("t1")
    .setIssuedAt()
    .setExpirationTime("15m");

describe("verifyAccessToken", () => {
  it("正規の RS256 トークンを受理する", async () => {
    const token = await base()
      .setProtectedHeader({ alg: "RS256", kid: "2026-08-a", typ: "at+jwt" })
      .sign(privateKey);
    await expect(verifyAccessToken(token, localJwks)).resolves.toMatchObject({ ok: true });
  });

  it("【混同攻撃】公開鍵を HMAC 鍵に使った HS256 トークンを拒否する", async () => {
    // RFC 8725 §2.1 の攻撃を実際に組み立てる。公開鍵は誰でも入手できる前提
    const header = Buffer.from(
      JSON.stringify({ alg: "HS256", kid: "2026-08-a", typ: "at+jwt" }),
    ).toString("base64url");
    const payload = Buffer.from(
      JSON.stringify({
        iss: "https://auth.example.com", aud: "https://api.example.com",
        sub: "u_01", jti: "t1", tenant_id: "3f1b7c8e-0000-4000-8000-000000000000", scope: "admin:all",
        iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 900,
      }),
    ).toString("base64url");
    const forged = `${header}.${payload}.${createHmac("sha256", publicKeyPem)
      .update(`${header}.${payload}`)
      .digest("base64url")}`;

    await expect(verifyAccessToken(forged, localJwks)).resolves.toEqual({
      ok: false,
      reason: "alg_not_allowed",
    });
  });

  it("【alg:none】署名なしトークンを拒否する", async () => {
    const header = Buffer.from(JSON.stringify({ alg: "none", typ: "at+jwt" })).toString("base64url");
    const payload = Buffer.from(JSON.stringify({ sub: "admin" })).toString("base64url");
    await expect(verifyAccessToken(`${header}.${payload}.`, localJwks)).resolves.toEqual({
      ok: false,
      reason: "alg_not_allowed",
    });
  });

  it("【種別混同】typ が at+jwt でないトークンを拒否する（RFC 9068 §4）", async () => {
    const idToken = await base()
      .setProtectedHeader({ alg: "RS256", kid: "2026-08-a", typ: "JWT" })
      .sign(privateKey);
    await expect(verifyAccessToken(idToken, localJwks)).resolves.toEqual({ ok: false, reason: "claim" });
  });

  it("【別テナント】aud が異なるトークンを拒否する（RFC 8725 §3.9）", async () => {
    const token = await base()
      .setAudience("https://other-api.example.com")
      .setProtectedHeader({ alg: "RS256", kid: "2026-08-a", typ: "at+jwt" })
      .sign(privateKey);
    await expect(verifyAccessToken(token, localJwks)).resolves.toEqual({ ok: false, reason: "claim" });
  });

  it("【期限切れ】exp を過ぎたトークンを拒否する", async () => {
    const token = await base()
      .setExpirationTime(Math.floor(Date.now() / 1000) - 60)
      .setProtectedHeader({ alg: "RS256", kid: "2026-08-a", typ: "at+jwt" })
      .sign(privateKey);
    await expect(verifyAccessToken(token, localJwks)).resolves.toEqual({ ok: false, reason: "expired" });
  });

  it("【契約違反】署名は正しいが tenant_id を欠くトークンを拒否する", async () => {
    const token = await new SignJWT({ scope: "orders:read" })
      .setProtectedHeader({ alg: "RS256", kid: "2026-08-a", typ: "at+jwt" })
      .setIssuer("https://auth.example.com").setAudience("https://api.example.com")
      .setSubject("u_01").setJti("t1").setIssuedAt().setExpirationTime("15m")
      .sign(privateKey);
    await expect(verifyAccessToken(token, localJwks)).resolves.toEqual({ ok: false, reason: "claim" });
  });
});