#!/usr/bin/env python3 """AppSecBench v1.0.0 build: generate train/validation/test JSONL splits. Design: - Enumerate every (vuln x language x framework x difficulty) combination that is realistic per vuln_catalog.applicable_*. - Render each with generators.build_case using a deterministic seed so the dataset is fully reproducible (re-running yields identical records). - Inject CVSS 3.1 vector+score. - Assign ASB-000001 sequential ids. - Split with a fixed seed: test 12%, validation 12%, rest train. - Write JSONL + a manifest. """ from __future__ import annotations import json import os import random from collections import defaultdict from vuln_catalog import (CATALOG, applicable_languages, applicable_frameworks, DIFFICULTIES) from generators import build_case from ruby_scala_gen import generic_ruby_scala from cvss import cvss_for ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) DATASET_DIR = os.path.join(ROOT, "dataset") SEED = 42 VERSION = "1.1.0" # How many (language/framework) variations to draw per vuln at each difficulty. # v1.1.0 raises caps vs v1.0.0 and adds Ruby/Rails + Scala/Spring Boot + Angular/Vue, # growing coverage to ~900 records while keeping the dataset balanced. PER_VULN_PER_DIFFICULTY = { "Beginner": 4, "Intermediate": 4, "Advanced": 3, "Expert": 3, "Real-world enterprise": 3, } def iter_combos(): for vuln, *_ in CATALOG: langs = applicable_languages(vuln) # Give each vuln a stable per-language framework rotation. for lang in langs: fws = applicable_frameworks(vuln, lang) for fw in fws: for diff in DIFFICULTIES: yield vuln, lang, fw, diff def main(): # Group combos by (vuln, difficulty) to apply per-vuln sampling counts. groups = defaultdict(list) for vuln, lang, fw, diff in iter_combos(): groups[(vuln, diff)].append((vuln, lang, fw, diff)) rng = random.Random(SEED) selected = [] for (vuln, diff), combos in groups.items(): # shuffle deterministically then take a cap c = list(combos) rng.shuffle(c) cap = PER_VULN_PER_DIFFICULTY.get(diff, 2) selected.extend(c[:cap]) # Globally shuffle for id assignment determinism rng.shuffle(selected) records = [] gen_errors = [] for idx, (vuln, lang, fw, diff) in enumerate(selected, start=1): bid = f"ASB-{idx:06d}" try: case = build_case(vuln, lang, fw, diff, seed=hash((bid, vuln, lang, fw, diff)) & 0xFFFF) except Exception as e: gen_errors.append(f"{vuln}|{lang}|{fw}|{diff}: {type(e).__name__}: {e}") continue vector, score = cvss_for(vuln, diff) severity = _sev_label(vuln, diff, score) rec = { "benchmark_id": bid, "title": case["title"], "category": case["category"], "language": lang, "framework": case["framework"], "application_type": case["application_type"], "source_type": case["source_type"], "vulnerability_name": case["vulnerability_name"], "vulnerability_description": case["vulnerability_description"], "vulnerable_code": case["vulnerable_code"], "secure_code": case["secure_code"], "exploit_example": case["exploit_example"], "exploitability_explanation": case["exploitability_explanation"], "attack_prerequisites": case["attack_prerequisites"], "expected_llm_analysis": case["expected_llm_analysis"], "expected_detection": case["expected_detection"], "expected_fix": case["expected_fix"], "expected_secure_code": case["expected_secure_code"], "expected_severity": severity, "expected_confidence": case["expected_confidence"], "expected_cwe": case["expected_cwe"], "expected_owasp": case["expected_owasp"], "expected_owasp_api": case["expected_owasp_api"], "expected_owasp_llm": case["expected_owasp_llm"], "expected_cvss": vector, "expected_cvss_score": score, "expected_false_positive_probability": case["expected_false_positive_probability"], "expected_false_negative_probability": case["expected_false_negative_probability"], "evaluation_rubric": case["evaluation_rubric"], "scoring_criteria": case["scoring_criteria"], "tags": case["tags"], "references": case["references"], "metadata": { "difficulty": diff, "category": case["category"], "owasp": case["expected_owasp"], "owasp_api": case["expected_owasp_api"], "owasp_llm": case["expected_owasp_llm"], "cwe": case["expected_cwe"], "cvss_vector": vector, "cvss_score": score, "generated_by": "AppSecBench generator v1.1.0", "source": "original/synthetic", "license": "MIT", "schema_version": "1.1.0", }, } records.append(rec) # Split split_rng = random.Random(SEED + 1) items = list(records) split_rng.shuffle(items) n = len(items) n_test = max(1, round(n * 0.12)) n_val = max(1, round(n * 0.12)) test = items[:n_test] val = items[n_test:n_test + n_val] train = items[n_test + n_val:] os.makedirs(DATASET_DIR, exist_ok=True) for name, split in (("train", train), ("validation", val), ("test", test)): path = os.path.join(DATASET_DIR, f"{name}.jsonl") with open(path, "w", encoding="utf-8") as f: for r in split: f.write(json.dumps(r, ensure_ascii=False) + "\n") print(f"Wrote {len(split):4d} -> {name}.jsonl") if gen_errors: print(f"\n=== GENERATION ERRORS ({len(gen_errors)}) ===") for e in gen_errors: print(" ", e) manifest = { "name": "AppSecBench", "version": VERSION, "total_records": n, "splits": {"train": len(train), "validation": len(val), "test": len(test)}, "seed": SEED, "languages": sorted({r["language"] for r in records}), "frameworks": sorted({r["framework"] for r in records if r["framework"] != "None"}), "vulnerabilities": sorted({r["vulnerability_name"] for r in records}), "difficulties": DIFFICULTIES, } with open(os.path.join(ROOT, "manifest.json"), "w", encoding="utf-8") as f: json.dump(manifest, f, indent=2) print(f"Total {n} records. Manifest written.") return manifest def _sev_label(vuln, diff, score): # Use the CVSS base score to derive severity, but keep a floor aligned with # the weakness type (e.g. XSS is rarely Critical). if score >= 9.0: return "Critical" if score >= 7.0: return "High" if score >= 4.0: return "Medium" return "Low" if __name__ == "__main__": main()