Webアプリケーション脆弱性対策：OWASP Top 10から学ぶ実践的防御策

// 脆弱なコード例（Express.js）
app.get('/api/user/:id/profile', (req, res) => {
  const userId = req.params.id;
  
  // 権限チェックなしでユーザー情報を取得
  db.getUserProfile(userId)
    .then(profile => {
      res.json(profile);
    });
});

// 改善されたコード例（Express.js）
app.get('/api/user/:id/profile', authenticate, (req, res) => {
  const userId = req.params.id;
  const currentUserId = req.user.id;
  
  // 自分自身のプロファイルか、管理者権限を持っているかをチェック
  if (userId === currentUserId || req.user.isAdmin) {
    db.getUserProfile(userId)
      .then(profile => {
        res.json(profile);
      });
  } else {
    res.status(403).json({ error: 'アクセス権限がありません' });
  }
});

// ミドルウェアを使用した権限チェック（Express.js）
const checkPermission = (requiredPermission) => {
  return (req, res, next) => {
    if (req.user && req.user.permissions.includes(requiredPermission)) {
      next();
    } else {
      res.status(403).json({ error: '必要な権限がありません' });
    }
  };
};

// 使用例
app.get('/api/admin/users', authenticate, checkPermission('MANAGE_USERS'), (req, res) => {
  // ユーザー一覧を返す処理
});

// JWTトークン生成時に適切な権限情報を含める
const jwt = require('jsonwebtoken');

function generateToken(user) {
  return jwt.sign({
    sub: user.id,
    role: user.role,
    permissions: user.permissions,
    exp: Math.floor(Date.now() / 1000) + (60 * 60) // 1時間有効
  }, process.env.JWT_SECRET);
}

// 適切なCORS設定（Express.js）
const cors = require('cors');

// 本番環境では信頼できるオリジンのみを許可
const allowedOrigins = ['https://dx-media.example', 'https://api.dx-media.example'];

app.use(cors({
  origin: function(origin, callback) {
    if (!origin || allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('CORS policy violation'));
    }
  },
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true
}));

// 脆弱なコード例（Node.js）
const crypto = require('crypto');

function encryptData(data) {
  // 弱い暗号化アルゴリズム（DES）を使用
  const cipher = crypto.createCipheriv('des', 'weakkey8', '12345678');
  let encrypted = cipher.update(data, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return encrypted;
}

// パスワードのハッシュ化が不十分
function hashPassword(password) {
  // 単純なMD5ハッシュ（ソルトなし）
  return crypto.createHash('md5').update(password).digest('hex');
}

// 改善されたコード例（Node.js）
const crypto = require('crypto');

function encryptData(data, key) {
  // 強力なアルゴリズム（AES-256-GCM）を使用
  const iv = crypto.randomBytes(16); // ランダムな初期化ベクトル
  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  
  let encrypted = cipher.update(data, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  
  // 認証タグを取得（GCMモードの利点）
  const authTag = cipher.getAuthTag();
  
  // IV、暗号文、認証タグを返す
  return {
    iv: iv.toString('hex'),
    encrypted: encrypted,
    authTag: authTag.toString('hex')
  };
}

// 改善されたパスワードハッシュ（Node.js）
const bcrypt = require('bcrypt');

async function hashPassword(password) {
  // bcryptを使用し、適切なコスト係数を設定
  const saltRounds = 12;
  return await bcrypt.hash(password, saltRounds);
}

async function verifyPassword(password, hash) {
  return await bcrypt.compare(password, hash);
}

// Express.jsでのHTTPS強制
app.use((req, res, next) => {
  if (!req.secure && process.env.NODE_ENV === 'production') {
    return res.redirect(`https://${req.headers.host}${req.url}`);
  }
  next();
});

// Helmet.jsを使用したセキュリティヘッダー設定
const helmet = require('helmet');
app.use(helmet());

// Strict-Transport-Security（HSTS）の設定
app.use(helmet.hsts({
  maxAge: 31536000, // 1年
  includeSubDomains: true,
  preload: true
}));

// SQLインジェクションに脆弱なコード例（Node.js + MySQL）
app.post('/login', (req, res) => {
  const username = req.body.username;
  const password = req.body.password;
  
  // 危険な文字列連結によるSQLクエリ構築
  const query = `SELECT * FROM users WHERE username = '${username}' AND password = '${password}'`;
  
  db.query(query, (err, results) => {
    if (results.length > 0) {
      // ログイン成功処理
    } else {
      // ログイン失敗処理
    }
  });
});

// 改善されたコード例（Node.js + MySQL）
app.post('/login', (req, res) => {
  const username = req.body.username;
  const password = req.body.password;
  
  // プリペアドステートメントを使用
  const query = 'SELECT * FROM users WHERE username = ? AND password = ?';
  
  db.query(query, [username, password], (err, results) => {
    if (results.length > 0) {
      // ログイン成功処理
    } else {
      // ログイン失敗処理
    }
  });
});

// Sequelize ORMを使用した安全な実装
const { User } = require('./models');

app.post('/login', async (req, res) => {
  try {
    const user = await User.findOne({
      where: {
        username: req.body.username,
        password: req.body.password // 実際にはハッシュ化されたパスワードを使用
      }
    });
    
    if (user) {
      // ログイン成功処理
    } else {
      // ログイン失敗処理
    }
  } catch (error) {
    // エラー処理
  }
});

// express-validatorを使用した入力検証
const { body, validationResult } = require('express-validator');

app.post('/api/articles',
  // 入力検証ルールを定義
  body('title').isLength({ min: 5, max: 100 }).trim().escape(),
  body('content').isLength({ min: 10 }).trim(),
  body('authorId').isNumeric(),
  
  async (req, res) => {
    // バリデーションエラーの確認
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    
    // 検証済みデータの処理
    try {
      const article = await Article.create({
        title: req.body.title,
        content: req.body.content,
        authorId: req.body.authorId
      });
      
      res.status(201).json(article);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
);

// 危険な実装
const { exec } = require('child_process');

app.get('/ping', (req, res) => {
  const ip = req.query.ip;
  exec(`ping -c 4 ${ip}`, (error, stdout, stderr) => {
    res.send(stdout);
  });
});

// 安全な実装
const { spawn } = require('child_process');

app.get('/ping', (req, res) => {
  const ip = req.query.ip;
  
  // IPアドレスの形式をバリデーション
  if (!/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/.test(ip)) {
    return res.status(400).send('不正なIPアドレス形式です');
  }
  
  // 引数を配列として渡し、シェル解釈を回避
  const ping = spawn('ping', ['-c', '4', ip]);
  
  let output = '';
  ping.stdout.on('data', (data) => {
    output += data.toString();
  });
  
  ping.on('close', (code) => {
    res.send(output);
  });
});

// 安全でない設計の例（パスワードリセット機能）
app.post('/password-reset', (req, res) => {
  const email = req.body.email;
  
  // 問題点1: アカウント列挙攻撃に脆弱
  db.getUserByEmail(email)
    .then(user => {
      if (!user) {
        return res.status(404).json({ error: 'ユーザーが見つかりません' });
      }
      
      // 問題点2: 簡単に予測可能なリセットコード
      const resetCode = Math.floor(1000 + Math.random() * 9000); // 4桁の数字
      
      // 問題点3: リセットコードの有効期限なし
      db.storeResetCode(user.id, resetCode)
        .then(() => {
          // メール送信処理
          sendResetEmail(user.email, resetCode);
          res.json({ message: 'リセットコードを送信しました' });
        });
    });
});

// 改善されたパスワードリセット機能
const crypto = require('crypto');

app.post('/password-reset-request', rateLimiter, (req, res) => {
  const email = req.body.email;
  
  // アカウント列挙攻撃防止のため常に同じレスポンスを返す
  const genericMessage = { message: 'アカウントが存在する場合、リセット手順をメールで送信しました' };
  
  db.getUserByEmail(email)
    .then(user => {
      if (!user) {
        // 存在しないユーザーでも遅延を入れて応答時間を一定に
        setTimeout(() => {
          res.json(genericMessage);
        }, 1000);
        return;
      }
      
      // 安全なリセットトークンの生成
      const resetToken = crypto.randomBytes(32).toString('hex');
      const hashedToken = crypto.createHash('sha256').update(resetToken).digest('hex');
      
      // トークンの有効期限を設定（1時間）
      const expiresAt = new Date();
      expiresAt.setHours(expiresAt.getHours() + 1);
      
      db.storeResetToken(user.id, hashedToken, expiresAt)
        .then(() => {
          // メール送信処理
          const resetUrl = `https://dx-media.example/reset-password?token=${resetToken}&email=${encodeURIComponent(email)}`;
          sendResetEmail(user.email, resetUrl);
          res.json(genericMessage);
        });
    });
});

// パスワードリセット処理
app.post('/password-reset', rateLimiter, async (req, res) => {
  const { email, token, newPassword } = req.body;
  
  // トークンのハッシュ化
  const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
  
  try {
    // 有効なトークンの検証
    const resetRequest = await db.getResetRequest(email, hashedToken);
    if (!resetRequest || resetRequest.expiresAt < new Date()) {
      return res.status(400).json({ error: 'リセットトークンが無効または期限切れです' });
    }
    
    // パスワード強度の検証
    if (!isStrongPassword(newPassword)) {
      return res.status(400).json({ error: 'パスワードが要件を満たしていません' });
    }
    
    // パスワードのハッシュ化と更新
    const hashedPassword = await bcrypt.hash(newPassword, 12);
    await db.updateUserPassword(resetRequest.userId, hashedPassword);
    
    // 使用済みトークンの削除
    await db.deleteResetRequest(resetRequest.id);
    
    res.json({ message: 'パスワードがリセットされました' });
  } catch (error) {
    res.status(500).json({ error: '内部エラーが発生しました' });
  }
});

// レート制限ミドルウェア
const rateLimit = require('express-rate-limit');

const rateLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 5, // IPアドレスごとに5リクエストまで
  message: { error: '試行回数が多すぎます。しばらく経ってから再試行してください。' }
});

// 従来のユーザーストーリー
「ユーザーとして、パスワードを忘れた場合にリセットできるようにしたい」

// セキュリティ要件を組み込んだユーザーストーリー
「ユーザーとして、パスワードを忘れた場合に、安全かつ本人確認が適切に行われる形でパスワードをリセットできるようにしたい」

// 具体的な受け入れ基準
1. リセットリンクは一意で予測不可能であること
2. リセットリンクは60分後に期限切れになること
3. リセット操作の前に本人確認のための追加情報を要求すること
4. リセット後には通知メールが送信されること
5. 1時間あたりのリセット試行回数は5回までに制限されること

// 詳細なエラーメッセージを表示する脆弱な例
app.use((err, req, res, next) => {
  // 問題点: 攻撃者に有用な情報を提供するエラーメッセージ
  res.status(500).json({
    error: err.message,
    stack: err.stack,
    query: req.query,
    body: req.body
  });
});

// クロスドメインリソース共有（CORS）の不適切な設定
app.use(cors({
  // 問題点: すべてのドメインからのリクエストを許可
  origin: '*',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

// 改善された本番環境向けエラーハンドリング
app.use((err, req, res, next) => {
  // 開発環境では詳細なエラー情報を表示
  if (process.env.NODE_ENV === 'development') {
    return res.status(500).json({
      error: err.message,
      stack: err.stack
    });
  }
  
  // 本番環境では一般的なエラーメッセージのみを表示
  res.status(500).json({
    error: '内部サーバーエラーが発生しました。後ほど再試行してください。'
  });
  
  // エラーをログに記録（管理者のみが確認可能）
  logger.error({
    message: err.message,
    stack: err.stack,
    requestId: req.id,
    user: req.user ? req.user.id : 'unauthenticated',
    path: req.path,
    method: req.method
  });
});

// Helmet.jsを使用したセキュリティヘッダー設定
const helmet = require('helmet');

// 基本的なセキュリティヘッダーを設定
app.use(helmet());

// コンテンツセキュリティポリシー（CSP）の設定
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", "'unsafe-inline'", 'trusted-cdn.com'],
    styleSrc: ["'self'", "'unsafe-inline'", 'trusted-cdn.com'],
    imgSrc: ["'self'", 'data:', 'trusted-cdn.com'],
    connectSrc: ["'self'", 'api.dx-media.example'],
    fontSrc: ["'self'", 'trusted-cdn.com'],
    objectSrc: ["'none'"],
    mediaSrc: ["'self'"],
    frameSrc: ["'none'"]
  }
}));

// その他の重要なセキュリティヘッダー
app.use(helmet.referrerPolicy({ policy: 'same-origin' }));
app.use(helmet.permittedCrossDomainPolicies({ permittedPolicies: 'none' }));
app.use(helmet.expectCt({ maxAge: 86400, enforce: true }));

# Nginx設定例
server {
    listen 80;
    server_name dx-media.example;
    
    # HTTPをHTTPSにリダイレクト
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name dx-media.example;
    
    # SSL設定
    ssl_certificate /etc/letsencrypt/live/dx-media.example/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/dx-media.example/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305';
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    
    # セキュリティヘッダー
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
    add_header X-Frame-Options SAMEORIGIN;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    
    # 不要なサーバー情報の非表示
    server_tokens off;
    
    # レート制限
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
    limit_req zone=mylimit burst=20 nodelay;
    
    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
    
    # 隠しファイルへのアクセスを拒否
    location ~ /\. {
        deny all;
    }
}

// AWS S3バケットのセキュアな設定（AWS SDK v3）
const { S3Client, PutBucketPolicyCommand } = require('@aws-sdk/client-s3');

const s3Client = new S3Client({ region: 'us-east-1' });

// S3バケットの安全なポリシー設定
async function secureBucket(bucketName) {
  const bucketPolicy = {
    Version: '2012-10-17',
    Statement: [
      {
        Sid: 'AllowSSLRequestsOnly',
        Effect: 'Deny',
        Principal: '*',
        Action: 's3:*',
        Resource: [
          `arn:aws:s3:::${bucketName}`,
          `arn:aws:s3:::${bucketName}/*`
        ],
        Condition: {
          Bool: {
            'aws:SecureTransport': 'false'
          }
        }
      }
    ]
  };

  const params = {
    Bucket: bucketName,
    Policy: JSON.stringify(bucketPolicy)
  };

  try {
    const command = new PutBucketPolicyCommand(params);
    await s3Client.send(command);
    console.log(`Bucket ${bucketName} policy updated successfully`);
  } catch (err) {
    console.error(`Error updating bucket policy: ${err}`);
  }
}

// 脆弱性を持つ依存関係の例（package.json）
{
  "name": "my-application",
  "version": "1.0.0",
  "dependencies": {
    "express": "4.14.0",        // 古いバージョン
    "lodash": "4.17.11",        // 脆弱性のあるバージョン
    "jquery": "1.12.4",         // 非常に古いバージョン
    "moment": "2.20.1",         // セキュリティパッチ適用前のバージョン
    "node-sass": "4.5.0"        // 既知の脆弱性を持つバージョン
  }
}

// npm監査によるセキュリティ脆弱性のチェック
// package.jsonに追加するスクリプト
{
  "scripts": {
    "audit": "npm audit",
    "audit:fix": "npm audit fix",
    "preinstall": "npm audit",
    "postupdate": "npm audit"
  }
}

# GitHubのDependabotの設定例（.github/dependabot.yml）
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    target-branch: "develop"
    labels:
      - "dependencies"
      - "security"
    allow:
      - dependency-type: "direct"
    ignore:
      - dependency-name: "express"
        versions: ["5.x"]  # メジャーバージョンアップは手動で確認

# GitHub Actionsでのセキュリティスキャン（.github/workflows/security-scan.yml）
name: Security Scan

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  schedule:
    - cron: '0 0 * * 0'  # 毎週日曜日に実行

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run npm audit
        run: npm audit --audit-level=high
      
      - name: Run Snyk to check for vulnerabilities
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          command: test --severity-threshold=high

# Dockerfileのベストプラクティス
FROM node:18-alpine AS base

# 特権の低いユーザーを作成
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001 -G nodejs

WORKDIR /app

# 依存関係を別レイヤーにインストールして再利用
COPY package*.json ./
RUN npm ci --only=production

# 本番用の依存関係をコピー
COPY --chown=nodejs:nodejs . .

# 不要なファイルを削除して攻撃対象を減らす
RUN rm -rf tests/ documentation/ .git/

# 非特権ユーザーに切り替え
USER nodejs

EXPOSE 3000
CMD ["node", "server.js"]

# GitHubActionsでのDockerイメージスキャン
name: Docker Image Scan

on:
  push:
    branches: [ main ]
    paths:
      - 'Dockerfile'
      - 'docker-compose.yml'

jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Build Docker image
        run: docker build -t myapp:latest .
      
      - name: Scan Docker image for vulnerabilities
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'myapp:latest'
          format: 'table'
          exit-code: '1'
          ignore-unfixed: true
          severity: 'CRITICAL,HIGH'

// バージョン管理の自動化を支援するスクリプト例
const { execSync } = require('child_process');
const fs = require('fs');

// 依存関係のリストと許可されたバージョンを定義
const allowedPackages = {
  'express': '^4.17.1',
  'react': '^17.0.2',
  'lodash': '^4.17.21'
};

// package.jsonを読み込む
const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
const dependencies = packageJson.dependencies || {};

// 非推奨パッケージや不要なパッケージを検出
for (const [pkg, version] of Object.entries(dependencies)) {
  if (!allowedPackages[pkg]) {
    console.warn(`警告: 未承認のパッケージ ${pkg}@${version} が検出されました。レビューが必要です。`);
  } else if (version !== allowedPackages[pkg]) {
    console.warn(`警告: パッケージ ${pkg} のバージョンが推奨版と異なります。現在: ${version}, 推奨: ${allowedPackages[pkg]}`);
  }
}

// 利用されていない依存関係を検出
try {
  console.log('使用されていない依存関係を検出中...');
  const result = execSync('npx depcheck', { encoding: 'utf8' });
  console.log(result);
} catch (error) {
  console.error('依存関係チェック中にエラーが発生しました:', error.message);
}

// 多要素認証の実装例
const speakeasy = require('speakeasy');
const QRCode = require('qrcode');

// 2FAの設定
app.post('/setup-2fa', authenticate, async (req, res) => {
  // ユーザー固有のシークレットを生成
  const secret = speakeasy.generateSecret({
    name: `MyApp:${req.user.email}`
  });
  
  // シークレットをユーザーデータに保存
  await User.updateOne(
    { _id: req.user.id },
    { twoFactorSecret: secret.base32 }
  );
  
  // QRコードを生成してユーザーに表示
  QRCode.toDataURL(secret.otpauth_url, (err, image_data) => {
    res.json({ 
      secret: secret.base32, 
      qrCode: image_data 
    });
  });
});

// 2FA検証
app.post('/verify-2fa', async (req, res) => {
  const { userId, token } = req.body;
  
  // ユーザーのシークレットを取得
  const user = await User.findById(userId);
  
  // トークンの検証
  const verified = speakeasy.totp.verify({
    secret: user.twoFactorSecret,
    encoding: 'base32',
    token: token
  });
  
  if (verified) {
    // 認証成功
    const jwtToken = generateJWT(user);
    res.json({ token: jwtToken });
  } else {
    // 認証失敗
    res.status(401).json({ error: '無効な認証コードです' });
  }
});

// パスワード強度検証ミドルウェア
const zxcvbn = require('zxcvbn');

function validatePassword(req, res, next) {
  const { password } = req.body;
  
  // 最小長チェック
  if (password.length < 10) {
    return res.status(400).json({
      error: 'パスワードは10文字以上必要です'
    });
  }
  
  // zxcvbnでパスワード強度をチェック
  const result = zxcvbn(password);
  
  if (result.score < 3) {
    return res.status(400).json({
      error: 'パスワードが弱すぎます',
      suggestions: result.feedback.suggestions
    });
  }
  
  next();
}

// 使用例
app.post('/register', validatePassword, async (req, res) => {
  // ユーザー登録処理
});

// Expressセッション設定の例
const session = require('express-session');

app.use(session({
  secret: process.env.SESSION_SECRET,
  name: '__Secure-sessionId', // デフォルト名を使用しない
  cookie: {
    httpOnly: true,
    secure: true,          // HTTPSのみ
    maxAge: 60 * 60 * 1000, // 1時間
    sameSite: 'strict'
  },
  resave: false,
  saveUninitialized: false
}));

// セッションローテーション（認証状態変更時に再生成）
app.post('/login', (req, res) => {
  // ユーザー認証
  authenticateUser(req.body)
    .then(user => {
      // 既存のセッションを無効化
      req.session.regenerate(err => {
        if (err) {
          return res.status(500).json({ error: 'セッション生成に失敗しました' });
        }
        
        // 新しいセッションにユーザー情報を設定
        req.session.user = {
          id: user.id,
          role: user.role
        };
        
        res.json({ message: 'ログイン成功' });
      });
    })
    .catch(err => {
      res.status(401).json({ error: '認証に失敗しました' });
    });
});

<!-- CDNリソースの整合性検証 -->
<script src="https://cdn.dx-media.example/library.js"
        integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC"
        crossorigin="anonymous"></script>

// シリアライズされたデータの安全な検証
const { parse, stringify } = require('superjson');
const Joi = require('joi');

// データスキーマの定義
const userSchema = Joi.object({
  id: Joi.number().required(),
  name: Joi.string().max(100).required(),
  email: Joi.string().email().required(),
  role: Joi.string().valid('user', 'admin').required()
});

// デシリアライズ時のデータ検証
app.post('/deserialize', (req, res) => {
  try {
    // シリアライズされたデータをパース
    const data = parse(req.body.data);
    
    // スキーマ検証
    const { error, value } = userSchema.validate(data);
    
    if (error) {
      return res.status(400).json({ error: '不正なデータ形式です' });
    }
    
    // 検証済みデータを使用
    processUser(value);
    res.json({ success: true });
  } catch (err) {
    res.status(400).json({ error: 'デシリアライズに失敗しました' });
  }
});

// データの署名と検証
const crypto = require('crypto');

// データに署名
function signData(data, privateKey) {
  const sign = crypto.createSign('SHA256');
  sign.update(JSON.stringify(data));
  return sign.sign(privateKey, 'base64');
}

// 署名の検証
function verifyData(data, signature, publicKey) {
  const verify = crypto.createVerify('SHA256');
  verify.update(JSON.stringify(data));
  return verify.verify(publicKey, signature, 'base64');
}

// 使用例
app.post('/api/actions', (req, res) => {
  const { data, signature } = req.body;
  
  // 署名の検証
  if (!verifyData(data, signature, CONFIG.publicKey)) {
    return res.status(401).json({ error: '署名が無効です' });
  }
  
  // 検証済みデータを処理
  processVerifiedData(data);
  res.json({ success: true });
});

// Winstonロガーを使用した構造化ログ
const winston = require('winston');

// ロガーの設定
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { service: 'user-service' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// 本番環境でないときはコンソールにも出力
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

// 認証関連のログ記録
app.post('/login', (req, res) => {
  const { username } = req.body;
  
  authenticateUser(req.body)
    .then(user => {
      // 成功ログの記録
      logger.info('ログイン成功', {
        userId: user.id,
        username,
        ip: req.ip,
        userAgent: req.headers['user-agent']
      });
      
      // ログイン処理
      // ...
    })
    .catch(error => {
      // 失敗ログの記録
      logger.warn('ログイン失敗', {
        username,
        ip: req.ip,
        userAgent: req.headers['user-agent'],
        reason: error.message
      });
      
      res.status(401).json({ error: '認証に失敗しました' });
    });
});

// セキュリティイベント監視ミドルウェア
function securityMonitor(req, res, next) {
  const start = Date.now();
  
  // レスポンス完了後の処理
  res.on('finish', () => {
    const duration = Date.now() - start;
    
    // セキュリティイベントをチェック
    if (res.statusCode === 401 || res.statusCode === 403) {
      logger.warn('アクセス拒否', {
        path: req.path,
        method: req.method,
        statusCode: res.statusCode,
        ip: req.ip,
        userId: req.user ? req.user.id : 'anonymous',
        duration
      });
    }
    
    // レート制限違反や疑わしい動作の検出
    if (duration < 10 && req.path.includes('/api/')) {
      logger.warn('疑わしい高速リクエスト', {
        path: req.path,
        method: req.method,
        ip: req.ip,
        duration
      });
    }
  });
  
  next();
}

// ミドルウェアの使用
app.use(securityMonitor);

// URLのサニタイズとホワイトリスト
const { URL } = require('url');
const dns = require('dns').promises;

// 許可されたドメインのリスト
const ALLOWED_DOMAINS = [
  'api.dx-media.example',
  'api.trusted-service.com'
];

// IPアドレスが内部ネットワークかチェック
function isInternalIP(ip) {
  // プライベートIPレンジのチェック
  return /^(127\.|10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.)/.test(ip) ||
         ip === '::1' || ip === 'localhost';
}

// URL検証ミドルウェア
async function validateExternalUrl(req, res, next) {
  try {
    const { externalUrl } = req.body;
    
    if (!externalUrl) {
      return next();
    }
    
    // 有効なURLか検証
    const parsedUrl = new URL(externalUrl);
    
    // スキームの検証
    if (parsedUrl.protocol !== 'https:') {
      return res.status(400).json({ error: 'HTTPSのみ許可されています' });
    }
    
    // ドメインの検証
    if (!ALLOWED_DOMAINS.includes(parsedUrl.hostname)) {
      return res.status(400).json({ error: '許可されていないドメインです' });
    }
    
    // DNSルックアップでIPを解決
    const ips = await dns.resolve(parsedUrl.hostname);
    
    // 内部IPかチェック
    for (const ip of ips) {
      if (isInternalIP(ip)) {
        return res.status(400).json({ error: '内部ネットワークへのアクセスは許可されていません' });
      }
    }
    
    // 検証に通過した場合はリクエストを続行
    next();
  } catch (error) {
    res.status(400).json({ error: '無効なURL形式です' });
  }
}

// 使用例
app.post('/fetch-external-data', validateExternalUrl, async (req, res) => {
  try {
    const { externalUrl } = req.body;
    
    // 検証済みのURLにリクエスト
    const response = await axios.get(externalUrl, {
      timeout: 5000,        // タイムアウトを設定
      maxRedirects: 2,      // リダイレクト回数を制限
      validateStatus: null  // すべてのステータスコードを処理
    });
    
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: '外部データの取得に失敗しました' });
  }
});

// 低権限プロキシサービスの利用例
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');

// メインアプリケーション
const app = express();

// 外部リクエスト用の分離されたプロキシ（低権限で実行）
const proxyApp = express();

// プロキシの設定
proxyApp.use('/api/proxy', validateExternalUrl, createProxyMiddleware({
  router: (req) => req.body.externalUrl,
  changeOrigin: true,
  pathRewrite: { '^/api/proxy': '' },
  onProxyReq: (proxyReq, req, res) => {
    // 特定のリクエストヘッダーを削除
    proxyReq.removeHeader('Authorization');
    proxyReq.removeHeader('Cookie');
  }
}));

// 低権限サービスとしてリッスン
proxyApp.listen(3001, '127.0.0.1');

// メインアプリからプロキシへの内部ルーティング
app.post('/fetch-external', validateExternalUrl, async (req, res) => {
  try {
    const response = await axios.post('http://127.0.0.1:3001/api/proxy', {
      externalUrl: req.body.externalUrl
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: '外部データの取得に失敗しました' });
  }
});