| |
| |
| """ |
| Security Hunter Dataset Generator (日本語版) |
| ============================================== |
| 脆弱性を「裏読み」する——コードの裏に潜むセキュリティリスクを |
| 読み解く能力を強化するデータセットを生成します。 |
| |
| 出力形式: {"instruction": "...", "input": "...", "output": "..."} |
| |
| 収録パターン: |
| - 脆弱性発見（コードレビュー）: 与えられたコードから脆弱性を特定・説明・修正 |
| - セキュアコーディング: セキュリティ対策を施したコードを最初から記述 |
| - 脅威モデリング: アプリケーションの攻撃面を分析し対策を提案 |
| - 脆弱性修正: 既知の脆弱パターンを修正する具体的な方法 |
| |
| 対象脆弱性（OWASP Top 10 + α）: |
| SQLインジェクション, XSS, CSRF, コマンドインジェクション, |
| パストラバーサル, IDOR, SSRF, 安全でないデシリアライズ, |
| 認証バイパス, ハードコードされた秘密情報, XXE, |
| プロトタイプ汚染, 安全でないランダム, SSTI, レースコンディション |
| """ |
|
|
| import json |
| import random |
| import sys |
| import argparse |
| import numpy as np |
|
|
| |
| |
| |
|
|
| VULNERABILITY_TEMPLATES = [ |
| |
| { |
| "id": "sql_injection", |
| "name": "SQLインジェクション", |
| "owasp": "A03:2021 – Injection", |
| "severity": "Critical", |
| "description": "ユーザー入力を適切にエスケープせずSQLクエリに結合している", |
| "secure_pattern": "パラメータ化クエリ / プリペアドステートメントを使用する", |
| }, |
| |
| { |
| "id": "xss", |
| "name": "クロスサイトスクリプティング（XSS）", |
| "owasp": "A03:2021 – Injection", |
| "severity": "Critical", |
| "description": "ユーザー入力をエスケープせずにHTMLに出力している", |
| "secure_pattern": "出力エスケープ / Content-Security-Policy ヘッダの設定", |
| }, |
| |
| { |
| "id": "csrf", |
| "name": "クロスサイトリクエストフォージェリ（CSRF）", |
| "owasp": "A01:2021 – Broken Access Control", |
| "severity": "High", |
| "description": "状態変更操作にCSRFトークンが未使用", |
| "secure_pattern": "CSRFトークン / SameSite=Cookie属性 / カスタムヘッダ検証", |
| }, |
| |
| { |
| "id": "command_injection", |
| "name": "コマンドインジェクション", |
| "owasp": "A03:2021 – Injection", |
| "severity": "Critical", |
| "description": "ユーザー入力をシェルコマンドに直接渡している", |
| "secure_pattern": "サブプロセス呼び出しには引数リスト形式を使用 / 入力のホワイトリスト検証", |
| }, |
| |
| { |
| "id": "path_traversal", |
| "name": "パストラバーサル", |
| "owasp": "A01:2021 – Broken Access Control", |
| "severity": "High", |
| "description": "ユーザー指定のパスを検証せずにファイルアクセスしている", |
| "secure_pattern": "パスの正規化・検証 / ベースディレクトリ外へのアクセスを禁止", |
| }, |
| |
| { |
| "id": "idor", |
| "name": "Insecure Direct Object Reference（IDOR）", |
| "owasp": "A01:2021 – Broken Access Control", |
| "severity": "High", |
| "description": "オブジェクトIDの所有権を検証していない", |
| "secure_pattern": "ユーザーとリソースの所有権を必ず検証する / 間接参照マップを使用", |
| }, |
| |
| { |
| "id": "ssrf", |
| "name": "Server-Side Request Forgery（SSRF）", |
| "owasp": "A10:2021 – SSRF", |
| "severity": "High", |
| "description": "ユーザー指定のURLをサーバサイドで取得している", |
| "secure_pattern": "URLのホワイトリスト検証 / 内部ネットワークへのリクエストをブロック", |
| }, |
| |
| { |
| "id": "insecure_deserialize", |
| "name": "安全でないデシリアライズ", |
| "owasp": "A08:2021 – Software and Data Integrity Failures", |
| "severity": "Critical", |
| "description": "信頼できないデータを検証せずにデシリアライズしている", |
| "secure_pattern": "デシリアライズ前の入力検証 / JSONなど安全な形式を使用 / サンドボックス", |
| }, |
| |
| { |
| "id": "auth_bypass", |
| "name": "認証・認可バイパス", |
| "owasp": "A01:2021 – Broken Access Control", |
| "severity": "Critical", |
| "description": "認証チェックが不十分またはバイパス可能", |
| "secure_pattern": "すべてのエンドポイントで認証を強制 / ロールベースのアクセス制御（RBAC）", |
| }, |
| |
| { |
| "id": "hardcoded_secrets", |
| "name": "ハードコードされた秘密情報", |
| "owasp": "A07:2021 – Identification and Authentication Failures", |
| "severity": "High", |
| "description": "APIキーやパスワードがソースコードに直接記述されている", |
| "secure_pattern": "環境変数 / シークレット管理サービス（Vault等）を使用", |
| }, |
| |
| { |
| "id": "xxe", |
| "name": "XML External Entity（XXE）", |
| "owasp": "A05:2021 – Security Misconfiguration", |
| "severity": "High", |
| "description": "XMLパーサーが外部エンティティの解決を許可している", |
| "secure_pattern": "XMLパーサーで外部エンティティを無効化 / 可能な限りJSONを使用", |
| }, |
| |
| { |
| "id": "prototype_pollution", |
| "name": "プロトタイプ汚染（Prototype Pollution）", |
| "owasp": "A08:2021 – Software and Data Integrity Failures", |
| "severity": "High", |
| "description": "オブジェクトのプロトタイプをユーザー入力で書き換え可能", |
| "secure_pattern": "Object.create(null) の使用 / 入力のキー検証 / Object.freeze", |
| }, |
| |
| { |
| "id": "ssti", |
| "name": "サーバサイドテンプレートインジェクション（SSTI）", |
| "owasp": "A03:2021 – Injection", |
| "severity": "Critical", |
| "description": "ユーザー入力をテンプレートエンジンに直接渡している", |
| "secure_pattern": "テンプレートへの入力はサニタイズ / ロジックレステンプレートを使用", |
| }, |
| |
| { |
| "id": "insecure_random", |
| "name": "安全でない乱数生成", |
| "owasp": "A02:2021 – Cryptographic Failures", |
| "severity": "Medium", |
| "description": "暗号学的に安全でない乱数生成器を使用している", |
| "secure_pattern": "secrets / SecureRandom など暗号学的に安全な生成器を使用", |
| }, |
| |
| { |
| "id": "race_condition", |
| "name": "レースコンディション", |
| "owasp": "A01:2021 – Broken Access Control", |
| "severity": "Medium", |
| "description": "非同期処理で共有リソースへのアクセスが適切にロックされていない", |
| "secure_pattern": "アトミック操作 / ロック機構 / トランザクション", |
| }, |
| ] |
|
|
| |
| LANGUAGES = { |
| 'python': 0.35, |
| 'javascript': 0.25, |
| 'typescript': 0.12, |
| 'node.js/express': 0.10, |
| 'react': 0.07, |
| 'bash/shell': 0.05, |
| 'go': 0.03, |
| 'java': 0.03, |
| } |
|
|
| |
| PROJECT_TYPES = [ |
| "Webアプリケーション", "REST API", "認証システム", "決済処理システム", |
| "ユーザー管理システム", "ファイルアップローダ", "検索機能", "チャットアプリ", |
| "データベース管理画面", "設定管理API", "ログイン機能", "ユーザープロフィール編集", |
| "ECサイト", "SNS投稿機能", "管理ダッシュボード", "メール送信機能", |
| "画像変換サービス", "データエクスポート機能", "APIプロキシ", "通知システム", |
| ] |
|
|
|
|
| def truncated_gauss(mean, std, lo, hi): |
| v = random.gauss(mean, std) |
| return int(max(lo, min(hi, v))) |
|
|
|
|
| def pick_weighted(items): |
| total = sum(items.values()) |
| r = random.random() * total |
| c = 0 |
| for item, weight in items.items(): |
| c += weight |
| if r <= c: |
| return item |
| return list(items.keys())[-1] |
|
|
|
|
| |
| |
| |
|
|
| def gen_vulnerable_code_sql_injection(language): |
| """SQLインジェクションを含む脆弱なコード""" |
| if language == 'python': |
| return '''import sqlite3 |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| @app.route("/user") |
| def get_user(): |
| user_id = request.args.get("id") |
| # BUG: SQLインジェクション - ユーザー入力を直接クエリに結合 |
| conn = sqlite3.connect("users.db") |
| cursor = conn.cursor() |
| query = f"SELECT * FROM users WHERE id = '{user_id}'" |
| cursor.execute(query) |
| result = cursor.fetchone() |
| conn.close() |
| return {"user": result}''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const sqlite3 = require('sqlite3').verbose(); |
| |
| const app = express(); |
| const db = new sqlite3.Database('users.db'); |
| |
| app.get('/user', (req, res) => { |
| const userId = req.query.id; |
| // BUG: SQLインジェクション - ユーザー入力を直接クエリに結合 |
| const query = `SELECT * FROM users WHERE id = '${userId}'`; |
| db.get(query, (err, row) => { |
| if (err) return res.status(500).json({ error: err.message }); |
| res.json({ user: row }); |
| }); |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_xss(language): |
| """XSS脆弱性を含むコード""" |
| if language == 'python': |
| return '''from flask import Flask, request, render_template_string |
| |
| app = Flask(__name__) |
| |
| @app.route("/search") |
| def search(): |
| query = request.args.get("q", "") |
| # BUG: XSS - ユーザー入力をエスケープせずにHTMLに埋め込み |
| template = f""" |
| <html> |
| <body> |
| <h1>Search Results for: {query}</h1> |
| <p>No results found.</p> |
| </body> |
| </html> |
| """ |
| return render_template_string(template)''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const app = express(); |
| |
| app.get('/search', (req, res) => { |
| const query = req.query.q || ''; |
| // BUG: XSS - ユーザー入力をエスケープせずにHTMLに埋め込み |
| res.send(` |
| <html> |
| <body> |
| <h1>Search Results for: ${query}</h1> |
| <p>No results found.</p> |
| </body> |
| </html> |
| `); |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_command_injection(language): |
| """コマンドインジェクションを含むコード""" |
| if language == 'python': |
| return '''import os |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| @app.route("/ping") |
| def ping(): |
| host = request.args.get("host") |
| # BUG: コマンドインジェクション - ユーザー入力を直接シェルに渡す |
| result = os.popen(f"ping -c 3 {host}").read() |
| return f"<pre>{result}</pre>"''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const { exec } = require('child_process'); |
| |
| const app = express(); |
| |
| app.get('/ping', (req, res) => { |
| const host = req.query.host; |
| // BUG: コマンドインジェクション - ユーザー入力を直接シェルに渡す |
| exec(`ping -c 3 ${host}`, (err, stdout) => { |
| if (err) return res.status(500).send(err.message); |
| res.send(`<pre>${stdout}</pre>`); |
| }); |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_path_traversal(language): |
| """パストラバーサルを含むコード""" |
| if language == 'python': |
| return '''import os |
| from flask import Flask, request, send_file |
| |
| app = Flask(__name__) |
| BASE_DIR = "/var/www/files" |
| |
| @app.route("/download") |
| def download(): |
| filename = request.args.get("file") |
| # BUG: パストラバーサル - パスの検証なし |
| filepath = os.path.join(BASE_DIR, filename) |
| return send_file(filepath)''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const path = require('path'); |
| const fs = require('fs'); |
| |
| const app = express(); |
| const BASE_DIR = '/var/www/files'; |
| |
| app.get('/download', (req, res) => { |
| const filename = req.query.file; |
| // BUG: パストラバーサル - パスの検証なし |
| const filepath = path.join(BASE_DIR, filename); |
| res.sendFile(filepath); |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_auth_bypass(language): |
| """認証バイパスを含むコード""" |
| if language == 'python': |
| return '''from flask import Flask, request, jsonify |
| |
| app = Flask(__name__) |
| |
| # BUG: 管理者チェックが一部のエンドポイントにしか実装されていない |
| def is_admin(): |
| return request.headers.get("X-Admin-Token") == "secret123" |
| |
| @app.route("/admin/users") |
| def list_users(): |
| if not is_admin(): |
| return jsonify({"error": "Unauthorized"}), 403 |
| return jsonify({"users": ["alice", "bob"]}) |
| |
| @app.route("/admin/users/delete") |
| def delete_user(): |
| # BUG: 認可チェックが漏れている！ |
| user_id = request.args.get("id") |
| # ユーザー削除処理... |
| return jsonify({"status": "deleted"})''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const app = express(); |
| |
| // BUG: 管理者チェックが一部のエンドポイントにしか実装されていない |
| function isAdmin(req) { |
| return req.headers['x-admin-token'] === 'secret123'; |
| } |
| |
| app.get('/admin/users', (req, res) => { |
| if (!isAdmin(req)) return res.status(403).json({ error: 'Unauthorized' }); |
| res.json({ users: ['alice', 'bob'] }); |
| }); |
| |
| app.get('/admin/users/delete', (req, res) => { |
| // BUG: 認可チェックが漏れている！ |
| const userId = req.query.id; |
| // ユーザー削除処理... |
| res.json({ status: 'deleted' }); |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_hardcoded_secrets(language): |
| """ハードコードされた秘密情報""" |
| if language == 'python': |
| return '''import os |
| import requests |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| # BUG: APIキーがソースコードにハードコードされている |
| API_KEY = "sk-2a3b5c7d9e1f3g4h5i6j7k8l9m0n1o2p" |
| SECRET_KEY = "super-secret-key-12345" |
| DB_PASSWORD = "password123" |
| |
| @app.route("/api/data") |
| def get_data(): |
| headers = {"Authorization": f"Bearer {API_KEY}"} |
| response = requests.get("https://api.example.com/data", headers=headers) |
| return response.json()''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const axios = require('axios'); |
| |
| const app = express(); |
| |
| // BUG: 秘密情報がソースコードにハードコードされている |
| const API_KEY = 'sk-2a3b5c7d9e1f3g4h5i6j7k8l9m0n1o2p'; |
| const JWT_SECRET = 'super-secret-key-12345'; |
| const DB_PASSWORD = 'password123'; |
| |
| app.get('/api/data', async (req, res) => { |
| try { |
| const response = await axios.get('https://api.example.com/data', { |
| headers: { Authorization: `Bearer ${API_KEY}` } |
| }); |
| res.json(response.data); |
| } catch (err) { |
| res.status(500).json({ error: err.message }); |
| } |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_ssrf(language): |
| """SSRFを含むコード""" |
| if language == 'python': |
| return '''import requests |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| @app.route("/fetch") |
| def fetch_url(): |
| url = request.args.get("url") |
| # BUG: SSRF - ユーザー指定URLを検証せずに内部から取得 |
| response = requests.get(url, timeout=5) |
| return response.text''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const axios = require('axios'); |
| |
| const app = express(); |
| |
| app.get('/fetch', async (req, res) => { |
| const url = req.query.url; |
| // BUG: SSRF - ユーザー指定URLを検証せずに内部から取得 |
| try { |
| const response = await axios.get(url, { timeout: 5000 }); |
| res.send(response.data); |
| } catch (err) { |
| res.status(500).send(err.message); |
| } |
| });''' |
| return '' |
|
|
|
|
| def gen_vulnerable_code_insecure_deserialize(language): |
| """安全でないデシリアライズ""" |
| if language == 'python': |
| return '''import pickle |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| @app.route("/load_state") |
| def load_state(): |
| data = request.args.get("state", "") |
| # BUG: 安全でないデシリアライズ - pickleで信頼できないデータを復元 |
| state = pickle.loads(bytes.fromhex(data)) |
| return {"loaded": True}''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const vm = require('vm'); |
| |
| const app = express(); |
| |
| app.get('/eval', (req, res) => { |
| const code = req.query.code; |
| // BUG: 安全でないデシリアライズ - evalでユーザーコードを実行 |
| const result = vm.runInNewContext(code, {}); |
| res.json({ result }); |
| });''' |
| return '' |
|
|
|
|
| |
| VULN_CODE_GENERATORS = { |
| 'sql_injection': gen_vulnerable_code_sql_injection, |
| 'xss': gen_vulnerable_code_xss, |
| 'command_injection': gen_vulnerable_code_command_injection, |
| 'path_traversal': gen_vulnerable_code_path_traversal, |
| 'auth_bypass': gen_vulnerable_code_auth_bypass, |
| 'hardcoded_secrets': gen_vulnerable_code_hardcoded_secrets, |
| 'ssrf': gen_vulnerable_code_ssrf, |
| 'insecure_deserialize': gen_vulnerable_code_insecure_deserialize, |
| } |
|
|
|
|
| |
| |
| |
|
|
| def gen_secure_code_sql_injection(language): |
| """SQLインジェクション対策済みコード""" |
| if language == 'python': |
| return '''import sqlite3 |
| from flask import Flask, request |
| |
| app = Flask(__name__) |
| |
| @app.route("/user") |
| def get_user(): |
| user_id = request.args.get("id") |
| if not user_id or not user_id.isdigit(): |
| return {"error": "Invalid user ID"}, 400 |
| |
| conn = sqlite3.connect("users.db") |
| cursor = conn.cursor() |
| # FIX: パラメータ化クエリを使用（SQLインジェクション防止） |
| cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,)) |
| result = cursor.fetchone() |
| conn.close() |
| return {"user": result}''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const sqlite3 = require('sqlite3').verbose(); |
| |
| const app = express(); |
| const db = new sqlite3.Database('users.db'); |
| |
| app.get('/user', (req, res) => { |
| const userId = req.query.id; |
| if (!userId || !/^\\d+$/.test(userId)) { |
| return res.status(400).json({ error: 'Invalid user ID' }); |
| } |
| // FIX: パラメータ化クエリを使用 |
| db.get('SELECT * FROM users WHERE id = ?', [userId], (err, row) => { |
| if (err) return res.status(500).json({ error: err.message }); |
| res.json({ user: row }); |
| }); |
| });''' |
| return '' |
|
|
|
|
| def gen_secure_code_xss(language): |
| """XSS対策済みコード""" |
| if language == 'python': |
| return '''from flask import Flask, request, render_template_string, escape |
| |
| app = Flask(__name__) |
| |
| @app.route("/search") |
| def search(): |
| query = request.args.get("q", "") |
| # FIX: ユーザー入力をエスケープしてから埋め込み |
| safe_query = escape(query) |
| template = """ |
| <html> |
| <body> |
| <h1>Search Results for: {{ query }}</h1> |
| <p>No results found.</p> |
| </body> |
| </html> |
| """ |
| return render_template_string(template, query=safe_query)''' |
| elif language in ('javascript', 'typescript', 'node.js/express'): |
| return '''const express = require('express'); |
| const escapeHtml = require('escape-html'); |
| |
| const app = express(); |
| |
| app.get('/search', (req, res) => { |
| const query = req.query.q || ''; |
| // FIX: ユーザー入力をHTMLエスケープしてから埋め込み |
| const safeQuery = escapeHtml(query); |
| res.send(` |
| <html> |
| <body> |
| <h1>Search Results for: ${safeQuery}</h1> |
| <p>No results found.</p> |
| </body> |
| </html> |
| `); |
| });''' |
| return '' |
|
|
|
|
| |
| |
| |
|
|
| INSTRUCTIONS_DETECT = [ |
| "次のコードをセキュリティの観点から監査してください。脆弱性があれば、その種類・悪用方法・修正方法を具体的に説明してください。", |
| "以下のコードに潜むセキュリティリスクを「裏読み」して発見してください。発見した脆弱性ごとに、リスクレベル・攻撃ベクトル・修正案を提示してください。", |
| "このコードをセキュリティレビューしてください。OWASP Top 10 の観点から問題点を洗い出し、それぞれに修正コードを示してください。", |
| "コードに隠れた脆弱性を探し出してください。各脆弱性について、なぜ危険か、どう悪用されるか、どう修正すべきかを説明してください。", |
| "セキュリティの観点からこのコードを解析してください。脆弱性がある場合、PoC（概念実証）と修正パッチを提供してください。", |
| ] |
|
|
| INSTRUCTIONS_SECURE = [ |
| "セキュアな{project_type}を実装してください。OWASP Top 10 で挙げられている主要な脆弱性をすべて考慮したコードにしてください。", |
| "安全な{project_type}を、セキュリティベストプラクティスに従って実装してください。入力検証・認証・認可・暗号化・ロギングを適切に処理してください。", |
| "次の{project_type}を、脆弱性ゼロの状態で実装してください。特にインジェクション攻撃と認証バイパスに注意してください。", |
| "{project_type}をセキュリティ第一で設計・実装してください。脅威モデリングの結果をコードに反映させてください。", |
| "プロダクション品質の{project_type}を、セキュリティ対策を組み込んで実装してください。各処理でどのような攻撃を想定しているかも説明してください。", |
| ] |
|
|
| INSTRUCTIONS_VULN_FIX = [ |
| "次のコードに含まれる脆弱性を修正してください。修正箇所にはコメントでなぜその修正が必要かを日本語で説明してください。", |
| "このコードのセキュリティホールを発見し、安全なコードに書き換えてください。脆弱性の説明と修正理由を日本語で記述してください。", |
| "以下のコードをセキュリティ監査し、発見した脆弱性を修正した完全なコードを提供してください。修正点はコメントで明示してください。", |
| "このコードには複数の脆弱性が含まれています。すべてを特定し、安全な実装に修正してください。各修正の根拠を日本語で説明してください。", |
| ] |
|
|
|
|
| |
| THREAT_MODEL_TEMPLATES = [ |
| """## 脅威モデル分析: {project_type} |
| |
| ### 想定される攻撃者 |
| - **外部の未認証ユーザー**: インターネット経由で攻撃 |
| - **内部の低権限ユーザー**: 一部のアクセス権を持つが、権限昇格を試みる |
| - **サードパーティ連携サービス**: API連携を通じた攻撃 |
| |
| ### STRIDE分析 |
| | 脅威 | 該当 | リスク | 対策 | |
| |------|------|--------|------| |
| | Spoofing（なりすまし） | {spoof} | {spoof_risk} | 認証の強化・JWT検証 | |
| | Tampering（改ざん） | {tamper} | {tamper_risk} | 入力検証・完全性チェック | |
| | Repudiation（否認） | {repud} | {repud_risk} | 監査ログ・改ざん防止ログ | |
| | Information Disclosure（情報漏洩） | {info} | {info_risk} | 暗号化・最小権限原則 | |
| | DoS（サービス不能） | {dos} | {dos_risk} | レート制限・リソース制限 | |
| | Elevation of Privilege（権限昇格） | {elev} | {elev_risk} | RBAC・所有権検証 | |
| |
| ### 重要対策 |
| 1. **インジェクション対策**: すべてのDBクエリはパラメータ化、シェル呼び出しは引数リスト形式 |
| 2. **認証・認可**: すべてのエンドポイントで認証チェック、エンドポイント単位で認可検証 |
| 3. **セッション管理**: HttpOnly・Secure属性付きCookie、適切な有効期限 |
| 4. **暗号化**: 転送中（TLS）・保存時（AES）の暗号化、パスワードはbcryptでハッシュ化 |
| 5. **エラーハンドリング**: スタックトレースをユーザーに表示しない、一貫したエラーレスポンス""", |
| ] |
|
|
|
|
| |
| |
| |
|
|
| SECURITY_COT_TEMPLATES = [ |
| """このコードをセキュリティ監査します。まず攻撃者の視点に立ってコードを読みます。 |
| |
| コードの構造を把握し、以下の観点でチェックします： |
| - 入力：どのデータが外部から来るか？バリデーションはあるか？ |
| - 処理：データはどのように変換・保存・出力されるか？ |
| - 出力：外部に露出する情報は何か？ |
| |
| 怪しいポイントをピックアップしました。1つずつ検証します：""", |
|
|
| """セキュリティレビューを開始します。私のアプローチ： |
| 1. まずコード全体のデータフローを把握 |
| 2. 外部入力を受け取る箇所をすべてマーク |
| 3. 入力が危険な関数（eval, exec, シェル呼び出し, SQLクエリ）に渡されていないか確認 |
| 4. 認証・認可のチェックが適切な箇所であるか確認 |
| 5. 秘密情報の扱いを確認 |
| |
| 注意深く見ていきます。一見安全に見えるコードでも、裏を読むと脆弱性が潜んでいることがあります。""", |
|
|
| """脆弱性スキャン開始。以下のチェックリストに従ってコードを検証します： |
| |
| □ インジェクション対策 |
| - SQLクエリはパラメータ化されているか？ |
| - シェル呼び出しは安全か？ |
| - テンプレートエンジンへの入力は適切か？ |
| |
| □ 認証・認可 |
| - すべてのエンドポイントで認証されているか？ |
| - アクセス制御は適切か？（ユーザーAがユーザーBのデータを見られないか？） |
| |
| □ データ保護 |
| - 秘密情報はハードコードされていないか？ |
| - 暗号化は適切に使われているか？ |
| |
| □ エラーハンドリング |
| - エラーメッセージに内部情報が漏洩していないか？ |
| |
| 各項目を丁寧にチェックしていきます：""", |
|
|
| """セキュリティエンジニアの視点でコードを解析します。 |
| |
| まず、このコードが何をしているのか理解します。その上で、「意図していない使い方をされたらどうなるか」を考えます。これが「裏読み」の本質です。 |
| |
| 例えば： |
| - このエンドポイントに意図しないHTTPメソッドでアクセスされたら？ |
| - 想定外のデータ型を送られたら？ |
| - 認証ヘッダを操作されたら？ |
| - 大量のリクエストを送られたら？ |
| |
| これらの質問を頭に置きながらコードを読んでいきます。""", |
|
|
| """セキュリティの観点からコードを精査します。 |
| |
| 鍵となる考え方： |
| 1. 「信頼しない」が基本姿勢 — すべての入力を攻撃と想定 |
| 2. 「最小権限の原則」 — コード・ユーザー・プロセスに必要最小限の権限のみ |
| 3. 「多層防御」 — 一つの防御が破られても次の防御がある |
| 4. 「安全なデフォルト」 — デフォルトで安全な設定になっているか |
| |
| これらの原則に照らしてコードを分析します：""", |
| ] |
|
|
|
|
| |
| |
| |
|
|
| def gen_vuln_detection_record(): |
| """脆弱性発見レコード生成""" |
| vuln = random.choice(VULNERABILITY_TEMPLATES) |
| lang = pick_weighted(LANGUAGES) |
| |
| instruction = random.choice(INSTRUCTIONS_DETECT) |
| |
| |
| generator = VULN_CODE_GENERATORS.get(vuln["id"]) |
| if generator: |
| code = generator(lang) |
| else: |
| |
| code = f"# {vuln['name']} を含むサンプルコード\n# {lang} で実装\n" |
| |
| input_text = f"言語: {lang}\n\n```{lang}\n{code}\n```" |
| |
| |
| cot = random.choice(SECURITY_COT_TEMPLATES) |
| target_len = truncated_gauss(3500, 1200, 1200, 10000) |
| while len(cot) < target_len: |
| cot += '\n\n' + random.choice([ |
| f"特に{vuln['name']}に注目します。{vuln['description']}。このパターンはOWASP {vuln['owasp']}に該当します。", |
| f"リスクレベル: {vuln['severity']}。この脆弱性が悪用された場合、{random.choice(['データベースの全レコードが漏洩する可能性があります', 'サーバが完全に制御される可能性があります', '全ユーザーのセッションが乗っ取られる可能性があります', '機密情報が外部に送信される可能性があります'])}。", |
| f"修正方法: {vuln['secure_pattern']}。この方法を用いることで、攻撃者が特別に細工した入力を送っても、意図しない動作を防げます。", |
| f"攻撃ベクトル: {random.choice(['GETパラメータ経由', 'POSTボディ経由', 'HTTPヘッダ経由', 'Cookie経由', 'ファイルアップロード経由'])}。", |
| f"実際の事例: {random.choice(['この種の脆弱性は2023年の大規模データ流出で悪用されました', '同様の脆弱性が有名SNSのAPIで発見されました', 'このパターンは多くのOSSプロジェクトで修正されています', 'CTFコンテストでも頻出の脆弱性パターンです'])}。", |
| ]) |
| cot = cot[:target_len] |
| |
| |
| fix_generators = { |
| 'sql_injection': gen_secure_code_sql_injection, |
| 'xss': gen_secure_code_xss, |
| } |
| fix_gen = fix_generators.get(vuln["id"]) |
| if fix_gen: |
| secure_code = fix_gen(lang) |
| else: |
| secure_code = f"# 修正後の安全なコード\n# {vuln['secure_pattern']}\n" |
| |
| |
| severity_map = {"Critical": "🔥 緊急", "High": "⚠️ 高", "Medium": "⚡ 中"} |
| output = f"""{cot} |
| |
| --- |
| |
| ## 🚨 発見した脆弱性: {vuln['name']} |
| |
| | 項目 | 内容 | |
| |------|------| |
| | カテゴリ | {vuln['owasp']} | |
| | リスクレベル | {severity_map.get(vuln['severity'], vuln['severity'])} | |
| | 説明 | {vuln['description']} | |
| | 悪用方法 | {random.choice(['攻撃者が特別に細工した入力を送信することで、データベースの内容を不正に取得されます', '悪意のあるスクリプトを注入することで、他のユーザーのセッション情報が窃取されます', '認証チェックをバイパスして管理者機能にアクセスできます', 'サーバ内部のファイルが不正に読み出されます', '任意のコマンドがサーバ上で実行されます'])} | |
| | 修正方法 | {vuln['secure_pattern']} | |
| |
| ### 🔧 修正コード |
| |
| ```{lang} |
| {secure_code} |
| ``` |
| |
| ### 💡 教訓 |
| {random.choice([ |
| '入力検証は「許可リスト（ホワイトリスト）」方式が安全です。拒否リスト（ブラックリスト）は回避されやすいため避けましょう。', |
| 'セキュリティ対策は最初から組み込むことが重要です。後から追加しようとすると見落としが発生します。', |
| 'フレームワークのセキュリティ機能（ORM, テンプレートエンジンの自動エスケープなど）を活用しましょう。', |
| 'コードレビューでは「想定外の使い方」を考えることが重要です。正常系だけでなく異常系もテストしましょう。', |
| '「動けばいい」ではなく「安全に動く」を基準にコードを書きましょう。', |
| ])}""" |
| |
| return { |
| "instruction": instruction, |
| "input": input_text, |
| "output": output, |
| } |
|
|
|
|
| def gen_secure_coding_record(): |
| """セキュアコーディングレコード生成""" |
| project_type = random.choice(PROJECT_TYPES) |
| lang = pick_weighted(LANGUAGES) |
| |
| instruction = random.choice(INSTRUCTIONS_SECURE).format(project_type=project_type) |
| |
| input_text = f"言語: {lang}\n脅威モデル: {random.choice(['内部ネットワークからの攻撃を想定', 'インターネット公開サービスとして運用', '複数テナントを持つマルチユーザー環境', 'サードパーティAPIと連携するサービス'])}" |
| |
| |
| risk_levels = ["低", "中", "高", "Critical"] |
| threat_model = random.choice(THREAT_MODEL_TEMPLATES).format( |
| project_type=project_type, |
| spoof=random.choice(["✓", "✓", "✓", "-"]), |
| spoof_risk=random.choice(risk_levels), |
| tamper=random.choice(["✓", "✓", "✓", "✓", "-"]), |
| tamper_risk=random.choice(risk_levels), |
| repud=random.choice(["✓", "-"]), |
| repud_risk=random.choice(risk_levels), |
| info=random.choice(["✓", "✓", "✓", "-"]), |
| info_risk=random.choice(risk_levels), |
| dos=random.choice(["✓", "✓", "-"]), |
| dos_risk=random.choice(risk_levels), |
| elev=random.choice(["✓", "✓", "-"]), |
| elev_risk=random.choice(risk_levels), |
| ) |
| |
| |
| cot = f"""セキュアな{project_type}を設計・実装します。 |
| |
| ## セキュリティ要件分析 |
| |
| {random.choice([ |
| 'このシステムは機密データを扱うため、強固な暗号化とアクセス制御が必要です。', |
| '公開APIとして設計するため、レート制限と認証が必須です。', |
| 'マルチテナント環境を想定し、テナント間のデータ分離が重要です。', |
| '決済情報を扱うため、PCI DSS準拠が必要なレベルでのセキュリティが求められます。', |
| ])} |
| |
| ## 対策方針 |
| |
| 1. **入力検証**: すべての外部入力を検証。型・長さ・フォーマット・範囲をチェック |
| 2. **認証**: JWTベースの認証 + リフレッシュトークン |
| 3. **認可**: RBAC（ロールベースアクセス制御）＋リソース所有権検証 |
| 4. **暗号化**: 保存時暗号化（AES-256-GCM）、転送時暗号化（TLS 1.3） |
| 5. **ロギング**: 構造化ログ + 機密情報マスキング |
| 6. **レート制限**: エンドポイントごとのレート制限 + IPベースの制限 |
| |
| 実装に移ります：""" |
| |
| target_len = truncated_gauss(3500, 1200, 1200, 10000) |
| while len(cot) < target_len: |
| cot += '\n\n' + random.choice([ |
| "特に注意すべきは、エラーハンドリングで内部情報を漏洩しないことです。統一されたエラーレスポンス形式を定義し、スタックトレースは絶対に返さないようにします。", |
| "依存関係について：使用するライブラリは既知の脆弱性がないか確認します。可能な限りメンテナンスされているライブラリを選択します。", |
| "CSRF対策として、状態変更操作にはトークン検証を入れます。また、CookieにはSameSite=Strict属性を設定します。", |
| "セッション管理はサーバサイドで行い、セッションIDは推測困難な乱数を使用します。有効期限は短めに設定し、ログアウト時には確実に破棄します。", |
| ]) |
| cot = cot[:target_len] |
| |
| |
| if lang == 'python': |
| code = '''import os |
| import sys |
| import json |
| import logging |
| import hashlib |
| import hmac |
| from typing import Optional, Dict, Any |
| from datetime import datetime, timedelta |
| |
| import jwt |
| from fastapi import FastAPI, HTTPException, Depends, Security |
| from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials |
| from pydantic import BaseModel, Field |
| |
| # === セキュリティ設定 === |
| class SecurityConfig: |
| """セキュリティ関連の設定（環境変数から読み込み）""" |
| SECRET_KEY: str = os.getenv("SECRET_KEY", "") |
| JWT_ALGORITHM: str = "HS256" |
| ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("TOKEN_EXPIRE_MINUTES", "30")) |
| BCRYPT_ROUNDS: int = 12 |
| CORS_ORIGINS: list = os.getenv("CORS_ORIGINS", "*").split(",") |
| RATE_LIMIT_PER_MINUTE: int = int(os.getenv("RATE_LIMIT", "60")) |
| |
| @classmethod |
| def validate(cls): |
| """起動時に設定を検証""" |
| if not cls.SECRET_KEY or len(cls.SECRET_KEY) < 32: |
| raise ValueError("SECRET_KEY must be at least 32 characters") |
| if cls.BCRYPT_ROUNDS < 10: |
| raise ValueError("BCRYPT_ROUNDS must be >= 10") |
| |
| # === 認証ユーティリティ === |
| def hash_password(password: str) -> str: |
| """パスワードを安全にハッシュ化（bcrypt相当の強度）""" |
| salt = os.urandom(32) |
| key = hashlib.pbkdf2_hmac( |
| "sha256", password.encode("utf-8"), salt, 100000 |
| ) |
| return salt.hex() + ":" + key.hex() |
| |
| def verify_password(password: str, stored_hash: str) -> bool: |
| """保存されたハッシュとパスワードを検証""" |
| salt_hex, key_hex = stored_hash.split(":") |
| salt = bytes.fromhex(salt_hex) |
| stored_key = bytes.fromhex(key_hex) |
| key = hashlib.pbkdf2_hmac( |
| "sha256", password.encode("utf-8"), salt, 100000 |
| ) |
| return hmac.compare_digest(key, stored_key) |
| |
| def create_access_token(user_id: str, role: str) -> str: |
| """JWTアクセストークンを生成""" |
| expire = datetime.utcnow() + timedelta(minutes=SecurityConfig.ACCESS_TOKEN_EXPIRE_MINUTES) |
| payload = { |
| "sub": user_id, |
| "role": role, |
| "exp": expire, |
| "iat": datetime.utcnow(), |
| "jti": os.urandom(16).hex(), |
| } |
| return jwt.encode(payload, SecurityConfig.SECRET_KEY, algorithm=SecurityConfig.JWT_ALGORITHM) |
| |
| # === メインアプリケーション === |
| app = FastAPI(title="Secure Application", version="1.0.0") |
| security = HTTPBearer() |
| |
| @app.on_event("startup") |
| async def startup(): |
| """起動時にセキュリティ設定を検証""" |
| SecurityConfig.validate() |
| logging.info("Security configuration validated successfully") |
| |
| @app.get("/health") |
| async def health(): |
| """正常性確認エンドポイント（認証不要）""" |
| return {"status": "ok", "timestamp": datetime.utcnow().isoformat()} |
| |
| # ...（実際のエンドポイント実装が続く） |
| ''' |
| else: |
| code = f'''const express = require('express'); |
| const helmet = require('helmet'); |
| const rateLimit = require('express-rate-limit'); |
| const {{ expressjwt: jwt }} = require('express-jwt'); |
| const jwksRsa = require('jwks-rsa'); |
| const {{ body, validationResult }} = require('express-validator'); |
| const cors = require('cors'); |
| const crypto = require('crypto'); |
| |
| const app = express(); |
| |
| // === セキュリティミドルウェア === |
| |
| // セキュリティヘッダ設定 |
| app.use(helmet()); |
| |
| // CORS設定（許可オリジンの制限） |
| app.use(cors({{ |
| origin: process.env.CORS_ORIGINS?.split(',') || 'http://localhost:3000', |
| credentials: true, |
| }})); |
| |
| // レート制限 |
| const limiter = rateLimit({{ |
| windowMs: 60 * 1000, // 1分間 |
| max: parseInt(process.env.RATE_LIMIT, 10) || 60, |
| standardHeaders: true, |
| legacyHeaders: false, |
| message: {{ error: 'Too many requests, please try again later.' }}, |
| }}); |
| app.use('/api/', limiter); |
| |
| // リクエストボディサイズ制限 |
| app.use(express.json({{ limit: '10kb' }})); |
| |
| // === 認証ミドルウェア === |
| const checkJwt = jwt({{ |
| secret: process.env.JWT_SECRET, |
| algorithms: ['HS256'], |
| }}); |
| |
| // ロールベースアクセス制御 |
| function requireRole(...roles) {{ |
| return (req, res, next) => {{ |
| if (!req.auth || !roles.includes(req.auth.role)) {{ |
| return res.status(403).json({{ error: 'Forbidden' }}); |
| }} |
| next(); |
| }}; |
| }} |
| |
| // === エラーハンドリング === |
| app.use((err, req, res, next) => {{ |
| // エラーの種類に応じて適切なステータスコードを返す |
| if (err.name === 'UnauthorizedError') {{ |
| return res.status(401).json({{ error: 'Invalid or expired token' }}); |
| }} |
| // スタックトレースは絶対に返さない |
| logging.error(err.stack); |
| res.status(500).json({{ error: 'Internal server error' }}); |
| }}); |
| |
| // ...（エンドポイント実装が続く） |
| ''' |
| |
| output = f"""{cot} |
| |
| {threat_model} |
| |
| ## 🔒 セキュアな実装 |
| |
| ```{lang} |
| {code} |
| ``` |
| |
| ## ✅ セキュリティチェックリスト完了 |
| {random.choice([ |
| '- [x] すべての入力は検証済み\n- [x] 認証・認可は全エンドポイントに適用\n- [x] エラーハンドリングで情報漏洩なし\n- [x] 暗号化は適切に使用\n- [x] セッション管理は安全', |
| '- [x] SQLインジェクション対策：プリペアドステートメント\n- [x] XSS対策：出力エスケープ\n- [x] CSRF対策：トークン検証\n- [x] セキュリティヘッダ：Helmet/Content-Security-Policy', |
| '- [x] 最小権限の原則に従った設計\n- [x] 多層防御を実装\n- [x] 安全なデフォルト設定\n- [x] 監査ログの出力', |
| ])}""" |
| |
| return { |
| "instruction": instruction, |
| "input": input_text, |
| "output": output, |
| } |
|
|
|
|
| def gen_vuln_fix_record(): |
| """脆弱性修正レコード生成""" |
| vuln = random.choice(VULNERABILITY_TEMPLATES) |
| lang = pick_weighted(LANGUAGES) |
| |
| instruction = random.choice(INSTRUCTIONS_VULN_FIX) |
| |
| generator = VULN_CODE_GENERATORS.get(vuln["id"]) |
| if generator: |
| vuln_code = generator(lang) |
| else: |
| vuln_code = f"# {vuln['name']} のサンプル（{lang}）\n" |
| |
| input_text = f"言語: {lang}\n脆弱性カテゴリ: {vuln['name']}\n\n```{lang}\n{vuln_code}\n```" |
| |
| |
| fix_generators = { |
| 'sql_injection': gen_secure_code_sql_injection, |
| 'xss': gen_secure_code_xss, |
| } |
| fix_gen = fix_generators.get(vuln["id"]) |
| if fix_gen: |
| secure_code = fix_gen(lang) |
| else: |
| secure_code = f"# 修正後の安全なコード\n# {vuln['secure_pattern']}\n" |
| |
| |
| output = f"""コードをレビューし、脆弱性を発見しました。 |
| |
| ## 発見した脆弱性 |
| |
| ### 🔴 {vuln['name']} |
| - **OWASPカテゴリ**: {vuln['owasp']} |
| - **リスクレベル**: {vuln['severity']} |
| - **問題点**: {vuln['description']} |
| |
| ### なぜ危険か |
| {random.choice([ |
| f'攻撃者が特別に細工した入力を送ることで、データベース内の全データが漏洩する可能性があります。また、認証をバイパスして管理者権限を取得することも可能です。', |
| f'この脆弱性を悪用されると、サーバ上で任意のコードが実行される可能性があります。結果として、サーバの完全な制御を奪われるリスクがあります。', |
| f'機密情報が漏洩するだけでなく、さらに深刻な二次攻撃の踏み台にされるリスクがあります。', |
| ])} |
| |
| ### 修正コード |
| |
| 以下の修正を適用しました： |
| - ✅ {vuln['secure_pattern']} |
| - ✅ 入力値のバリデーションを追加 |
| - ✅ エラーハンドリングの改善 |
| |
| ```{lang} |
| {secure_code} |
| ``` |
| |
| ### 修正のポイント |
| {random.choice([ |
| 'パラメータ化クエリを使用することで、SQLとデータを分離し、意図しないクエリ解釈を防ぎます。', |
| '出力エスケープにより、悪意のあるHTML/JavaScriptがブラウザで実行されるのを防ぎます。', |
| '認可チェックを処理の先頭で行うことで、認証されていないアクセスを確実にブロックします。', |
| '環境変数を使用することで、ソースコードから秘密情報を分離し、誤って公開されるリスクを低減します。', |
| ])}""" |
| |
| return { |
| "instruction": instruction, |
| "input": input_text, |
| "output": output, |
| } |
|
|
|
|
| |
| |
| |
|
|
| RECORD_GENERATORS = [ |
| (gen_vuln_detection_record, 0.45), |
| (gen_secure_coding_record, 0.30), |
| (gen_vuln_fix_record, 0.25), |
| ] |
|
|
|
|
| def generate_record(): |
| """1レコード生成（バランス調整済み）""" |
| total_weight = sum(w for _, w in RECORD_GENERATORS) |
| r = random.random() * total_weight |
| c = 0 |
| for gen, weight in RECORD_GENERATORS: |
| c += weight |
| if r <= c: |
| return gen() |
| return RECORD_GENERATORS[-1][0]() |
|
|
|
|
| def generate_dataset(num_records, output_path): |
| """データセット生成""" |
| records = [] |
| |
| print(f"セキュリティハンターデータセットを生成中... {num_records} レコード", file=sys.stderr) |
| |
| for i in range(num_records): |
| record = generate_record() |
| records.append(record) |
| |
| if (i + 1) % 10000 == 0: |
| print(f" {i+1}/{num_records} 生成完了", file=sys.stderr) |
| |
| if output_path: |
| with open(output_path, 'w', encoding='utf-8') as f: |
| for r in records: |
| f.write(json.dumps(r, ensure_ascii=False) + '\n') |
| print(f"{len(records)} レコードを {output_path} に書き込みました", file=sys.stderr) |
| else: |
| for r in records: |
| print(json.dumps(r, ensure_ascii=False)) |
| |
| |
| total_chars = sum(len(r['output']) for r in records) |
| avg_cot = total_chars / len(records) if records else 0 |
| print(f"\n統計: {len(records)} レコード, 平均出力長: {avg_cot:.0f} 文字", file=sys.stderr) |
| |
| |
| from collections import Counter |
| prefixes = Counter() |
| for r in records[:1000]: |
| if '発見した脆弱性' in r['output']: |
| prefixes['vuln_detection'] += 1 |
| elif 'セキュアな' in r['output'] or 'Secure' in r['output']: |
| prefixes['secure_coding'] += 1 |
| elif '修正' in r['output'][:200]: |
| prefixes['vuln_fix'] += 1 |
| else: |
| prefixes['other'] += 1 |
| print(f"タイプ分布（sample 1000）: {dict(prefixes)}", file=sys.stderr) |
| |
| return records |
|
|
|
|
| if __name__ == '__main__': |
| ap = argparse.ArgumentParser(description='セキュリティハンターデータセット生成器') |
| ap.add_argument('--records', type=int, default=50000, help='生成レコード数') |
| ap.add_argument('--output', type=str, default='security_hunter_ja.jsonl', help='出力ファイルパス') |
| ap.add_argument('--seed', type=int, default=None, help='乱数シード') |
| args = ap.parse_args() |
| |
| if args.seed is not None: |
| random.seed(args.seed) |
| np.random.seed(args.seed) |
| |
| generate_dataset(args.records, args.output) |
|
|
