File size: 4,634 Bytes
82c37ae aa831cb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | ---
license: apache-2.0
task_categories:
- text-classification
language:
- en
tags:
- security
- code-review
- benchmark
- vulnerability-analysis
- evaluation
pretty_name: GuardBench
size_categories:
- n<1K
configs:
- config_name: default
data_files: items.jsonl
---
# GuardBench
A benchmark for one question: **can the model follow a guard?**
Every failure worth caring about that we measured on real code in August 2026 was a guard
question, in one direction or the other:
- the base and LOREA Pilot announced disabled TLS in code that passes its SSL context correctly,
a symlink escape in code with realpath+commonpath confinement ten lines above the call, and a
spoofable forwarded header behind a loopback gate. Guard present, guard unread.
- Ginko v1 cleared a real timing attack because `startswith("Bearer ")` sat on the tainted path.
Guard present, guard irrelevant, cleared anyway.
FBE cannot see either. In a 50-token snippet the guard and the sink are adjacent and the example
is too short to miss one, so FBE-safe reports about 3 percent false alarms while the same model
gets three of four wrong on a 1,500-line file. GuardBench puts distance between the guard and the
sink, because distance is what the failure needs.
## The six shapes
120 items: 20 patterns across 19 vulnerability classes, six shapes each.
| shape | guard | correct verdict | what it catches |
|---|---|---|---|
| `none` | absent | VULNERABLE | baseline: can it find anything |
| `covers` | present, applied, sufficient | SAFE | false alarms on defended code |
| `covers_alt` | a second correct implementation, defended differently | SAFE | as above, so one wrong answer does not move the rate 12 points |
| `wrong_value` | present, applied to a sibling value | VULNERABLE | the tainted value slipped past |
| `irrelevant` | present, applied to the right value, does not address the weakness | VULNERABLE | mistaking a format check for a control |
| `elsewhere` | defined and used in this file, not on this path | VULNERABLE | helper exists, call site skips it |
`irrelevant` is the shape no existing corpus has and the one Ginko fails. `covers` is the shape
the base and Pilot fail.
## Rules that make it scoreable
**Distance is required.** In every item the guard is a helper defined above, a decorator, a
branch several lines up, or a constant declared at module scope. Never the line before the sink.
**Verdicts are parsed, never matched.** Every item requires a final `VERDICT: VULNERABLE <class>`
or `VERDICT: SAFE` line. A missing line is a scored failure, not a guess. The FBE grader counted
"does not contain any vulnerabilities" as claiming a vulnerability, and no benchmark here will
repeat that.
**Three prompt phrasings per item.** Ginko dropped its verdict line on 48 of 65 FBE items purely
because the harness said "Analyze this code for security issues" where its training said "Review
this code for security problems". A model that only works on one phrasing is not working, and the
benchmark should show that rather than reward it.
**Ground truth by construction.** Each item is written as a base plus a delta that defines the
label. Nothing here is labelled by a model or by judgement.
**No overlap with anything a model here was trained or selected on.** Checked by 7-gram shingle
overlap against all 459 Cyber training seeds and all 169 FBE items: worst overlap 0 percent. One
pattern was rewritten when its HMAC helper measured 29 percent against a training seed.
## Scoring
Report four numbers, and never one alone:
accuracy over all items
false alarms on `covers` only - the base/Pilot failure
missed on `irrelevant` - the Ginko failure
no-verdict rate over all prompt variants - brittleness
Verified against degenerate strategies: always-VULNERABLE scores 67 percent raw and **50 percent
balanced**; always-SAFE scores 33 percent raw and **50 percent balanced**. Raw accuracy is printed
but should never be quoted alone.
## Running it
python3 guardbench/run.py --tag <name> [--model <path>] [--adapter <path>] [--prompts 1|2|3]
Generations are appended to `results/partial_<tag>.jsonl` as they complete, and a re-run skips
what is already there. An interrupted run resumes rather than starting over. `--prompts 1` drops
the brittleness measurement and cuts the run to a third.
To score a partial or finished run without generating anything:
python3 -c "import json,sys; sys.path.insert(0,'guardbench'); import run; \
rows=[json.loads(l) for l in open('guardbench/results/partial_<tag>.jsonl')]; \
run.report(rows,'<tag>')"
|