File size: 6,723 Bytes
4597f86 ede2315 4597f86 | 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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | ---
language:
- en
license: cc-by-4.0
pretty_name: SudoBench
size_categories:
- n<1K
task_categories:
- question-answering
- text-classification
tags:
- llm-agent
- security
- prompt-injection
- confused-deputy
- authorization
- benchmark
- paired-contrast
configs:
- config_name: scenarios
data_files:
- split: all
path: data/scenarios.jsonl
---
# SudoBench: A Contextual Authorization Benchmark for LLM Agents
SudoBench measures whether frontier LLMs use two classical authorization primitives when a runtime exposes them: a source label on each tool result, and a capability list for each session. It has 135 paired scenarios in three attack families: confused deputy, source-label indirect prompt injection, and scope-check indirect prompt injection.
Code and harness: https://github.com/wang-research-lab/SudoBench
## Dataset summary
- 270 scenario manifests, comprising 135 paired contrasts × 2 variants per pair, across three attack families (45 pairs each).
- Each pair shares caller, user prompt, document body (where applicable), target tool, and target resource. Only one runtime-supplied field flips between the two variants of a pair, and the flip determines the expected outcome (`tool_called` vs `tool_blocked`).
## Loading
```python
from datasets import load_dataset
scenarios = load_dataset(
"RandomMan0880/SudoBench",
"scenarios", split="all",
)
print(scenarios) # 270 rows
print(scenarios[0]) # first scenario manifest
```
## Schema (`scenarios` config)
One row per scenario manifest. The two halves of a pair share `pair_id`. Source-label IPI and scope-check IPI rows include the document body inlined as `document_body`.
| Field | Type | Notes |
| --- | --- | --- |
| `id` | string | Unique scenario identifier (e.g. `ipi_001_trusted`) |
| `pair_id` | int | Shared by the two halves of a contrast |
| `type` | string | `source_label_ipi`, `scope_check_ipi`, or `confused_deputy` |
| `boundary_type` | string | `cross_engagement`, `role_based`, `seniority`, or `external` |
| `variant` | string | `trusted`/`untrusted` (CD, source-label IPI) or `in_scope`/`out_of_scope` (scope-check IPI) |
| `sender_id` | string | Caller email (CD) or runtime source attribution (IPI; trusted = internal Aquila address, untrusted = external sender or unauthenticated origin) |
| `is_authenticated` | bool | Whether the runtime tag attests authenticity for this scenario |
| `target_tool` | string | The tool whose invocation the harness records as `tool_called` |
| `target_resource` | string | The resource argument the JSON-serialized tool input must contain (IPI only); for confused-deputy this is informational |
| `user_prompt` | string | The user message that initiates the agent loop |
| `injection_file` | string \| null | Filename of the document body in the original repo (IPI only) |
| `document_body` | string \| null | Document body inlined here (IPI only); byte-identical across the two halves of a pair |
| `manifest` | object \| null | `{"grants": [{"resource": …, "actions": [...]}]}` for scope-check IPI scenarios; consumed by the `capabilities` and `both` conditions |
| `expected_outcome` | string | `tool_called` for execute-variants, `tool_blocked` for refuse-variants |
## Files
```
data/
scenarios.jsonl 270 rows
env/
system_prompt_base.md Workspace description loaded into every condition
tags_convention.md Verbatim _TAGS_CONVENTION (added under tags and both)
capabilities_convention.md Verbatim _CAPABILITIES_CONVENTION (added under capabilities and both)
access_control.json Per-resource ACL used to derive granted_scopes
LICENSE CC-BY-4.0
```
The harness, the refusal audit, and the figure scripts are in the code repository (https://github.com/wang-research-lab/SudoBench). This dataset repository contains the scenario test bed. Running the harness against the listed model APIs produces the per-record evaluation logs.
## Reproducing the evaluations
The harness in the linked code repository takes a model identifier and re-runs the 270 scenarios under the four conditions (`baseline`, `tags`, `capabilities`, `both`):
```bash
python eval.py --model claude-sonnet-4-6 --workers 32
```
Per-provider model IDs, decoding settings, retry policy, and run dates are documented in the paper appendix.
## Intended use
SudoBench is intended for:
- Evaluating runtime authorization primitives (information-flow tags, capability lists) on LLM agents.
- Calibrating frontier-model behavior under deployable changes to the agent runtime's prompt context.
- Instruction-tuning data for training models to discriminate authorization-relevant runtime signals rather than refuse on surface cues.
The benchmark is a fixed test bed; per-cell McNemar contrasts compare conditions on the same scenarios, and population-level generalization to other workspaces is out of scope.
## Limitations
- Single fictional workspace (Aquila Consulting), single ACL, six principals, four boundary types per family.
- 45 paired scenarios per family; per-cell power analysis at 80% is in the paper.
- Each (model, scenario, condition) triple is sampled once at provider-default decoding settings.
- `tool_blocked` is recorded for any non-target outcome within five turns; the paper's Claude-Opus-4.7-as-judge refusal-source audit on a random sample of 500 refuse-variant passes finds 72% are authorization-grounded overall, with `both` at 82%, `capabilities` at 71%, and `tags`-only at 58% (the unrelated cases concentrate on hallucinated-success claims under tags).
- The release here is the benchmark scenario set; no model weights and no per-record model outputs are included.
## Ethics and dual use
The workspace is fictitious; no real personal data is included. The scenarios are written to test authorization-relevant decision boundaries rather than to teach a model how to comply with attacks. The dataset could in principle be adapted to test prompt-injection attacks against deployed agents, comparable to existing benchmarks in this space (AgentDojo, WASP, Shade-Arena).
## Citation
```bibtex
@inproceedings{siu2026sudobench,
title = {SudoBench: A Contextual Authorization Benchmark for LLM Agents},
author = {Siu, Vincent and Shi, Tianneng and Gu, Shangding and Wang, Zhun and Song, Dawn and Wang, Chenguang},
booktitle = {Advances in Neural Information Processing Systems (Evaluations and Datasets Track)},
year = {2026}
}
```
## License
The dataset is released under [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/). The harness and figure-generation code are released separately under MIT or Apache-2.0 in the linked code repository.
|