// Base64URL エンコード/デコードの実装
 
function base64UrlEncode(input: string | Uint8Array): string {
  let bytes: Uint8Array;
  if (typeof input === 'string') {
    bytes = new TextEncoder().encode(input);
  } else {
    bytes = input;
  }
 
  // 標準 Base64 にエンコード
  const base64 = btoa(String.fromCharCode(...bytes));
 
  // Base64URL に変換: + → -, / → _, = 除去
  return base64
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');
}
 
function base64UrlDecode(input: string): Uint8Array {
  // Base64URL → 標準 Base64 に復元
  let base64 = input
    .replace(/-/g, '+')
    .replace(/_/g, '/');
 
  // パディングを追加
  while (base64.length % 4 !== 0) {
    base64 += '=';
  }
 
  const binary = atob(base64);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i++) {
    bytes[i] = binary.charCodeAt(i);
  }
  return bytes;
}
 
// JWT を手動でデコード（署名検証なし、デバッグ用）
function decodeJwtPayload(token: string): Record<string, unknown> {
  const parts = token.split('.');
  if (parts.length !== 3) {
    throw new Error('Invalid JWT format: expected 3 parts separated by dots');
  }
 
  const payloadBytes = base64UrlDecode(parts[1]);
  const payloadJson = new TextDecoder().decode(payloadBytes);
  return JSON.parse(payloadJson);
}

// ES256 での JWT 実装（jose ライブラリ）
import { SignJWT, jwtVerify, generateKeyPair, exportJWK } from 'jose';
 
// 鍵ペア生成
const { publicKey, privateKey } = await generateKeyPair('ES256');
 
// JWT 署名（発行）
async function issueToken(userId: string, role: string): Promise<string> {
  return new SignJWT({
    sub: userId,
    role,
    permissions: getRolePermissions(role),
  })
    .setProtectedHeader({ alg: 'ES256', kid: 'key-2024-01' })
    .setIssuer('https://auth.example.com')
    .setAudience('https://api.example.com')
    .setIssuedAt()
    .setExpirationTime('15m')  // 15分
    .setJti(crypto.randomUUID())
    .sign(privateKey);
}
 
// JWT 検証
async function verifyToken(token: string) {
  const { payload } = await jwtVerify(token, publicKey, {
    issuer: 'https://auth.example.com',
    audience: 'https://api.example.com',
    algorithms: ['ES256'],  // 許可するアルゴリズムを明示
  });
 
  return payload;
}

// EdDSA（Ed25519）での JWT 実装
import { SignJWT, jwtVerify, generateKeyPair } from 'jose';
 
// Ed25519 鍵ペア生成
const { publicKey, privateKey } = await generateKeyPair('EdDSA', {
  crv: 'Ed25519',
});
 
async function issueEdDSAToken(userId: string): Promise<string> {
  return new SignJWT({
    sub: userId,
    scope: 'read write',
  })
    .setProtectedHeader({ alg: 'EdDSA', crv: 'Ed25519', kid: 'ed-key-01' })
    .setIssuer('https://auth.example.com')
    .setAudience('https://api.example.com')
    .setIssuedAt()
    .setExpirationTime('15m')
    .setJti(crypto.randomUUID())
    .sign(privateKey);
}
 
async function verifyEdDSAToken(token: string) {
  const { payload, protectedHeader } = await jwtVerify(token, publicKey, {
    algorithms: ['EdDSA'],
    issuer: 'https://auth.example.com',
    audience: 'https://api.example.com',
  });
 
  console.log('Algorithm:', protectedHeader.alg);  // EdDSA
  console.log('User:', payload.sub);
 
  return payload;
}

// 各アルゴリズムの鍵生成コマンド（OpenSSL）
// HS256: openssl rand -base64 32
// RS256: openssl genrsa -out private.pem 2048
//        openssl rsa -in private.pem -pubout -out public.pem
// ES256: openssl ecparam -genkey -name prime256v1 -noout -out private-ec.pem
//        openssl ec -in private-ec.pem -pubout -out public-ec.pem
// EdDSA: openssl genpkey -algorithm ED25519 -out private-ed.pem
//        openssl pkey -in private-ed.pem -pubout -out public-ed.pem
 
// Node.js での鍵生成
import { generateKeyPair, exportJWK, exportPKCS8, exportSPKI } from 'jose';
 
async function generateKeys(algorithm: string) {
  const { publicKey, privateKey } = await generateKeyPair(algorithm);
 
  // JWK 形式でエクスポート
  const publicJWK = await exportJWK(publicKey);
  const privateJWK = await exportJWK(privateKey);
 
  // PEM 形式でエクスポート
  const publicPEM = await exportSPKI(publicKey);
  const privatePEM = await exportPKCS8(privateKey);
 
  return { publicJWK, privateJWK, publicPEM, privatePEM };
}
 
// 使用例
const es256Keys = await generateKeys('ES256');
const eddsaKeys = await generateKeys('EdDSA');
const rs256Keys = await generateKeys('RS256');

// クレーム設計例
 
// アクセストークンのペイロード（最小限）
interface AccessTokenPayload {
  sub: string;         // ユーザーID
  role: 'user' | 'admin' | 'super_admin';
  org_id?: string;     // マルチテナント用
  scope?: string;      // OAuth 2.0 スコープ
  token_version?: number; // 強制失効用
  // exp, iat, iss, aud は jose が自動設定
}
 
// ID トークンのペイロード（ユーザー情報含む）
interface IDTokenPayload {
  sub: string;
  email: string;
  name: string;
  picture?: string;
  email_verified: boolean;
  locale?: string;
  updated_at?: number;
}
 
// リフレッシュトークンのペイロード
interface RefreshTokenPayload {
  sub: string;
  jti: string;         // 一意ID（失効管理用）
  family: string;      // トークンファミリー（リプレイ検知用）
  token_version: number;
}
 
// マルチテナント向けアクセストークン
interface MultiTenantAccessToken {
  sub: string;
  org_id: string;
  org_role: 'owner' | 'admin' | 'member' | 'viewer';
  permissions: string[];  // 細粒度の権限
  features: string[];     // テナントの有効機能
}
 
// アクセストークンには最小限の情報のみ含め、
// 詳細なユーザー情報が必要な場合は /userinfo エンドポイントを使用

// aud クレームの厳密な検証
import { jwtVerify } from 'jose';
 
// マイクロサービスごとの検証設定
const serviceConfig = {
  'user-service': {
    audience: 'https://user-api.example.com',
    requiredScopes: ['read:user', 'write:user'],
  },
  'order-service': {
    audience: 'https://order-api.example.com',
    requiredScopes: ['read:order', 'write:order'],
  },
  'payment-service': {
    audience: 'https://payment-api.example.com',
    requiredScopes: ['process:payment'],
  },
};
 
async function verifyServiceToken(
  token: string,
  serviceName: keyof typeof serviceConfig
) {
  const config = serviceConfig[serviceName];
 
  const { payload } = await jwtVerify(token, publicKey, {
    algorithms: ['ES256'],
    issuer: 'https://auth.example.com',
    audience: config.audience,  // このサービス専用の aud
  });
 
  // スコープ検証
  const tokenScopes = (payload.scope as string || '').split(' ');
  const hasRequiredScopes = config.requiredScopes.every(
    (scope) => tokenScopes.includes(scope)
  );
 
  if (!hasRequiredScopes) {
    throw new Error(`Insufficient scopes. Required: ${config.requiredScopes.join(', ')}`);
  }
 
  return payload;
}

// JWKS エンドポイントの実装
import { exportJWK, generateKeyPair, importJWK } from 'jose';
 
// 鍵の管理
class KeyManager {
  private keys: Map<string, {
    publicKey: CryptoKey;
    privateKey: CryptoKey;
    createdAt: Date;
    expiresAt: Date;
  }> = new Map();
  private currentKeyId: string = '';
  private rotationIntervalMs: number = 30 * 24 * 60 * 60 * 1000; // 30日
  private gracePeriodMs: number = 24 * 60 * 60 * 1000; // 24時間の猶予
 
  async initialize() {
    await this.rotateKey();
    // 定期的なローテーションをスケジュール
    setInterval(() => this.rotateKey(), this.rotationIntervalMs);
  }
 
  async rotateKey() {
    const keyId = `key-${Date.now()}`;
    const { publicKey, privateKey } = await generateKeyPair('ES256');
    const now = new Date();
 
    this.keys.set(keyId, {
      publicKey,
      privateKey,
      createdAt: now,
      expiresAt: new Date(now.getTime() + this.rotationIntervalMs + this.gracePeriodMs),
    });
    this.currentKeyId = keyId;
 
    // 期限切れの鍵を削除
    this.cleanupExpiredKeys();
 
    console.log(`Key rotated. Current key: ${keyId}. Total keys: ${this.keys.size}`);
  }
 
  private cleanupExpiredKeys() {
    const now = new Date();
    for (const [kid, keyInfo] of this.keys) {
      if (kid !== this.currentKeyId && keyInfo.expiresAt < now) {
        this.keys.delete(kid);
        console.log(`Expired key removed: ${kid}`);
      }
    }
  }
 
  // 現在の秘密鍵（署名用）
  getCurrentSigningKey() {
    return {
      kid: this.currentKeyId,
      privateKey: this.keys.get(this.currentKeyId)!.privateKey,
    };
  }
 
  // JWKS（公開鍵セット）
  async getJWKS() {
    const keys = [];
    for (const [kid, { publicKey }] of this.keys) {
      const jwk = await exportJWK(publicKey);
      keys.push({ ...jwk, kid, use: 'sig', alg: 'ES256' });
    }
    return { keys };
  }
 
  // kid で公開鍵を取得（検証用）
  getPublicKey(kid: string) {
    return this.keys.get(kid)?.publicKey;
  }
}
 
// JWKS エンドポイント
// GET /.well-known/jwks.json
app.get('/.well-known/jwks.json', async (req, res) => {
  const jwks = await keyManager.getJWKS();
 
  // JWKS はキャッシュ可能（ただし短めの TTL）
  res.set('Cache-Control', 'public, max-age=900'); // 15分
  res.json(jwks);
});

// リモート JWKS を使った JWT 検証（マイクロサービス側）
import { createRemoteJWKSet, jwtVerify } from 'jose';
 
// JWKS URI からの公開鍵取得（キャッシュ付き）
const JWKS = createRemoteJWKSet(
  new URL('https://auth.example.com/.well-known/jwks.json'),
  {
    cooldownDuration: 30_000,  // 最小再取得間隔: 30秒
    cacheMaxAge: 600_000,      // キャッシュ TTL: 10分
  }
);
 
async function verifyTokenWithRemoteJWKS(token: string) {
  try {
    const { payload, protectedHeader } = await jwtVerify(token, JWKS, {
      algorithms: ['ES256'],
      issuer: 'https://auth.example.com',
      audience: 'https://api.example.com',
      clockTolerance: 30,  // 30秒のクロックスキュー許容
    });
 
    console.log(`Token verified with key: ${protectedHeader.kid}`);
    return payload;
  } catch (error) {
    // JWKS 取得失敗時のフォールバック
    if (error instanceof TypeError && error.message.includes('fetch')) {
      console.error('JWKS endpoint unreachable. Using cached keys.');
      // キャッシュされた鍵で再試行（jose が自動で行う）
      throw new Error('Authentication service unavailable');
    }
    throw error;
  }
}

// 安全な JWT 検証の実装
import { jwtVerify, errors } from 'jose';
 
async function verifyAccessToken(token: string) {
  try {
    const { payload, protectedHeader } = await jwtVerify(token, publicKey, {
      // 必ず指定すべきオプション
      algorithms: ['ES256'],                    // 許可アルゴリズムを限定
      issuer: 'https://auth.example.com',       // 発行者を検証
      audience: 'https://api.example.com',      // 対象者を検証
      clockTolerance: 30,                       // 時刻の許容誤差（秒）
      maxTokenAge: '15m',                       // 最大有効期間
    });
 
    // 追加の検証
    if (!payload.sub) throw new Error('Missing subject');
    if (!payload.role) throw new Error('Missing role');
 
    // kid の検証（許可された鍵IDのみ）
    if (protectedHeader.kid && !isValidKeyId(protectedHeader.kid)) {
      throw new Error('Invalid key ID');
    }
 
    // jti の一意性検証（リプレイ攻撃防止）
    if (payload.jti) {
      const isUsed = await checkJtiUsed(payload.jti as string);
      if (isUsed) throw new Error('Token already used');
      await markJtiUsed(payload.jti as string, payload.exp as number);
    }
 
    return {
      userId: payload.sub,
      role: payload.role as string,
      permissions: payload.permissions as string[],
    };
  } catch (error) {
    if (error instanceof errors.JWTExpired) {
      throw new AuthError('Token expired', 'TOKEN_EXPIRED');
    }
    if (error instanceof errors.JWTClaimValidationFailed) {
      throw new AuthError('Invalid token claims', 'INVALID_CLAIMS');
    }
    if (error instanceof errors.JWSSignatureVerificationFailed) {
      throw new AuthError('Invalid signature', 'INVALID_SIGNATURE');
    }
    throw new AuthError('Invalid token', 'INVALID_TOKEN');
  }
}
 
// kid バリデーション
function isValidKeyId(kid: string): boolean {
  // 英数字とハイフンのみ許可（インジェクション防止）
  return /^[a-zA-Z0-9_-]{1,64}$/.test(kid);
}
 
// jti 使用済みチェック（Redis）
async function checkJtiUsed(jti: string): Promise<boolean> {
  const exists = await redis.exists(`jti:${jti}`);
  return exists === 1;
}
 
async function markJtiUsed(jti: string, exp: number): Promise<void> {
  const ttl = exp - Math.floor(Date.now() / 1000);
  if (ttl > 0) {
    await redis.setex(`jti:${jti}`, ttl, '1');
  }
}

// Express 用 JWT 認証ミドルウェア
import { Request, Response, NextFunction } from 'express';
import { jwtVerify, createRemoteJWKSet, errors } from 'jose';
 
interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    role: string;
    permissions: string[];
    orgId?: string;
  };
}
 
const JWKS = createRemoteJWKSet(
  new URL('https://auth.example.com/.well-known/jwks.json')
);
 
// 認証ミドルウェア
function requireAuth() {
  return async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
    const authHeader = req.headers.authorization;
 
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        error: 'authentication_required',
        message: 'Bearer token is required',
      });
    }
 
    const token = authHeader.substring(7);
 
    try {
      const { payload } = await jwtVerify(token, JWKS, {
        algorithms: ['ES256'],
        issuer: 'https://auth.example.com',
        audience: 'https://api.example.com',
        clockTolerance: 30,
      });
 
      req.user = {
        userId: payload.sub as string,
        role: payload.role as string,
        permissions: (payload.permissions as string[]) || [],
        orgId: payload.org_id as string | undefined,
      };
 
      next();
    } catch (error) {
      if (error instanceof errors.JWTExpired) {
        return res.status(401).json({
          error: 'token_expired',
          message: 'Access token has expired',
        });
      }
      return res.status(401).json({
        error: 'invalid_token',
        message: 'Invalid access token',
      });
    }
  };
}
 
// 認可ミドルウェア
function requirePermission(...requiredPermissions: string[]) {
  return (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Not authenticated' });
    }
 
    const hasPermission = requiredPermissions.every(
      (perm) => req.user!.permissions.includes(perm)
    );
 
    if (!hasPermission) {
      return res.status(403).json({
        error: 'insufficient_permissions',
        message: `Required permissions: ${requiredPermissions.join(', ')}`,
      });
    }
 
    next();
  };
}
 
// 使用例
app.get('/api/users',
  requireAuth(),
  requirePermission('read:user'),
  async (req: AuthenticatedRequest, res) => {
    const users = await userService.listUsers(req.user!.orgId);
    res.json(users);
  }
);
 
app.delete('/api/users/:id',
  requireAuth(),
  requirePermission('delete:user'),
  async (req: AuthenticatedRequest, res) => {
    await userService.deleteUser(req.params.id, req.user!.userId);
    res.status(204).send();
  }
);

// リフレッシュトークンローテーションの実装
import crypto from 'crypto';
 
class RefreshTokenService {
  constructor(private db: Database, private redis: Redis) {}
 
  // リフレッシュトークン発行
  async issueRefreshToken(userId: string, family?: string): Promise<string> {
    const token = crypto.randomBytes(64).toString('base64url');
    const hashedToken = this.hashToken(token);
    const tokenFamily = family || crypto.randomUUID();
 
    await this.db.refreshToken.create({
      data: {
        hashedToken,
        userId,
        family: tokenFamily,
        expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7日
        used: false,
      },
    });
 
    return token;
  }
 
  // リフレッシュトークンの使用（ローテーション）
  async rotateToken(token: string): Promise<{
    accessToken: string;
    refreshToken: string;
  }> {
    const hashedToken = this.hashToken(token);
 
    const stored = await this.db.refreshToken.findFirst({
      where: { hashedToken },
    });
 
    if (!stored) {
      throw new AuthError('Invalid refresh token', 'INVALID_TOKEN');
    }
 
    // 期限切れチェック
    if (stored.expiresAt < new Date()) {
      throw new AuthError('Refresh token expired', 'TOKEN_EXPIRED');
    }
 
    // リプレイ検知: 使用済みトークンが再使用された場合
    if (stored.used) {
      // トークンファミリー全体を無効化（セキュリティ侵害の可能性）
      await this.revokeTokenFamily(stored.family);
      console.warn(
        `Refresh token reuse detected! Family: ${stored.family}, User: ${stored.userId}`
      );
      throw new AuthError('Token reuse detected. All sessions revoked.', 'TOKEN_REUSE');
    }
 
    // 旧トークンを使用済みに
    await this.db.refreshToken.update({
      where: { id: stored.id },
      data: { used: true, usedAt: new Date() },
    });
 
    // 新しいリフレッシュトークンを同じファミリーで発行
    const newRefreshToken = await this.issueRefreshToken(stored.userId, stored.family);
 
    // 新しいアクセストークン発行
    const accessToken = await issueAccessToken(stored.userId);
 
    return { accessToken, refreshToken: newRefreshToken };
  }
 
  // トークンファミリー全体の無効化
  async revokeTokenFamily(family: string): Promise<void> {
    await this.db.refreshToken.updateMany({
      where: { family },
      data: { revokedAt: new Date() },
    });
  }
 
  // ユーザーの全トークン無効化（パスワード変更、アカウント侵害時）
  async revokeAllUserTokens(userId: string): Promise<void> {
    await this.db.refreshToken.updateMany({
      where: { userId },
      data: { revokedAt: new Date() },
    });
  }
 
  private hashToken(token: string): string {
    return crypto.createHash('sha256').update(token).digest('hex');
  }
}

// Redis を使った JWT ブラックリスト
class TokenBlacklist {
  constructor(private redis: Redis) {}
 
  // トークンをブラックリストに追加
  async revoke(jti: string, exp: number): Promise<void> {
    const ttl = exp - Math.floor(Date.now() / 1000);
    if (ttl > 0) {
      // トークンの残り有効期限分だけ保持（メモリ節約）
      await this.redis.setex(`blacklist:${jti}`, ttl, '1');
    }
  }
 
  // トークンがブラックリストに含まれるか
  async isRevoked(jti: string): Promise<boolean> {
    const result = await this.redis.get(`blacklist:${jti}`);
    return result !== null;
  }
 
  // 複数トークンの一括失効
  async revokeMany(tokens: Array<{ jti: string; exp: number }>): Promise<void> {
    const pipeline = this.redis.pipeline();
    const now = Math.floor(Date.now() / 1000);
 
    for (const { jti, exp } of tokens) {
      const ttl = exp - now;
      if (ttl > 0) {
        pipeline.setex(`blacklist:${jti}`, ttl, '1');
      }
    }
 
    await pipeline.exec();
  }
}
 
// Token Version による失効（ユーザー単位）
class TokenVersionService {
  constructor(private redis: Redis, private db: Database) {}
 
  // ユーザーのトークンバージョンを取得
  async getVersion(userId: string): Promise<number> {
    const cached = await this.redis.get(`token_version:${userId}`);
    if (cached) return parseInt(cached, 10);
 
    const user = await this.db.user.findUnique({
      where: { id: userId },
      select: { tokenVersion: true },
    });
 
    const version = user?.tokenVersion || 0;
    await this.redis.setex(`token_version:${userId}`, 3600, version.toString());
    return version;
  }
 
  // トークンバージョンをインクリメント（全トークン無効化）
  async incrementVersion(userId: string): Promise<number> {
    const newVersion = await this.db.user.update({
      where: { id: userId },
      data: { tokenVersion: { increment: 1 } },
      select: { tokenVersion: true },
    });
 
    await this.redis.setex(
      `token_version:${userId}`,
      3600,
      newVersion.tokenVersion.toString()
    );
 
    return newVersion.tokenVersion;
  }
 
  // トークンのバージョン検証
  async isValidVersion(userId: string, tokenVersion: number): Promise<boolean> {
    const currentVersion = await this.getVersion(userId);
    return tokenVersion >= currentVersion;
  }
}
 
// 検証フローに組み込み
async function verifyTokenWithBlacklist(token: string) {
  const payload = await verifyAccessToken(token);
 
  // ブラックリストチェック
  if (payload.jti && await blacklist.isRevoked(payload.jti)) {
    throw new AuthError('Token has been revoked', 'TOKEN_REVOKED');
  }
 
  // Token Version チェック
  if (payload.token_version !== undefined) {
    const isValid = await tokenVersionService.isValidVersion(
      payload.userId,
      payload.token_version as number
    );
    if (!isValid) {
      throw new AuthError('Token version outdated', 'TOKEN_VERSION_OUTDATED');
    }
  }
 
  return payload;
}
 
// ログアウト時
async function logout(token: string) {
  const payload = await verifyAccessToken(token);
  if (payload.jti && payload.exp) {
    await blacklist.revoke(payload.jti, payload.exp);
  }
}
 
// パスワード変更時（全セッション無効化）
async function onPasswordChange(userId: string) {
  await tokenVersionService.incrementVersion(userId);
  await refreshTokenService.revokeAllUserTokens(userId);
}

// JWE の実装（jose ライブラリ）
import { CompactEncrypt, compactDecrypt, generateKeyPair } from 'jose';
 
// 受信者の RSA 鍵ペア
const { publicKey, privateKey } = await generateKeyPair('RSA-OAEP-256');
 
// JWE 暗号化
async function encryptPayload(payload: Record<string, unknown>): Promise<string> {
  const encoder = new TextEncoder();
  const plaintext = encoder.encode(JSON.stringify(payload));
 
  return new CompactEncrypt(plaintext)
    .setProtectedHeader({
      alg: 'RSA-OAEP-256',  // 鍵暗号化アルゴリズム
      enc: 'A256GCM',       // コンテンツ暗号化アルゴリズム
      typ: 'JWT',
    })
    .encrypt(publicKey);
}
 
// JWE 復号
async function decryptPayload(jwe: string): Promise<Record<string, unknown>> {
  const { plaintext } = await compactDecrypt(jwe, privateKey);
  const decoder = new TextDecoder();
  return JSON.parse(decoder.decode(plaintext));
}
 
// Nested JWT（JWS を JWE で包む）
async function createNestedJwt(
  userId: string,
  sensitiveData: Record<string, unknown>
): Promise<string> {
  // Step 1: JWS（署名付きJWT）を作成
  const jws = await new SignJWT({
    sub: userId,
    ...sensitiveData,
  })
    .setProtectedHeader({ alg: 'ES256' })
    .setIssuedAt()
    .setExpirationTime('15m')
    .sign(signingPrivateKey);
 
  // Step 2: JWS を JWE で暗号化
  const encoder = new TextEncoder();
  return new CompactEncrypt(encoder.encode(jws))
    .setProtectedHeader({
      alg: 'RSA-OAEP-256',
      enc: 'A256GCM',
      cty: 'JWT',  // Content Type: 中身が JWT であることを示す
    })
    .encrypt(encryptionPublicKey);
}

// Cookie でのリフレッシュトークン設定
function setRefreshTokenCookie(res: Response, refreshToken: string) {
  res.cookie('refresh_token', refreshToken, {
    httpOnly: true,          // JavaScript からアクセス不可
    secure: true,            // HTTPS のみ
    sameSite: 'strict',      // 同一サイトのみ送信
    path: '/api/auth',       // 認証エンドポイントのみに送信
    maxAge: 7 * 24 * 60 * 60 * 1000, // 7日
    domain: '.example.com',  // サブドメイン共有
  });
}
 
// リフレッシュエンドポイント
app.post('/api/auth/refresh', async (req, res) => {
  const refreshToken = req.cookies.refresh_token;
 
  if (!refreshToken) {
    return res.status(401).json({ error: 'No refresh token' });
  }
 
  try {
    const { accessToken, refreshToken: newRefreshToken } =
      await refreshTokenService.rotateToken(refreshToken);
 
    // 新しいリフレッシュトークンを Cookie に設定
    setRefreshTokenCookie(res, newRefreshToken);
 
    // アクセストークンはレスポンスボディで返す（メモリに保持）
    res.json({ access_token: accessToken, token_type: 'Bearer', expires_in: 900 });
  } catch (error) {
    // リフレッシュ失敗時は Cookie を削除
    res.clearCookie('refresh_token', { path: '/api/auth' });
    return res.status(401).json({ error: 'Invalid refresh token' });
  }
});
 
// フロントエンド側: アクセストークンのメモリ管理
class TokenManager {
  private accessToken: string | null = null;
  private refreshTimer: NodeJS.Timeout | null = null;
 
  setAccessToken(token: string, expiresIn: number) {
    this.accessToken = token;
 
    // 有効期限の 80% 時点で自動リフレッシュ
    if (this.refreshTimer) clearTimeout(this.refreshTimer);
    this.refreshTimer = setTimeout(
      () => this.refresh(),
      expiresIn * 0.8 * 1000
    );
  }
 
  getAccessToken(): string | null {
    return this.accessToken;
  }
 
  async refresh(): Promise<void> {
    try {
      const res = await fetch('/api/auth/refresh', {
        method: 'POST',
        credentials: 'include', // Cookie を送信
      });
 
      if (!res.ok) {
        this.accessToken = null;
        window.location.href = '/login';
        return;
      }
 
      const { access_token, expires_in } = await res.json();
      this.setAccessToken(access_token, expires_in);
    } catch (error) {
      console.error('Token refresh failed:', error);
    }
  }
 
  // Axios インターセプターでの使用
  setupAxiosInterceptor(axios: AxiosInstance) {
    axios.interceptors.request.use((config) => {
      const token = this.getAccessToken();
      if (token) {
        config.headers.Authorization = `Bearer ${token}`;
      }
      return config;
    });
 
    axios.interceptors.response.use(
      (response) => response,
      async (error) => {
        if (error.response?.status === 401 && !error.config._retry) {
          error.config._retry = true;
          await this.refresh();
          error.config.headers.Authorization = `Bearer ${this.getAccessToken()}`;
          return axios(error.config);
        }
        return Promise.reject(error);
      }
    );
  }
}

// パフォーマンス計測ユーティリティ
async function benchmarkAlgorithms() {
  const algorithms = ['HS256', 'RS256', 'ES256', 'EdDSA'] as const;
  const iterations = 10000;
 
  for (const alg of algorithms) {
    // 鍵生成
    let signingKey: any;
    let verifyKey: any;
 
    if (alg === 'HS256') {
      const secret = new TextEncoder().encode('super-secret-key-at-least-256-bits!!!');
      signingKey = verifyKey = secret;
    } else {
      const options = alg === 'EdDSA' ? { crv: 'Ed25519' as const } : undefined;
      const keys = await generateKeyPair(alg, options);
      signingKey = keys.privateKey;
      verifyKey = keys.publicKey;
    }
 
    // 署名ベンチマーク
    const signStart = performance.now();
    let token = '';
    for (let i = 0; i < iterations; i++) {
      token = await new SignJWT({ sub: 'user_123', role: 'admin' })
        .setProtectedHeader({ alg })
        .setExpirationTime('15m')
        .sign(signingKey);
    }
    const signTime = (performance.now() - signStart) / iterations;
 
    // 検証ベンチマーク
    const verifyStart = performance.now();
    for (let i = 0; i < iterations; i++) {
      await jwtVerify(token, verifyKey, { algorithms: [alg] });
    }
    const verifyTime = (performance.now() - verifyStart) / iterations;
 
    console.log(`${alg}: sign=${signTime.toFixed(3)}ms, verify=${verifyTime.toFixed(3)}ms, size=${token.length}bytes`);
  }
}

// 演習 1 の解答テンプレート
function exercise1(jwt: string) {
  const parts = jwt.split('.');
  console.log(`パート数: ${parts.length}`);
 
  // ヘッダーのデコード
  const header = JSON.parse(
    Buffer.from(parts[0], 'base64url').toString()
  );
  console.log('ヘッダー:', header);
 
  // ペイロードのデコード
  const payload = JSON.parse(
    Buffer.from(parts[1], 'base64url').toString()
  );
  console.log('ペイロード:', payload);
 
  // 有効期限の変換
  const expDate = new Date(payload.exp * 1000);
  console.log('有効期限:', expDate.toISOString());
 
  // 署名部分（バイナリデータ、デコードしても意味のある文字列にはならない）
  console.log('署名（Base64URL）:', parts[2]);
  console.log('署名サイズ:', Buffer.from(parts[2], 'base64url').length, 'bytes');
}