| |
| """AppSecBench v1.1.0 validation + QA report. |
| |
| Checks (full list documented in the dataset card / docs/methodology.md): |
| - JSON validity & duplicate ids |
| - All required fields present & non-empty |
| - Enums: language, framework, severity, difficulty, confidence, source_type |
| - CWE / OWASP / OWASP-API / OWASP-LLM format |
| - CVSS 3.1 vector format + recomputed score consistency vs expected_cvss_score |
| - Reference URLs well-formed |
| - Tag list non-empty; vulnerable != secure; label consistency vs catalog |
| - Metadata completeness & internal consistency |
| - Syntax checks per language via compile_check |
| Emits validation_report.md + validation_summary.json under validation/. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| from collections import Counter |
|
|
| import compile_check |
| from vuln_catalog import CATALOG_BY_NAME |
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| DATASET_DIR = os.path.join(ROOT, "dataset") |
| VALID_DIR = os.path.join(ROOT, "validation") |
|
|
| REQUIRED = [ |
| "benchmark_id", "title", "category", "language", "framework", "application_type", |
| "source_type", "vulnerability_name", "vulnerability_description", "vulnerable_code", |
| "secure_code", "exploit_example", "exploitability_explanation", "attack_prerequisites", |
| "expected_llm_analysis", "expected_detection", "expected_fix", "expected_secure_code", |
| "expected_severity", "expected_confidence", "expected_cwe", "expected_owasp", |
| "expected_cvss", "expected_cvss_score", "expected_false_positive_probability", |
| "expected_false_negative_probability", "evaluation_rubric", "scoring_criteria", |
| "tags", "references", "metadata", |
| ] |
| LANGUAGES = {"Python", "Java", "JavaScript", "TypeScript", "Go", "Rust", "PHP", |
| "C#", "Kotlin", "Swift", "C", "C++", "Ruby", "Scala", "YAML", "Dockerfile", "Bash"} |
| FRAMEWORKS = {"Flask", "FastAPI", "Django", "Spring Boot", "Express", "NestJS", |
| "Next.js", "Laravel", "ASP.NET Core", "Gin", "Echo", "Fiber", |
| "Android", "iOS", "Rails", "Angular", "Vue", "None", ""} |
| SEVERITIES = {"Low", "Medium", "High", "Critical"} |
| DIFFICULTIES = {"Beginner", "Intermediate", "Advanced", "Expert", "Real-world enterprise"} |
| CONFIDENCES = {"Low", "Medium", "High"} |
| SOURCE_TYPES = {"synthetic", "recreated", "educational"} |
| CVSS_RE = re.compile(r"^CVSS:3\.1/AV:[NALP]/AC:[LH]/PR:[NLH]/UI:[NR]/S:[CU]/C:[NLH]/I:[NLH]/A:[NLH]$") |
| CWE_RE = re.compile(r"^CWE-\d+$") |
| OWASP_RE = re.compile(r"^A\d{2}:2021$") |
| OWASP_API_RE = re.compile(r"^API\d{1,2}:2023$") |
| OWASP_LLM_RE = re.compile(r"^LLM\d{2}:2025$") |
| URL_RE = re.compile(r"^https?://[^\s]+$") |
| SPLITS = ("train", "validation", "test") |
|
|
|
|
| def recompute_cvss_score(vector: str) -> float: |
| from cvss import compute_base_vector |
| parts = dict(p.split(":") for p in vector.split("/")[1:]) |
| _, score = compute_base_vector(av=parts["AV"], ac=parts["AC"], pr=parts["PR"], |
| ui=parts["UI"], s=parts["S"], c=parts["C"], |
| i=parts["I"], a=parts["A"]) |
| return score |
|
|
|
|
| def main(): |
| errors, warnings = [], [] |
| all_ids, all_recs = Counter(), [] |
|
|
| for name in SPLITS: |
| path = os.path.join(DATASET_DIR, f"{name}.jsonl") |
| with open(path, encoding="utf-8") as f: |
| for i, line in enumerate(f, 1): |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| obj = json.loads(line) |
| except json.JSONDecodeError as e: |
| errors.append(f"{name}:{i}: bad JSON {e}") |
| continue |
| all_recs.append(obj) |
| rid = obj.get("benchmark_id", f"<no-id:{name}:{i}>") |
| all_ids[rid] += 1 |
|
|
| for fld in REQUIRED: |
| v = obj.get(fld) |
| if isinstance(v, str) and not v.strip(): |
| errors.append(f"{rid}: empty {fld}") |
| elif v is None: |
| errors.append(f"{rid}: missing {fld}") |
|
|
| if obj.get("language") not in LANGUAGES: |
| errors.append(f"{rid}: bad language {obj.get('language')}") |
| if obj.get("framework") not in FRAMEWORKS: |
| errors.append(f"{rid}: bad framework {obj.get('framework')}") |
| if obj.get("expected_severity") not in SEVERITIES: |
| errors.append(f"{rid}: bad severity {obj.get('expected_severity')}") |
| diff = obj.get("metadata", {}).get("difficulty") |
| if diff not in DIFFICULTIES: |
| errors.append(f"{rid}: bad difficulty {diff}") |
| if obj.get("expected_confidence") not in CONFIDENCES: |
| errors.append(f"{rid}: bad confidence {obj.get('expected_confidence')}") |
| if obj.get("source_type") not in SOURCE_TYPES: |
| errors.append(f"{rid}: bad source_type {obj.get('source_type')}") |
| if not CWE_RE.match(obj.get("expected_cwe", "")): |
| errors.append(f"{rid}: bad cwe {obj.get('expected_cwe')}") |
| if not OWASP_RE.match(obj.get("expected_owasp", "")): |
| errors.append(f"{rid}: bad owasp {obj.get('expected_owasp')}") |
| owl = obj.get("expected_owasp_llm", "") |
| if owl and not OWASP_LLM_RE.match(owl): |
| warnings.append(f"{rid}: odd owasp_llm {owl}") |
| oapi = obj.get("expected_owasp_api", "") |
| if oapi and not OWASP_API_RE.match(oapi): |
| warnings.append(f"{rid}: odd owasp_api {oapi}") |
|
|
| cvss = obj.get("expected_cvss", "") |
| if not CVSS_RE.match(cvss): |
| errors.append(f"{rid}: bad cvss vector {cvss}") |
| else: |
| try: |
| recomputed = recompute_cvss_score(cvss) |
| stated = float(obj.get("expected_cvss_score", -1)) |
| if abs(recomputed - stated) > 0.05: |
| errors.append(f"{rid}: cvss score mismatch recomputed={recomputed} stated={stated}") |
| except Exception as e: |
| errors.append(f"{rid}: cvss recompute failed {e}") |
|
|
| refs = obj.get("references", []) |
| if not isinstance(refs, list) or not refs: |
| errors.append(f"{rid}: references must be non-empty list") |
| else: |
| for u in refs: |
| if not URL_RE.match(str(u)): |
| warnings.append(f"{rid}: odd reference {u}") |
|
|
| if not isinstance(obj.get("tags"), list) or not obj["tags"]: |
| errors.append(f"{rid}: tags must be non-empty list") |
|
|
| if obj.get("vulnerable_code") == obj.get("secure_code"): |
| errors.append(f"{rid}: vulnerable_code equals secure_code") |
|
|
| cat = CATALOG_BY_NAME.get(obj.get("vulnerability_name", "")) |
| if cat: |
| if obj.get("expected_cwe") != cat["cwe"]: |
| errors.append(f"{rid}: cwe mismatch catalog") |
| if obj.get("expected_owasp") != cat["owasp"]: |
| errors.append(f"{rid}: owasp mismatch catalog") |
| else: |
| errors.append(f"{rid}: unknown vulnerability_name {obj.get('vulnerability_name')}") |
|
|
| md = obj.get("metadata", {}) |
| if md.get("cwe") != obj.get("expected_cwe"): |
| errors.append(f"{rid}: metadata.cwe mismatch") |
| if md.get("cvss_vector") != cvss: |
| errors.append(f"{rid}: metadata.cvss_vector mismatch") |
| if not isinstance(md.get("cvss_score"), (int, float)): |
| errors.append(f"{rid}: metadata.cvss_score missing") |
|
|
| for fld in ("vulnerable_code", "secure_code"): |
| code = obj.get(fld, "") |
| ok, detail = compile_check.check(obj.get("language"), code) |
| if ok is False: |
| errors.append(f"{rid}: {fld} [{obj.get('language')}] {detail}") |
| elif ok is None: |
| warnings.append(f"{rid}: {fld} [{obj.get('language')}] unchecked ({detail})") |
|
|
| for rid, c in all_ids.items(): |
| if c > 1: |
| errors.append(f"duplicate id {rid} x{c}") |
|
|
| stats = { |
| "total_records": len(all_recs), |
| "by_language": dict(Counter(r["language"] for r in all_recs)), |
| "by_framework": dict(Counter(r["framework"] for r in all_recs if r["framework"] != "None")), |
| "by_severity": dict(Counter(r["expected_severity"] for r in all_recs)), |
| "by_cwe": dict(Counter(r["expected_cwe"] for r in all_recs)), |
| "by_owasp": dict(Counter(r["expected_owasp"] for r in all_recs)), |
| "by_category": dict(Counter(r["category"] for r in all_recs)), |
| "by_difficulty": dict(Counter(r["metadata"]["difficulty"] for r in all_recs)), |
| "by_vulnerability": dict(Counter(r["vulnerability_name"] for r in all_recs)), |
| "unique_cwe": sorted({r["expected_cwe"] for r in all_recs}), |
| "unique_owasp": sorted({r["expected_owasp"] for r in all_recs}), |
| "unique_vulnerabilities": sorted({r["vulnerability_name"] for r in all_recs}), |
| } |
|
|
| os.makedirs(VALID_DIR, exist_ok=True) |
| with open(os.path.join(VALID_DIR, "validation_summary.json"), "w", encoding="utf-8") as f: |
| json.dump({"errors": errors, "warnings": warnings, "stats": stats}, f, indent=2, ensure_ascii=False) |
|
|
| status = "PASS" if not errors else "FAIL" |
| report_lines = ( |
| ["# AppSecBench Validation Report", "", f"**Status:** {status}", |
| f"**Records:** {stats['total_records']}", |
| f"**Errors:** {len(errors)} | **Warnings:** {len(warnings)}", "", |
| "## Distributions", "", |
| f"- Languages: {len(stats['by_language'])}", f"- Frameworks: {len(stats['by_framework'])}", |
| f"- CWEs: {len(stats['unique_cwe'])}", f"- OWASP: {len(stats['unique_owasp'])}", |
| f"- Vulnerabilities: {len(stats['unique_vulnerabilities'])}", "", |
| "## Errors"] |
| + ([f"- {e}" for e in errors] or ["(none)"]) + [""] |
| + ["## Warnings (sample)"] |
| + ([f"- {w}" for w in warnings[:50]] or ["(none)"]) |
| ) |
| with open(os.path.join(VALID_DIR, "validation_report.md"), "w", encoding="utf-8") as f: |
| f.write("\n".join(report_lines)) |
|
|
| print(status) |
| print(f"records={stats['total_records']} errors={len(errors)} warnings={len(warnings)}") |
| for e in errors[:30]: |
| print(" ERR", e) |
| return 0 if status == "PASS" else 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
