// スコープベースの API 認可
 
// スコープ定義
const SCOPES = {
  'articles:read': 'Read articles',
  'articles:write': 'Create and update articles',
  'articles:delete': 'Delete articles',
  'users:read': 'Read user profiles',
  'users:write': 'Update user profiles',
  'org:settings': 'Manage organization settings',
  'org:billing': 'Manage billing',
  'admin': 'Full administrative access',
} as const;
 
type Scope = keyof typeof SCOPES;
 
// スコープの包含関係を定義
const SCOPE_HIERARCHY: Record<string, Scope[]> = {
  'admin': Object.keys(SCOPES) as Scope[],
  'articles:write': ['articles:read'],
  'articles:delete': ['articles:read', 'articles:write'],
  'users:write': ['users:read'],
  'org:settings': [],
  'org:billing': [],
};
 
// スコープの展開（階層を考慮）
function expandScopes(scopes: Scope[]): Set<Scope> {
  const expanded = new Set<Scope>(scopes);
 
  for (const scope of scopes) {
    const implied = SCOPE_HIERARCHY[scope];
    if (implied) {
      implied.forEach(s => expanded.add(s));
    }
  }
 
  return expanded;
}
 
// スコープ検証ミドルウェア
function requireScope(...requiredScopes: Scope[]) {
  return (req: Request, res: Response, next: Function) => {
    const tokenScopes = req.auth?.scopes as Scope[] || [];
    const expandedScopes = expandScopes(tokenScopes);
 
    const hasAll = requiredScopes.every(s => expandedScopes.has(s));
    if (!hasAll) {
      return res.status(403).json({
        error: 'insufficient_scope',
        message: 'You do not have the required permissions',
        required_scopes: requiredScopes,
        granted_scopes: tokenScopes,
        // WWW-Authenticate ヘッダー（RFC 6750 §3.1）
      });
    }
 
    next();
  };
}
 
// 使用例
app.get('/api/articles', requireScope('articles:read'), listArticles);
app.post('/api/articles', requireScope('articles:write'), createArticle);
app.delete('/api/articles/:id', requireScope('articles:delete'), deleteArticle);
app.get('/api/users', requireScope('users:read'), listUsers);
app.put('/api/users/:id', requireScope('users:write'), updateUser);
app.get('/api/org/settings', requireScope('org:settings'), getOrgSettings);

// スコープの説明を人間可読にする
const SCOPE_DESCRIPTIONS: Record<Scope, { title: string; description: string; risk: 'low' | 'medium' | 'high' }> = {
  'articles:read': {
    title: '記事の閲覧',
    description: 'あなたのアカウントの記事を読み取ります',
    risk: 'low',
  },
  'articles:write': {
    title: '記事の作成・編集',
    description: 'あなたのアカウントで記事を作成・編集します',
    risk: 'medium',
  },
  'articles:delete': {
    title: '記事の削除',
    description: 'あなたのアカウントの記事を削除します',
    risk: 'high',
  },
  'users:read': {
    title: 'ユーザー情報の閲覧',
    description: 'あなたのプロフィール情報を読み取ります',
    risk: 'low',
  },
  'users:write': {
    title: 'ユーザー情報の更新',
    description: 'あなたのプロフィール情報を更新します',
    risk: 'medium',
  },
  'org:settings': {
    title: '組織設定の管理',
    description: '組織の設定を変更します',
    risk: 'high',
  },
  'org:billing': {
    title: '課金情報の管理',
    description: '支払い情報やプランを変更します',
    risk: 'high',
  },
  'admin': {
    title: '管理者アクセス',
    description: '全ての操作を実行できます',
    risk: 'high',
  },
};
 
// 同意画面のAPI
app.get('/api/oauth/consent', async (req, res) => {
  const requestedScopes = (req.query.scope as string).split(' ') as Scope[];
 
  const scopeDetails = requestedScopes.map(scope => ({
    scope,
    ...SCOPE_DESCRIPTIONS[scope],
  }));
 
  res.json({
    client: {
      name: 'Third Party App',
      logo: 'https://example.com/logo.png',
    },
    scopes: scopeDetails,
    hasHighRisk: scopeDetails.some(s => s.risk === 'high'),
  });
});

// API キーの生成と管理
import crypto from 'crypto';
 
// API キー生成
function generateApiKey(type: 'secret' | 'public', env: 'live' | 'test'): {
  key: string;
  prefix: string;
  hash: string;
  lastFour: string;
} {
  const prefixMap = {
    'secret-live': 'sk_live_',
    'secret-test': 'sk_test_',
    'public-live': 'pk_live_',
    'public-test': 'pk_test_',
  };
 
  const prefix = prefixMap[`${type}-${env}`];
  const randomPart = crypto.randomBytes(24).toString('base64url');
  // 24 bytes = 32 文字の base64url = 192 ビットのエントロピー
  const key = `${prefix}${randomPart}`;
  const hash = crypto.createHash('sha256').update(key).digest('hex');
  const lastFour = randomPart.slice(-4);
 
  return { key, prefix, hash, lastFour };
}
 
// API キー保存
async function createApiKey(
  userId: string,
  name: string,
  scopes: string[],
  options: {
    expiresInDays?: number;
    rateLimit?: number;
    ipWhitelist?: string[];
  } = {}
) {
  const { key, prefix, hash, lastFour } = generateApiKey('secret', 'live');
 
  const expiresAt = options.expiresInDays
    ? new Date(Date.now() + options.expiresInDays * 24 * 60 * 60 * 1000)
    : null;
 
  await db.apiKey.create({
    data: {
      userId,
      name,
      prefix,            // 検索・表示用（平文）
      keyHash: hash,     // 検証用（ハッシュ）
      lastFour,          // 表示用（末尾4文字）
      scopes,
      rateLimit: options.rateLimit ?? 1000, // リクエスト/時間
      ipWhitelist: options.ipWhitelist ?? [],
      lastUsedAt: null,
      expiresAt,
      revokedAt: null,
    },
  });
 
  // この時点でのみ完全なキーを返す
  return {
    key,
    prefix,
    lastFour,
    message: 'This key will only be shown once. Please save it securely.',
  };
}
 
// API キーの一覧取得（ハッシュは返さない）
async function listApiKeys(userId: string) {
  const keys = await db.apiKey.findMany({
    where: { userId },
    select: {
      id: true,
      name: true,
      prefix: true,
      lastFour: true,
      scopes: true,
      lastUsedAt: true,
      expiresAt: true,
      revokedAt: true,
      createdAt: true,
    },
    orderBy: { createdAt: 'desc' },
  });
 
  return keys.map(k => ({
    ...k,
    // 表示用: sk_live_****abcd
    maskedKey: `${k.prefix}****${k.lastFour}`,
    isExpired: k.expiresAt ? k.expiresAt < new Date() : false,
    isRevoked: !!k.revokedAt,
  }));
}

// API キー検証
async function validateApiKey(key: string): Promise<ApiKeyData | null> {
  // プレフィックスの確認
  const validPrefixes = ['sk_live_', 'sk_test_', 'pk_live_', 'pk_test_'];
  const hasValidPrefix = validPrefixes.some(p => key.startsWith(p));
  if (!hasValidPrefix) return null;
 
  // ハッシュ化して検索
  const hash = crypto.createHash('sha256').update(key).digest('hex');
 
  const apiKey = await db.apiKey.findUnique({
    where: { keyHash: hash },
    include: { user: true },
  });
 
  // 存在チェック
  if (!apiKey) return null;
 
  // 取り消しチェック
  if (apiKey.revokedAt) {
    console.warn(`Revoked API key used: ${apiKey.id}`);
    return null;
  }
 
  // 有効期限チェック
  if (apiKey.expiresAt && apiKey.expiresAt < new Date()) {
    console.warn(`Expired API key used: ${apiKey.id}`);
    return null;
  }
 
  // 最終使用日時を更新（非同期、リクエストをブロックしない）
  db.apiKey.update({
    where: { id: apiKey.id },
    data: { lastUsedAt: new Date() },
  }).catch(() => {});
 
  return {
    userId: apiKey.userId,
    scopes: apiKey.scopes,
    keyId: apiKey.id,
    rateLimit: apiKey.rateLimit,
    ipWhitelist: apiKey.ipWhitelist,
    isTestKey: key.includes('_test_'),
  };
}
 
// API キーのローテーション
async function rotateApiKey(userId: string, oldKeyId: string) {
  // 古いキーの情報を取得
  const oldKey = await db.apiKey.findFirst({
    where: { id: oldKeyId, userId },
  });
 
  if (!oldKey) throw new Error('API key not found');
 
  // 新しいキーを生成
  const newKeyData = await createApiKey(userId, oldKey.name, oldKey.scopes, {
    rateLimit: oldKey.rateLimit,
    ipWhitelist: oldKey.ipWhitelist,
  });
 
  // 古いキーにグレースピリオドを設定（即座に無効化しない）
  const gracePeriod = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24時間
  await db.apiKey.update({
    where: { id: oldKeyId },
    data: { expiresAt: gracePeriod },
  });
 
  return {
    newKey: newKeyData,
    oldKeyExpiresAt: gracePeriod,
    message: 'Old key will remain valid for 24 hours. Please update your integration.',
  };
}
 
// API キーの取り消し
async function revokeApiKey(userId: string, keyId: string) {
  await db.apiKey.update({
    where: { id: keyId, userId },
    data: { revokedAt: new Date() },
  });
}

// API キー認証ミドルウェア
async function apiKeyAuth(req: Request, res: Response, next: Function) {
  // API キーの取得元（優先順位）
  const key =
    req.headers['x-api-key'] as string ||                    // カスタムヘッダー
    req.headers.authorization?.replace('Bearer ', '') ||     // Authorization ヘッダー
    req.query.api_key as string;                             // クエリパラメータ（非推奨）
 
  if (!key) {
    return res.status(401).json({
      error: 'unauthorized',
      message: 'API key is required. Provide it via X-API-Key header or Authorization: Bearer header.',
    });
  }
 
  // クエリパラメータ経由の場合は警告
  if (req.query.api_key) {
    res.setHeader('X-Warning', 'Passing API key via query parameter is deprecated. Use X-API-Key header instead.');
  }
 
  const apiKeyData = await validateApiKey(key);
  if (!apiKeyData) {
    return res.status(401).json({
      error: 'invalid_api_key',
      message: 'The provided API key is invalid, expired, or revoked.',
    });
  }
 
  // IP ホワイトリストのチェック
  if (apiKeyData.ipWhitelist.length > 0) {
    const clientIp = req.ip || req.headers['x-forwarded-for'];
    if (!apiKeyData.ipWhitelist.includes(clientIp as string)) {
      return res.status(403).json({
        error: 'ip_not_allowed',
        message: 'Request from this IP address is not allowed.',
      });
    }
  }
 
  // テストキーの分離
  if (apiKeyData.isTestKey && process.env.NODE_ENV === 'production') {
    // テストキーは本番環境ではテストデータのみアクセス可能
    req.isTestMode = true;
  }
 
  req.auth = apiKeyData;
  next();
}

// リソースの所有者チェック
interface ResourcePolicy {
  resourceType: string;
  actions: string[];
  check: (userId: string, resourceId: string, action: string) => Promise<boolean>;
}
 
// ポリシー定義
const articlePolicy: ResourcePolicy = {
  resourceType: 'article',
  actions: ['read', 'update', 'delete', 'publish'],
 
  async check(userId: string, resourceId: string, action: string): Promise<boolean> {
    const article = await db.article.findUnique({
      where: { id: resourceId },
      include: { author: true },
    });
 
    if (!article) return false;
 
    // 公開記事は誰でも読める
    if (action === 'read' && article.status === 'published') return true;
 
    // 自分の記事は操作可能
    if (article.authorId === userId) return true;
 
    // 同じ組織のadminは操作可能
    const user = await db.user.findUnique({ where: { id: userId } });
    if (user?.role === 'admin' && user?.orgId === article.orgId) return true;
 
    // editor はドラフト以外を publish できる
    if (action === 'publish' && user?.role === 'editor' && user?.orgId === article.orgId) {
      return true;
    }
 
    return false;
  },
};
 
const commentPolicy: ResourcePolicy = {
  resourceType: 'comment',
  actions: ['read', 'update', 'delete'],
 
  async check(userId: string, resourceId: string, action: string): Promise<boolean> {
    const comment = await db.comment.findUnique({
      where: { id: resourceId },
      include: { article: true },
    });
 
    if (!comment) return false;
 
    // コメントは誰でも読める（親記事が公開の場合）
    if (action === 'read' && comment.article.status === 'published') return true;
 
    // 自分のコメントは更新・削除可能
    if (comment.authorId === userId) return true;
 
    // 記事の著者はコメントを削除可能
    if (action === 'delete' && comment.article.authorId === userId) return true;
 
    // admin は全コメントを操作可能
    const user = await db.user.findUnique({ where: { id: userId } });
    if (user?.role === 'admin') return true;
 
    return false;
  },
};
 
// ポリシーレジストリ
const policyRegistry = new Map<string, ResourcePolicy>([
  ['article', articlePolicy],
  ['comment', commentPolicy],
]);
 
// 汎用的なリソース認可関数
async function authorizeResourceAccess(
  userId: string,
  resourceType: string,
  resourceId: string,
  action: string
): Promise<boolean> {
  const policy = policyRegistry.get(resourceType);
  if (!policy) {
    console.warn(`No policy defined for resource type: ${resourceType}`);
    return false;
  }
 
  if (!policy.actions.includes(action)) {
    console.warn(`Unknown action '${action}' for resource type: ${resourceType}`);
    return false;
  }
 
  return policy.check(userId, resourceId, action);
}
 
// ミドルウェアとして使用
function authorizeResource(resourceType: string, action: string) {
  return async (req: Request, res: Response, next: Function) => {
    const resourceId = req.params.id;
    const userId = req.auth.userId;
 
    const allowed = await authorizeResourceAccess(userId, resourceType, resourceId, action);
 
    if (!allowed) {
      // セキュリティ上の理由で 404 を返す場合
      // → リソースの存在を隠したい場合
      const hideExistence = resourceType === 'article';
      const statusCode = hideExistence ? 404 : 403;
 
      return res.status(statusCode).json({
        error: statusCode === 404 ? 'not_found' : 'forbidden',
        message: statusCode === 404
          ? 'Resource not found'
          : 'You do not have permission to perform this action',
      });
    }
 
    next();
  };
}
 
// ルート定義
app.get('/api/articles/:id', apiKeyAuth, authorizeResource('article', 'read'), getArticle);
app.put('/api/articles/:id', apiKeyAuth, requireScope('articles:write'), authorizeResource('article', 'update'), updateArticle);
app.delete('/api/articles/:id', apiKeyAuth, requireScope('articles:delete'), authorizeResource('article', 'delete'), deleteArticle);
app.post('/api/articles/:id/publish', apiKeyAuth, requireScope('articles:write'), authorizeResource('article', 'publish'), publishArticle);

// フィールドレベルの認可
// → リソースへのアクセスは許可するが、一部のフィールドを隠す
 
interface FieldFilter {
  [field: string]: boolean | ((user: AuthData) => boolean);
}
 
const articleFieldFilters: Record<string, FieldFilter> = {
  // 公開記事: 全フィールド
  viewer: {
    id: true,
    title: true,
    content: true,
    author: true,
    createdAt: true,
    // 内部フィールドは非表示
    internalNotes: false,
    moderationStatus: false,
    revenue: false,
  },
  // 著者: 内部メモも表示
  author: {
    id: true,
    title: true,
    content: true,
    author: true,
    createdAt: true,
    internalNotes: true,
    moderationStatus: true,
    revenue: false,
  },
  // 管理者: 全フィールド
  admin: {
    id: true,
    title: true,
    content: true,
    author: true,
    createdAt: true,
    internalNotes: true,
    moderationStatus: true,
    revenue: true,
  },
};
 
function filterFields(data: Record<string, any>, role: string): Record<string, any> {
  const filter = articleFieldFilters[role] || articleFieldFilters.viewer;
  const filtered: Record<string, any> = {};
 
  for (const [key, value] of Object.entries(data)) {
    const allowed = filter[key];
    if (allowed === true || (typeof allowed === 'function' && allowed(data))) {
      filtered[key] = value;
    }
  }
 
  return filtered;
}

// Redis ベースのレート制限
import Redis from 'ioredis';
 
interface RateLimitConfig {
  windowMs: number;     // ウィンドウサイズ（ミリ秒）
  max: number;          // 最大リクエスト数
  keyPrefix?: string;   // Redis キープレフィックス
}
 
class RateLimiter {
  private redis: Redis;
 
  constructor(redis: Redis) {
    this.redis = redis;
  }
 
  async check(identifier: string, config: RateLimitConfig): Promise<{
    allowed: boolean;
    remaining: number;
    resetAt: Date;
    limit: number;
  }> {
    const key = `${config.keyPrefix || 'rl'}:${identifier}`;
    const now = Date.now();
    const windowStart = now - config.windowMs;
 
    // スライディングウィンドウ方式
    const pipeline = this.redis.pipeline();
    // 古いエントリを削除
    pipeline.zremrangebyscore(key, '-inf', windowStart);
    // 現在のリクエストを追加
    pipeline.zadd(key, now, `${now}-${Math.random()}`);
    // ウィンドウ内のリクエスト数を取得
    pipeline.zcard(key);
    // TTL を設定
    pipeline.expire(key, Math.ceil(config.windowMs / 1000));
 
    const results = await pipeline.exec();
    const count = results![2][1] as number;
 
    const allowed = count <= config.max;
    const remaining = Math.max(0, config.max - count);
    const resetAt = new Date(now + config.windowMs);
 
    return { allowed, remaining, resetAt, limit: config.max };
  }
}
 
// レート制限ミドルウェア
function rateLimitMiddleware(redis: Redis, config: RateLimitConfig) {
  const limiter = new RateLimiter(redis);
 
  return async (req: Request, res: Response, next: Function) => {
    // API キーベースの識別子
    const identifier = req.auth?.keyId || req.ip || 'anonymous';
 
    const result = await limiter.check(identifier, config);
 
    // レスポンスヘッダーの設定（RFC 6585 準拠）
    res.setHeader('X-RateLimit-Limit', result.limit);
    res.setHeader('X-RateLimit-Remaining', result.remaining);
    res.setHeader('X-RateLimit-Reset', Math.ceil(result.resetAt.getTime() / 1000));
 
    if (!result.allowed) {
      res.setHeader('Retry-After', Math.ceil(config.windowMs / 1000));
      return res.status(429).json({
        error: 'rate_limit_exceeded',
        message: `Too many requests. Limit: ${result.limit} per ${config.windowMs / 1000}s`,
        retry_after: Math.ceil(config.windowMs / 1000),
      });
    }
 
    next();
  };
}
 
// プランベースのレート制限
const PLAN_RATE_LIMITS: Record<string, RateLimitConfig> = {
  free: { windowMs: 60 * 60 * 1000, max: 100, keyPrefix: 'rl:free' },
  pro: { windowMs: 60 * 60 * 1000, max: 1000, keyPrefix: 'rl:pro' },
  enterprise: { windowMs: 60 * 60 * 1000, max: 10000, keyPrefix: 'rl:ent' },
};
 
function planBasedRateLimit(redis: Redis) {
  return async (req: Request, res: Response, next: Function) => {
    const plan = req.auth?.plan || 'free';
    const config = PLAN_RATE_LIMITS[plan] || PLAN_RATE_LIMITS.free;
 
    return rateLimitMiddleware(redis, config)(req, res, next);
  };
}
 
// 使用例
app.use('/api/', apiKeyAuth, planBasedRateLimit(redis));

// エンドポイント別のレート制限
const ENDPOINT_RATE_LIMITS: Record<string, RateLimitConfig> = {
  // 読み取り系: 緩い制限
  'GET:/api/articles': { windowMs: 60 * 1000, max: 100 },
  'GET:/api/users': { windowMs: 60 * 1000, max: 50 },
 
  // 書き込み系: 厳しい制限
  'POST:/api/articles': { windowMs: 60 * 1000, max: 10 },
  'PUT:/api/articles/:id': { windowMs: 60 * 1000, max: 20 },
 
  // 削除系: 非常に厳しい制限
  'DELETE:/api/articles/:id': { windowMs: 60 * 1000, max: 5 },
 
  // 認証系: 最も厳しい制限
  'POST:/api/auth/login': { windowMs: 15 * 60 * 1000, max: 5 },
  'POST:/api/auth/register': { windowMs: 60 * 60 * 1000, max: 3 },
};
 
function endpointRateLimit(redis: Redis) {
  const limiter = new RateLimiter(redis);
 
  return async (req: Request, res: Response, next: Function) => {
    const routeKey = `${req.method}:${req.route?.path || req.path}`;
    const config = ENDPOINT_RATE_LIMITS[routeKey];
 
    if (!config) return next(); // 制限なし
 
    const identifier = `${req.auth?.keyId || req.ip}:${routeKey}`;
    const result = await limiter.check(identifier, config);
 
    res.setHeader('X-RateLimit-Limit', result.limit);
    res.setHeader('X-RateLimit-Remaining', result.remaining);
 
    if (!result.allowed) {
      return res.status(429).json({
        error: 'rate_limit_exceeded',
        message: `Rate limit exceeded for ${routeKey}`,
      });
    }
 
    next();
  };
}

// テナント分離ミドルウェア
function tenantIsolation() {
  return async (req: Request, res: Response, next: Function) => {
    const userId = req.auth.userId;
    const user = await db.user.findUnique({
      where: { id: userId },
      include: { organization: true },
    });
 
    if (!user?.orgId) {
      return res.status(403).json({
        error: 'no_organization',
        message: 'You must belong to an organization to access this resource.',
      });
    }
 
    // リクエストにテナントコンテキストを設定
    req.tenantId = user.orgId;
    req.tenantSlug = user.organization!.slug;
 
    // Prisma のクエリに自動でテナントフィルターを追加
    req.prisma = prisma.$extends({
      query: {
        $allModels: {
          async findMany({ args, query }) {
            args.where = { ...args.where, orgId: req.tenantId };
            return query(args);
          },
          async findFirst({ args, query }) {
            args.where = { ...args.where, orgId: req.tenantId };
            return query(args);
          },
          async findUnique({ args, query }) {
            // findUnique は where に orgId を追加できないため
            // 結果を取得後にチェック
            const result = await query(args);
            if (result && 'orgId' in result && result.orgId !== req.tenantId) {
              return null; // テナント外のリソース
            }
            return result;
          },
          async create({ args, query }) {
            args.data = { ...args.data, orgId: req.tenantId };
            return query(args);
          },
          async update({ args, query }) {
            // update 前にテナントチェック
            const existing = await db[args.model as any].findFirst({
              where: { ...args.where, orgId: req.tenantId },
            });
            if (!existing) {
              throw new Error('Resource not found or access denied');
            }
            return query(args);
          },
          async delete({ args, query }) {
            // delete 前にテナントチェック
            const existing = await db[args.model as any].findFirst({
              where: { ...args.where, orgId: req.tenantId },
            });
            if (!existing) {
              throw new Error('Resource not found or access denied');
            }
            return query(args);
          },
        },
      },
    });
 
    next();
  };
}
 
// 使用例
app.use('/api/', apiKeyAuth, tenantIsolation());
 
// テナント分離されたエンドポイント
app.get('/api/articles', async (req, res) => {
  // req.prisma を使うとテナントフィルターが自動適用
  const articles = await req.prisma.article.findMany({
    orderBy: { createdAt: 'desc' },
    take: 20,
  });
  // → WHERE org_id = 'tenant_123' が自動追加される
 
  res.json(articles);
});

// テナント間でデータを共有する場合のパターン
// 例: マーケットプレイスでテナント A の記事をテナント B が閲覧
 
interface SharedResource {
  resourceType: string;
  resourceId: string;
  ownerOrgId: string;
  sharedWithOrgId: string;
  permissions: string[]; // ['read'] or ['read', 'write']
  expiresAt?: Date;
}
 
async function checkSharedAccess(
  orgId: string,
  resourceType: string,
  resourceId: string,
  action: string
): Promise<boolean> {
  const share = await db.sharedResource.findFirst({
    where: {
      sharedWithOrgId: orgId,
      resourceType,
      resourceId,
      permissions: { has: action },
      OR: [
        { expiresAt: null },
        { expiresAt: { gt: new Date() } },
      ],
    },
  });
 
  return !!share;
}

// 統一的なエラーレスポンス
 
// 401 Unauthorized
{
  "error": "unauthorized",
  "message": "Authentication required",
  "docs_url": "https://docs.myapi.com/auth"
}
 
// 403 Forbidden（スコープ不足）
{
  "error": "insufficient_scope",
  "message": "You do not have the required permissions",
  "required_scopes": ["articles:write"],
  "granted_scopes": ["articles:read"],
  "docs_url": "https://docs.myapi.com/scopes"
}
 
// 403 Forbidden（リソース認可）
{
  "error": "forbidden",
  "message": "You do not have permission to perform this action on this resource",
  "resource_type": "article",
  "action": "delete"
}
 
// 429 Too Many Requests
{
  "error": "rate_limit_exceeded",
  "message": "Too many requests",
  "limit": 1000,
  "remaining": 0,
  "reset_at": "2024-01-01T12:00:00Z",
  "retry_after": 3600
}

// RFC 6750 に準拠した WWW-Authenticate ヘッダー
function setWWWAuthenticate(res: Response, options: {
  realm?: string;
  error?: string;
  errorDescription?: string;
  scope?: string;
}) {
  const parts = [`Bearer realm="${options.realm || 'api'}"`];
 
  if (options.error) {
    parts.push(`error="${options.error}"`);
  }
  if (options.errorDescription) {
    parts.push(`error_description="${options.errorDescription}"`);
  }
  if (options.scope) {
    parts.push(`scope="${options.scope}"`);
  }
 
  res.setHeader('WWW-Authenticate', parts.join(', '));
}
 
// 使用例
// 401: 認証なし
setWWWAuthenticate(res, {
  realm: 'api',
  error: 'invalid_token',
  errorDescription: 'The access token is invalid',
});
 
// 403: スコープ不足
setWWWAuthenticate(res, {
  realm: 'api',
  error: 'insufficient_scope',
  scope: 'articles:write',
});

// API キー検証でのタイミング攻撃対策
import crypto from 'crypto';
 
// 悪い例: 早期リターンでタイミング情報が漏洩
function unsafeValidate(providedKey: string, storedHash: string): boolean {
  const hash = crypto.createHash('sha256').update(providedKey).digest('hex');
  return hash === storedHash; // ← タイミング攻撃に脆弱
}
 
// 良い例: 一定時間比較
function safeValidate(providedKey: string, storedHash: string): boolean {
  const hash = crypto.createHash('sha256').update(providedKey).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(hash, 'hex'),
    Buffer.from(storedHash, 'hex')
  );
}

// IDOR 対策: 自分のリソースのみ返す
app.get('/api/me/profile', auth, async (req, res) => {
  const profile = await db.user.findUnique({
    where: { id: req.auth.userId }, // セッションの userId を使用
    select: { id: true, name: true, email: true, image: true },
  });
  res.json(profile);
});
 
// IDOR 対策: リソースの所有者チェック
app.get('/api/articles/:id', auth, async (req, res) => {
  const article = await db.article.findFirst({
    where: {
      id: req.params.id,
      // テナントフィルター
      orgId: req.auth.orgId,
    },
  });
 
  if (!article) {
    return res.status(404).json({ error: 'not_found' });
  }
 
  res.json(article);
});

// Mass Assignment 攻撃:
// クライアントが送信した body に予期しないフィールドが含まれる
 
// 悪い例
app.put('/api/articles/:id', async (req, res) => {
  await db.article.update({
    where: { id: req.params.id },
    data: req.body, // ← req.body に { role: 'admin' } が含まれている可能性
  });
});
 
// 良い例: 許可するフィールドを明示的に指定
app.put('/api/articles/:id', async (req, res) => {
  const allowedFields = ['title', 'content', 'tags', 'status'];
  const data: Record<string, any> = {};
 
  for (const field of allowedFields) {
    if (req.body[field] !== undefined) {
      data[field] = req.body[field];
    }
  }
 
  await db.article.update({
    where: { id: req.params.id },
    data,
  });
});
 
// さらに良い例: Zod でバリデーション
import { z } from 'zod';
 
const updateArticleSchema = z.object({
  title: z.string().min(1).max(200).optional(),
  content: z.string().optional(),
  tags: z.array(z.string()).optional(),
  status: z.enum(['draft', 'published', 'archived']).optional(),
});
 
app.put('/api/articles/:id', async (req, res) => {
  const parsed = updateArticleSchema.safeParse(req.body);
  if (!parsed.success) {
    return res.status(400).json({ error: 'validation_error', details: parsed.error.issues });
  }
 
  await db.article.update({
    where: { id: req.params.id },
    data: parsed.data,
  });
});