SudoBench

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

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):

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

@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. The harness and figure-generation code are released separately under MIT or Apache-2.0 in the linked code repository.