// サーバー側: Basic認証ミドルウェア（Express.js）
function basicAuthMiddleware(req, res, next) {
  const authHeader = req.headers.authorization;
 
  if (!authHeader || !authHeader.startsWith('Basic ')) {
    res.setHeader('WWW-Authenticate', 'Basic realm="API"');
    return res.status(401).json({
      type: 'https://api.example.com/errors/unauthorized',
      title: 'Authentication Required',
      status: 401,
      detail: 'Basic authentication credentials are required.',
    });
  }
 
  // Base64デコード
  const base64Credentials = authHeader.substring(6);
  const credentials = Buffer.from(base64Credentials, 'base64').toString('utf-8');
  const [username, password] = credentials.split(':');
 
  // タイミング攻撃を防ぐための定数時間比較
  const expectedUsername = process.env.API_USERNAME;
  const expectedPassword = process.env.API_PASSWORD;
 
  const usernameMatch = crypto.timingSafeEqual(
    Buffer.from(username.padEnd(256)),
    Buffer.from(expectedUsername.padEnd(256))
  );
  const passwordMatch = crypto.timingSafeEqual(
    Buffer.from(password.padEnd(256)),
    Buffer.from(expectedPassword.padEnd(256))
  );
 
  if (!usernameMatch || !passwordMatch) {
    return res.status(401).json({
      type: 'https://api.example.com/errors/invalid-credentials',
      title: 'Invalid Credentials',
      status: 401,
      detail: 'The provided username or password is incorrect.',
    });
  }
 
  req.authenticatedUser = username;
  next();
}
 
// 使用例
app.get('/api/v1/health', basicAuthMiddleware, (req, res) => {
  res.json({ status: 'ok', authenticatedAs: req.authenticatedUser });
});

# Python（Flask）でのBasic認証実装
import hmac
import base64
from functools import wraps
from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
def require_basic_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
 
        if not auth:
            return jsonify({
                'error': 'Authentication required',
                'detail': 'Basic authentication credentials are required.'
            }), 401, {'WWW-Authenticate': 'Basic realm="API"'}
 
        # タイミング攻撃を防ぐための定数時間比較
        expected_user = app.config['API_USERNAME']
        expected_pass = app.config['API_PASSWORD']
 
        user_valid = hmac.compare_digest(auth.username, expected_user)
        pass_valid = hmac.compare_digest(auth.password, expected_pass)
 
        if not (user_valid and pass_valid):
            return jsonify({
                'error': 'Invalid credentials',
                'detail': 'The provided username or password is incorrect.'
            }), 401
 
        request.authenticated_user = auth.username
        return f(*args, **kwargs)
    return decorated
 
@app.route('/api/v1/health')
@require_basic_auth
def health_check():
    return jsonify({'status': 'ok', 'user': request.authenticated_user})

// サーバー側: API Key の検証（Express.js）
import crypto from 'crypto';
 
async function authenticateApiKey(req, res, next) {
  // 複数のヘッダー形式に対応
  const apiKey = req.headers['authorization']?.replace('Bearer ', '')
                 || req.headers['x-api-key'];
 
  if (!apiKey) {
    return res.status(401).json({
      type: 'https://api.example.com/errors/unauthorized',
      title: 'Authentication Required',
      status: 401,
      detail: 'API key is missing. Include it in the Authorization header.',
    });
  }
 
  // キーのフォーマット検証（プレフィックスチェック）
  if (!/^(sk|pk)_(live|test)_[a-zA-Z0-9]{24,}$/.test(apiKey)) {
    return res.status(401).json({
      type: 'https://api.example.com/errors/invalid-api-key-format',
      title: 'Invalid API Key Format',
      status: 401,
      detail: 'The API key format is invalid.',
    });
  }
 
  // ハッシュで検索（平文保存しない）
  const hashedKey = crypto.createHash('sha256').update(apiKey).digest('hex');
  const keyRecord = await db.apiKeys.findOne({
    hash: hashedKey,
    revokedAt: null,
  });
 
  if (!keyRecord) {
    return res.status(401).json({
      type: 'https://api.example.com/errors/invalid-api-key',
      title: 'Invalid API Key',
      status: 401,
      detail: 'The provided API key is invalid or has been revoked.',
    });
  }
 
  // テストキーでの本番アクセスを防止
  if (apiKey.includes('_test_') && process.env.NODE_ENV === 'production') {
    return res.status(403).json({
      type: 'https://api.example.com/errors/test-key-in-production',
      title: 'Test Key Not Allowed',
      status: 403,
      detail: 'Test API keys cannot be used in the production environment.',
    });
  }
 
  // 最終使用日時の更新
  await db.apiKeys.updateOne(
    { hash: hashedKey },
    { $set: { lastUsedAt: new Date() } }
  );
 
  req.apiKey = keyRecord;
  req.account = await db.accounts.findOne({ id: keyRecord.accountId });
  next();
}
 
// API Keyの発行
async function issueApiKey(accountId, options = {}) {
  const prefix = options.isPublic ? 'pk' : 'sk';
  const env = options.isTest ? 'test' : 'live';
 
  // 暗号学的に安全なランダム文字列を生成
  const randomPart = crypto.randomBytes(32).toString('base64url');
  const apiKey = `${prefix}_${env}_${randomPart}`;
 
  // ハッシュ化して保存（平文は保存しない）
  const hashedKey = crypto.createHash('sha256').update(apiKey).digest('hex');
 
  await db.apiKeys.insertOne({
    hash: hashedKey,
    prefix: `${prefix}_${env}_${randomPart.substring(0, 4)}`,
    accountId,
    scopes: options.scopes || ['read'],
    rateLimit: options.rateLimit || 1000,
    createdAt: new Date(),
    expiresAt: options.expiresAt || null,
    revokedAt: null,
    lastUsedAt: null,
  });
 
  // 平文のキーは発行時のみ返却（以後は取得不可）
  return {
    key: apiKey,
    prefix: `${prefix}_${env}_${randomPart.substring(0, 4)}...`,
    scopes: options.scopes || ['read'],
    expiresAt: options.expiresAt || null,
  };
}

// API Keyのローテーション実装
async function rotateApiKey(accountId, oldKeyPrefix) {
  // 旧キーを検索
  const oldKeyRecord = await db.apiKeys.findOne({
    accountId,
    prefix: { $regex: `^${oldKeyPrefix}` },
    revokedAt: null,
  });
 
  if (!oldKeyRecord) {
    throw new Error('Active API key not found');
  }
 
  // 新しいキーを発行
  const newKey = await issueApiKey(accountId, {
    scopes: oldKeyRecord.scopes,
    rateLimit: oldKeyRecord.rateLimit,
  });
 
  // 旧キーにグレースピリオドを設定（24時間後に無効化）
  const gracePeriod = new Date(Date.now() + 24 * 60 * 60 * 1000);
  await db.apiKeys.updateOne(
    { _id: oldKeyRecord._id },
    {
      $set: {
        deprecatedAt: new Date(),
        revokedAt: gracePeriod,
      },
    }
  );
 
  return {
    newKey: newKey.key,
    oldKeyRevokedAt: gracePeriod,
    message: 'Old key will remain valid for 24 hours.',
  };
}

// Authorization Code Flow の実装例（Express.js）
import express from 'express';
import crypto from 'crypto';
 
const app = express();
 
const OAUTH_CONFIG = {
  clientId: process.env.OAUTH_CLIENT_ID,
  clientSecret: process.env.OAUTH_CLIENT_SECRET,
  authorizationEndpoint: 'https://auth.example.com/authorize',
  tokenEndpoint: 'https://auth.example.com/oauth/token',
  redirectUri: 'https://app.example.com/callback',
  scopes: ['users:read', 'orders:read'],
};
 
// ステップ1: 認可リクエストの開始
app.get('/auth/login', (req, res) => {
  // CSRF防止用のstateパラメータを生成
  const state = crypto.randomBytes(32).toString('hex');
  req.session.oauthState = state;
 
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: OAUTH_CONFIG.clientId,
    redirect_uri: OAUTH_CONFIG.redirectUri,
    scope: OAUTH_CONFIG.scopes.join(' '),
    state: state,
  });
 
  res.redirect(`${OAUTH_CONFIG.authorizationEndpoint}?${params}`);
});
 
// ステップ2: コールバック処理
app.get('/callback', async (req, res) => {
  const { code, state, error } = req.query;
 
  // エラーチェック
  if (error) {
    return res.status(400).json({
      error: 'OAuth error',
      detail: req.query.error_description || error,
    });
  }
 
  // stateパラメータの検証（CSRF防止）
  if (state !== req.session.oauthState) {
    return res.status(403).json({
      error: 'Invalid state',
      detail: 'State parameter mismatch. Possible CSRF attack.',
    });
  }
  delete req.session.oauthState;
 
  // ステップ3: 認可コードをトークンに交換
  const tokenResponse = await fetch(OAUTH_CONFIG.tokenEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code: code,
      redirect_uri: OAUTH_CONFIG.redirectUri,
      client_id: OAUTH_CONFIG.clientId,
      client_secret: OAUTH_CONFIG.clientSecret,
    }),
  });
 
  if (!tokenResponse.ok) {
    const errorData = await tokenResponse.json();
    return res.status(400).json({
      error: 'Token exchange failed',
      detail: errorData.error_description || 'Failed to exchange code for token.',
    });
  }
 
  const tokens = await tokenResponse.json();
  // {
  //   access_token: "eyJhbG...",
  //   token_type: "Bearer",
  //   expires_in: 3600,
  //   refresh_token: "rt_abc...",
  //   scope: "users:read orders:read"
  // }
 
  // セッションにトークンを保存
  req.session.accessToken = tokens.access_token;
  req.session.refreshToken = tokens.refresh_token;
  req.session.tokenExpiresAt = Date.now() + tokens.expires_in * 1000;
 
  res.redirect('/dashboard');
});

// SPA向け PKCE実装例
class OAuthPKCEClient {
  constructor(config) {
    this.config = config;
  }
 
  // code_verifierの生成（43-128文字のランダム文字列）
  generateCodeVerifier() {
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    return this.base64UrlEncode(array);
  }
 
  // code_challengeの計算
  async generateCodeChallenge(verifier) {
    const encoder = new TextEncoder();
    const data = encoder.encode(verifier);
    const digest = await crypto.subtle.digest('SHA-256', data);
    return this.base64UrlEncode(new Uint8Array(digest));
  }
 
  // Base64URLエンコード
  base64UrlEncode(buffer) {
    return btoa(String.fromCharCode(...buffer))
      .replace(/\+/g, '-')
      .replace(/\//g, '_')
      .replace(/=+$/, '');
  }
 
  // 認可リクエストの開始
  async startAuthorization() {
    const codeVerifier = this.generateCodeVerifier();
    const codeChallenge = await this.generateCodeChallenge(codeVerifier);
    const state = crypto.randomUUID();
 
    // code_verifierとstateをセッションストレージに保存
    sessionStorage.setItem('pkce_code_verifier', codeVerifier);
    sessionStorage.setItem('oauth_state', state);
 
    const params = new URLSearchParams({
      response_type: 'code',
      client_id: this.config.clientId,
      redirect_uri: this.config.redirectUri,
      scope: this.config.scopes.join(' '),
      state: state,
      code_challenge: codeChallenge,
      code_challenge_method: 'S256',
    });
 
    window.location.href =
      `${this.config.authorizationEndpoint}?${params}`;
  }
 
  // コールバック処理（トークン交換）
  async handleCallback() {
    const params = new URLSearchParams(window.location.search);
    const code = params.get('code');
    const state = params.get('state');
    const error = params.get('error');
 
    if (error) {
      throw new Error(`OAuth error: ${params.get('error_description') || error}`);
    }
 
    // stateの検証
    const savedState = sessionStorage.getItem('oauth_state');
    if (state !== savedState) {
      throw new Error('State mismatch: possible CSRF attack');
    }
 
    // code_verifierの取得
    const codeVerifier = sessionStorage.getItem('pkce_code_verifier');
    if (!codeVerifier) {
      throw new Error('Code verifier not found');
    }
 
    // セッションストレージのクリーンアップ
    sessionStorage.removeItem('oauth_state');
    sessionStorage.removeItem('pkce_code_verifier');
 
    // トークン交換
    const response = await fetch(this.config.tokenEndpoint, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        code: code,
        redirect_uri: this.config.redirectUri,
        client_id: this.config.clientId,
        code_verifier: codeVerifier,
      }),
    });
 
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(
        `Token exchange failed: ${errorData.error_description || errorData.error}`
      );
    }
 
    return response.json();
  }
}
 
// 使用例
const oauth = new OAuthPKCEClient({
  clientId: 'spa_client_123',
  authorizationEndpoint: 'https://auth.example.com/authorize',
  tokenEndpoint: 'https://auth.example.com/oauth/token',
  redirectUri: 'https://spa.example.com/callback',
  scopes: ['openid', 'profile', 'email'],
});
 
// ログインボタンクリック時
document.getElementById('loginBtn').addEventListener('click', () => {
  oauth.startAuthorization();
});
 
// コールバックページ
if (window.location.pathname === '/callback') {
  oauth.handleCallback()
    .then(tokens => {
      console.log('Login successful:', tokens);
      // access_tokenをメモリに保持（localStorageには保存しない）
    })
    .catch(error => {
      console.error('Login failed:', error);
    });
}

// Client Credentials Flow の実装例
async function getServiceToken() {
  const response = await fetch('https://auth.example.com/oauth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: process.env.SERVICE_CLIENT_ID,
      client_secret: process.env.SERVICE_CLIENT_SECRET,
      scope: 'internal:admin',
    }),
  });
 
  if (!response.ok) {
    throw new Error(`Token request failed: ${response.status}`);
  }
 
  return response.json();
}
 
// トークンキャッシュ付きクライアント
class ServiceAuthClient {
  constructor() {
    this.token = null;
    this.expiresAt = 0;
  }
 
  async getToken() {
    // トークンの有効期限を5分前にチェック（バッファ）
    if (this.token && Date.now() < this.expiresAt - 5 * 60 * 1000) {
      return this.token;
    }
 
    const tokenData = await getServiceToken();
    this.token = tokenData.access_token;
    this.expiresAt = Date.now() + tokenData.expires_in * 1000;
 
    return this.token;
  }
 
  async authenticatedFetch(url, options = {}) {
    const token = await this.getToken();
    return fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        Authorization: `Bearer ${token}`,
      },
    });
  }
}

// JWT の検証（jose ライブラリ）- 本番品質の実装
import { jwtVerify, createRemoteJWKSet, errors } from 'jose';
 
// JWKS（JSON Web Key Set）から公開鍵を取得
// JWKSエンドポイントは認可サーバーが公開する
const JWKS = createRemoteJWKSet(
  new URL('https://auth.example.com/.well-known/jwks.json'),
  {
    cooldownDuration: 30000,  // 30秒のクールダウン（連続リクエスト防止）
    cacheMaxAge: 600000,      // 10分のキャッシュ
  }
);
 
async function verifyToken(token) {
  try {
    const { payload, protectedHeader } = await jwtVerify(token, JWKS, {
      issuer: 'https://auth.example.com',
      audience: 'https://api.example.com',
      algorithms: ['RS256', 'ES256'],  // 許可するアルゴリズムを明示
      maxTokenAge: '1h',               // 発行から1時間以内
      clockTolerance: 30,              // 30秒のクロックスキュー許容
    });
 
    return {
      userId: payload.sub,
      scopes: payload.scope?.split(' ') || [],
      roles: payload.role ? [payload.role] : [],
      expiresAt: new Date(payload.exp * 1000),
      issuedAt: new Date(payload.iat * 1000),
    };
  } catch (error) {
    if (error instanceof errors.JWTExpired) {
      throw new AuthError('TOKEN_EXPIRED', 'The access token has expired.');
    }
    if (error instanceof errors.JWTClaimValidationFailed) {
      throw new AuthError('INVALID_CLAIMS', `Token claim validation failed: ${error.message}`);
    }
    if (error instanceof errors.JWSSignatureVerificationFailed) {
      throw new AuthError('INVALID_SIGNATURE', 'Token signature verification failed.');
    }
    throw new AuthError('INVALID_TOKEN', 'The access token is invalid.');
  }
}
 
// カスタムエラークラス
class AuthError extends Error {
  constructor(code, message) {
    super(message);
    this.code = code;
    this.name = 'AuthError';
  }
}
 
// Express.js ミドルウェア
async function jwtAuthMiddleware(req, res, next) {
  const authHeader = req.headers.authorization;
 
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({
      type: 'https://api.example.com/errors/missing-token',
      title: 'Authentication Required',
      status: 401,
      detail: 'A Bearer token is required in the Authorization header.',
    });
  }
 
  const token = authHeader.substring(7);
 
  try {
    req.user = await verifyToken(token);
    next();
  } catch (error) {
    if (error instanceof AuthError) {
      const status = error.code === 'TOKEN_EXPIRED' ? 401 : 403;
      return res.status(status).json({
        type: `https://api.example.com/errors/${error.code.toLowerCase().replace(/_/g, '-')}`,
        title: error.code,
        status: status,
        detail: error.message,
      });
    }
    return res.status(401).json({
      type: 'https://api.example.com/errors/authentication-failed',
      title: 'Authentication Failed',
      status: 401,
      detail: 'Failed to authenticate the request.',
    });
  }
}

// JWT の発行（jose ライブラリ）
import { SignJWT, importPKCS8 } from 'jose';
import fs from 'fs';
 
// 秘密鍵の読み込み（RS256）
const privateKeyPem = fs.readFileSync('./keys/private.pem', 'utf-8');
const privateKey = await importPKCS8(privateKeyPem, 'RS256');
 
async function issueAccessToken(user, scopes) {
  const token = await new SignJWT({
    scope: scopes.join(' '),
    role: user.role,
    email: user.email,
  })
    .setProtectedHeader({
      alg: 'RS256',
      typ: 'JWT',
      kid: 'key_2024_01',
    })
    .setSubject(user.id)
    .setIssuer('https://auth.example.com')
    .setAudience('https://api.example.com')
    .setIssuedAt()
    .setExpirationTime('15m')  // 15分の有効期限
    .setJti(crypto.randomUUID())
    .sign(privateKey);
 
  return token;
}
 
async function issueRefreshToken(user) {
  const refreshTokenId = crypto.randomUUID();
 
  // Refresh Tokenはデータベースに保存（ステートフル）
  await db.refreshTokens.insertOne({
    id: refreshTokenId,
    userId: user.id,
    createdAt: new Date(),
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30日
    revokedAt: null,
    family: crypto.randomUUID(), // Token Rotation用のファミリーID
  });
 
  // Refresh TokenもJWTとして発行（ただしペイロードは最小限）
  const token = await new SignJWT({ type: 'refresh' })
    .setProtectedHeader({ alg: 'RS256', typ: 'JWT' })
    .setSubject(user.id)
    .setIssuer('https://auth.example.com')
    .setExpirationTime('30d')
    .setJti(refreshTokenId)
    .sign(privateKey);
 
  return token;
}

// Refresh Token Rotation の実装
async function refreshTokens(refreshToken) {
  // 1. Refresh Tokenの検証
  let payload;
  try {
    const result = await jwtVerify(refreshToken, JWKS, {
      issuer: 'https://auth.example.com',
    });
    payload = result.payload;
  } catch {
    throw new AuthError('INVALID_REFRESH_TOKEN', 'The refresh token is invalid.');
  }
 
  // 2. データベースでトークンの状態を確認
  const tokenRecord = await db.refreshTokens.findOne({ id: payload.jti });
 
  if (!tokenRecord) {
    throw new AuthError('TOKEN_NOT_FOUND', 'Refresh token not found.');
  }
 
  // 3. 既に無効化されたトークンが使われた場合 → 盗難の可能性
  if (tokenRecord.revokedAt) {
    // 同じファミリーの全トークンを無効化（セキュリティ対策）
    await db.refreshTokens.updateMany(
      { family: tokenRecord.family },
      { $set: { revokedAt: new Date(), revokeReason: 'reuse_detected' } }
    );
 
    // セキュリティアラートの送信
    await notifySecurityTeam({
      type: 'REFRESH_TOKEN_REUSE',
      userId: tokenRecord.userId,
      tokenId: tokenRecord.id,
      family: tokenRecord.family,
    });
 
    throw new AuthError(
      'TOKEN_REUSE_DETECTED',
      'Refresh token reuse detected. All sessions have been revoked.'
    );
  }
 
  // 4. 有効期限の確認
  if (tokenRecord.expiresAt < new Date()) {
    throw new AuthError('REFRESH_TOKEN_EXPIRED', 'The refresh token has expired.');
  }
 
  // 5. 古いRefresh Tokenを無効化
  await db.refreshTokens.updateOne(
    { id: tokenRecord.id },
    { $set: { revokedAt: new Date(), revokeReason: 'rotated' } }
  );
 
  // 6. ユーザー情報を取得
  const user = await db.users.findOne({ id: tokenRecord.userId });
 
  // 7. 新しいトークンペアを発行
  const newAccessToken = await issueAccessToken(user, user.scopes);
  const newRefreshToken = await issueRefreshToken(user);
 
  // 新しいRefresh Tokenは同じファミリーに属させる
  await db.refreshTokens.updateOne(
    { id: (await jwtVerify(newRefreshToken, JWKS)).payload.jti },
    { $set: { family: tokenRecord.family } }
  );
 
  return {
    access_token: newAccessToken,
    token_type: 'Bearer',
    expires_in: 900, // 15分
    refresh_token: newRefreshToken,
  };
}

// スコープチェックミドルウェア
function requireScope(...requiredScopes) {
  return (req, res, next) => {
    if (!req.user || !req.user.scopes) {
      return res.status(401).json({
        type: 'https://api.example.com/errors/unauthenticated',
        title: 'Authentication Required',
        status: 401,
      });
    }
 
    const tokenScopes = req.user.scopes;
 
    // 階層的スコープの解決
    const effectiveScopes = resolveHierarchicalScopes(tokenScopes);
 
    const hasAllScopes = requiredScopes.every(
      scope => effectiveScopes.includes(scope)
    );
 
    if (!hasAllScopes) {
      return res.status(403).json({
        type: 'https://api.example.com/errors/insufficient-scope',
        title: 'Insufficient Scope',
        status: 403,
        detail: `Required scopes: ${requiredScopes.join(', ')}`,
        required_scopes: requiredScopes,
        granted_scopes: tokenScopes,
      });
    }
 
    next();
  };
}
 
// 階層的スコープの解決
function resolveHierarchicalScopes(scopes) {
  const hierarchy = {
    'admin:all': ['users:read', 'users:write', 'users:delete',
                  'orders:read', 'orders:write', 'orders:delete',
                  'billing:read', 'billing:manage'],
    'users:write': ['users:read'],
    'users:delete': ['users:read', 'users:write'],
    'orders:write': ['orders:read'],
    'orders:delete': ['orders:read', 'orders:write'],
    'billing:manage': ['billing:read'],
  };
 
  const resolved = new Set(scopes);
  for (const scope of scopes) {
    if (hierarchy[scope]) {
      hierarchy[scope].forEach(s => resolved.add(s));
    }
  }
 
  return Array.from(resolved);
}
 
// ルーティングへの適用
app.get('/api/v1/users', requireScope('users:read'), listUsers);
app.post('/api/v1/users', requireScope('users:write'), createUser);
app.delete('/api/v1/users/:id', requireScope('users:delete'), deleteUser);
app.get('/api/v1/orders', requireScope('orders:read'), listOrders);
app.post('/api/v1/orders', requireScope('orders:write'), createOrder);
app.get('/api/v1/billing', requireScope('billing:read'), getBilling);
app.post('/api/v1/billing', requireScope('billing:manage'), updateBilling);

// Node.js でのmTLSサーバー設定
import https from 'https';
import fs from 'fs';
import express from 'express';
 
const app = express();
 
// mTLSミドルウェア: クライアント証明書の情報を抽出
app.use((req, res, next) => {
  const cert = req.socket.getPeerCertificate();
 
  if (!req.client.authorized) {
    return res.status(403).json({
      error: 'Client certificate required',
      detail: 'A valid client certificate is required for this endpoint.',
    });
  }
 
  req.clientCert = {
    subject: cert.subject,
    issuer: cert.issuer,
    serialNumber: cert.serialNumber,
    fingerprint: cert.fingerprint256,
    validFrom: cert.valid_from,
    validTo: cert.valid_to,
  };
 
  next();
});
 
const server = https.createServer(
  {
    key: fs.readFileSync('./certs/server-key.pem'),
    cert: fs.readFileSync('./certs/server-cert.pem'),
    ca: fs.readFileSync('./certs/ca-cert.pem'),
    requestCert: true,       // クライアント証明書を要求
    rejectUnauthorized: true, // 無効な証明書は拒否
  },
  app
);
 
server.listen(443, () => {
  console.log('mTLS server running on port 443');
});

// NG: アルゴリズムを指定しない（トークンのalgヘッダーを信頼してしまう）
const payload = jwt.verify(token, publicKey); // 危険
 
// OK: 許可するアルゴリズムを明示的に指定
const payload = jwt.verify(token, publicKey, {
  algorithms: ['RS256'],  // RS256のみ許可
});
 
// OK: joseライブラリでの安全な検証
const { payload } = await jwtVerify(token, JWKS, {
  algorithms: ['RS256', 'ES256'],  // 許可リストを明示
  issuer: 'https://auth.example.com',
  audience: 'https://api.example.com',
});

// クロックスキュー対策付きのJWT検証
const { payload } = await jwtVerify(token, JWKS, {
  issuer: 'https://auth.example.com',
  audience: 'https://api.example.com',
  algorithms: ['RS256'],
  clockTolerance: 30,  // 30秒のクロックスキューを許容
});

// 並行リフレッシュ問題の解決: リフレッシュキュー
class TokenManager {
  constructor(config) {
    this.config = config;
    this.accessToken = null;
    this.refreshPromise = null; // リフレッシュ中のPromiseを共有
  }
 
  async getAccessToken() {
    return this.accessToken;
  }
 
  async refreshAccessToken() {
    // 既にリフレッシュ中であれば、同じPromiseを返す（重複防止）
    if (this.refreshPromise) {
      return this.refreshPromise;
    }
 
    this.refreshPromise = this._doRefresh();
 
    try {
      const result = await this.refreshPromise;
      return result;
    } finally {
      this.refreshPromise = null; // リフレッシュ完了後にクリア
    }
  }
 
  async _doRefresh() {
    const response = await fetch(this.config.tokenEndpoint, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      credentials: 'include', // HttpOnly Cookieを送信
      body: new URLSearchParams({
        grant_type: 'refresh_token',
      }),
    });
 
    if (!response.ok) {
      // リフレッシュ失敗 → ログイン画面にリダイレクト
      this.accessToken = null;
      throw new Error('Token refresh failed');
    }
 
    const data = await response.json();
    this.accessToken = data.access_token;
    return data;
  }
 
  // 自動リトライ付きfetch
  async authenticatedFetch(url, options = {}) {
    let response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        Authorization: `Bearer ${this.accessToken}`,
      },
    });
 
    if (response.status === 401) {
      // トークンをリフレッシュしてリトライ
      await this.refreshAccessToken();
      response = await fetch(url, {
        ...options,
        headers: {
          ...options.headers,
          Authorization: `Bearer ${this.accessToken}`,
        },
      });
    }
 
    return response;
  }
}
 
// 使用例
const tokenManager = new TokenManager({
  tokenEndpoint: 'https://auth.example.com/oauth/token',
});
 
// 並行リクエストでもリフレッシュは1回だけ
const [users, orders, billing] = await Promise.all([
  tokenManager.authenticatedFetch('/api/v1/users'),
  tokenManager.authenticatedFetch('/api/v1/orders'),
  tokenManager.authenticatedFetch('/api/v1/billing'),
]);

// 課題: このBasic認証クライアントをBearer Token方式に変更せよ
class ApiClient {
  constructor(username, password) {
    this.credentials = btoa(`${username}:${password}`);
  }
 
  async getUsers() {
    const response = await fetch('https://api.example.com/v1/users', {
      headers: {
        'Authorization': `Basic ${this.credentials}`,
      },
    });
    return response.json();
  }
}
 
// 要件:
// 1. コンストラクタでトークンエンドポイントのURLを受け取る
// 2. client_id と client_secret を使って Client Credentials Flow で
//    Access Token を取得するメソッドを実装する
// 3. トークンの有効期限管理（期限切れ前に自動更新）を実装する
// 4. APIリクエスト時に Bearer Token を使用する

// 課題: 以下のコードの3つのセキュリティ問題を特定し修正せよ
class OAuthPKCE {
  generateCodeVerifier() {
    // 問題1: Math.randomは暗号学的に安全ではない
    return Math.random().toString(36).substring(2, 15);
  }
 
  async generateCodeChallenge(verifier) {
    // 問題2: code_challenge_method が plain（SHA-256を使うべき）
    return verifier;
  }
 
  async startAuth() {
    const verifier = this.generateCodeVerifier();
    const challenge = await this.generateCodeChallenge(verifier);
 
    // 問題3: localStorageはXSS脆弱（sessionStorageを使うべき）
    localStorage.setItem('code_verifier', verifier);
 
    const params = new URLSearchParams({
      response_type: 'code',
      client_id: this.clientId,
      redirect_uri: this.redirectUri,
      code_challenge: challenge,
      code_challenge_method: 'plain',
    });
 
    window.location.href = `${this.authEndpoint}?${params}`;
  }
}
 
// 修正要件:
// 1. crypto.getRandomValues を使用した安全なランダム生成
// 2. SHA-256 + Base64URL エンコードで code_challenge を生成
// 3. sessionStorage を使用（またはメモリ内クロージャ）
// 4. code_challenge_method を 'S256' に変更

// 演習の骨格コード
class MultiTenantJwtAuth {
  constructor() {
    this.jwksClients = new Map(); // テナントごとのJWKSクライアントキャッシュ
    this.allowedIssuers = new Set(); // 許可されたissuerのセット
  }
 
  // TODO: 以下のメソッドを実装せよ
 
  async loadAllowedIssuers() {
    // データベースから許可されたissuerを読み込む
  }
 
  getJwksClient(issuer) {
    // issuerに対応するJWKSクライアントを取得（キャッシュ付き）
  }
 
  async verifyToken(token) {
    // 1. JWTをデコード（検証前）してissuerを取得
    // 2. issuerがホワイトリストに含まれるか確認
    // 3. issuerに対応するJWKSクライアントで検証
    // 4. 検証済みペイロードを返す
  }
 
  middleware() {
    // Express.jsミドルウェアを返す
    return async (req, res, next) => {
      // 認証処理
    };
  }
}