TL;DR
MobileProbe is a new red-teaming framework that adaptively evaluates the security of mobile GUI agents by injecting malicious instructions based on an agent’s actual execution path. By moving away from static, "fixed-point" benchmarks, it uncovers significant vulnerabilities in state-of-the-art agents, achieving over an 85% attack success rate across diverse architectures.
What Problem Does This Paper Address?
Mobile GUI agents (like those powered by LLMs) are designed to navigate apps autonomously to complete complex tasks. However, they are highly susceptible to Environmental Injection Attacks (EIA), where an attacker embeds malicious instructions into UI content (like an email or a fake dialog) to hijack the agent's behavior.
Existing security benchmarks for these agents suffer from two major flaws:
- Instance Specificity: Attacks are manually crafted for specific steps in specific apps, making them hard to scale.
- Insufficient Test Coverage: Agents are non-deterministic. If an agent takes a slightly different path than the one envisioned by the benchmark creator, it might bypass the "fixed" injection point entirely. As shown in Figure 1, this leads to a "coverage gap" where an agent is incorrectly labeled as "safe" simply because it never encountered the attack.
Methods
MobileProbe introduces a dual-layer, trajectory-aware architecture to make red-teaming adaptive:
- Probing & Evaluation Platform: This layer uses automated "pentesting" to discover injectable surfaces across apps (e.g., where user-generated text appears) and creates reusable templates. During a live run, a background monitor triggers the injection only when the agent reaches a matched page.
- Red Team Agentic System: This is the "brain" of the attack, operating in three phases:
- AttackPathExplorer: It analyzes the agent's benign trajectory to find the most "vulnerable" moment to strike—specifically where the agent is about to make a consequential decision.
- PayloadGenerator: It synthesizes initial attack payloads by combining different strategies (like "Urgency Appeal" or "Authority Impersonation") and styles (like "System Notification").
- EvolutionaryRefiner: It uses an LLM-based feedback loop to iteratively refine the payload. To save on expensive live executions, it uses "surrogate pre-filtering" to weed out payloads that aren't semantically or visually consistent before testing them on the agent.
Datasets
The authors constructed a benchmark of 83 long-horizon attack instances spanning 12 mobile applications.
- Base Tasks: Derived from the MobileWorld benchmark.
- Attack Goals: Categorized using the classic CIA (Confidentiality, Integrity, Availability) framework.
- Vectors: Evaluated using two primary vectors: Malicious Text (embedded in legitimate content) and In-App Fake Dialogs (rendered by a potentially compromised app).
The researchers compared candidate injection vectors based on privilege, reliability, and capacity, ultimately selecting Malicious Text and In-App Fake Dialogs for their high reliability and unconstrained capacity (see Table I below).
Key Insights and Ideas
- The "Path Uncertainty" Problem: Even the same agent might follow different routes across repeated runs. MobileProbe’s ability to select injection points after observing a trajectory is crucial for fair comparison.
- Stealth is Possible: Many successful attacks achieved "Stealth Hijacking," where the agent fulfilled the malicious goal (e.g., exfiltrating data) while still appearing to complete the user's original task. This makes these attacks incredibly hard for a human user to detect.
- Lightweight Models are Riskier: Smaller, on-device models (like GUI-Owl) showed significantly weaker "safety discrimination" than larger frontier models, often following payloads that were only marginally relevant to the context.
- Context Switching Weakens Defense: Attacks were more successful in cross-app tasks. Frequent transitions between apps seem to degrade the agent's ability to distinguish between legitimate UI and injected adversarial content.
Key Results
MobileProbe was tested against three representative agent architectures: Gemini-3.1-Pro (closed-source), GUI-Owl (open-source on-device), and an agentic framework.
- High Success Rate: MobileProbe achieved an Attack Success Rate (ASR) of 85.1% to 86.3%, significantly outperforming human-written templates (~7-34%) and zero-shot LLM baselines (~8-16%).
- Improved Coverage: It reduced the Payload Miss Rate (PMR)—the frequency of an agent never seeing the attack—from as high as 22.9% in fixed benchmarks to just 3.6% - 6.0%.
- Refinement Matters: The evolutionary refinement process was vital; removing it caused the ASR to plummet from 85.1% to just 28.5%.
Limitations and Future Work
While MobileProbe is a major step forward, the authors note a few areas for growth:
- Intra-agent Uncertainty: Even with adaptive selection, an agent might deviate during the adversarial run. Running multiple benign trajectories before selection could mitigate this.
- Domain Coverage: The current benchmark covers 12 apps, but hasn't yet touched highly sensitive categories like finance or healthcare.
- Defense Integration: The paper focuses on the "red team" (attack) side; future work is needed to integrate these findings into "blue team" (defense) mechanisms, such as runtime monitors that flag unauthorized data transmissions.
Summary updated