Webセキュリティ OWASP Top 10 完全ガイド2025：開発者が必ず防ぐべき10大脆弱性

# 攻撃者がURLのIDを変更して他のユーザー情報にアクセス
GET /api/users/12345/profile  -> 自分のプロフィール
GET /api/users/12346/profile  -> 他のユーザーのプロフィール（権限なしでアクセス!）

// 脆弱 - 権限確認なしで直接取得
app.get('/api/users/:id/profile', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user); // IDさえ分かれば誰でもアクセス可能!
});

// 脆弱 - ロールのみ確認、リソース所有権未確認
app.delete('/api/posts/:id', requireRole('user'), async (req, res) => {
  await Post.findByIdAndDelete(req.params.id); // 他ユーザーの投稿も削除可能!
  res.json({ message: 'Deleted' });
});

// 安全 - リソース所有権の確認
app.get('/api/users/:id/profile', authenticate, async (req, res) => {
  if (req.params.id !== req.user.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  const user = await User.findById(req.params.id);
  res.json(user);
});

// 安全 - 所有権 + ロール確認
app.delete('/api/posts/:id', authenticate, async (req, res) => {
  const post = await Post.findById(req.params.id);
  if (!post) return res.status(404).json({ error: 'Not found' });

  if (post.authorId !== req.user.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  await post.deleteOne();
  res.json({ message: 'Deleted' });
});

// 脆弱: MD5でパスワードハッシュ
const crypto = require('crypto');
const hashedPassword = crypto.createHash('md5').update(password).digest('hex');

// 脆弱: ハードコードされた暗号化キー
const SECRET_KEY = 'my-super-secret-key-123';
const encrypted = encrypt(data, SECRET_KEY);

const bcrypt = require('bcrypt');

// 安全: bcryptで自動ソルト生成
const SALT_ROUNDS = 12;
const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
const isMatch = await bcrypt.compare(inputPassword, hashedPassword);

// 安全: 環境変数からキー読み込み + AES-256-GCM使用
const crypto = require('crypto');
const SECRET_KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex');

function encrypt(plaintext) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-gcm', SECRET_KEY, iv);
  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
  const tag = cipher.getAuthTag();
  return { iv: iv.toString('hex'), encrypted: encrypted.toString('hex'), tag: tag.toString('hex') };
}

// 安全: TLS 1.2以上のみ許可
const server = https.createServer({
  minVersion: 'TLSv1.2',
  ciphers: 'TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256',
});

-- 正常なクエリ
SELECT * FROM users WHERE username = 'admin' AND password = 'password123'

-- 攻撃入力: username = ' OR '1'='1' --
SELECT * FROM users WHERE username = '' OR '1'='1' --' AND password = ''
-- 結果: すべてのユーザー情報が返される!

// ===== SQL Injection =====

// 脆弱: 文字列結合でクエリ生成
const query = `SELECT * FROM users WHERE username = '${username}' AND password = '${password}'`;
db.query(query);

// 安全: パラメータ化クエリ（Prepared Statement）
const query = 'SELECT * FROM users WHERE username = ? AND password = ?';
db.query(query, [username, hashedPassword]);

// 安全: ORM使用（Sequelize例）
const user = await User.findOne({
  where: { username, password: hashedPassword },
});

// ===== NoSQL Injection =====

// 脆弱: ユーザー入力を直接クエリに使用
app.post('/login', async (req, res) => {
  const user = await User.findOne(req.body);
});

// 安全: 型検証 + mongo-sanitize
const sanitize = require('mongo-sanitize');
app.post('/login', async (req, res) => {
  const username = sanitize(req.body.username);
  if (typeof username !== 'string') return res.status(400).send('Invalid input');
  const user = await User.findOne({ username, password: hashedPassword });
});

// ===== OS Command Injection =====

// 脆弱: ユーザー入力をシェルコマンドに直接使用
const { exec } = require('child_process');
exec(`ping ${userInput}`, callback);
// 攻撃: userInput = "8.8.8.8; rm -rf /"

// 安全: execFile使用（シェル解釈なし）
const { execFile } = require('child_process');
execFile('ping', ['-c', '4', userInput], callback);

// ===== Stored XSS =====

// 脆弱: ユーザー入力をそのままHTMLに挿入
app.get('/comments', async (req, res) => {
  const comments = await Comment.find();
  let html = '';
  comments.forEach(c => {
    html += `<div>${c.text}</div>`; // XSS脆弱!
  });
  res.send(html);
});

// 安全: 出力エンコーディング
const he = require('he');
comments.forEach(c => {
  html += `<div>${he.encode(c.text)}</div>`;
});

// ReactはデフォルトでXSS防止（JSXが自動エスケープ）
function Comment({ text }) {
  return <div>{text}</div>; // 自動的にHTMLエスケープされる
}

// 原則1: Rate Limiting（リクエスト制限）
const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分
  max: 5, // 最大5回試行
  message: 'Too many login attempts. Please try again after 15 minutes.',
  standardHeaders: true,
});
app.post('/login', loginLimiter, loginHandler);

// 原則2: ビジネスロジック検証
async function applyCoupon(userId, couponCode) {
  const coupon = await Coupon.findOne({ code: couponCode });
  if (!coupon || coupon.usedBy.includes(userId)) {
    throw new Error('Invalid or already used coupon');
  }
  // アトミック更新でレースコンディション防止
  const result = await Coupon.findOneAndUpdate(
    { code: couponCode, usedBy: { $ne: userId } },
    { $push: { usedBy: userId } },
    { new: true }
  );
  if (!result) throw new Error('Coupon already used');
  return result;
}

// 安全: Helmetミドルウェア + セキュリティ強化
const helmet = require('helmet');
const app = express();
app.use(helmet());
app.disable('x-powered-by');

// 安全: エラーメッセージの情報漏洩防止
app.use((err, req, res, next) => {
  console.error(err.stack); // サーバーログにのみ記録
  res.status(500).json({
    error: 'Internal Server Error', // 一般的なメッセージのみ返却
  });
});

# Docker セキュリティ設定

# 脆弱: rootユーザーで実行
FROM node:20
COPY . .
CMD ["node", "server.js"]

# 安全: non-rootユーザー使用
FROM node:20-slim
RUN groupadd -r appuser && useradd -r -g appuser appuser
WORKDIR /app
COPY --chown=appuser:appuser . .
USER appuser
CMD ["node", "server.js"]

# npm依存関係の脆弱性監査
npm audit
npm audit fix

# Snykで脆弱性スキャン
npx snyk test
npx snyk monitor

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    reviewers:
      - "security-team"

// 安全: 暗号学的に安全なランダムセッションID
const crypto = require('crypto');
function createSession() {
  return crypto.randomBytes(32).toString('hex'); // 256ビットランダム
}

// 安全: 明示的アルゴリズム指定
const payload = jwt.verify(token, secret, {
  algorithms: ['HS256'],
  issuer: 'my-app',
  audience: 'my-api',
});

// MFA実装
const speakeasy = require('speakeasy');

async function setupMFA(userId) {
  const secret = speakeasy.generateSecret({
    name: `MyApp:user-${userId}`,
    issuer: 'MyApp',
  });
  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);
  await User.updateOne({ _id: userId }, { mfaSecret: encrypt(secret.base32) });
  return { qrCodeUrl, backupCodes: generateBackupCodes() };
}

function verifyMFA(token, userSecret) {
  return speakeasy.totp.verify({
    secret: userSecret,
    encoding: 'base32',
    token: token,
    window: 1,
  });
}

// 安全: デシリアライズ前にスキーマ検証
const Joi = require('joi');
const schema = Joi.object({
  name: Joi.string().max(100).required(),
  age: Joi.number().integer().min(0).max(150),
  email: Joi.string().email(),
});

app.post('/api/data', (req, res) => {
  const { error, value } = schema.validate(req.body);
  if (error) return res.status(400).json({ error: error.details });
  processData(value);
});

const winston = require('winston');

const securityLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { service: 'security' },
  transports: [
    new winston.transports.File({ filename: 'security.log' }),
  ],
});

function logAuthEvent(event) {
  securityLogger.info('Authentication event', {
    type: event.type,
    userId: event.userId,
    ip: event.ip,
    userAgent: event.userAgent,
    timestamp: new Date().toISOString(),
    // パスワードは絶対にログに記録しない!
  });
}

function logAuditEvent(action, userId, resource, details) {
  securityLogger.info('Audit event', {
    action,
    userId,
    resource,
    details,
    timestamp: new Date().toISOString(),
  });
}

const axios = require('axios');
const { URL } = require('url');
const dns = require('dns').promises;
const ipaddr = require('ipaddr.js');

// 脆弱: ユーザー入力URLに直接リクエスト
app.post('/api/fetch-url', async (req, res) => {
  const response = await axios.get(req.body.url);
  res.json(response.data);
});

// 安全: URL検証 + IP遮断
async function isUrlSafe(urlString) {
  const parsed = new URL(urlString);

  if (parsed.protocol !== 'https:') return false;

  const blockedHosts = ['localhost', '127.0.0.1', '0.0.0.0', 'metadata.google.internal'];
  if (blockedHosts.includes(parsed.hostname)) return false;

  const addresses = await dns.resolve4(parsed.hostname);
  for (const addr of addresses) {
    const ip = ipaddr.parse(addr);
    if (ip.range() !== 'unicast') return false;
  }
  return true;
}

app.post('/api/fetch-url', async (req, res) => {
  if (!await isUrlSafe(req.body.url)) {
    return res.status(403).json({ error: 'URL not allowed' });
  }
  const response = await axios.get(req.body.url, {
    timeout: 5000,
    maxRedirects: 0,
  });
  res.json(response.data);
});

const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.render('form', { csrfToken: req.csrfToken() });
});

app.post('/transfer', csrfProtection, (req, res) => {
  processTransfer(req.body);
});

// SameSiteクッキーでCSRF防御
res.cookie('session', sessionId, {
  httpOnly: true,
  secure: true,
  sameSite: 'Strict',
  maxAge: 3600000,
});

const cors = require('cors');

// 脆弱: すべてのオリジンを許可
app.use(cors());

// 安全: 特定のオリジンのみ許可
app.use(cors({
  origin: ['https://myapp.com', 'https://admin.myapp.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  credentials: true,
  maxAge: 86400,
}));

app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", "'nonce-abc123'"],
    styleSrc: ["'self'", "https://fonts.googleapis.com"],
    imgSrc: ["'self'", "data:", "https:"],
    connectSrc: ["'self'", "https://api.myapp.com"],
    fontSrc: ["'self'", "https://fonts.gstatic.com"],
    objectSrc: ["'none'"],
    frameSrc: ["'none'"],
  },
}));

const rateLimit = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');

const limiter = rateLimit({
  store: new RedisStore({
    sendCommand: (...args) => redisClient.call(...args),
  }),
  windowMs: 15 * 60 * 1000,
  max: 100,
  standardHeaders: true,
  legacyHeaders: false,
  keyGenerator: (req) => req.ip,
});

const authLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 5 });
const apiLimiter = rateLimit({ windowMs: 60 * 1000, max: 30 });

app.use('/api/auth', authLimiter);
app.use('/api/', apiLimiter);

app.use((req, res, next) => {
  // XSS防御
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-XSS-Protection', '0');

  // Clickjacking防御
  res.setHeader('X-Frame-Options', 'DENY');

  // HTTPS強制
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');

  // Referrer情報制限
  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');

  // ブラウザ機能制限
  res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');

  // CSP
  res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'");

  next();
});

# GitHub Actionsセキュリティスキャン統合
name: Security Scan
on: [push, pull_request]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Snyk
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

      - name: Run Semgrep
        uses: semgrep/semgrep-action@v1
        with:
          config: p/owasp-top-ten

      - name: Run Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          severity: 'CRITICAL,HIGH'