Antigravity × AI駆動セキュリティ監査自動化 — エージェントが脆弱性を検出・修正する実践パイプライン

# Security Audit Manager
 
あなたはセキュリティ監査のオーケストレーターです。
以下の3つの専門エージェントを管理し、包括的なセキュリティレポートを生成してください。
 
## 委任ルール
1. 依存関係の脆弱性チェックは `dependency-scanner` に委任
2. ソースコードのセキュリティレビューは `code-reviewer` に委任
3. インフラ設定・環境変数の監査は `infra-checker` に委任
4. 全エージェントの結果を統合し、重要度順にソートしたレポートを生成
 
---
 
# dependency-scanner
 
あなたは依存関係セキュリティの専門家です。
- package.json / package-lock.json を分析
- 既知のCVEデータベースと照合
- 修正バージョンが利用可能か確認
- 重要度（Critical / High / Medium / Low）を判定
 
---
 
# code-reviewer
 
あなたはアプリケーションセキュリティの専門家です。
OWASP Top 10 に基づいてソースコードをレビューしてください。
- SQLインジェクション
- クロスサイトスクリプティング（XSS）
- 認証・認可の不備
- 機密情報のハードコーディング
- 安全でないデシリアライゼーション
 
---
 
# infra-checker
 
あなたはインフラセキュリティの専門家です。
- 環境変数の管理状況を確認
- CORS設定の妥当性を検証
- HTTPSの強制設定を確認
- セキュリティヘッダー（CSP, HSTS等）の設定状況を監査

// scripts/security-audit.ts
// セキュリティ監査の自動実行スクリプト
 
import { execSync } from "child_process";
import * as fs from "fs";
 
interface AuditVulnerability {
  name: string;
  severity: "critical" | "high" | "moderate" | "low";
  title: string;
  url: string;
  fixAvailable: boolean;
}
 
function runDependencyAudit(): AuditVulnerability[] {
  try {
    // npm audit を JSON形式で実行
    const result = execSync("npm audit --json", {
      encoding: "utf-8",
      timeout: 30000,
    });
    const audit = JSON.parse(result);
 
    return Object.entries(audit.vulnerabilities || {}).map(
      ([name, data]: [string, any]) => ({
        name,
        severity: data.severity,
        title: data.title || "Unknown vulnerability",
        url: data.url || "",
        fixAvailable: !!data.fixAvailable,
      })
    );
  } catch (error: any) {
    // npm audit はexit code 1で脆弱性を報告する
    if (error.stdout) {
      const audit = JSON.parse(error.stdout);
      return Object.entries(audit.vulnerabilities || {}).map(
        ([name, data]: [string, any]) => ({
          name,
          severity: data.severity,
          title: data.title || "Unknown vulnerability",
          url: data.url || "",
          fixAvailable: !!data.fixAvailable,
        })
      );
    }
    throw error;
  }
}
 
// 実行と結果出力
const vulnerabilities = runDependencyAudit();
const critical = vulnerabilities.filter((v) => v.severity === "critical");
const high = vulnerabilities.filter((v) => v.severity === "high");
 
console.log(`\n🔍 依存関係セキュリティレポート`);
console.log(`${"=".repeat(50)}`);
console.log(`Critical: ${critical.length} 件`);
console.log(`High: ${high.length} 件`);
console.log(`Total: ${vulnerabilities.length} 件`);
 
// 期待する出力例:
// 🔍 依存関係セキュリティレポート
// ==================================================
// Critical: 0 件
// High: 2 件
// Total: 8 件

## 依存関係脆弱性レポート
 
| パッケージ | 重要度 | CVE | 到達可能性 | 修正バージョン | 推奨アクション |
|-----------|--------|-----|-----------|---------------|--------------|
| lodash    | High   | (CVE 番号) | 直接依存・呼び出しあり | 4.17.22 | `npm update lodash` |
| express   | Medium | (CVE 番号) | 推移的依存・経路なし | 4.19.3  | 次回の定期更新で吸収 |

// lib/security-patterns.ts
// セキュリティパターン検出ライブラリ
 
export const SQL_INJECTION_PATTERNS = [
  // 文字列連結によるクエリ構築（危険）
  /`SELECT.*\$\{.*\}`/g,
  /['"]SELECT.*['"] \+ /g,
  /query\(.*\+.*\)/g,
 
  // テンプレートリテラルの直接挿入（危険）
  /\.query\(`[^`]*\$\{[^}]+\}[^`]*`\)/g,
 
  // eval や Function コンストラクタ（極めて危険）
  /eval\s*\(/g,
  /new\s+Function\s*\(/g,
] as const;
 
export const XSS_PATTERNS = [
  // innerHTML への未サニタイズ入力
  /\.innerHTML\s*=\s*(?!['"`])/g,
  // dangerouslySetInnerHTML（React）
  /dangerouslySetInnerHTML\s*=\s*\{\s*\{\s*__html:\s*(?!DOMPurify)/g,
  // document.write
  /document\.write\s*\(/g,
] as const;
 
export const AUTH_PATTERNS = [
  // ハードコードされたシークレット
  /(?:password|secret|api[_-]?key|token)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
  // JWT検証のスキップ
  /verify\s*:\s*false/g,
] as const;
 
// Math.random() は「トークン生成に使うと危険」だが、
// アニメーションのゆらぎ・リトライのジッタ・ランダム表示でも同じだけ当たる。
// critical に混ぜると本当に見るべき行が埋もれるため、severity: "low" の別枠に分ける。
export const WEAK_RANDOM_PATTERNS = [
  /Math\.random\(\)/g,
] as const;
 
interface SecurityIssue {
  type: string;
  severity: "critical" | "high" | "medium" | "low";
  file: string;
  line: number;
  message: string;
  recommendation: string;
}
 
/** ルール表。ここに1行足すだけで検査項目が増える形にしておく */
const RULES = [
  {
    patterns: SQL_INJECTION_PATTERNS,
    type: "SQL_INJECTION",
    severity: "critical",
    message: "SQL文に未サニタイズの入力が直接挿入されています",
    recommendation: "パラメータ化クエリまたはORMを使用してください",
  },
  {
    patterns: XSS_PATTERNS,
    type: "XSS",
    severity: "high",
    message: "未サニタイズの入力がDOMに挿入される可能性があります",
    recommendation: "DOMPurifyまたはテキストノードを使用してください",
  },
  {
    // ここを配線し忘れるとシークレットのハードコードが素通りする
    patterns: AUTH_PATTERNS,
    type: "AUTH",
    severity: "critical",
    message: "認証情報のハードコード、または検証のスキップが疑われます",
    recommendation: "環境変数へ退避し、検証フラグを有効化してください",
  },
  {
    patterns: WEAK_RANDOM_PATTERNS,
    type: "WEAK_RANDOM",
    severity: "low",
    message: "Math.random() は暗号用途に使えません",
    recommendation:
      "トークン生成なら crypto.randomUUID() / randomBytes() へ。演出用途なら無視して構いません",
  },
] as const satisfies readonly {
  patterns: readonly RegExp[];
  type: string;
  severity: SecurityIssue["severity"];
  message: string;
  recommendation: string;
}[];
 
/** 改行位置を1度だけ index 化し、二分探索で行番号を引く */
function buildLineIndex(content: string): number[] {
  const starts = [0];
  for (let i = 0; i < content.length; i++) {
    if (content[i] === "\n") starts.push(i + 1);
  }
  return starts;
}
 
function lineFromIndex(starts: number[], pos: number): number {
  let lo = 0;
  let hi = starts.length - 1;
  while (lo < hi) {
    const mid = (lo + hi + 1) >> 1;
    if (starts[mid] <= pos) lo = mid;
    else hi = mid - 1;
  }
  return lo + 1;
}
 
/**
 * ファイルをスキャンしてセキュリティ問題を検出する
 */
export function scanFile(
  content: string,
  filePath: string
): SecurityIssue[] {
  const issues: SecurityIssue[] = [];
  const lineStarts = buildLineIndex(content);
 
  for (const rule of RULES) {
    for (const pattern of rule.patterns) {
      // matchAll は g フラグ必須。元の正規表現の lastIndex を汚さないよう複製する
      const re = new RegExp(
        pattern.source,
        pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g"
      );
      for (const match of content.matchAll(re)) {
        issues.push({
          type: rule.type,
          severity: rule.severity,
          file: filePath,
          line: lineFromIndex(lineStarts, match.index!),
          message: rule.message,
          recommendation: rule.recommendation,
        });
      }
    }
  }
 
  const order = { critical: 0, high: 1, medium: 2, low: 3 } as const;
  return issues.sort((a, b) => order[a.severity] - order[b.severity]);
}
 
// 実行例（4行のサンプルをスキャンした結果を severity 順に整形）:
// critical SQL_INJECTION  line 1
// critical AUTH           line 2
// high     XSS            line 3
// low      WEAK_RANDOM    line 4

// scripts/check-security-headers.ts
// Webアプリのセキュリティヘッダーを検証するスクリプト
 
interface SecurityHeaderCheck {
  header: string;
  expected: string | RegExp;
  severity: "critical" | "high" | "medium";
  description: string;
}
 
const REQUIRED_HEADERS: SecurityHeaderCheck[] = [
  {
    header: "Strict-Transport-Security",
    expected: /max-age=\d{8,}/,
    severity: "critical",
    description: "HSTS: HTTPSの強制（max-ageは1年以上推奨）",
  },
  {
    header: "Content-Security-Policy",
    expected: /default-src/,
    severity: "high",
    description: "CSP: XSSやデータインジェクション攻撃の防御",
  },
  {
    header: "X-Content-Type-Options",
    expected: "nosniff",
    severity: "medium",
    description: "MIMEタイプスニッフィングの防止",
  },
  {
    header: "X-Frame-Options",
    expected: /DENY|SAMEORIGIN/,
    severity: "medium",
    description: "クリックジャッキング攻撃の防止",
  },
  {
    header: "Referrer-Policy",
    expected: /strict-origin|no-referrer/,
    severity: "medium",
    description: "リファラ情報の漏洩防止",
  },
];
 
async function checkSecurityHeaders(url: string): Promise<number> {
  // HEAD ではなく GET を使う。
  // CSP を HTML 応答の組み立て経路でのみ付与している構成では、
  // HEAD がその経路を通らず「CSP 未設定」と誤判定されるため。
  const response = await fetch(url, { method: "GET" });
  await response.arrayBuffer(); // 本文は捨てるが、必ず読み切ってソケットを解放する
 
  console.log(`\n🛡️ セキュリティヘッダー監査: ${url}`);
  console.log("=".repeat(60));
 
  let issues = 0;
 
  for (const check of REQUIRED_HEADERS) {
    const value = response.headers.get(check.header);
    const passed = value
      ? typeof check.expected === "string"
        ? value === check.expected
        : check.expected.test(value)
      : false;
 
    const status = passed ? "✅" : "❌";
    console.log(`${status} ${check.header}`);
 
    if (!passed) {
      console.log(`   重要度: ${check.severity}`);
      console.log(`   説明: ${check.description}`);
      console.log(`   現在の値: ${value || "(未設定)"}`);
      issues++;
    }
  }
 
  console.log(`\n合計: ${issues} 件の問題が見つかりました`);
  return issues;
}
 
// CI から実行される入口。
// TARGET_URL を読み、問題があれば非ゼロ終了させる（ここが無いとジョブが常に成功する）
const targetUrl = process.env.TARGET_URL;
if (!targetUrl) {
  console.error("TARGET_URL が未設定です");
  process.exit(2);
}
const found = await checkSecurityHeaders(targetUrl);
process.exit(found > 0 ? 1 : 0);
 
// 期待する出力例:
// 🛡️ セキュリティヘッダー監査: https://your-app.example.com
// ============================================================
// ✅ Strict-Transport-Security
// ❌ Content-Security-Policy
//    重要度: high
//    説明: CSP: XSSやデータインジェクション攻撃の防御
//    現在の値: (未設定)
// ✅ X-Content-Type-Options
// ✅ X-Frame-Options
// ✅ Referrer-Policy
//
// 合計: 1 件の問題が見つかりました

// csp-head-vs-get.mjs — HEAD と GET で返るヘッダが変わることの再現
import http from "node:http";
 
const srv = http.createServer((req, res) => {
  const headers = {
    "Strict-Transport-Security": "max-age=31536000",
    "X-Content-Type-Options": "nosniff",
  };
  // CSP を「HTML を組み立てる経路」でのみ付与している構成の再現
  if (req.method === "GET") headers["Content-Security-Policy"] = "default-src 'self'";
  res.writeHead(200, headers);
  res.end(req.method === "GET" ? "<html></html>" : undefined);
});
 
await new Promise((r) => srv.listen(0, r));
const url = `http://127.0.0.1:${srv.address().port}/`;
 
for (const method of ["HEAD", "GET"]) {
  const r = await fetch(url, { method });
  if (method === "GET") await r.arrayBuffer();
  console.log(method.padEnd(4), "CSP =", r.headers.get("content-security-policy") ?? "(未設定と判定される)");
}
srv.close();
 
// 実行結果:
// HEAD CSP = (未設定と判定される)
// GET  CSP = default-src 'self'

// scripts/check-env-security.ts
// 環境変数と機密情報の管理状態を監査するスクリプト
 
import * as fs from "fs";
import * as path from "path";
import { execSync } from "child_process";
 
const SENSITIVE_PATTERNS = [
  /API[_-]?KEY/i,
  /SECRET/i,
  /PASSWORD/i,
  /TOKEN/i,
  /PRIVATE[_-]?KEY/i,
  /DATABASE[_-]?URL/i,
  /STRIPE[_-]?SECRET/i,
];
 
function auditEnvSecurity(projectRoot: string): number {
  const issues: string[] = [];
 
  // .gitignore の記述チェック。
  // includes(".env") だと ".env.example" にも当たり、無視されていないのに
  // 「安全」と誤判定する。行単位で完全一致を見る。
  const gitignorePath = path.join(projectRoot, ".gitignore");
  const ignoredLines = fs.existsSync(gitignorePath)
    ? fs
        .readFileSync(gitignorePath, "utf-8")
        .split("\n")
        .map((l) => l.trim())
    : [];
  const envIgnored = ignoredLines.some((l) =>
    [".env", ".env*", "*.env", ".env.local"].includes(l)
  );
  if (!envIgnored) {
    issues.push("⚠️ CRITICAL: .env が .gitignore で無視されていません");
  }
 
  // .gitignore の記述よりも強い証拠は「実際に追跡されているか」。
  // 一度コミットされたファイルは .gitignore を後から足しても追跡され続ける。
  const tracked = execSync("git ls-files", { cwd: projectRoot, encoding: "utf-8" })
    .split("\n")
    .filter((f) => /(^|\/)\.env($|\.)/.test(f) && !/\.example$/.test(f));
  for (const f of tracked) {
    issues.push(`🚨 CRITICAL: ${f} が Git に追跡されています（履歴からの削除が必要）`);
  }
 
  // ソースコード内のハードコードされたシークレットを検出
  const srcDir = path.join(projectRoot, "src");
  if (fs.existsSync(srcDir)) {
    scanDirectory(srcDir, issues);
  }
 
  console.log("\n🔐 環境変数セキュリティ監査レポート");
  console.log("=".repeat(50));
 
  if (issues.length === 0) {
    console.log("✅ 問題は検出されませんでした");
  } else {
    issues.forEach((issue) => console.log(issue));
  }
  return issues.length;
}
 
function scanDirectory(dir: string, issues: string[]): void {
  const files = fs.readdirSync(dir, { withFileTypes: true });
 
  for (const file of files) {
    const fullPath = path.join(dir, file.name);
 
    if (file.isDirectory() && file.name !== "node_modules") {
      scanDirectory(fullPath, issues);
    } else if (
      file.isFile() &&
      /\.(ts|js|tsx|jsx)$/.test(file.name)
    ) {
      const content = fs.readFileSync(fullPath, "utf-8");
      const lines = content.split("\n");
 
      lines.forEach((line, index) => {
        SENSITIVE_PATTERNS.forEach((pattern) => {
          if (
            pattern.test(line) &&
            /['"][^'"]{8,}['"]/.test(line)
          ) {
            issues.push(
              `⚠️ HIGH: ${fullPath}:${index + 1} — ` +
                `機密情報がハードコードされている可能性`
            );
          }
        });
      });
    }
  }
}
 
// CI から実行される入口。検出したら非ゼロで終了する
process.exit(auditEnvSecurity(process.cwd()) > 0 ? 1 : 0);
 
// 出力例:
// 🔐 環境変数セキュリティ監査レポート
// ==================================================
// ⚠️ HIGH: src/config/database.ts:15 — 機密情報がハードコードされている可能性
// ⚠️ CRITICAL: .env が .gitignore に含まれていません

# .github/workflows/security-audit.yml
name: Security Audit
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
  schedule:
    # 毎週月曜 9:00 JST に定期実行
    - cron: "0 0 * * 1"
 
jobs:
  dependency-scan:
    name: Dependency Vulnerability Scan
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Run npm audit
        run: |
          # --json は監査結果があると非ゼロで終わるため、レポート保存側で吸収する
          npm audit --json > audit-report.json || true
          # 判定はこちらで行う。`|| true` を付けると検出しても常に成功し、
          # ゲートとして機能しなくなる
          npm audit --audit-level=high
 
      - name: Upload audit report
        uses: actions/upload-artifact@v4
        with:
          name: audit-report
          path: audit-report.json
 
  code-security-review:
    name: Code Security Review
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Run security pattern scan
        # scanFile が critical を返したらここで落とす
        run: npx tsx scripts/security-audit.ts
 
      - name: Check for hardcoded secrets
        run: |
          # 機密情報のハードコードを検出
          if grep -rn \
            -e "API_KEY\s*=\s*['\"][^'\"]*['\"]" \
            -e "SECRET\s*=\s*['\"][^'\"]*['\"]" \
            --include="*.ts" --include="*.js" \
            --exclude-dir=node_modules \
            src/; then
            echo "::error::Hardcoded secrets detected!"
            exit 1
          fi
 
  security-headers:
    name: Security Headers Check
    runs-on: ubuntu-latest
    if: github.event_name == 'schedule'
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Check production security headers
        # スクリプト側で TARGET_URL を読み、未検出=0 / 検出=1 / 未設定=2 を返す
        run: npx tsx scripts/check-security-headers.ts
        env:
          TARGET_URL: ${{ secrets.PRODUCTION_URL }}

// 検出された箇所（並び替え順をクエリに埋め込んでいる）
const rows = await db.query(
  `SELECT * FROM wallpapers ORDER BY ${sortColumn} DESC LIMIT 50`
);

// エージェントの提案（動きません）
const rows = await db.query(
  "SELECT * FROM wallpapers ORDER BY $1 DESC LIMIT 50",
  [sortColumn]
);

const SORTABLE = {
  created: "created_at",
  downloads: "download_count",
  rating: "rating_avg",
} as const;
 
// 未知のキーは既定値に落とす。ここを通った値だけが SQL に入る
const column = SORTABLE[sortColumn as keyof typeof SORTABLE] ?? "created_at";
const rows = await db.query(
  `SELECT * FROM wallpapers ORDER BY ${column} DESC LIMIT 50`
);