--- license: cc-by-4.0 language: - en tags: - security - code - static-analysis - ai-generated-code - vibe-coding - sast - benchmark - vulnerability-detection pretty_name: AI Code Security — Golden Set size_categories: - n<1K task_categories: - text-classification configs: - config_name: default data_files: golden.jsonl --- # AI Code Security — Golden Set A small, **hand-labeled** benchmark of code snippets — *vulnerable*, *safe*, and *needs-audit* — for evaluating how well a tool detects security problems in **AI-generated code** ("vibe coding"). Every case is a minimal, self-contained example with a known, by-construction ground-truth label. Crucially, the set is built around **safe twins**: many vulnerable cases are paired with a near-identical *safe* variant living at the same file path. This makes the benchmark measure **precision**, not just detection — a tool that flags everything trivially "catches" every vulnerability and is useless in practice. This is the public version of the internal "golden" set used to certify [Axyr](https://axyr.dev), a deterministic security layer for AI-generated code. It is released so others can **reproduce, evaluate, and critique the labels**. The detection engine is not part of this release; only the labeled cases are. --- ## At a glance | | | |---|---| | **Cases** | **118** | | **Labels** | 57 vulnerable · 41 safe · 20 warning | | **Frameworks / stacks** | Next.js (65) · Express (26) · SQL (15) · FastAPI (12) | | **Vulnerability classes** | 34 (see the coverage matrix) | | **Severity of positive findings** | 36 critical · 22 high · 19 medium | | **Findings per positive case** | exactly 1 (each case isolates a single issue) | | **Provenance groups** | `synthetic-v1` (112) · `cve-repro-v1` (6) | | **Safe-twin families** | 12 (35 cases live in a paired family) | | **Real-CVE reproductions** | 6 (every CVE id is a real, published advisory) | | **CWE-tagged cases** | 53 (mapped from the category taxonomy) | | **Format** | JSON Lines (`golden.jsonl`), one object per case | | **License** | CC BY 4.0 | --- ## 1. Why this set exists AI coding agents now write code faster than anyone reviews it. The failure mode is not that the code looks obviously wrong — it is that it **looks reviewed**: it compiles, it is neatly formatted, and it passes the happy-path tests, while quietly containing an unscoped delete, a missing ownership check, or a secret that leaks into the client bundle. Most public code-security benchmarks were not designed around these specific failure modes, and many of them measure only **recall** (did the tool find the bug?) without measuring **precision** (did it stay quiet on the near-identical correct version?). A detector tuned only for recall can reach 100% by alarming on everything — and is then ignored by developers, which is its own failure. This set targets exactly that gap: AI-code failure modes, with paired safe twins so that false positives are first-class, measurable outcomes. --- ## 2. Composition **Labels** | Label | Count | Meaning | |---|---:|---| | `vulnerable` | 57 | A concrete, exploitable security defect is present. | | `warning` | 20 | Risky / context-dependent; should be surfaced for human audit (e.g. a permissive RLS policy, a `NOT NULL` migration with no default, a dependency one edit away from a popular package). | | `safe` | 41 | Correct code, including the safe twins of vulnerable cases. A finding here is a false positive. | **Stacks** | Stack | Count | |---|---:| | Next.js (App Router / API routes) | 65 | | Express (Node) | 26 | | Raw SQL / migrations | 15 | | FastAPI (Python) | 12 | **Severity** (of the 77 positive cases — `vulnerable` + `warning`) | Severity | Count | |---|---:| | critical | 36 | | high | 22 | | medium | 19 | Each positive case carries **exactly one** expected finding, so the signal is unambiguous and a tool's hit/miss on a given case is well defined. --- ## 3. The safe-twin methodology This is the design choice that makes the set a benchmark rather than a list of bad code. For **12 scenario families**, the same file path appears at least twice: once in a vulnerable (or warning) form and once in a near-identical safe form. **35 of the 118 cases** belong to such a paired family. The pairs differ by the smallest change that flips the verdict, for example: - an `await prisma.invoice.delete(...)` **before** the auth check (vulnerable) vs. **after** an early-return auth guard (safe); - a query reading a record **by `id` alone** (IDOR) vs. the same query filtered by `ownerId` (safe); - a `NOT NULL` column added **without** a default (warning — fails on a populated table) vs. **with** a default (safe); - an RLS policy `using (true)` (warning — no real isolation) vs. `using (auth.uid() = owner_id)` (safe). A tool is only credible on a family if it flags the dangerous member **and** stays silent on its safe twin. Flagging both means it has learned the wrong signal (e.g. "any `delete` is bad") and would drown a real codebase in noise. --- ## 4. Coverage matrix The 77 positive cases span 34 vulnerability classes, grouped here into families. Counts are the number of expected findings in each class. ### Data destruction & migrations (24) `destructive_query` (12) · `destructive_migration` (5) · `integrity_drop` (1) · `dropped_trigger` (1) · `breaking_rename` (1) · `risky_not_null_migration` (1) · `locking_index_migration` (1) · `locking_constraint_migration` (1) · `risky_type_change` (1) ### Injection (17) `sql_injection` (9) · `command_injection` (3) · `insecure_deserialization` (2) · `nosql_injection` (1) · `code_injection` (1) · `xss` (1) ### Other web / crypto (11) `ssrf` (4) · `path_traversal` (4) · `open_redirect` (1) · `insecure_random` (1) · `weak_crypto` (1) ### Secret exposure (10) `secret_in_response` (5) · `server_secret_in_client` (2) · `public_secret_env` (1) · `secret_in_logs` (1) · `hardcoded_secret` (1) ### Access control & tenant isolation (7) `missing_authorization` (2) · `idor` (2) · `missing_rls` (1) · `permissive_rls_policy` (1) · `tenant_isolation_break` (1) ### Dependencies / supply chain (8) `insecure_dependency_source` (3) · `malicious_install_script` (3) · `dependency_typosquat` (1) · `known_malicious_package` (1) > The distribution is **illustrative, not representative**: it reflects which > classes we chose to cover, not their true prevalence in AI-generated code. --- ## 5. Real-CVE reproductions Six cases (`group: cve-repro-v1`) reproduce the **pattern** of a real, published vulnerability. They are minimal re-implementations of the defect class — the original copyrighted source is **not** copied. Every CVE id below is a real advisory you can verify on the [NVD](https://nvd.nist.gov) or the GitHub Advisory Database. | Case id | Reference | Class | |---|---|---| | `cve_2014_6394_express_sendfile_traversal` | CVE-2014-6394 | path traversal (`send`) | | `cve_2017_5941_node_serialize_deser` | CVE-2017-5941 | insecure deserialization | | `cve_2023_26111_node_static_path_traversal` | CVE-2023-26111 | path traversal (`node-static`) | | `cve_2024_39338_axios_ssrf` | CVE-2024-39338 | SSRF (`axios`) | | `cve_2025_53107_git_mcp_command_injection` | CVE-2025-53107 / GHSA-3q26-f695-pp76 | command injection (MCP server) | | `cve_2026_41640_nocobase_concat_sqli` | CVE-2026-41640 | SQL injection (NocoBase, string concatenation) | These let you check that a tool recognizes the *shape* of known real-world defects, not just synthetic textbook examples. --- ## 6. Data schema `golden.jsonl` — one JSON object per line: | Field | Type | Description | |---|---|---| | `id` | string | Stable, unique case identifier. | | `label` | string | One of `vulnerable`, `safe`, `warning`. The ground truth. | | `stack` | string | Framework hint: `nextjs`, `express`, `fastapi`, `sql`. | | `group` | string | Provenance group for leave-one-group-out evaluation: `synthetic-v1` (hand-written) or `cve-repro-v1` (real-CVE pattern reproductions). | | `path` | string | The intended file path of the snippet (shared across a twin family). | | `categories` | string[] | Vulnerability classes for the expected finding(s); empty for `safe`. | | `cwe` | string[] | CWE identifier(s) mapped from the category taxonomy. Data-loss / migration classes have no clean standard CWE and are intentionally left empty. | | `code` | string | The full, self-contained snippet. | **Load it:** ```python from datasets import load_dataset ds = load_dataset("axyr/ai-code-security-golden", split="train") print(ds[0]["label"], ds[0]["categories"], ds[0]["cwe"]) ``` --- ## 7. Intended use & evaluation protocol Use the set to benchmark any tool that analyzes source for security issues (SAST, an LLM judge, a custom linter). A suggested protocol: 1. For each row, run your analyzer on `code`, using `path` as the filename and `stack` as the framework hint. 2. Score against the label: - **`vulnerable`** — the analyzer should report at least one finding matching `categories`. A miss is a **false negative** (the most costly error). - **`safe`** — the analyzer should report nothing. Any finding is a **false positive**. - **`warning`** — apply your policy; the expected behaviour is "surface for review". 3. Report **separately**: recall on vulnerable cases, false-positive rate on safe cases, and behaviour on warnings. Give special attention to the **12 twin families** — a tool that flags the vulnerable member *and* its safe twin has learned the wrong signal. 4. Use the `group` field for a **leave-one-group-out** check: scores on `cve-repro-v1` (real-world patterns) vs. `synthetic-v1` (hand-written) tell you whether a tool generalizes or has overfit to one style. 5. Do **not** collapse this into a single "accuracy" figure. The errors are asymmetric: a missed vulnerability is far worse than a false alarm, and a benchmark average hides exactly that. --- ## 8. Labeling methodology - **Ground truth by construction.** Each case is authored to exhibit (or avoid) one specific issue; the label follows from how the case was built, not from any tool's output. - **One issue per positive case.** Positive cases carry exactly one expected finding so that hit/miss is unambiguous and composite cases don't blur results. - **Three labels.** `vulnerable` (exploitable defect), `warning` (risky / context-dependent, audit-worthy), `safe` (correct, including twins). - **Minimal and self-contained.** Snippets are reduced to the smallest code that still expresses the issue, to isolate the signal from incidental noise. --- ## 9. Limitations — please read This set is a **sanity floor and a precision probe**, not a certification. - **Small and curated.** 118 cases are not a statistical sample of real-world code. Scores here do **not** extrapolate to an accuracy percentage "in the wild". - **Synthetic and minimal.** Cases isolate one issue under clean conditions. They test pattern recognition, **not** performance on large, noisy, real codebases. - **Mostly single-file.** Inter-file / inter-procedural defects (a sink in one file, the tainted source in another) are largely **out of scope** in this version. - **Author judgment.** Labels reflect the authors' security judgment and are published precisely so they can be **challenged**. Some `warning` calls are inherently context-dependent (a permissive policy may be intentional). - **Coverage is illustrative.** The class distribution reflects our choices, not real-world prevalence. - **Necessary, not sufficient.** Passing every case does **not** make a tool "secure"; failing cases shows it misses known patterns. Treat results accordingly. - **No comparative claims ship with this data.** It is released as raw ground truth only — no leaderboard, no "tool X wins", no unverifiable accuracy numbers. --- ## 10. Provenance The set is the public, curated version of the internal certification suite for [Axyr](https://axyr.dev). Within Axyr, these classes map to the product's checks (database safety, code safety, dependency safety, secret exposure), but this release contains **only** the labeled cases — no rules, no engine, no scores. It exists so the security community can reproduce and critique the labels. If you find a mislabeled case or a class we should cover, please open a discussion on the dataset page. --- ## 11. License Released under **CC BY 4.0**. You may use, modify, and redistribute the cases, including for evaluating commercial and open-source tools, provided you give appropriate credit. --- ## 12. Citation ```bibtex @misc{axyr_golden_2026, title = {AI Code Security --- Golden Set}, author = {Axyr}, year = {2026}, howpublished = {Hugging Face Datasets}, url = {https://huggingface.co/datasets/axyr/ai-code-security-golden}, note = {A hand-labeled benchmark of vulnerable/safe/warning code for evaluating security analysis of AI-generated code.} } ``` --- ## 13. Changelog - **v2 (2026-06-04)** — 118 cases (up from 47). Added 6 real-CVE pattern reproductions (every id verified against NVD), supply-chain and migration classes (34 total), CWE ids mapped from the category taxonomy, the `group` provenance field for leave-one-group-out evaluation, the 12 safe-twin families, and a documented evaluation protocol. - **v1** — initial release, 47 cases.