// TOTP の内部実装（教育目的、本番では otplib を使用）
import crypto from 'crypto';
 
function generateTOTP(
  secret: Buffer,      // 秘密鍵（生バイト）
  period: number = 30, // タイムステップ（秒）
  digits: number = 6,  // OTP の桁数
  algorithm: string = 'sha1'
): string {
  // Step 1: タイムステップの計算
  const time = Math.floor(Date.now() / 1000 / period);
 
  // Step 2: タイムステップを8バイトのビッグエンディアンに変換
  const timeBuffer = Buffer.alloc(8);
  timeBuffer.writeBigUInt64BE(BigInt(time));
 
  // Step 3: HMAC-SHA1 を計算
  const hmac = crypto.createHmac(algorithm, secret).update(timeBuffer).digest();
 
  // Step 4: Dynamic Truncation
  const offset = hmac[hmac.length - 1] & 0x0f;
  const binary = (
    ((hmac[offset] & 0x7f) << 24) |
    ((hmac[offset + 1] & 0xff) << 16) |
    ((hmac[offset + 2] & 0xff) << 8) |
    (hmac[offset + 3] & 0xff)
  );
 
  // Step 5: 指定桁数に切り詰め
  const otp = binary % Math.pow(10, digits);
 
  // Step 6: 先頭のゼロを保持してゼロパディング
  return otp.toString().padStart(digits, '0');
}
 
// 検証（前後のウィンドウも許容）
function verifyTOTP(
  token: string,
  secret: Buffer,
  window: number = 1  // 前後何ステップを許容するか
): boolean {
  const period = 30;
  const currentTime = Math.floor(Date.now() / 1000);
 
  for (let i = -window; i <= window; i++) {
    const time = Math.floor(currentTime / period) + i;
    const timeBuffer = Buffer.alloc(8);
    timeBuffer.writeBigUInt64BE(BigInt(time));
 
    const hmac = crypto.createHmac('sha1', secret).update(timeBuffer).digest();
    const offset = hmac[hmac.length - 1] & 0x0f;
    const binary = (
      ((hmac[offset] & 0x7f) << 24) |
      ((hmac[offset + 1] & 0xff) << 16) |
      ((hmac[offset + 2] & 0xff) << 8) |
      (hmac[offset + 3] & 0xff)
    );
    const otp = (binary % 1000000).toString().padStart(6, '0');
 
    // タイミングセーフな比較
    if (crypto.timingSafeEqual(Buffer.from(otp), Buffer.from(token))) {
      return true;
    }
  }
 
  return false;
}

// TOTP 実装（otplib）
import { authenticator } from 'otplib';
import qrcode from 'qrcode';
 
// セットアップ: 秘密鍵の生成
async function setupTOTP(userId: string, email: string) {
  const secret = authenticator.generateSecret(); // Base32 エンコード
 
  // 秘密鍵を暗号化してDBに保存（MFA有効化前は仮保存）
  await db.mfaSetup.create({
    data: {
      userId,
      secret: encrypt(secret),  // AES で暗号化して保存
      verified: false,
    },
  });
 
  // QRコード生成
  const otpauthUrl = authenticator.keyuri(email, 'MyApp', secret);
  const qrCodeUrl = await qrcode.toDataURL(otpauthUrl);
 
  return { qrCodeUrl, secret }; // secret はバックアップ用に表示
}
 
// セットアップ検証: ユーザーが入力したコードを確認
async function verifyTOTPSetup(userId: string, token: string) {
  const setup = await db.mfaSetup.findUnique({ where: { userId } });
  if (!setup) throw new Error('MFA setup not found');
 
  const secret = decrypt(setup.secret);
  const isValid = authenticator.verify({ token, secret });
 
  if (!isValid) {
    throw new Error('Invalid TOTP code');
  }
 
  // MFA を有効化
  await db.$transaction([
    db.user.update({
      where: { id: userId },
      data: { mfaEnabled: true },
    }),
    db.mfaSetup.update({
      where: { userId },
      data: { verified: true },
    }),
  ]);
 
  // リカバリーコード生成
  const recoveryCodes = generateRecoveryCodes();
  await saveRecoveryCodes(userId, recoveryCodes);
 
  return { recoveryCodes }; // ユーザーに1度だけ表示
}
 
// 認証時の検証
async function verifyTOTP(userId: string, token: string): Promise<boolean> {
  const setup = await db.mfaSetup.findUnique({
    where: { userId, verified: true },
  });
  if (!setup) return false;
 
  const secret = decrypt(setup.secret);
 
  // リプレイ攻撃防止: 使用済みコードをチェック
  const codeKey = `totp:used:${userId}:${token}`;
  const isUsed = await redis.exists(codeKey);
  if (isUsed) return false;
 
  // ウィンドウ=1: 前後30秒のコードも許容
  const isValid = authenticator.verify({ token, secret });
 
  if (isValid) {
    // 使用済みとして記録（90秒間保持 = period * 3）
    await redis.setex(codeKey, 90, '1');
  }
 
  return isValid;
}

// WebAuthn 実装（@simplewebauthn/server + @simplewebauthn/browser）
 
// サーバー側: 登録オプション生成
import {
  generateRegistrationOptions,
  verifyRegistrationResponse,
  generateAuthenticationOptions,
  verifyAuthenticationResponse,
} from '@simplewebauthn/server';
 
const rpName = 'My App';
const rpID = 'example.com';
const origin = 'https://example.com';
 
// 登録: オプション生成
async function getRegistrationOptions(userId: string) {
  const user = await db.user.findUnique({ where: { id: userId } });
  const existingDevices = await db.credential.findMany({
    where: { userId },
  });
 
  const options = await generateRegistrationOptions({
    rpName,
    rpID,
    userID: new TextEncoder().encode(userId),
    userName: user!.email,
    attestationType: 'none',
    excludeCredentials: existingDevices.map((d) => ({
      id: d.credentialId,
      transports: d.transports,
    })),
    authenticatorSelection: {
      residentKey: 'preferred',          // Passkey をサポート
      userVerification: 'preferred',     // 生体認証を推奨
    },
  });
 
  // チャレンジを一時保存（5分間有効）
  await redis.setex(
    `webauthn:challenge:${userId}`,
    300,
    options.challenge
  );
 
  return options;
}
 
// 登録: レスポンス検証
async function verifyRegistration(userId: string, response: any) {
  const expectedChallenge = await redis.get(`webauthn:challenge:${userId}`);
  if (!expectedChallenge) {
    throw new Error('Challenge expired or not found');
  }
 
  const verification = await verifyRegistrationResponse({
    response,
    expectedChallenge,
    expectedOrigin: origin,
    expectedRPID: rpID,
  });
 
  if (verification.verified && verification.registrationInfo) {
    const { credential } = verification.registrationInfo;
 
    // クレデンシャルを保存
    await db.credential.create({
      data: {
        userId,
        credentialId: Buffer.from(credential.id),
        publicKey: Buffer.from(credential.publicKey),
        counter: credential.counter,
        transports: response.response.transports,
        deviceType: verification.registrationInfo.credentialDeviceType,
        backedUp: verification.registrationInfo.credentialBackedUp,
        createdAt: new Date(),
      },
    });
 
    // チャレンジを削除
    await redis.del(`webauthn:challenge:${userId}`);
  }
 
  return verification;
}
 
// 認証: オプション生成
async function getAuthenticationOptions(email?: string) {
  let allowCredentials: any[] = [];
 
  if (email) {
    // メールアドレスが指定された場合、そのユーザーのクレデンシャルを取得
    const user = await db.user.findUnique({ where: { email } });
    if (user) {
      const credentials = await db.credential.findMany({
        where: { userId: user.id },
      });
      allowCredentials = credentials.map((c) => ({
        id: c.credentialId,
        transports: c.transports,
      }));
    }
  }
  // email が指定されない場合、allowCredentials を空にする
  // → Discoverable Credential（Passkey）が使われる
 
  const options = await generateAuthenticationOptions({
    rpID,
    allowCredentials,
    userVerification: 'preferred',
  });
 
  // チャレンジを一時保存
  const challengeKey = email || 'anonymous';
  await redis.setex(
    `webauthn:auth:challenge:${challengeKey}`,
    300,
    options.challenge
  );
 
  return options;
}
 
// 認証: レスポンス検証
async function verifyAuthentication(response: any, email?: string) {
  // クレデンシャルIDからユーザーを特定
  const credential = await db.credential.findFirst({
    where: {
      credentialId: Buffer.from(response.id, 'base64url'),
    },
    include: { user: true },
  });
 
  if (!credential) {
    throw new Error('Credential not found');
  }
 
  const challengeKey = email || 'anonymous';
  const expectedChallenge = await redis.get(
    `webauthn:auth:challenge:${challengeKey}`
  );
 
  if (!expectedChallenge) {
    throw new Error('Challenge expired');
  }
 
  const verification = await verifyAuthenticationResponse({
    response,
    expectedChallenge,
    expectedOrigin: origin,
    expectedRPID: rpID,
    credential: {
      id: credential.credentialId,
      publicKey: credential.publicKey,
      counter: credential.counter,
    },
  });
 
  if (verification.verified) {
    // カウンターを更新（クローン検知）
    await db.credential.update({
      where: { id: credential.id },
      data: {
        counter: verification.authenticationInfo.newCounter,
        lastUsedAt: new Date(),
      },
    });
 
    // チャレンジを削除
    await redis.del(`webauthn:auth:challenge:${challengeKey}`);
 
    return { verified: true, user: credential.user };
  }
 
  return { verified: false, user: null };
}

// クライアント側: WebAuthn 登録・認証
import {
  startRegistration,
  startAuthentication,
  browserSupportsWebAuthn,
  platformAuthenticatorIsAvailable,
} from '@simplewebauthn/browser';
 
// WebAuthn サポートチェック
async function checkWebAuthnSupport() {
  const supported = browserSupportsWebAuthn();
  const platformAvailable = await platformAuthenticatorIsAvailable();
 
  return {
    supported,              // ブラウザが WebAuthn をサポート
    platformAvailable,       // 指紋/顔認証が使用可能
    canUsePasskeys: supported && platformAvailable,
  };
}
 
// Passkey 登録
async function registerPasskey() {
  const support = await checkWebAuthnSupport();
  if (!support.supported) {
    throw new Error('このブラウザは Passkey をサポートしていません');
  }
 
  // サーバーからオプション取得
  const optionsRes = await fetch('/api/webauthn/register/options', {
    method: 'POST',
    credentials: 'include',
  });
  const options = await optionsRes.json();
 
  try {
    // ブラウザの認証ダイアログを表示
    const registration = await startRegistration({ optionsJSON: options });
 
    // サーバーに検証を送信
    const verifyRes = await fetch('/api/webauthn/register/verify', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(registration),
      credentials: 'include',
    });
 
    if (!verifyRes.ok) {
      throw new Error('登録の検証に失敗しました');
    }
 
    return verifyRes.json();
  } catch (error: any) {
    if (error.name === 'NotAllowedError') {
      throw new Error('認証がキャンセルされました');
    }
    if (error.name === 'InvalidStateError') {
      throw new Error('この認証器は既に登録されています');
    }
    throw error;
  }
}
 
// Passkey 認証
async function authenticateWithPasskey(email?: string) {
  const optionsRes = await fetch('/api/webauthn/authenticate/options', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email }),
  });
  const options = await optionsRes.json();
 
  try {
    const authentication = await startAuthentication({ optionsJSON: options });
 
    const verifyRes = await fetch('/api/webauthn/authenticate/verify', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(authentication),
      credentials: 'include',
    });
 
    if (!verifyRes.ok) {
      throw new Error('認証に失敗しました');
    }
 
    return verifyRes.json();
  } catch (error: any) {
    if (error.name === 'NotAllowedError') {
      throw new Error('認証がキャンセルされました');
    }
    throw error;
  }
}
 
// Conditional UI（入力フィールドに Passkey 候補を表示）
async function setupConditionalUI() {
  if (!browserSupportsWebAuthn()) return;
 
  try {
    const optionsRes = await fetch('/api/webauthn/authenticate/options', {
      method: 'POST',
    });
    const options = await optionsRes.json();
 
    // mediation: 'conditional' で Conditional UI を有効化
    const authentication = await startAuthentication({
      optionsJSON: options,
      useBrowserAutofill: true, // Conditional UI を使用
    });
 
    // 自動的に認証が完了した場合の処理
    const verifyRes = await fetch('/api/webauthn/authenticate/verify', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(authentication),
      credentials: 'include',
    });
 
    if (verifyRes.ok) {
      window.location.href = '/dashboard';
    }
  } catch (error) {
    console.log('Conditional UI not available or cancelled');
  }
}

// OTP の実装（レート制限、ブルートフォース対策付き）
import crypto from 'crypto';
 
class OTPService {
  constructor(
    private db: Database,
    private redis: Redis,
    private smsService: SMSService,
    private emailService: EmailService
  ) {}
 
  // OTP 生成・送信
  async sendOTP(userId: string, channel: 'sms' | 'email'): Promise<void> {
    const user = await this.db.user.findUnique({ where: { id: userId } });
    if (!user) throw new Error('User not found');
 
    // レート制限: 1分に1回まで
    const rateLimitKey = `otp:ratelimit:${userId}`;
    const isLimited = await this.redis.exists(rateLimitKey);
    if (isLimited) {
      throw new Error('Please wait before requesting a new code');
    }
 
    // 1日の送信上限: 10回まで
    const dailyKey = `otp:daily:${userId}:${new Date().toISOString().slice(0, 10)}`;
    const dailyCount = await this.redis.incr(dailyKey);
    if (dailyCount === 1) {
      await this.redis.expire(dailyKey, 86400); // 24時間
    }
    if (dailyCount > 10) {
      throw new Error('Daily OTP limit exceeded');
    }
 
    // 6桁のランダムコード
    const code = crypto.randomInt(100000, 999999).toString();
 
    // ハッシュ化して保存
    const hashedCode = crypto.createHash('sha256').update(code).digest('hex');
 
    // 既存の未使用コードを無効化
    await this.db.otpCode.updateMany({
      where: { userId, usedAt: null },
      data: { usedAt: new Date() },
    });
 
    await this.db.otpCode.create({
      data: {
        userId,
        code: hashedCode,
        channel,
        expiresAt: new Date(Date.now() + 10 * 60 * 1000), // 10分有効
        attempts: 0,
      },
    });
 
    // レート制限を設定（60秒）
    await this.redis.setex(rateLimitKey, 60, '1');
 
    // 送信
    if (channel === 'sms') {
      await this.smsService.send(user.phone!, `認証コード: ${code}`);
    } else {
      await this.emailService.send(user.email, {
        subject: '認証コード',
        html: `
          <p>あなたの認証コードは <strong>${code}</strong> です。</p>
          <p>このコードは10分間有効です。</p>
          <p>心当たりがない場合は、このメールを無視してください。</p>
        `,
      });
    }
  }
 
  // OTP 検証
  async verifyOTP(userId: string, code: string): Promise<boolean> {
    const otpRecord = await this.db.otpCode.findFirst({
      where: {
        userId,
        expiresAt: { gt: new Date() },
        usedAt: null,
      },
      orderBy: { createdAt: 'desc' },
    });
 
    if (!otpRecord) return false;
 
    // 試行回数制限（ブルートフォース対策）
    if (otpRecord.attempts >= 5) {
      await this.db.otpCode.update({
        where: { id: otpRecord.id },
        data: { usedAt: new Date() }, // 無効化
      });
 
      // アカウントロックアウト
      await this.lockAccount(userId, 15 * 60); // 15分
 
      return false;
    }
 
    // 試行回数をインクリメント
    await this.db.otpCode.update({
      where: { id: otpRecord.id },
      data: { attempts: { increment: 1 } },
    });
 
    // タイミングセーフな比較
    const hashedInput = crypto.createHash('sha256').update(code).digest('hex');
    const isValid = crypto.timingSafeEqual(
      Buffer.from(hashedInput),
      Buffer.from(otpRecord.code)
    );
 
    if (!isValid) return false;
 
    // 使用済みに
    await this.db.otpCode.update({
      where: { id: otpRecord.id },
      data: { usedAt: new Date() },
    });
 
    return true;
  }
 
  private async lockAccount(userId: string, durationSeconds: number): Promise<void> {
    await this.redis.setex(`account:locked:${userId}`, durationSeconds, '1');
  }
}

// リカバリーコード生成・管理
import crypto from 'crypto';
 
class RecoveryCodeService {
  constructor(private db: Database, private redis: Redis) {}
 
  // リカバリーコード生成
  generateRecoveryCodes(count: number = 10): string[] {
    return Array.from({ length: count }, () => {
      // 10文字の安全なランダムコード（例: "a3f8-e2b1-c7d9"）
      const bytes = crypto.randomBytes(6);
      const hex = bytes.toString('hex');
      return `${hex.slice(0, 4)}-${hex.slice(4, 8)}-${hex.slice(8, 12)}`;
    });
  }
 
  // リカバリーコードの保存
  async saveCodes(userId: string, codes: string[]): Promise<void> {
    // 既存のコードを削除
    await this.db.recoveryCode.deleteMany({ where: { userId } });
 
    // ハッシュ化して保存
    const hashedCodes = codes.map((code) => ({
      userId,
      code: crypto.createHash('sha256').update(code).digest('hex'),
      used: false,
    }));
 
    await this.db.recoveryCode.createMany({ data: hashedCodes });
  }
 
  // リカバリーコードの検証
  async verifyCode(userId: string, code: string): Promise<boolean> {
    // レート制限
    const rateLimitKey = `recovery:ratelimit:${userId}`;
    const attempts = await this.redis.incr(rateLimitKey);
    if (attempts === 1) {
      await this.redis.expire(rateLimitKey, 3600); // 1時間
    }
    if (attempts > 10) {
      throw new Error('Too many recovery attempts. Try again later.');
    }
 
    const hashedCode = crypto.createHash('sha256').update(code).digest('hex');
 
    const record = await this.db.recoveryCode.findFirst({
      where: { userId, code: hashedCode, used: false },
    });
 
    if (!record) return false;
 
    // 使用済みにマーク
    await this.db.recoveryCode.update({
      where: { id: record.id },
      data: { used: true, usedAt: new Date() },
    });
 
    // 残りのコード数を確認
    const remaining = await this.db.recoveryCode.count({
      where: { userId, used: false },
    });
 
    // 残り少ない場合は通知
    if (remaining <= 2) {
      await this.notifyLowCodes(userId, remaining);
    }
 
    // 全て使用済みの場合は MFA を一時無効化して再設定を促す
    if (remaining === 0) {
      await this.promptMfaReset(userId);
    }
 
    return true;
  }
 
  // リカバリーコードの再生成
  async regenerateCodes(userId: string): Promise<string[]> {
    const codes = this.generateRecoveryCodes();
    await this.saveCodes(userId, codes);
    return codes;
  }
 
  private async notifyLowCodes(userId: string, remaining: number): Promise<void> {
    const user = await this.db.user.findUnique({ where: { id: userId } });
    if (user) {
      await emailService.send(user.email, {
        subject: 'リカバリーコードが残りわずかです',
        html: `<p>リカバリーコードの残りが ${remaining} 個です。安全のため、新しいコードを生成してください。</p>`,
      });
    }
  }
 
  private async promptMfaReset(userId: string): Promise<void> {
    // 一時的なMFAリセットトークンを発行
    const resetToken = crypto.randomBytes(32).toString('hex');
    await this.redis.setex(`mfa:reset:${userId}`, 3600, resetToken);
  }
}

// ステップアップ認証の実装
interface AuthLevel {
  level: number;
  methods: string[];
  authenticatedAt: Date;
}
 
class StepUpAuthService {
  // 認証レベルの定義
  private readonly AUTH_LEVELS = {
    basic: { level: 1, maxAge: 24 * 60 * 60 },      // 24時間
    elevated: { level: 2, maxAge: 15 * 60 },         // 15分
    critical: { level: 3, maxAge: 5 * 60 },          // 5分
  };
 
  // 操作に必要な認証レベル
  private readonly OPERATION_LEVELS: Record<string, keyof typeof this.AUTH_LEVELS> = {
    'view:profile': 'basic',
    'update:profile': 'basic',
    'change:password': 'elevated',
    'change:mfa': 'elevated',
    'delete:account': 'critical',
    'transfer:funds': 'critical',
    'admin:users': 'critical',
  };
 
  // 現在の認証レベルを確認
  async checkAuthLevel(
    userId: string,
    operation: string
  ): Promise<{ allowed: boolean; requiredLevel: string; currentLevel: number }> {
    const requiredLevelName = this.OPERATION_LEVELS[operation] || 'basic';
    const requiredLevel = this.AUTH_LEVELS[requiredLevelName];
 
    // セッションから認証情報を取得
    const authInfo = await this.getAuthInfo(userId);
 
    if (!authInfo) {
      return { allowed: false, requiredLevel: requiredLevelName, currentLevel: 0 };
    }
 
    // 認証レベルが足りるか
    const levelSufficient = authInfo.level >= requiredLevel.level;
 
    // 認証の鮮度が十分か
    const ageSeconds = (Date.now() - authInfo.authenticatedAt.getTime()) / 1000;
    const freshEnough = ageSeconds <= requiredLevel.maxAge;
 
    return {
      allowed: levelSufficient && freshEnough,
      requiredLevel: requiredLevelName,
      currentLevel: authInfo.level,
    };
  }
 
  // ステップアップ認証を実行
  async performStepUp(
    userId: string,
    method: 'totp' | 'webauthn' | 'password',
    credential: string
  ): Promise<boolean> {
    let verified = false;
 
    switch (method) {
      case 'totp':
        verified = await verifyTOTP(userId, credential);
        break;
      case 'webauthn':
        const result = await verifyAuthentication(JSON.parse(credential));
        verified = result.verified;
        break;
      case 'password':
        const user = await db.user.findUnique({ where: { id: userId } });
        verified = user ? await argon2.verify(user.password, credential) : false;
        break;
    }
 
    if (verified) {
      await this.upgradeAuthLevel(userId, method);
    }
 
    return verified;
  }
 
  private async upgradeAuthLevel(userId: string, method: string): Promise<void> {
    const current = await this.getAuthInfo(userId) || {
      level: 0,
      methods: [],
      authenticatedAt: new Date(),
    };
 
    current.level = Math.min(current.level + 1, 3);
    current.methods.push(method);
    current.authenticatedAt = new Date();
 
    await redis.setex(
      `auth:level:${userId}`,
      24 * 60 * 60,
      JSON.stringify(current)
    );
  }
 
  private async getAuthInfo(userId: string): Promise<AuthLevel | null> {
    const data = await redis.get(`auth:level:${userId}`);
    return data ? JSON.parse(data) : null;
  }
}
 
// Express ミドルウェアとして使用
function requireAuthLevel(operation: string) {
  return async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
    const result = await stepUpAuth.checkAuthLevel(req.user!.userId, operation);
 
    if (result.allowed) {
      return next();
    }
 
    return res.status(403).json({
      error: 'step_up_required',
      requiredLevel: result.requiredLevel,
      currentLevel: result.currentLevel,
      message: 'Additional authentication required for this operation',
    });
  };
}
 
// 使用例
app.post('/api/transfer',
  requireAuth(),
  requireAuthLevel('transfer:funds'),
  async (req, res) => {
    // 高リスク操作の実行
    await transferFunds(req.body);
    res.json({ success: true });
  }
);

// 信頼済みデバイスの管理
class TrustedDeviceService {
  constructor(private db: Database, private redis: Redis) {}
 
  // デバイスを信頼済みとして登録
  async trustDevice(userId: string, req: Request): Promise<string> {
    const deviceId = crypto.randomUUID();
    const hashedDeviceId = crypto.createHash('sha256').update(deviceId).digest('hex');
 
    const deviceInfo = {
      userId,
      hashedDeviceId,
      userAgent: req.headers['user-agent'] || 'unknown',
      ip: req.ip,
      trustedAt: new Date(),
      expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30日
    };
 
    await this.db.trustedDevice.create({ data: deviceInfo });
 
    return deviceId;
  }
 
  // デバイスが信頼済みか確認
  async isDeviceTrusted(userId: string, deviceId: string): Promise<boolean> {
    if (!deviceId) return false;
 
    const hashedDeviceId = crypto.createHash('sha256').update(deviceId).digest('hex');
 
    const device = await this.db.trustedDevice.findFirst({
      where: {
        userId,
        hashedDeviceId,
        expiresAt: { gt: new Date() },
      },
    });
 
    return device !== null;
  }
 
  // Cookie でデバイスIDを管理
  setDeviceCookie(res: Response, deviceId: string): void {
    res.cookie('trusted_device', deviceId, {
      httpOnly: true,
      secure: true,
      sameSite: 'lax',
      maxAge: 30 * 24 * 60 * 60 * 1000, // 30日
      path: '/',
    });
  }
}
 
// ログインフローへの組み込み
async function loginWithMFA(email: string, password: string, req: Request, res: Response) {
  // Step 1: パスワード認証
  const user = await authenticatePassword(email, password);
  if (!user) {
    return res.status(401).json({ error: 'Invalid credentials' });
  }
 
  // Step 2: MFA が有効な場合
  if (user.mfaEnabled) {
    // 信頼済みデバイスか確認
    const deviceId = req.cookies.trusted_device;
    const isTrusted = await trustedDeviceService.isDeviceTrusted(user.id, deviceId);
 
    if (isTrusted) {
      // MFA をスキップ
      const tokens = await issueTokens(user);
      return res.json(tokens);
    }
 
    // MFA が必要
    const mfaToken = await issueMfaToken(user.id); // 一時的なトークン（5分有効）
    return res.json({
      requireMFA: true,
      mfaToken,
      availableMethods: await getAvailableMFAMethods(user.id),
    });
  }
 
  // MFA なしでログイン
  const tokens = await issueTokens(user);
  return res.json(tokens);
}

// Magic Link 認証の実装
class MagicLinkService {
  constructor(
    private db: Database,
    private redis: Redis,
    private emailService: EmailService
  ) {}
 
  // Magic Link の送信
  async sendMagicLink(email: string): Promise<void> {
    // ユーザーの存在有無に関わらず同じレスポンス
    const user = await this.db.user.findUnique({ where: { email } });
 
    if (!user) {
      // タイミング攻撃防止のため、同じ時間をかける
      await new Promise((resolve) => setTimeout(resolve, 200));
      return;
    }
 
    // レート制限
    const rateLimitKey = `magiclink:ratelimit:${email}`;
    const isLimited = await this.redis.exists(rateLimitKey);
    if (isLimited) return;
 
    // トークン生成
    const token = crypto.randomBytes(32).toString('base64url');
    const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
    await this.db.magicLink.create({
      data: {
        userId: user.id,
        token: hashedToken,
        expiresAt: new Date(Date.now() + 15 * 60 * 1000), // 15分
      },
    });
 
    await this.redis.setex(rateLimitKey, 60, '1');
 
    // メール送信
    const loginUrl = `${process.env.APP_URL}/auth/magic-link?token=${token}`;
    await this.emailService.send(email, {
      subject: 'ログインリンク',
      html: `
        <p>以下のリンクをクリックしてログインしてください（15分有効）:</p>
        <a href="${loginUrl}">ログインする</a>
        <p>心当たりがない場合は、このメールを無視してください。</p>
      `,
    });
  }
 
  // Magic Link の検証
  async verifyMagicLink(token: string): Promise<{ userId: string } | null> {
    const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
    const magicLink = await this.db.magicLink.findFirst({
      where: {
        token: hashedToken,
        expiresAt: { gt: new Date() },
        usedAt: null,
      },
    });
 
    if (!magicLink) return null;
 
    // 使用済みにする
    await this.db.magicLink.update({
      where: { id: magicLink.id },
      data: { usedAt: new Date() },
    });
 
    return { userId: magicLink.userId };
  }
}