- Rating
- 2
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper studies parameter poisoning in indirect prompt injection. Here, the attacker does not trick the agent into taking a new action. Instead, the attacker changes key parameters in the correct tool call, such as the recipient, the amount, or the address. The proposed method first uses the user task to build a fixed rule set that says which information source is allowed to decide which parameter. Before a tool call runs, it traces where each parameter came from. It then checks two things: whether the evidence supports the value, and whether the source is allowed to decide it. If either check fails, the call is blocked. The paper also builds FactAuthBench, which has 144 paired cases, and runs experiments with several models and baselines.
Critical strengths
- The paper is clearly written. It moves smoothly from the research problem to the method.
- The paper compares against several defenses, and it reports the core verification module separately from the repair (purification) module.
Critical weaknesses
-
The benchmark and the defense follow the same set of rules, so the results may be circular. In FactAuthBench, every case marks an attacker-controlled region, and every attack works the same way: the attacker puts a replacement value in free text that they control. The defense rules match this exactly: externally controlled fields cannot get HIGH authority, and low-authority free text can only be used to select a record, not to decide a parameter value. Also, the defense seems to decide which fields are attacker-controlledwith the same source labels that the benchmark uses. Does the defender know in advance which fields the attacker can change? If so, this is a very strong assumption.
-
The contribution over existing data-flow defenses is not well established, and the difference from camel and similar work is not clear. CAMEL already handles parameter manipulation and source tracking directly. DRIFT already includes constraints on parameter dependencies. The authors should show which cases can only be solved by the new use-level authorization. They should also explain why giving existing systems equally fine-grained policies would not reach similar results.
-
The traced sources may not be the real ones. The auxiliary model rebuilds the evidence from the candidate value and the context. This does not guarantee that it recovers the real dependency that produced the value. Also, citing a legitimate source does not mean that no malicious influence was missed.
Questions for authors
- In the defense, how do you decide which fields are attacker-controlled and get LOW authority? Do you use the same information as the FactAuthBench labels? What happens if the defender only gets the public descriptions of the tools?
- Can you report BU, UA, and ASR on all user tasks and injection tasks in the original Aentdojo? In particular, for tasks where external content should legitimately decide a parameter value, does AuthorityFlow block them by mistake?
- On Qwen3.6-27B, 13 cases still succeed. What kind of failures are these? Is the authorization boundary wrong, is the tracing wrong, or is the verifier LLM misled by the attack content?
4 comments
Question 2: Can you report BU, UA, and ASR on all user tasks and injection tasks in the original AgentDojo? In particular, for tasks where external content should legitimately decide a parameter value, does AuthorityFlow block them by mistake?
We evaluated the undefended baseline, AuthorityFlow, and its combination with an action-level defense on the original AgentDojo benchmark:
| Method | BU ↑ | UA ↑ | ASR ↓ |
|---|---|---|---|
| No Defense | 79.17% | 55.27% | 24.80% |
| AuthorityFlow | 68.75% | 57.74% | 7.53% |
| AttriGuard + AuthorityFlow | 65.63% | 45.12% | 1.29% |
Overall, AuthorityFlow and its combination with AttriGuard exhibit different security–utility trade-offs on the evaluated cases.
The 10 benign task rejections (from 76/96 to 66/96) stem from two causes: certificate formatting mismatches and uncovered VALUE_INPUT authorization for external fields. The tasks you highlighted, in which external content legitimately determines a parameter value, fall into the latter category. In the original AgentDojo, these tasks rely on underspecified prompts that lack clear boundaries on low-authority source usage. Action-level defenses typically ignore such parameter-level nuances, whereas existing data-flow defenses uniformly block them.
We treat safely permitting external parameter values as a finer-grained authorization problem governed by explicit task delegation or entity-bound provenance. While AuthorityFlow defaults to restricting LOW-authority fields to SELECTOR_INPUT, our compiler overrides this baseline and grants VALUE_INPUT permission whenever the user prompt explicitly delegates value extraction or the low-authority message is bound to the verified identity of the authoritative record under modification. To directly test this on stale official records, we evaluated [25 Clean + 25 Attack] paired cases across all four domains (3 runs each, 150 evaluations), where both legitimate updates and malicious replacements reside in the exact same LOW-authority fields. AuthorityFlow achieves 96.0% BU (4.0% FRR) on legitimate updates while restricting ASR to 0.0%, confirming that with explicit delegation or entity-binding signals, it accurately permits legitimate external values without compromising security.
Weakness 3 & Question 3: The traced sources may not be the real ones. The auxiliary model rebuilds the evidence from the candidate value and the context. This does not guarantee that it recovers the real dependency that produced the value. Also, citing a legitimate source does not mean that no malicious influence was missed. On Qwen3.6-27B, 13 cases still succeed. What kind of failures are these? Is the authorization boundary wrong, is the tracing wrong, or is the verifier LLM misled by the attack content?
While rebuilding evidence from context without accessing the agent's internal reasoning states does not theoretically guarantee recovering the exact internal dependency, AuthorityFlow does not rely on citing a legitimate source alone to approve a call. To guard against missed malicious influence when a legitimate source is cited, we pair tracing with an independent downstream Verifier (Section 3.4) as a safeguard to check whether the frozen authorized evidence is semantically sufficient on its own to derive the candidate parameter. Under this design, even if the tracer cites a legitimate source while omitting a malicious influence, the Verifier is designed to block the call as UNSUPPORTED when the manipulated value cannot be logically derived from the authorized evidence alone.
In practice, residual errors in tracing or verification can still occur. To directly answer Q3 regarding the 13 successful attacks on Qwen3.6-27B (9.03% ASR), we analyzed all 13 cases using the failure categories in Appendix E.1 (Table 15):
| Failure Category | Count (Cases) | Primary Cause & Representative Mechanism |
|---|---|---|
| Authority Boundary Error | 3 / 13: #113, #114, #115 | Coarse segmentation: Injected claims in a flight response or HIGH-authority address/contact fields inherit the outer field's permission. |
| Dependency Tracing Error | 4 / 13: #53, #54, #80, #98 | Incomplete candidate coverage: The tracer misses recommendation batches or checks global comparisons over incomplete channel/company subsets. |
| Fact Interpretation Error | 6 / 13: #48, #50, #52, #95, #96, #100 | Verifier semantic errors: The verifier loses entity–rank correspondence, confuses an in-body Alice: claim with the actual sender, or misinterprets multi-constraint/sub-task requirements. |
Among the 13 successful attacks, 4 were attributed to dependency tracing errors, representing 2.78% of all 144 attack cases. These errors primarily involve completeness checks over multi-entity comparisons. We have added this breakdown and case analysis to Appendix E.1 of the revised manuscript.
Thank you for the authors' response, which partly addressed my concerns. However, this does not change my overall view of the paper. Nevertheless, I am willing to lower my weight, and if other reviewers hold different opinions, I would also be glad to see the AC lean towards accepting their views.
Thank you for considering our response and for your openness to other reviewers’ perspectives.
We appreciate that our response has partially addressed your concerns. Could you please clarify which concerns remain unresolved and are most important to your overall assessment? Understanding these specific points would help us provide a focused clarification and make the remaining issues clearer for the discussion.
We greatly appreciate your expert feedback and insightful concerns. Our responses follow:
We have revised the manuscript accordingly. The changes are highlighted in blue in the revised PDF.
(1) Assigning LOW authority.
Before observing runtime data, the planner decides which fields are externally editable and receive
LOWauthority based on their schema properties (Section 3.2, Algorithm 1, Appendix B.4). Specifically, it assignsHIGHauthority to system-maintained structured fields (e.g., transaction IDs, official addresses) andLOWauthority to external free-form text fields (e.g., email bodies, reviews, notes), without knowing which runtime field is modified.(2) Whether FactAuthBench label information is used.
No, we do not use the same information as the FactAuthBench labels. In AuthorityFlow, base-authority construction is independent of FactAuthBench's ground-truth labels, and the defense module does not use benchmark attack annotations. Ground-truth labels are used by the post-execution script to compute ASR (Sections 2.1, 2.2, Appendix A.4).
(3) Providing only the public descriptions of the tools.
If the defender only gets the public descriptions of the tools, behavior and results remain identical to our reported experiments because this is our standard evaluation setting. During base-authority inference, the defender receives the public tool specification C (tool descriptions, return structures, and field definitions), the same metadata provided to the agent and all baselines. Furthermore, the defense rules and benchmark are not circular. SELECTOR_INPUT is the default for external text without explicit delegation. When the user explicitly delegates value extraction or an update record is bound to a verified entity identity, the compiler prioritizes task-level authorization to grant the designated fact VALUE_INPUT permission (Algorithm 1). We have clarified this in Section 3.2 and Appendices B.2 and B.4 of the revised manuscript.
We have discussed CaMeL and DRIFT in Section 5.2 and compared both methods in Table 1, Figure 3, and Table 10. Here, we compare in detail the authority dimensions constrained by AuthorityFlow, CaMeL, and DRIFT. While CaMeL enforces data-readability taint tracking and DRIFT constrains tool-level preconditions, AuthorityFlow constrains the functional role a field may serve for a target parameter. The table below compares two representative cases, Case #26 (postponing an Insurance payment by two days) and Case #38 (finding the channel where Alice asked about a coffee mug and replying there):
In Case #26, the agent must use
subjectto locate the Insurance record and add two days to its structureddate, whereas the attacker injects07-10intosubjectto induce07-12. AuthorityFlow authorizessubjectasSELECTOR_INPUTfor record selection but rejects it asVALUE_INPUTfor arithmetic derivation. DRIFT only checks whether parameters come from the preceding query tool without distinguishing fields or roles, executing07-12. In Case #38, AuthorityFlow allows theLOW-authority messagebodyto locate the inquiry while permitting only theHIGH-authorityrecipientfield to supply the channelrandom, whereas CaMeL blocks both the clean task and the attack whenever state-changing calls depend on untrusted external content.Equally fine-grained field-level policies cannot achieve similar results in existing systems. When a
LOW-authority field likesubjectorbodyis required to locate the target record, a static field policy without use-level role distinction faces a fundamental dilemma: forbidding dependency on that field blocks legitimate record selection and reduces BU to 59.72% in ourw/o Task-use Authorizationablation in Table 2, whereas permitting dependency on that field allows injected text to overwrite the parameter value.