// BOLA 防御の実装パターン (Express.js)
 
// NG: オブジェクトIDのみで認可チェックなし
app.get('/api/orders/:orderId', async (req, res) => {
  const order = await Order.findById(req.params.orderId);
  res.json(order);  // 他人の注文も取得できてしまう
});
 
// OK: ミドルウェアパターンでオブジェクト所有者の検証
function authorizeResource(model, ownerField = 'userId') {
  return async (req, res, next) => {
    const resource = await model.findById(req.params.id);
    if (!resource) {
      return res.status(404).json({ error: 'Resource not found' });
    }
    if (resource[ownerField].toString() !== req.user.id) {
      // 注意: 403 ではなく 404 を返すことで、リソースの存在を隠す
      return res.status(404).json({ error: 'Resource not found' });
    }
    req.resource = resource;
    next();
  };
}
 
app.get('/api/orders/:id', authenticate, authorizeResource(Order), (req, res) => {
  res.json(req.resource);
});
 
// OK: クエリレベルでの所有者フィルタリング (より安全)
app.get('/api/orders/:orderId', authenticate, async (req, res) => {
  const order = await Order.findOne({
    _id: req.params.orderId,
    userId: req.user.id,  // 認証ユーザのIDで絞り込み
  });
  if (!order) return res.status(404).json({ error: 'Not found' });
  res.json(order);
});
 
// OK: RBAC + ABAC の組み合わせ
app.get('/api/orders/:orderId', authenticate, async (req, res) => {
  const order = await Order.findById(req.params.orderId);
  if (!order) return res.status(404).json({ error: 'Not found' });
 
  // 管理者は全注文にアクセス可能
  if (req.user.role === 'admin') return res.json(order);
 
  // サポート担当は自部門の注文のみ
  if (req.user.role === 'support') {
    if (order.department !== req.user.department) {
      return res.status(404).json({ error: 'Not found' });
    }
    return res.json(order);
  }
 
  // 一般ユーザは自分の注文のみ
  if (order.userId.toString() !== req.user.id) {
    return res.status(404).json({ error: 'Not found' });
  }
  res.json(order);
});

// NG: リクエストボディをそのまま使う
app.put('/api/users/:id', authenticate, async (req, res) => {
  const user = await User.findByIdAndUpdate(req.params.id, req.body);
  // 攻撃者が {"role": "admin", "verified": true} を送信可能!
  res.json(user);
});
 
// OK: 許可フィールドのホワイトリスト
const ALLOWED_USER_FIELDS = ['name', 'email', 'bio', 'avatar'];
 
app.put('/api/users/:id', authenticate, async (req, res) => {
  // ホワイトリストでフィルタリング
  const updates = {};
  for (const field of ALLOWED_USER_FIELDS) {
    if (req.body[field] !== undefined) {
      updates[field] = req.body[field];
    }
  }
 
  const user = await User.findOneAndUpdate(
    { _id: req.params.id, _id: req.user.id },  // 所有者チェック
    { $set: updates },
    { new: true, select: '-password -__v' }     // パスワードを除外
  );
 
  if (!user) return res.status(404).json({ error: 'Not found' });
  res.json(user);
});

const crypto = require('crypto');
 
// PKCE code_verifier と code_challenge の生成
function generatePKCE() {
  // code_verifier: 暗号学的にランダムな 43-128 文字
  const verifier = crypto.randomBytes(32).toString('base64url');
 
  // code_challenge: SHA-256 ハッシュの Base64URL エンコード
  const challenge = crypto
    .createHash('sha256')
    .update(verifier)
    .digest('base64url');
 
  return { verifier, challenge };
}
 
// 認可リクエストの構築
function buildAuthorizationUrl(config) {
  const { verifier, challenge } = generatePKCE();
  const state = crypto.randomBytes(16).toString('hex');
 
  // state と verifier をセッションに保存
  // (SPA の場合は sessionStorage に保存)
 
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: config.clientId,
    redirect_uri: config.redirectUri,
    scope: 'openid email profile',
    state: state,
    code_challenge: challenge,
    code_challenge_method: 'S256',
    // nonce: OIDC の場合、リプレイ攻撃防止
    nonce: crypto.randomBytes(16).toString('hex'),
  });
 
  return {
    url: `${config.authorizationEndpoint}?${params}`,
    state,
    verifier,
  };
}
 
// トークン交換
async function exchangeCodeForTokens(code, verifier, config) {
  const response = await fetch(config.tokenEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code: code,
      redirect_uri: config.redirectUri,
      client_id: config.clientId,
      code_verifier: verifier,  // PKCE: code_verifier を送信
    }),
  });
 
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Token exchange failed: ${error.error_description}`);
  }
 
  return response.json();
}

// リフレッシュトークンのローテーション実装
async function refreshAccessToken(refreshToken, config) {
  const response = await fetch(config.tokenEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: refreshToken,
      client_id: config.clientId,
    }),
  });
 
  if (!response.ok) {
    const error = await response.json();
    // リフレッシュトークンが無効 → 再ログインが必要
    if (error.error === 'invalid_grant') {
      throw new AuthenticationError('Session expired, please login again');
    }
    throw new Error(`Token refresh failed: ${error.error_description}`);
  }
 
  const tokens = await response.json();
  // ローテーション: 新しい refresh_token が返される
  // 古い refresh_token は無効化される (一度きりの使用)
  return {
    accessToken: tokens.access_token,
    refreshToken: tokens.refresh_token,  // 新しいリフレッシュトークン
    expiresIn: tokens.expires_in,
  };
}
 
// Axios インターセプタでの自動リフレッシュ
const api = axios.create({ baseURL: 'https://api.example.com' });
let isRefreshing = false;
let failedQueue = [];
 
api.interceptors.response.use(
  (response) => response,
  async (error) => {
    const originalRequest = error.config;
 
    if (error.response?.status === 401 && !originalRequest._retry) {
      if (isRefreshing) {
        // 既にリフレッシュ中なら、完了を待つ
        return new Promise((resolve, reject) => {
          failedQueue.push({ resolve, reject });
        }).then((token) => {
          originalRequest.headers['Authorization'] = `Bearer ${token}`;
          return api(originalRequest);
        });
      }
 
      originalRequest._retry = true;
      isRefreshing = true;
 
      try {
        const { accessToken, refreshToken } = await refreshAccessToken(
          getStoredRefreshToken(),
          config
        );
        storeTokens(accessToken, refreshToken);
 
        // キューに溜まったリクエストを再実行
        failedQueue.forEach(({ resolve }) => resolve(accessToken));
        failedQueue = [];
 
        originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;
        return api(originalRequest);
      } catch (refreshError) {
        failedQueue.forEach(({ reject }) => reject(refreshError));
        failedQueue = [];
        // セッション無効化 → ログイン画面へ
        logout();
        throw refreshError;
      } finally {
        isRefreshing = false;
      }
    }
 
    return Promise.reject(error);
  }
);

const jwt = require('jsonwebtoken');
const jwksClient = require('jwks-rsa');
 
// JWKS クライアント (公開鍵を自動取得 + キャッシュ)
const client = jwksClient({
  jwksUri: 'https://auth.example.com/.well-known/jwks.json',
  cache: true,            // 鍵をキャッシュ
  cacheMaxAge: 600000,    // 10分間キャッシュ
  rateLimit: true,        // レートリミット
  jwksRequestsPerMinute: 10,
});
 
// kid から署名検証鍵を取得
function getSigningKey(kid) {
  return new Promise((resolve, reject) => {
    client.getSigningKey(kid, (err, key) => {
      if (err) return reject(err);
      resolve(key.getPublicKey());
    });
  });
}
 
// JWT 検証ミドルウェア
async function verifyToken(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith('Bearer ')) {
    return res.status(401).json({
      error: 'unauthorized',
      message: 'Bearer token required',
    });
  }
 
  const token = authHeader.slice(7);
 
  try {
    // Step 1: ヘッダをデコード (検証前) して kid を取得
    const decoded = jwt.decode(token, { complete: true });
    if (!decoded || !decoded.header.kid) {
      return res.status(401).json({ error: 'Invalid token format' });
    }
 
    // Step 2: アルゴリズムがホワイトリストにあるか確認
    if (!['RS256', 'ES256'].includes(decoded.header.alg)) {
      return res.status(401).json({ error: 'Unsupported algorithm' });
    }
 
    // Step 3: JWKS から公開鍵を取得
    const publicKey = await getSigningKey(decoded.header.kid);
 
    // Step 4: 署名検証 + クレーム検証
    const payload = jwt.verify(token, publicKey, {
      algorithms: ['RS256', 'ES256'],  // 許可アルゴリズムを明示
      issuer: 'https://auth.example.com',
      audience: 'https://api.example.com',
      clockTolerance: 30,  // 時刻ずれ許容 (秒)
      maxAge: '1h',        // 発行からの最大経過時間
    });
 
    // Step 5: 追加のカスタム検証
    if (!payload.scope) {
      return res.status(403).json({ error: 'No scope in token' });
    }
 
    req.user = payload;
    req.token = token;
    next();
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({
        error: 'token_expired',
        message: 'Access token has expired',
      });
    }
    if (err.name === 'JsonWebTokenError') {
      return res.status(401).json({
        error: 'invalid_token',
        message: 'Token signature verification failed',
      });
    }
    // 予期しないエラーの詳細は返さない
    console.error('Token verification error:', err);
    return res.status(401).json({ error: 'Authentication failed' });
  }
}
 
// スコープベースの認可ミドルウェア
function requireScope(...requiredScopes) {
  return (req, res, next) => {
    const tokenScopes = (req.user.scope || '').split(' ');
    const hasAll = requiredScopes.every(s => tokenScopes.includes(s));
 
    if (!hasAll) {
      return res.status(403).json({
        error: 'insufficient_scope',
        message: `Required scopes: ${requiredScopes.join(', ')}`,
      });
    }
    next();
  };
}
 
// 使用例
app.get('/api/users', verifyToken, requireScope('users:read'), getUsers);
app.post('/api/users', verifyToken, requireScope('users:write'), createUser);
app.delete('/api/users/:id', verifyToken, requireScope('users:delete'), deleteUser);

import redis
import time
from functools import wraps
from flask import request, jsonify, g
import hashlib
 
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
 
def rate_limit(
    max_requests: int,
    window_seconds: int,
    key_func=None,
    scope: str = 'default'
):
    """スライディングウィンドウ方式の分散レートリミッター"""
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            # クライアント識別
            if key_func:
                client_id = key_func()
            else:
                # API キー > 認証ユーザ > IP アドレス の優先順位
                client_id = (
                    request.headers.get('X-API-Key') or
                    getattr(g, 'user_id', None) or
                    request.headers.get('X-Forwarded-For', '').split(',')[0].strip() or
                    request.remote_addr
                )
 
            # レートリミットキー (スコープ + エンドポイント + クライアント)
            key = f"ratelimit:{scope}:{f.__name__}:{hashlib.sha256(client_id.encode()).hexdigest()[:16]}"
            now = time.time()
 
            # Lua スクリプトでアトミックに処理 (Redis の競合状態を防止)
            lua_script = """
            local key = KEYS[1]
            local now = tonumber(ARGV[1])
            local window = tonumber(ARGV[2])
            local max_requests = tonumber(ARGV[3])
 
            -- 古いエントリを削除
            redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
 
            -- 現在のリクエスト数を取得
            local current = redis.call('ZCARD', key)
 
            if current < max_requests then
                -- 制限内: リクエストを記録
                redis.call('ZADD', key, now, now .. '-' .. math.random(1000000))
                redis.call('EXPIRE', key, window)
                return {current + 1, 0}
            else
                -- 制限超過: 最も古いエントリからリセット時間を計算
                local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
                local reset_at = oldest[2] + window
                return {current, reset_at}
            end
            """
 
            result = r.eval(lua_script, 1, key, now, window_seconds, max_requests)
            current_count = int(result[0])
            reset_at = float(result[1])
 
            # レスポンスヘッダ (RFC 7231 + draft-ietf-httpapi-ratelimit-headers)
            headers = {
                'X-RateLimit-Limit': str(max_requests),
                'X-RateLimit-Remaining': str(max(0, max_requests - current_count)),
                'X-RateLimit-Reset': str(int(now + window_seconds)),
                'RateLimit-Policy': f'{max_requests};w={window_seconds}',
            }
 
            if reset_at > 0:
                headers['Retry-After'] = str(int(reset_at - now))
                return jsonify({
                    'error': 'rate_limit_exceeded',
                    'message': f'Rate limit of {max_requests} requests per {window_seconds}s exceeded',
                    'retry_after': int(reset_at - now),
                }), 429, headers
 
            response = f(*args, **kwargs)
            # Flask のレスポンスにヘッダを追加
            if isinstance(response, tuple):
                body, status = response[0], response[1]
                return body, status, headers
            return response, 200, headers
 
        return wrapper
    return decorator
 
# 使用例: エンドポイントごとに異なるレートリミット
@app.route('/api/data')
@rate_limit(max_requests=100, window_seconds=60, scope='general')
def get_data():
    return jsonify({'data': 'ok'})
 
@app.route('/api/auth/login', methods=['POST'])
@rate_limit(max_requests=5, window_seconds=300, scope='auth')
def login():
    return jsonify({'token': '...'})
 
@app.route('/api/export', methods=['POST'])
@rate_limit(max_requests=3, window_seconds=3600, scope='expensive')
def export_data():
    return jsonify({'job_id': '...'})

# OpenAPI 3.0 でのセキュアなスキーマ定義
openapi: '3.0.3'
info:
  title: Secure API
  version: '1.0.0'
 
paths:
  /api/users:
    post:
      operationId: createUser
      security:
        - bearerAuth: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateUserRequest'
      responses:
        '201':
          description: User created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UserResponse'
        '400':
          $ref: '#/components/responses/ValidationError'
        '401':
          $ref: '#/components/responses/Unauthorized'
 
components:
  schemas:
    CreateUserRequest:
      type: object
      required: [name, email]
      additionalProperties: false  # 未定義フィールドを拒否
      properties:
        name:
          type: string
          minLength: 1
          maxLength: 100
          pattern: '^[a-zA-Z\s\-]+$'
          description: 名前 (英字、スペース、ハイフンのみ)
        email:
          type: string
          format: email
          maxLength: 254
          description: メールアドレス (RFC 5321 準拠)
        age:
          type: integer
          minimum: 0
          maximum: 150
          description: 年齢 (0-150)
        bio:
          type: string
          maxLength: 500
          description: 自己紹介 (HTML タグは除去)
 
    UserResponse:
      type: object
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        email:
          type: string
        createdAt:
          type: string
          format: date-time
 
  responses:
    ValidationError:
      description: Validation Error
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: 'validation_failed'
              details:
                type: array
                items:
                  type: object
                  properties:
                    field:
                      type: string
                    message:
                      type: string
 
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

import { z } from 'zod';
import { Request, Response, NextFunction } from 'express';
import DOMPurify from 'isomorphic-dompurify';
 
// スキーマ定義
const CreateUserSchema = z.object({
  name: z
    .string()
    .min(1, 'Name is required')
    .max(100, 'Name must be 100 characters or less')
    .regex(/^[a-zA-Z\s\-]+$/, 'Name must contain only letters, spaces, and hyphens')
    .transform(s => s.trim()),
 
  email: z
    .string()
    .email('Invalid email address')
    .max(254, 'Email must be 254 characters or less')
    .transform(s => s.toLowerCase().trim()),
 
  age: z
    .number()
    .int('Age must be an integer')
    .min(0, 'Age must be non-negative')
    .max(150, 'Age must be 150 or less')
    .optional(),
 
  bio: z
    .string()
    .max(500, 'Bio must be 500 characters or less')
    .transform(s => DOMPurify.sanitize(s, { ALLOWED_TAGS: [] }))  // HTML 除去
    .optional(),
}).strict();  // 未定義フィールドを拒否
 
// パスパラメータ
const UserIdSchema = z.object({
  id: z.string().uuid('Invalid user ID format'),
});
 
// クエリパラメータ
const PaginationSchema = z.object({
  page: z.coerce.number().int().min(1).default(1),
  limit: z.coerce.number().int().min(1).max(100).default(20),
  sort: z.enum(['createdAt', 'name', 'email']).default('createdAt'),
  order: z.enum(['asc', 'desc']).default('desc'),
});
 
// バリデーションミドルウェア
function validate<T extends z.ZodType>(schema: T, source: 'body' | 'params' | 'query' = 'body') {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req[source]);
 
    if (!result.success) {
      return res.status(400).json({
        error: 'validation_failed',
        details: result.error.issues.map(issue => ({
          field: issue.path.join('.'),
          message: issue.message,
          code: issue.code,
        })),
      });
    }
 
    // バリデーション済みデータで上書き (transform 済み)
    req[source] = result.data;
    next();
  };
}
 
// 使用例
app.post('/api/users',
  verifyToken,
  validate(CreateUserSchema, 'body'),
  createUser
);
 
app.get('/api/users/:id',
  verifyToken,
  validate(UserIdSchema, 'params'),
  getUser
);
 
app.get('/api/users',
  verifyToken,
  validate(PaginationSchema, 'query'),
  listUsers
);

const { body, param, query, validationResult } = require('express-validator');
const createDOMPurify = require('dompurify');
const { JSDOM } = require('jsdom');
const DOMPurify = createDOMPurify(new JSDOM('').window);
 
// バリデーションルール
const createUserValidation = [
  body('name')
    .trim()
    .isLength({ min: 1, max: 100 })
    .matches(/^[a-zA-Z\s\-]+$/)
    .withMessage('Name must contain only letters, spaces, and hyphens'),
 
  body('email')
    .isEmail()
    .normalizeEmail()
    .withMessage('Valid email is required'),
 
  body('age')
    .optional()
    .isInt({ min: 0, max: 150 })
    .withMessage('Age must be between 0 and 150'),
 
  body('bio')
    .optional()
    .isLength({ max: 500 })
    .customSanitizer(value => DOMPurify.sanitize(value, { ALLOWED_TAGS: [] })),
];
 
// バリデーション結果の処理
function validate(req, res, next) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      error: 'validation_failed',
      details: errors.array().map(e => ({
        field: e.path,
        message: e.msg,
        value: undefined,  // 入力値を返さない (シークレット漏洩防止)
      })),
    });
  }
  next();
}
 
app.post('/api/users', createUserValidation, validate, createUser);

const helmet = require('helmet');
 
// Helmet で基本的なセキュリティヘッダを設定
app.use(helmet());
 
// CORS の適切な設定
const cors = require('cors');
const allowedOrigins = [
  'https://app.example.com',
  'https://admin.example.com',
];
 
app.use(cors({
  origin: (origin, callback) => {
    // サーバ間通信 (origin なし) は許可
    if (!origin) return callback(null, true);
    if (allowedOrigins.includes(origin)) {
      return callback(null, true);
    }
    callback(new Error('Not allowed by CORS'));
  },
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Request-ID'],
  exposedHeaders: ['X-RateLimit-Limit', 'X-RateLimit-Remaining', 'X-RateLimit-Reset'],
  credentials: true,
  maxAge: 86400,       // preflight キャッシュ (24時間)
  optionsSuccessStatus: 204,
}));
 
// 追加のセキュリティヘッダ
app.use((req, res, next) => {
  // レスポンスの MIME タイプを強制
  res.setHeader('X-Content-Type-Options', 'nosniff');
  // クリックジャッキング防止
  res.setHeader('X-Frame-Options', 'DENY');
  // API レスポンスをキャッシュしない
  res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, private');
  res.setHeader('Pragma', 'no-cache');
  // API バージョンと廃止情報
  res.setHeader('API-Version', 'v1');
  // リクエストトレーシング
  res.setHeader('X-Request-ID', req.headers['x-request-id'] || crypto.randomUUID());
  next();
});

// Apollo Server セキュリティ設定
const { ApolloServer } = require('@apollo/server');
const depthLimit = require('graphql-depth-limit');
const { createComplexityLimitRule } = require('graphql-validation-complexity');
 
const server = new ApolloServer({
  typeDefs,
  resolvers,
  // イントロスペクションを本番で無効化
  introspection: process.env.NODE_ENV !== 'production',
  // バリデーションルール
  validationRules: [
    // クエリ深度制限 (最大 10)
    depthLimit(10),
    // クエリ複雑度制限
    createComplexityLimitRule(1000, {
      scalarCost: 1,
      objectCost: 2,
      listFactor: 10,
      onCost: (cost) => {
        console.log(`Query cost: ${cost}`);
      },
    }),
  ],
  // エラーフォーマット (内部エラーを隠す)
  formatError: (error) => {
    // スタックトレースを除去
    if (process.env.NODE_ENV === 'production') {
      return {
        message: error.message,
        extensions: {
          code: error.extensions?.code || 'INTERNAL_ERROR',
        },
      };
    }
    return error;
  },
  plugins: [
    // クエリサイズ制限
    {
      async requestDidStart() {
        return {
          async didResolveOperation(ctx) {
            const queryLength = ctx.request.query?.length || 0;
            if (queryLength > 10000) {
              throw new Error('Query too large');
            }
          },
        };
      },
    },
  ],
});

// 非推奨 API のヘッダ通知
function deprecateEndpoint(sunsetDate, link) {
  return (req, res, next) => {
    res.setHeader('Deprecation', 'true');
    res.setHeader('Sunset', sunsetDate);  // RFC 8594
    res.setHeader('Link', `<${link}>; rel="successor-version"`);
 
    // 廃止直前は Warning ヘッダも追加
    const sunset = new Date(sunsetDate);
    const daysUntilSunset = Math.ceil((sunset - new Date()) / (1000 * 60 * 60 * 24));
    if (daysUntilSunset <= 30) {
      res.setHeader('Warning',
        `299 - "This API version will be removed on ${sunsetDate}. Migrate to ${link}"`
      );
    }
 
    next();
  };
}
 
// v1 は 2025-06-01 に廃止
app.use('/api/v1',
  deprecateEndpoint('2025-06-01', 'https://api.example.com/v2'),
  v1Router
);
app.use('/api/v2', v2Router);

// NG: アルゴリズムを検証しない
const payload = jwt.verify(token, secret);
// 攻撃者が alg: "none" でトークンを偽造 → 署名検証がスキップされる
 
// NG: HS256 と RS256 の混同
const payload = jwt.verify(token, publicKey);
// 攻撃者が alg を "HS256" に変更し、公開鍵を対称鍵として使用
 
// OK: 許可するアルゴリズムを明示指定
const payload = jwt.verify(token, publicKey, {
  algorithms: ['RS256'],  // none, HS256 などを拒否
  issuer: 'https://auth.example.com',
  audience: 'https://api.example.com',
});

// NG: 内部情報を露出するエラーレスポンス
app.use((err, req, res, next) => {
  res.status(500).json({
    error: err.message,        // "ECONNREFUSED 10.0.1.5:5432" → DB の IP が漏洩
    stack: err.stack,          // ファイルパスが漏洩
    query: err.sql,            // SQL クエリが漏洩
    config: app.get('config'), // 設定情報が漏洩
  });
});
 
// OK: 安全なエラーレスポンス
app.use((err, req, res, next) => {
  // 内部ログには詳細を記録
  const requestId = req.headers['x-request-id'] || crypto.randomUUID();
  console.error({
    requestId,
    error: err.message,
    stack: err.stack,
    path: req.path,
    method: req.method,
    userId: req.user?.id,
  });
 
  // クライアントには最小限の情報のみ
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    error: statusCode >= 500 ? 'Internal Server Error' : err.message,
    requestId,  // サポートへの問い合わせ用
  });
});

// NG: DB のレコードをそのまま返す
app.get('/api/users/:id', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);  // password_hash, internal_notes, ssn 等も含まれる
});
 
// OK: レスポンス DTO でフィールドを明示的に選択
function toUserDTO(user) {
  return {
    id: user.id,
    name: user.name,
    email: user.email,
    avatar: user.avatar,
    createdAt: user.createdAt,
    // password_hash, ssn, internal_notes は含めない
  };
}
 
app.get('/api/users/:id', authenticate, async (req, res) => {
  const user = await User.findById(req.params.id)
    .select('id name email avatar createdAt');  // DB クエリでも制限
  if (!user) return res.status(404).json({ error: 'Not found' });
  res.json(toUserDTO(user));
});

// 対策: clockTolerance で許容範囲を設定
jwt.verify(token, key, {
  algorithms: ['RS256'],
  clockTolerance: 30,  // 30秒の時刻ずれを許容
});
 
// 追加対策: iat が未来でないことを確認
if (payload.iat > Math.floor(Date.now() / 1000) + 60) {
  throw new Error('Token issued in the future');
}

// 例: "admin" の視覚的に同一な Unicode 文字
const normalAdmin = 'admin';        // U+0061, U+0064, U+006D, U+0069, U+006E
const trickAdmin = '\u0430dmin';    // U+0430 (Cyrillic 'a'), rest is Latin
 
normalAdmin === trickAdmin;  // false
normalAdmin.normalize('NFKC') === trickAdmin.normalize('NFKC');  // false
 
// 対策: 入力を NFKC 正規化してから検証
function sanitizeUsername(input) {
  const normalized = input.normalize('NFKC');
  // ASCII 以外の文字を含む場合は拒否
  if (!/^[a-zA-Z0-9_\-]+$/.test(normalized)) {
    throw new Error('Username contains invalid characters');
  }
  return normalized;
}

// 修正対象
app.get('/api/documents/:docId', async (req, res) => {
  const doc = await Document.findById(req.params.docId);
  res.json(doc);
});
 
app.put('/api/documents/:docId', async (req, res) => {
  const doc = await Document.findByIdAndUpdate(req.params.docId, req.body);
  res.json(doc);
});