ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
summary
The gist
Indirect prompt injection (IPI) plants instructions in the content a tool-using LLM agent reads, steering the agent into harmful tool calls Abstract The strongest defenses are system-level…
In short
Indirect prompt injection tricks tool-using agents into executing harmful actions by planting malicious instructions within content they read at runtime. ROPE is a defense that enforces a structural trust policy, ensuring that any value reaching a state-changing tool must trace back to the user or their explicit records. This deterministic origin check maintains high utility while significantly reducing attack success rates compared to existing system defenses.
Key concepts
- Indirect Prompt Injection (IPI)
- This is an attack where malicious instructions are hidden inside content that an LLM agent reads during operation, rather than in the initial prompt. The goal is to trick the agent into using a tool in a harmful way by embedding commands within seemingly benign data it processes at runtime.
- ROPE (Routed Origin Policy Enforcement)
- ROPE enforces trust by checking if data reaching a tool has an unforgeable trace back to the user or their records. It treats information differently based on its source, only allowing state-changing tools to execute if the input meets strict origin criteria, making enforcement deterministic.
- Trust Anchors (T1, T2, T3)
- ROPE uses three origins for trust: T1 is the user's actual request; T2 is a value with an unforgeable runtime origin referenced by the user; and T3 are the user's authoritative records. This allows enforcement to be flexible, trusting specific sources based on how much detail was provided in the original task.
Terminology used across episodes
This episode discusses
- ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection · Paper Radio
- Get my drift? Catching LLM Task Drift with Activation Deltas
- Design Patterns for Securing LLM Agents against Prompt Injections
- LlamaFirewall: An open source guardrail system for building secure AI agents
- Securing AI Agents with Information-Flow Control
- Defeating Prompt Injections by Design
- Uncertainty-Aware, Risk-Adaptive Access Control for Agentic Systems using an LLM-Judged TBAC Model
- AttriGuard: Defeating Indirect Prompt Injection in LLM Agents via Causal Attribution of Tool Invocations
- Defending Against Indirect Prompt Injection Attacks With Spotlighting
- Taxonomy, Evaluation and Exploitation of IPI-Centric LLM Agent Defense Frameworks
- The Task Shield: Enforcing Task Alignment to Defend Against Indirect Prompt Injection in LLM Agents
- AgentLAB: Benchmarking LLM Agents against Long-Horizon Attacks
- Prompt Flow Integrity to Prevent Privilege Escalation in LLM Agents
- AgentDyn: Are Your Agent Security Defenses Deployable in Real-World Dynamic Environments?
- Robust Context-Aware Detection of Malicious Instructions in Text · Paper Radio
- AutoDojo: A Generative Benchmark for Evaluating Prompt Injection Defenses in LLM Agents · Paper Radio
- Ignore Previous Prompt: Attack Techniques For Language Models
- Progent: Securing AI Agents with Privilege Control
- PromptArmor: Simple yet Effective Prompt Injection Defenses
- Contextual Agent Security: A Policy for Every Purpose
- The Instruction Hierarchy: Training LLMs to Prioritize Privileged Instructions
The paper
ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection · Read on arXiv
Xinhang Ma, Chaowei Xiao, William Yeoh, Ning Zhang, Yevgeniy Vorobeychik
Washington University in St. Louis · Johns Hopkins University
Indirect prompt injection (IPI) plants instructions in the content a tool-using LLM agent reads, steering the agent into harmful tool calls. The strongest defenses are system-level, leveraging techniques such as task-conditional tool screening to prevent execution of malicious tools, and information-flow control to avoid tool execution with untrusted parameters. However, as agents grow more capable, users delegate more to automation. Consequently, tool execution sequences and parameter values are increasingly determined at runtime and cannot be reliably screened from solely user's query without significant utility loss. We present ROPE (Routed Origin Policy Enforcement), which is anchored in a structural notion of trust: a value may reach a state-changing tool only if it traces unforgeably to the user, a source the user explicitly named, or the user's own authoritative records. Enforcement is then a deterministic origin check over an audited set of sensitive tool parameters, and the only reliance on a language model involves solely the trusted user request, out of the attacker's reach. Our approach admits two provable guarantees: 1) at every step of a trajectory, no value whose only origin is attacker-writable content reaches an origin-guarded parameter, and 2) no rewording of an injection changes an admission decision. We evaluate across four agent models on open-ended agent suites, ROPE holds attack success rate to 1.6--2.6% while retaining 82--100% of undefended clean utility, significantly exceeding state-of-the-art system-level defenses in utility while attaining comparable or better security. Further, we show that optimizing the injection against ROPE is largely ineffective, while long-horizon attacks that defeat prior system-level defenses achieve zero success rate. Our code and logs are available at https://github.com/xhOwenMa/ROPE.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection".
Title and authors: Nadia: To get into the details of "ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection," they explain that indirect prompt injection is when instructions are hidden inside content an agent reads, which then steers the agent toward making harmful tool calls >
Elias: They argue that system-level defenses, like task-conditional tool screening or information flow control, struggle because agents delegate more and more of their work to runtime content >
Priya: So the core problem they're solving isn't just stopping bad text, but managing the trust when a value is being used in a state-changing tool call that came from somewhere we can’t easily verify >
Nadia: Exactly. They introduce ROPE as a defense that anchors trust structurally: it says a value only reaches a tool if it has an unforgeable trace back to the user, or someone the user named, or your own official records >
Elias: They then define enforcement as just a deterministic check over those sensitive tool parameters, meaning the only part of the language model involved is solely reading your trusted request >
Priya: And they show that this approach can achieve a success rate of about one point six to two point six percent against attacks while still keeping eighty-two to one hundred percent of the clean utility >
Nadia: That’s what makes it interesting because most defenses either crush the attack rate by losing utility or they are vulnerable because they rely on some kind of language model judge >
Elias: They highlight a failure mode shared by both families of defenses: whether the constraint is a plan or just a policy, it's settled before the delegated content arrives, causing over-defense when things get more open >
Priya: So this paper is essentially saying that we need to shift from trying to police every piece of content at runtime to rigorously checking where the data came from before it touches the tool >
Nadia: It shifts the focus from content screening to origin tracking, which they then operationalize with these three origins: your request, a named source, and your records >
Elias: That structural definition of trust is what lets them build a defense that is provably sound under mild conditions because the admission decisions don't change even if you try to paraphrase the injection >
Priya: I wonder about the data they used for this evaluation. Do those results hold up across different kinds of agent tasks, or was it mostly on one specific benchmark?
Nadia: They evaluated it across four different agent models on open-ended agent suites, which gives a pretty broad view of how it performs in real-world scenarios >
The paper's summary: Elias: Now let's talk about the specific improvements they suggest over previous system-level defenses, because they aren't just adding one feature, but a whole new way to think about enforcement >
Nadia: Their main improvement is using under-specification as a signal to condition the strictness of the enforcement, which is a really smart move for handling open tasks >
Priya: So if the request is super specific and detailed, ROPE pins that parameter directly to the request, which keeps things very deterministic >
Elias: Right. When it's fully specified, it only trusts that first origin, your actual request >
Nadia: But when a request delegates more to runtime content, ROPE widens its trust by admitting values from the named source or your authoritative records >
Priya: That seems like they are trading off the level of detail you provide for the level of trust they grant in the source material >
Elias: It's a way to recover utility that fixed origin policies lose when things get more delegated, because it lets them draw on those other origins without introducing a new language model judge into the check >
Nadia: They also introduce an origin tracker that labels every tool result by its structural origin, so results arriving as divided entries are filed under the unforgeable runtime identity >
Priya: So if a file is being read and it comes back in pieces, ROPE knows which piece belongs to the injection attempt versus what's legitimate content >
Elias: And they make sure that monolithic blocks, like a whole file body, get labeled as injectable even if the user named that exact file because it licenses no value >
Nadia: That’s a strong claim because it means you can't just name the source and assume anything in that output is safe anymore >
Priya: It seems like they are making a very clear distinction between data that came from an untrusted runtime flow versus data that has been clearly established as legitimate origin >
Elias: And they prove two things about this approach: first, it soundly maintains the trusted origin for tool parameter values at every step of the planning trajectory >
Nadia: And second, their admission decisions are invariant to paraphrasing of the injection, which means even if an attacker tries to change their wording slightly, ROPE still makes the same call >
Priya: So they’re arguing that this structural method is more robust than just trying to use a language model to guess if something is safe >
Elias: That's the core argument. it's about relying on traditional security mechanisms for origin tracking instead of guessing intent with an AI judge >
The paper's improvements: Nadia: So wrapping up the discussion on ROPE: this paper presents a defense that achieves low attack success rates while retaining eighty-two to one hundred percent of the task completion utility we'd expect from an undefended agent >
Elias: It’s anchored in a structural notion of trust where a value only reaches a tool if it traces back to the user, or someone you explicitly named, or your own authoritative records >
Priya: It seems like the biggest implication for us is that we can have more confidence in agents when they're doing tasks that are delegated and open-ended >
Nadia: Right. And they show that this approach works across various agent models on different suites, proving it’s not just a theoretical concept but something practical >
Elias: They also showed that the ordering of clean utility versus attack success rate doesn't change regardless of which specific agent model you are using >
Priya: I think what sticks is that they manage to keep the enforcement deterministic by confining the router to only read your initial, trusted request >
Nadia: Right. So it’s about provenance—figuring out which piece of content an agent reads and deciding whether that content can actually be acted upon >
Elias: The full title of the paper is "ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection," and it’s a solid approach to handling indirect prompt injection by focusing on where the data comes from >
Conclusion: Nadia: So we’ve been talking about ROPE, Routed Origin Policy Enforcement against Indirect Prompt Injection, and what this paper does to stop agents from getting tricked into using harmful tools >
Elias: Yeah, basically it puts a structural notion of trust on top of the agent's tool calls. It checks if the data coming in has a verifiable path back to you or someone you named >
Priya: I’m still thinking about how they handle those three origins: your actual request, something you mentioned at runtime, and your own records >
Nadia: Exactly. And they make the enforcement deterministic by pinning parameters to that initial request when the user is being specific >
Elias: But if the request is vague or delegates more work, ROPE widens its trust to include those named sources or your records, which lets it keep utility high >
Priya: I wonder if that flexibility introduces any new kinds of risk when you’re letting more arbitrary runtime data in >
Nadia: That’s a fair question. It just means the agent can still use those things safely as long as it comes from a source we recognize or one you explicitly pointed to >
Elias: The results show they keep eighty-two to one hundred percent of clean utility while cutting attack success rates down to about two percent >
Priya: That level of security while keeping almost all the agent's functionality seems like a big deal for practical deployment, not just theoretical safety >
Nadia: It’s a win because it doesn't force you to completely strip out the ability for the agent to use information from your named sources >
Elias: So this ROPE approach is about adding a layer of origin tracking that works with existing security mechanisms instead of relying on another language model judge >
Priya: It seems like a very grounded way to think about provenance, which is always the right starting point for us when we’re looking at measurement and privacy issues >
Nadia: So that’s ROPE for now. It gives us a solid framework for checking where an agent gets its instructions before it acts on them >
Elias: We'll keep an eye on how this origin tracking scales as agents get more complex and the delegation goes deeper >
More episodes
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18
- 2511.19218-From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment