acceptodds
Under review as a conference paper at ICLR 2027

The Same Pixels, Opposite Authority: Visual Data Injection in Computer-Use Agents

Abstract

Multimodal LLM agents use screenshots to populate tool arguments, but rasterization can preserve a displayed value while omitting the source information needed to authorize its use. We study Visual Data Injection (VDI), in which attacker-controlled visual data supplies a sensitive argument without an injected instruction or a change to the user-authorized operation. We introduce matched-raster, value-counterbalanced pairs that hold the screenshot, user request, and literal value fixed while varying hidden source permissions. This protocol isolates an information boundary: a screenshot-only policy cannot distinguish the two permission states. Under this protocol, Qwen2.5-VL and Qwen3-VL adopt unauthorized candidates in 98/100 observations each, and GPT-4o in 99/100. We propose a defense framework combining independent provenance acquisition, persistent lineage, and role-specific authority enforcement. Reference-origin experiments isolate contract checks using supplied provenance, while browser-origin experiments acquire evidence from live frame metadata. In the latter, enforcement preserves all same-origin candidate executions achieved by the raw models (33/50 for Qwen2.5-VL and 34/50 for GPT-4o) while reducing cross-origin candidate execution to 0/50 for both. Memory experiments show that retaining original provenance prevents unauthorized reuse after storage; error interventions show that unknown provenance triggers confirmation, whereas false trust can permit attacks. These controlled results support separating operation authorization from argument-source authorization, with effectiveness conditional on reliable provenance rather than visual appearance alone.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Visual Data Injection, Computer-Use Agents, Multimodal LLM Agents, Agent Security, Data Provenance, Argument-Level Authorization

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 2 reviews, above 68% of the others.
Reviewer_jyB2OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies agents built on vision language models that operate a computer by reading screenshots. When the agent takes a value from the screen, say a contact address shown in a card, the image keeps the value but drops the information about where that value came from. The paper calls the resulting attack Visual Data Injection. An attacker places its own value inside visual content it controls, and the agent copies that value into a sensitive argument of a tool call, such as the recipient of a message. The attack uses no hidden instruction and does not change what the user asked for. The agent does exactly what the user requested, it just takes the value from the wrong source.

To measure this cleanly, the authors build matched pairs of cases. Both cases in a pair share the same image file, the same user request, and the same shown value. Only a hidden label differs, marking the source as trusted in one case and attacker controlled in the other. Since the model sees identical input, it cannot behave differently across the pair. Under this setup, Qwen2.5-VL and Qwen3-VL adopt the attacker's value in 98 of 100 cases each, and GPT-4o in 99 of 100. The same pattern holds for deletion targets and command arguments, not only message recipients.

The defense has three parts. First, the system finds the source of incoming data on its own rather than trusting the model, for example by reading the frame address from the live browser. Second, it records where each value came from as the value moves through tools and memory. Third, before a tool call runs, a checker tests each argument against rules saying which sources may fill which role, so the right to run an operation is checked separately from the right to supply its arguments.

Validation comes in several pieces. With source labels supplied by hand, the checker blocks every attack, which shows the checking rules behave as designed. In a live browser test, the system reads real frame origins, keeps all legitimate executions (33 of 50 for Qwen2.5 and 34 of 50 for GPT-4o), and blocks all 50 cross origin attacks for both models, while a security aware prompt and a task alignment baseline fail to separate the two cases. Memory tests show that keeping the original source of a stored value blocks its later misuse, while trusting the memory container lets the attack through. Error tests show that a missing source triggers a confirmation request, while a source wrongly marked as trusted lets every attack through. A separate prototype recovers which source painted which pixels by suppressing one source at a time and comparing renders, though only for sources registered in advance. The authors also report negative results, for example the attack chain does not complete in a live multi turn loop, and they scope their claims to the controlled settings tested.

Critical strengths
  1. The paper isolates a real and previously blurry failure, and gives a clean way to measure it.

Agents that act from screenshots can pick up attacker values that carry no injected instruction and change nothing the user asked for. Earlier work on prompt injection mixes this case with instruction tricks and visual perception tricks, so it was hard to tell where the failure actually sits. The matched pair design fixes this. Two cases share the same image file, the same user request, and the same shown value, and only a hidden source label differs. A model that only sees the screen cannot act differently in the two cases, and the experiments confirm this exactly, with near identical adoption in both arms. The design also removes cheap shortcuts. The values have identical format, the trusted and attacker assignments are swapped across arms, and the shared image files are hash verified, so the result cannot be explained by the model spotting odd strings. This is consequential for my assessment because it turns a vague worry into a pinned down problem with a reusable measuring tool, and it proves the failure lives in the pipeline rather than in model cleverness, so model side fixes alone cannot close it.

  1. The evaluation is careful and honest in a way that makes the security claims believable.

The numbers are internally consistent, the statistical tests are the right choice for paired data, and the authors report results that cut against them, including a live multi turn test where the attack never completes and a small model that could not run the execution harness at all. The ablations do real explanatory work. Merging two argument roles into one check quietly restores the attack, which pinpoints where checking granularity matters. Marking a source as unknown leads to confirmation requests, while marking an attacker source as trusted lets every attack through, which shows the whole defense stands or falls on getting the source right. In the live browser test, reading the frame origin from the browser itself keeps all legitimate executions (33 of 50 and 34 of 50) and blocks all 50 attacks for both models, without changing anything the model sees. This is consequential for my assessment because the paper's practical message, that a system should check who may run an operation separately from who may supply its arguments, is backed by controlled evidence and honest negative results rather than by a plausibility argument.

Critical weaknesses
  1. The main defense numbers are close to guaranteed by the setup, and the checking machinery largely repeats concurrent work.

In the reference origin experiments, the checker is handed the true source label of every value and matches arguments by literal string comparison. Blocking all attacks under these conditions is nearly automatic, and it repeats what PACT already showed, namely that with given provenance, role based checks achieve perfect security on diagnostic suites. The gate design itself closely follows ECA. What remains new is obtaining the source from outside the model, and that part is validated for exactly one source class, iframe origins in a local two server setup, under the assumption that source metadata cannot be forged. The paper's own error test shows how much this assumption carries. Once an attacker source is falsely labeled as trusted, all 36 configurations let the attack through. So the defense reduces to a root of trust that the paper does not build, and the third stated contribution, the defense framework, is mostly an integration of existing mechanisms plus one acquisition result for a narrow case. This is consequential for my assessment because a fair share of the paper's weight sits on the defense claim, and that claim is thinner than the headline zeros suggest.

  1. The attack is demonstrated only in a forced single shot setting, and end to end harm is never shown.

The main protocol tells the model to return exactly one tool call using the displayed value, so adopting the shown value is close to instructed behavior rather than a discovered failure. The one live multi turn test points the other way. 46 of 50 attack cases end in an explicit stop, 4 make benign calls, and nothing sensitive executes. The authors call this limited integration evidence, which is honest, but it means the practical conversion of the attack into real harm is asserted by construction, not demonstrated. Model coverage adds to the concern. No purpose built computer use model is run through the execution experiments, no Claude computer use, no computer-use-preview class model, no UI-TARS, and Qwen3 appears only in the adoption experiment without being disclosed as adoption only in the limitations. This is consequential for my assessment because the paper frames VDI as an attack, while the evidence shows an information boundary plus a forced choice demonstration, which is a weaker claim and should be stated as such.

Questions for authors

Some points that require further clarification:

  1. Table 3. What exactly does the Decision audit column count, and over what denominator. Under the raw no guard condition, Qwen2.5 shows 50 allow while GPT-4o shows 34 allow for the same policy. As printed this reads like an error. If the difference comes from GPT-4o requesting confirmation in the remaining 16 cases, please state this and define the decision classes.

  2. Multi-slot suite. Qwen2.5 adopts attack values in 41 of 50 cases, but only 33 execute under no enforcement. Please state whether the 8 missing cases are the planning failures described for the clean arm, and whether the clean and attack planning failures are the same cases.

  3. Multi-slot images. Do the clean and attack arms share the same image files, as in the counterbalanced suite, or do the screenshots differ. If they differ, what rules out visual confounds in Tables 6 and 7.

  4. Qwen3. Please confirm that all execution results cover only Qwen2.5 and GPT-4o, and explain why Qwen3 was excluded from the execution experiments. The limitations disclose this for InternVL but not for Qwen3.

  5. Live loop, Appendix G.1. Which model was used, and why did no attack chain complete. Was the prompt, the environment, or the monitor different from the single shot setting. This matters because the attack evidence rests on forced single call demonstrations, and the live result currently reads as an unexplained contradiction.

Minor questions or suggestions I have:

  1. Same origin attacker content, for example user generated content hosted on the trusted site itself, where the origin check gives no signal. A short discussion of whether any acquisition mechanism could cover this case would help bound the approach.

  2. Running one purpose built computer use model, for example a Claude computer use or UI-TARS class model, through the browser origin protocol, even at small scale, would show whether the adoption pattern holds for models trained for this setting.

  3. Reporting the per step time cost of acquisition and checking in the live loop, and how the 2.94 second cold start scales with the number of registered sources, would clarify deployment practicality.

1 comment

Thank you for the review.

Q1. What is new relative to ADI, PACT, and ECA if correct labels suffice to reject attacks?

Rejection is expected when the reference-origin checker receives correct labels. Our contribution is to isolate the information missing at the screenshot interface. Each matched-raster pair fixes the screenshot, request, and candidate value while changing only the source's permission to supply it. A screenshot-only agent thus sees identical inputs. The browser-origin experiment tests whether independently acquired frame metadata can supply the missing evidence at execution time. Falsely marking an external source as trusted allows its value through. The appendix “Positioning against concurrent formulations” relates this result to prior work on data injection and argument authorization.

Q2. What do the forced single-call tasks establish beyond instructed adoption?

The reference-origin prompt requires the displayed value and forbids preliminary inspection, so adoption measures behavior under that constraint. The browser-origin prompt permits inspection or confirmation. We replay one proposal per prompting condition in both live origin settings. Without enforcement, the test outbox records sends to the candidate address in 33/50 cases for Qwen2.5 and 34/50 for GPT-4o under each origin. Enforcement preserves all corresponding same-origin sends and reduces cross-origin candidate sends to 0/50 for both models. Q7 reports the separate autonomous test.

Q3. How do Decision audit and execution counts differ?

Decision audit reports selected policy outcomes across 50 cases. Clean and Attack count completed calls using the candidate recipient. In the raw row, Qwen2.5 has 50 allows and 33/50 candidate executions in each origin condition. GPT-4o has 34 allows and 34/50 candidate executions in each. The browser policy also allows address-book contacts and requests confirmation for unmatched addresses. The audit gives only a partial breakdown of decisions.

Q4. Why do 41/50 adoptions yield 33/50 executions? Why did clean tasks fail?

Qwen2.5 placed the candidate in the target argument in 41/50 attack cases (16/17 recipient, 9/17 deletion, 16/16 command). Without enforcement, 33/50 produced the corresponding tool effect. A plan can contain the value even if the executor later stops on a non-allow decision or an adapter failure. All 16 clean failures involved unsupported preliminary reads (nine recipient, seven deletion). Role-specific enforcement preserved clean completion at 34/50 and reduced attack execution from 33/50 to 0/50.

Q5. Are multi-slot pairs pixel-identical?

The verified pixel-identical control applies to the primary value-counterbalanced single-slot suite, where each pair shares an image path and SHA-256 hash. The multi-slot suite reuses the same 50 source pages and generates values deterministically to test recipient, deletion-target, and command roles.

Q6. Which models contributed execution or adoption results?

We report execution for Qwen2.5 and GPT-4o, and single-slot adoption for Qwen3. InternVL contributes adoption results only. Its extra reads and non-canonical payload fields made an execution comparison in the recipient fixture uninformative.

Q7. Did the attack recur in the live loop?

The loop ran for up to four turns. On each turn, the evaluator captured the Playwright page, requested one action, applied the monitor, and returned the result to the agent. Of 50 attack cases, 46 ended in an explicit stop and four in a benign page call. None reached sensitive execution. The successful attack executions reported in the paper came from controlled replay.

Q8. Can origin identify attacker-controlled content on a trusted site?

Browser origin identifies a transport boundary. Same-origin user content needs a distinct content principal and a rule governing which arguments it may supply. Such a rule could also authorize a legitimate cross-origin service. Our prototype tests a configured same-origin/cross-origin boundary.

Q9. Did you test purpose-built computer-use models?

The execution evaluation covers Qwen2.5 and GPT-4o. It does not include a purpose-built computer-use model.

Reviewer_WTfMOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

The paper proposes a defense for what they term "visual data injection" - data collected from a screenshot in a browser use agent that is injected from somewhere in the page it shouldn't be. The defense works with three steps - provenance tracking, provenance propagation, and policy enforcement. The paper shows that these components reduce attack success rate while maintaining clean performance, on a benchmark drawn from 5 real websites.

Critical strengths

I have not seen work which explores the problem of VDI in screenshots.

The core components of the system are natural and reasonable.

Critical weaknesses

Setting/threat model. There are a couple issues with the threat model. One is that the paper does not evaluate against adaptive attacks on the system. Another is that they consider an adversary who only seeks to modify data sent in a standard control flow, but they do not motivate this.

Limited evaluation/scalability. The evaluation used by the paper is fairly limited, using short run tasks. Overall, some components of the approach break down as you scale. Even getting provenance in general on the web can be challenging, as this is website specific. Provenance propagation, on longer running tasks and tasks pulling from multiple sources, can generally balloon into issues. The paper does not offer solutions to these challenges, leaving the scope to fairly small tasks.

Questions for authors

I would really appreciate the authors clarifying how much the adversaries in their experiments stand to gain from running their attack.

1 comment

Thank you for the review.

Q1. What does the attacker gain, and why study attacks that leave the user-authorized operation unchanged?

Answer: An attacker can benefit even when the agent performs the operation the user requested. Suppose the user authorizes sending a record to Alice. An attacker-controlled contact panel supplies the attacker's address, and the agent uses it as the recipient. The send remains aligned with the requested operation, but the record goes to the attacker. This is why we hold the operation fixed: we study whether permission to send is incorrectly treated as permission for any visible source to supply the recipient. The same distinction applies when an attacker supplies the object to delete or the command to run.

Our experiments use synthetic records and destinations. We check the resulting browser or file state, so the execution results measure tool effects rather than argument adoption alone. They establish this failure in a controlled environment; the corresponding real-world benefit would be receiving the user's data through the substituted destination.

Q2. Does the evaluation cover adaptive attacks against the defense?

Answer: We have not tested adaptive-attack robustness. In the browser-origin experiment, the attacker controls the candidate content but cannot forge the frame-origin metadata read by the runtime. The experiment tests whether that independent evidence supports source-sensitive execution. Without enforcement, Qwen2.5 executes the candidate in 33/50 cases and GPT-4o in 34/50, in both origin conditions. Enforcement retains all of those same-origin executions and reduces cross-origin candidate execution to 0/50 for both models.

These results depend on the integrity of the acquired provenance. Our false-trust interventions expose that dependence: labeling an external source as trusted allows the attack through. Missing evidence instead triggers confirmation under the tested policy. As stated in "Limitations and discussion," the browser-origin evaluation does not cover same-origin compromise, adversarial canvas attribution, or adaptive attacks on paint localization. The error interventions measure dependence on evidence integrity, not adaptive robustness.

Q3. How does the approach handle longer tasks and values drawn from multiple sources?

Answer: We test short workflows with environment-specific acquisition. The browser-origin implementation covers one controlled source class, while the two-turn memory experiment tests whether a value retains its original source after storage and re-rendering. Longer tasks that combine sources, rewrite values, or perform calculations remain outside this evaluation.

In the memory experiment, Qwen2.5 stores and selects the candidate in 48/50 pairs and GPT-4o in 50/50. Retaining the original source blocks all corresponding attack calls and preserves the corresponding clean executions; treating the trusted memory container as the source allows the attacks through. This is the source-preservation problem we test. Acquiring and tracking provenance across longer, heterogeneous workflows remains open.

Q4. How do provenance acquisition, propagation, and enforcement differ across the experiments?

Answer: The reference-origin and browser-origin settings serve different purposes. In reference-origin, we supply the source labels to isolate contract checking. In browser-origin, we read the frame URLs from Chromium and apply the source policy to that evidence. The memory and error interventions test source preservation, missing evidence, and false trust. Keeping these distinctions explicit helps separate the acquisition problem from the downstream enforcement check.

Comments on the paper

1 comment

Thank you for the review.

Q1. What technical contribution does the paper make beyond ADI, PACT, ECA, and information-flow approaches?

Answer: When the screenshot, request, and candidate value are identical, what evidence can distinguish a source authorized to supply the value from one that lacks permission? Our matched-raster protocol isolates this question by holding all three inputs fixed across different permission states. The browser experiment then tests whether frame metadata obtained outside the model can supply the missing evidence at execution time.

ADI describes the broader threat of untrusted data influencing arguments. PACT tracks provenance across steps for semantic argument roles, and ECA uses external evidence for action-critical predicates. Our contribution is a controlled test of the source ambiguity at the screenshot interface and its connection to execution. The two-turn memory experiment also tests whether that source evidence survives storage and reuse.

Q2. Are the high adoption rates a consequence of requiring the agent to use the displayed value?

Answer: The reference-origin prompt explicitly requires the displayed value in a single tool call. In the matched-raster suite, Qwen2.5 used the displayed recipient in 98/100 authorized cases and 98/100 unauthorized cases. The paired rates show how reliably the value entered the argument under this instruction, even as source permission changed. They do not estimate attack frequency in unconstrained workflows.

The browser-origin prompt permits inspection or confirmation. In paired replay without enforcement, Qwen2.5 executed the candidate send in 33/50 cases and GPT-4o in 34/50 under each origin condition. Checking frame origin preserved those same-origin sends and reduced cross-origin candidate sends to 0/50 for both models, as recorded in the test outbox.

Q3. Is there an end-to-end example in which an attack succeeds without the defense and is prevented with it?

Answer: In controlled browser replay, we verified in the test outbox that cross-origin candidate sends succeeded without enforcement and were blocked with it, while the corresponding same-origin sends were preserved. In autonomous interaction, we did not reproduce a successful attack chain: of the 50 live-loop cases, 46 ended in explicit stops and four in benign page calls, with no sensitive execution.

Q4. How does the policy handle same-origin attacker content or legitimate cross-origin data?

Answer: The same-origin/cross-origin policy is configured for this experiment. Origin identifies where content was served; a separate policy determines whether that source may supply a particular argument. A same-origin user contribution may lack permission to supply a recipient, while a legitimate cross-origin service may have it. Supporting those cases requires identifying the relevant content principals and assigning permissions at that granularity.

We test acquisition at one browser-origin boundary. Same-origin user content, arbitrary screenshots, and native applications remain unresolved, as stated in "Limitations and discussion." The false-trust tests show why source assignment matters: once an external source is accepted as trusted, the downstream checker allows its values. Deployment therefore depends on sound verifiers or source registries.

Q5. Can lineage follow rewrites, mixed-source values, and calculations, and what is the cost for longer tasks?

Answer: The memory experiment tests one specific path: storing a value and then using its re-rendered form. Qwen2.5 selects the candidate in 48/50 pairs and GPT-4o in 50/50. Checking only the current memory container allows all corresponding attack calls; retaining the original source blocks those calls while preserving the corresponding clean executions. This shows why a trusted container must not replace the provenance of its contents.

The lineage graph records the source principals and generation process for a derived value. Our restricted audits cover normalization, decoding, concatenation, and alias lookup; unsupported semantic rewrites receive an unknown label. Under the tested policy, unknown provenance requires confirmation. Arbitrary paraphrases, computation, and composite arguments remain open. For overhead, the reported 2.94 s cold-start measurement is for the separate source-localization prototype, not lineage tracking over a long task.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.