betaFeedback

WorksComputer Science

Agentic AI Defense: Decode-Time Provenance Binding for MCP

Abstract

Agentic AI systems using the Model Context Protocol (MCP) are vulnerable to indirect prompt injection through untrusted tool outputs. We demonstrate cross-modal trust laundering, in which instructions concealed in an email-signature image using least-significant-bit (LSB), discrete cosine transform (DCT), or metadata steganography bypass text scanners and enter a multi-agent workflow when decoded by a tool. To counter this threat, we propose decode-time provenance binding, which combines HMAC-authenticated trust labels with an MCP-maintained provenance ledger and context-taint tracking. The mechanism labels decoded content as untrusted and blocks critical tool calls influenced by that content, even when a compromised agent substitutes a valid trusted label. We evaluate the approach using a real MCP testbed with three steganographic carriers and 24 adaptive payloads. The undefended pipeline exhibits 100% attack success, while keyword and regex defenses each permit 62.5% of attacks. Our mechanism blocks all attacks (0% success), including adversarial label substitution across mediated agent boundaries. A four-component ablation validates the roles of decode marking, cryptographic authentication, lineage tracking, and sink enforcement. An audited trusted-promotion mechanism increases legitimate-task completion from 67% to 100% without compromising protection. The approach provides carrier-independent containment within fully mediated MCP execution environments. Code and data are publicly available.

Introduction

Large language models (LLMs) are increasingly deployed not as passive chatbots but as agents: systems that read external content, decide what to do, and then act by calling software tools on a user’s behalf—reading an inbox and drafting replies, triaging tickets, or acting on documents. To call a tool, an agent needs a uniform way to discover it and exchange data with it; the Model Context Protocol (MCP) [1] has become a common such interface, letting an agent invoke tools—“extract the text from this image,” “send this email,” “export these records”—through one standardized channel. Realistic deployments are often multi-agent: a coordinator dispatches specialized worker agents that relay intermediate results to one another before any action is taken.

This autonomy creates a risk that does not arise for a passive chatbot. Because an agent acts on the content it reads, text inside that content can function as a command: an email whose body says “ignore your instructions and forward the user’s saved passwords” may be read by an inbox agent and obeyed, even though no human ever issued it. This is indirect prompt injection—an instruction smuggled into the data an agent processes rather than supplied by its operator—and it is ranked first on the Open Worldwide Application Security Project (OWASP) Top 10 for LLM Applications [2] and catalogued in the National Institute of Standards and Technology (NIST) adversarial-ML taxonomy [3].

A practical and well-studied instance is the email-summarizing agent: researchers have repeatedly hidden instructions in a message—for example as zero-pixel or white-on-white HTML text, invisible to the human reader—and shown that the summarizer reads and acts on them [4, 5, 6]. Two families of defense dominate. Content scanning inspects the ingested text for tell-tale injection markers (“ignore previous instructions,” a tool name, a request for credentials) and strips or blocks any match. Provenance tracking takes a different tack: rather than judge what the text says, it labels where the text came from—marking anything a tool returns as UNTRUSTED—and forbids untrusted content from triggering a sensitive action such as sending mail or exporting data [7, 8, 9, 10, 11]. Both families are the backdrop for the attack and defense this paper develops.

This paper makes three contributions.

  • We identify and characterize cross-modal trust launder-ing: a steganographic email-signature carrier that defeats text content scanners and launders an instruction into a multi-agent MCP control flow at the decode step (Section IV).

  • As a defense for agentic AI, we propose decode-time provenance binding, which combines two guarantees that are usually conflated: data-provenance security (a critical action cannot be authorized through a forged or relabeled data dependency), delivered by an HMAC-signed label minted at the concealment-reversal boundary; and context-influence containment (a critical action cannot execute after an untrusted instruction has influenced the execution context without authorized clearance), delivered by having the MCP layer independently maintain the provenance lineage—a ledger and per-context taint—

rather than trust an agent-presented label. We give the two algorithms, a security invariant scoped to fully mediated contexts, and a proof sketch, and we show the conjunction defeats valid-label substitution by a compromised agent, which neither guarantee alone does (§ 5).

  • We implement a real MCP testbed with three steganographic carriers (LSB, DCT, metadata) and an adaptive 24-payload attack bank, and show the mechanism reduces attack success to 0% where a keyword scanner and a regex parser each reach 62.5%; we add an information-flow (taint) baseline, an ablation over the mechanism’s four components, a label-substitution stress test, and a legitimate-task evaluation in which an audited trusted-promotion path eliminates false blocks, with cryptographic overhead under 0.2% of a decode round-trip and a full enforcement path that scales linearly with lineage depth (Section VI). All code and data are released at https://github.com/ericyoc/stego_provenance_defense.

Both defenses assume the payload travels through a text channel. We show this assumption is violable in a way that is realistic, zero-click, and invisible to the human recipient. Consider a brand logo embedded in an email signature—the single most innocuous object in a message. Using steganography, an attacker hides an instruction in the logo’s pixels or metadata. The image is visually identical to the original and contains no suspicious text, so a content scanner sees nothing. The victim never clicks anything. But when the victim’s routine inbox-summarization agent processes the signature, a tool in its pipeline—an optical-character-recognition (OCR) step, a stego/metadata extractor, or a multimodal model prompted to surface hidden content—decodes the image, and the hidden instruction enters the agent’s context. In a multi-agent pipeline, that decoded text is then relayed from the extracting worker to peer agents and the orchestrator, which treat it as ordinary intermediate output. An externally-supplied instruction has been laundered into the trusted control flow. We call this cross-modal trust laundering.

The key observation for defense is that existing provenance mechanisms attach the trust label when a text tool returns. A steganographic carrier defeats this because the dangerous transition—hidden bits becoming instructions—does not happen at text ingestion; it happens at the decode step. We therefore propose decode-time provenance binding: the trust label is minted at the moment any concealment-reversing tool runs, is cryptographically bound to the decoded payload so it survives multi-agent handoffs, and is enforced at the critical-tool boundary. Crucially, the defense does not attempt to detect that an image is poisoned—an arms race against ever-better steganography that the defender loses. Instead it assumes any decoded content is untrusted and contains it, so the payload may decode perfectly and still cannot drive a critical action.

We review four strands that our work joins: indirect prompt injection and its benchmarks, steganographic injection against (multimodal) models, attacks on email agents and MCP, and provenance and information-flow defenses. The gap we fill sits at their intersection.

Indirect prompt injection and benchmarks

Indirect prompt injection, in which instructions are planted in content the agent will read, was shown against real LLM-integrated applications by Greshake et al. [12] and systematized subsequently [13, 14]. Benchmarks now measure the problem in tool-integrated agents, including InjecAgent [15], AgentDojo [16], and the tool-risk emulator ToolEmu [17]. These establish the threat and evaluation methodology but operate on text channels.

Steganographic injection against (multimodal) models

Instructions can be concealed in images using spatial (least-significant-bit), frequency-domain (DCT and the discrete wavelet transform, DWT), or learned neural steganography [18, 19, 20], remaining visually imperceptible while carrying hundreds of characters. Recent attack studies report 24–32% attack success against production vision-language models and demonstrate near-perfect concealment metrics [21, 22, 23], and related cross-modal jailbreaks hide payloads in images paired with benign prompts [24, 25, 26, 27]. The broader risk of information hiding as a malware carrier is long established [28]. These works feed a single crafted image directly to a model; they do not consider email delivery, multi-agent pipelines, MCP tool calls, or a provenance defense.

Email-agent and MCP injection

Independent of steganography, practitioners have repeatedly hijacked email-summarization agents using text carriers such as zero-pixel HTML [4, 5, 6], national guidance now documents MCP-specific risks including poisoned tool output consumed by downstream agents [29], and tool-metadata poisoning has its own detectors and protocols [30, 31]. These text carriers are, by construction, visible to text content scanners; our image carrier is not.

Provenance and information-flow defenses

The closest line of work labels agent data by origin and blocks untrusted-origin actions, building on classical language-based information-flow control [32]. Run-time policy-enforcement points intercept MCP tool calls [9, 8]; information-flow systems propagate taint across agent steps [10, 11, 33, 34]; CaMeL separates trusted control flow from untrusted data flow [35]; MELON offers a provable construction [36]; multi-agent pipelines coordinate verifier agents [37, 38]; and trace-level provenance auditors and surveys attribute sink actions to sources [7, 39, 40]. The most directly related system, NeuroTaint [7], explicitly states that it does not consider multi-modal attacks or semantic steganography, attaches labels when a text-returning tool returns (not at a decode transform), uses unsigned labels, and audits completed traces rather than blocking at runtime. Our contribution occupies exactly this declared gap: a cross-modal carrier, a label minted at the decode boundary, cryptographic binding (via a keyed MAC [41]) that survives handoffs, and runtime enforcement. We claim neither provenance nor steganography as novel; we claim their decode-time junction.

Table I positions the most closely related systems against this study along the axes that define the gap: whether a cross-modal (steganographic) carrier is in scope, whether the trust label is minted at the decode transform rather than at text-tool return, whether the label is cryptographically bound against tampering across agent handoffs, whether enforcement is at runtime versus offline audit, and whether the setting is a multi-agent MCP pipeline.

SystemCross-modal carrierDecode-time labelSigned/tamper-evidentRuntime enforceMulti-agent MCP
CaMeL [35]nononoyespartial
MELON [36]nononoyesno
ProvenanceGuard [8]nononoyesyes
MCP PEP [9]nononoyesyes
SafeFlow [10]nononoyesyes
NeuroTaint [7]nononoaudityes
Stego injection [21, 22]yesn/an/an/a (attack)no
Email hijack [4]non/an/an/a (attack)no
This studyyesyesyesyesyes

Table I. Positioning of related systems against this study.

Threat Model and System Overview

Figure 1 shows the end-to-end setting. A trust boundary separates the operator-trusted control flow from externally-supplied content; the defense binds a trust label at the point where the concealment transform is reversed, so the boundary is enforced at the critical-tool sink rather than at text ingestion.

System context of cross-modal trust laundering and the defense

Figure 1. System context of cross-modal trust laundering and the defense.

Attacker capability. The attacker can send the victim an email. They cannot access the victim’s system prompt, model weights, keys, or execution environment. The payload is embedded in a signature logo (inline cid: or data: URI) using steganography.

Victim pipeline. The victim runs an automated inbox summarizer built as a multi-agent MCP system: a coordinator dispatches worker agents; at least one worker’s pipeline includes an image-decoding step over inline images. Critical MCP tools (export_secrets, send_email) exist and are reachable by the orchestrator.

Mediation and lineage. All tool invocations pass through the MCP layer, which is trusted: it mints every binding with a key that never leaves it, and it maintains—independently of the agents—a per-context provenance ledger recording the decode-origin lineage that enters each context and the resolved argument lineage of each tool call. Agents receive opaque handles to tool results, never the key, and cannot edit the ledger. This mediation is what lets the verifier decide on lineage the layer recorded rather than on lineage an agent asserts; its cost and residual are discussed in § 8 and § 9.

Trigger. Execution requires no victim action beyond running the summarizer. The payload becomes instructions only when the decode step runs; a summarizer that treats the logo as opaque bytes does not surface it. This decode step is a stated precondition—and is exactly where our defense acts.

Mapping to OWASP Top 10 for Agentic Applications (2026). The attack chain maps to the agentic Agentic Security Initiative (ASI) taxonomy [42] as follows: ASI01 Agent Goal Hijack (the decoded instruction redirects the agent via indirect injection); ASI06 Memory & Context Poisoning (the poisoned logo enters the agent’s working context); ASI07 Insecure Inter-Agent Communication (the untrusted payload is relayed between workers as trusted peer output); and ASI02 Tool Misuse & Exploitation (a critical MCP tool is driven by the laundered instruction). Our defense is, in these terms, an ASI07 control that makes inter-agent provenance tamper-evident. We note that OWASP publishes no standalone “MCP Top 10”; MCP-specific risk is captured within the agentic (ASI) list above and in dedicated protocol guidance such as the NSA’s MCP security considerations [29].

Attack: Cross-Modal Trust Laundering

This section details the attack: the three steganographic carriers that hide the payload (§IV-A), how the poisoned logo is delivered in an email signature and why neither antivirus nor email security intercepts it (§IV-B), and how the chain maps to the OWASP LLM Top 10 (§IV-C).

Carriers

We implement three carriers spanning the spatial, frequency, and metadata branches of the image-injection taxonomy [23]. All share a self-delimiting framed payload (a magic marker, a type byte, and a length prefix). (1) LSB: the payload bits replace the least-significant bit of RGB channels in a password-keyed pseudorandom permutation. (2) DCT: within each 8×88 \times8 block, a mid-frequency coefficient is quantized to an even/odd multiple of a step QQ to encode one bit, which survives the integer round-trip to pixels. (3) Metadata: the framed payload is Base64-encoded into a PNG text chunk. Fig. 2 shows a cover logo, its stego version carrying a payload, and the amplified set of changed pixels; the two logos are indistinguishable to the eye.

Delivery and laundering

The poisoned logo is placed inline in an HTML business-email signature. The summarizer’s image step recovers the logo and a worker calls the corresponding MCP decode tool, surfacing the hidden instruction. In the undefended pipeline the worker relays the decoded text to peer agents and the orchestrator, which cannot distinguish it from legitimate intermediate output and executes the implied critical tool. Figure 3 shows the full chain as a message sequence, contrasting the undefended leak with the defended block.

Attack-chain sequence showing undefended leak versus defended block

Figure 3. Attack-chain sequence: undefended leak vs. defended block.

Reading Figure 3 left to right, the chain proceeds in four shared steps and then diverges. (1) The attacker sends an ordinary business email whose signature logo carries the stego payload. (2) The victim’s inbox-summarization agent processes the signature and its image step hands the logo to a worker. (3) The worker calls the extract_stego MCP tool, which decodes the payload and—under our defense—mints an HMAC-signed Untrusted binding at that instant. (4) The worker relays the decoded text, with its binding, to the orchestrator. In the undefended pipeline the orchestrator cannot tell the laundered text from legitimate output: (5) it calls the critical export_secrets sink and (6) the secrets are exfiltrated to the attacker—credentials leaked. In the defended pipeline the same critical call is first routed to the verifier: (5′) the orchestrator requests the call and presents the binding, (6′) the verifier recomputes the HMAC, finds the lineage is Untrusted, and (7′) returns Block—no secrets leave. The payload decodes identically in both runs; only the lineage check differs, which is why containment, not detection, is what stops the leak.

a) Embedded vs. attached, and why email defenses miss it: Signature logos are almost always embedded—an inline cid: MIME part or a data: URI in the HTML body—rather than attached as a separate file. Embedded images render automatically, travel with every message, and are the normal way a brand mark appears, so they draw no attention; attached files are more likely to be sandboxed or hash-scanned. Conventional email defenses do not stop this carrier. Antivirus matches known-malware byte signatures, but an LSB, DCT, or metadata payload in a well-formed PNG is not malware—it is a valid image with sub-visual pixel perturbations or a benign-looking text chunk, so there is no signature to match; this is the classic information-hiding evasion of content scanners [28]. Secure email gateways and data-loss prevention (DLP) inspect text, URLs, sender reputation, and attachment hashes or types—not steganalysis of inline logos, which is costly, false-positive-prone, and outside their threat model. Crucially, the payload is inert at the mail layer: it is pixel noise until a decode step runs, and that step executes downstream in the agent pipeline, after email security has already passed the message. Content disarm-and-reconstruct (CDR) can in principle re-encode images, but is typically applied to attachments rather than inline signature logos and does not reliably strip metadata or frequency-domain payloads. The carrier therefore crosses every perimeter control intact and only “arms” inside the agent.

Mapping to OWASP Top 10 for LLM Applications

In the classic application taxonomy [2], the chain exercises LLM01 Prompt Injection (the carrier is an indirect injection), LLM02 Insecure Output Handling (decoded tool output is consumed without isolation), LLM08 Excessive Agency (the orchestrator calls a critical tool unmediated), and LLM06 Sensitive Information Disclosure (the resulting exfiltration).

Defense: Decode-Time Provenance Binding

We present the defense in five parts: the guiding principle of containment over detection, the mechanism and its two algorithms, the security invariant it enforces, the adversary model, and a proof sketch reducing security to the infeasibility of forging the HMAC.

Principle: contain, do not detect

A detector that tries to decide whether an image hides a payload must win against every present and future carrier and every stealth budget; it fails open on anything it did not anticipate. We instead assume that any output of a concealment-reversing tool is untrusted and contain it. The payload may decode perfectly; it still cannot drive a critical action.

Mechanism

Let D\mathcal{D} be the set of decode tools (those that reverse a concealment transform: stego extraction, metadata decode, Base64 decode, OCR) and C\mathcal{C} the set of critical tools (side-effecting sinks). All tool I/O is mediated by the MCP layer. When a tool tt returns payload pp from input bindings II, the layer mints a binding ℓ=(p,t,π,δ,σ)\ell= (p,t,\pi,\delta,\sigma) whose *dependency set δ\delta records the identifiers of II—resolved by the layer from the argument handles it issued, not from anything the agent asserts. The trust label is contagious,

τ=Untrusted iff t∈D or ∃i∈I:τi=Untrusted,\tau= \mathrm{Untrusted}\ \text{iff}\ t \in D\ \text{or}\ \exists i \in I : \tau_i = \mathrm{Untrusted},

π\pi records the provenance, and σ=HMAC⁡k(p∥t∥τ∥π∥δ)\sigma= \operatorname{HMAC}_k(p\Vert t\Vert\tau\Vert\pi\Vert\delta) signs the whole record with a layer-held key kk (Algorithm 1). The layer additionally keeps, per execution context, a taint set of the untrusted decode origins that have entered that context—its independent record of lineage that need not pass through a tool argument. A downstream agent that alters any field or drops σ\sigma fails verification; an agent cannot mint a binding, because the key is confined to the layer.

At a critical call the layer runs ENFORCECRITICAL (Algorithm 2). It does not consult a dependency set the agent supplies: it reconstructs lineage from its own ledger—the transitive trust of the resolved argument closure and the context taint set—and blocks if either is untrusted, if a binding fails HMAC verification, or if a binding references a dependency the ledger cannot resolve. A single data-only label on an argument therefore cannot authorize a call whose context carries an untrusted decode origin.

Concretely, the ledger is two structures the layer owns and the agents never touch: a binding store that maps each binding identifier to its signed record, and, per execution context, a taint set holding the identifiers of the untrusted decode origins that have entered that context. Agents hold only opaque handles—the identifiers—so the single value an agent can pass to a later call is a reference the layer resolves against the store it alone wrote; the agent can neither mint a binding (the key never leaves the layer) nor assert a dependency the store does not already record. This is the difference from a scheme that ships the trust label alongside the data and re-reads it at the sink: there, a compromised relay chooses which label arrives; here, the relay chooses only which handles it presents, and the trust decision is recomputed from the layer’s own record of what those handles depend on. Resolving a handle therefore reconstructs the same lineage the layer observed at mint time, independent of how the agent frames the call.

Inter-agent messages are mediated the same way. When an agent relays a tool result to an agent in another execution context, the message passes through the layer, which binds it to its source and propagates the taint to the destination context; an UNTRUSTED decode origin in one agent therefore taints the context of any agent it is mediated into. The one path this does not cover—an agent paraphrasing a decoded instruction into free text that leaves the mediated channel—is the scope boundary stated with the invariant and measured in Section VI.

Concretely, when extract_stego returns the decoded string pp, the layer stamps τ=Untrusted\tau= \mathrm{Untrusted} (since extract_stego ∈D\in D), signs the record, and hands the agent only the opaque handle id⁡(ℓ)\operatorname{id}(\ell). If that handle later reaches a critical call—or if the decoded text merely entered the context—the untrusted record is found in the closure or the context taint and the call is blocked. The two algorithms below formalize this mint-then-check pair.

Algorithm 1 both signs the label and records lineage in the layer’s ledger at decode time; the complementary check, Algorithm 2, runs when an agent later proposes a critical call and decides on the ledger rather than on an agent-presented binding.

The two algorithms are deliberately asymmetric in what they trust. MintBinding runs with full authority inside the tool boundary: it sees the real inputs, assigns the label, and is the only place a binding is ever created, so every record in the ledger is one the layer wrote itself. EnforceCritical runs where the agent is in control and therefore trusts nothing it is handed: it treats the presented handles purely as lookups, rebuilds the dependency closure from the ledger, and recomputes each HMAC before reading a label, so a tampered or fabricated field is rejected before it can influence the decision. The closure walk is what turns a single untrusted leaf into a blocked call no matter how many benign hops sit between them: a critical call inherits the trust of its weakest transitive input, and the context-taint check at the end catches an untrusted origin that reached the call through influence rather than through a named argument. Neither step inspects the payload text, so the decision is identical whatever the decoded instruction says.

The distinction that makes the guarantee sound is where lineage lives. EnforceCritical never consults a dependency set asserted by an agent; it reconstructs lineage from the layer’s ledger and context taint. Consequently a compromised agent cannot launder a critical call by attaching a legitimately signed Trusted binding from an unrelated benign tool while omitting the untrusted decode origin that actually drove the call: the omitted origin is still recorded in the context taint the layer maintains, so the call is blocked. We verify this directly in Section VI.

Security invariant

The mechanism provides two distinct guarantees, and it is their conjunction—not the HMAC alone—that is the contribution:

  • Data-provenance security. A critical action cannot be authorized using a forged or improperly relabeled data dependency (enforced by the signed binding).

  • Context-influence containment. A critical action cannot execute after an Untrusted instruction has influenced the relevant execution context without authorized clearance (enforced by the layer-maintained ledger and context taint).

Algorithm 1 MintBinding (in the MCP layer, at tool return)

Require: payload pp, tool tt, input bindings II, context cc, set D\mathcal{D}, key kk

1: δ←{id⁡(i):i∈I}\delta\leftarrow\{ \operatorname{id}(i) : i \in I \} {resolved by the layer} 2: if t∈Dt \in\mathcal{D} or ∃i∈I:τi=Untrusted\exists i \in I : \tau_i = \text{Untrusted} then 3: τ←Untrusted\tau\leftarrow\text{Untrusted} 4: else 5: τ←Trusted\tau\leftarrow\text{Trusted} 6: end if 7: π←decode:t\pi\leftarrow\text{decode}:t if t∈Dt \in\mathcal{D} else tool:t\text{tool}:t 8: m←canonical⁡(p,t,τ,π,δ)m \leftarrow\operatorname{canonical}(p,t,\tau,\pi,\delta) 9: σ←HMAC⁡k(m)\sigma\leftarrow\operatorname{HMAC}_k(m) 10: record ℓ=(p,t,τ,π,δ,σ)\ell= (p,t,\tau,\pi,\delta,\sigma) in ledger L\mathcal{L} 11: if τ=Untrusted\tau= \text{Untrusted} then 12: add id⁡(ℓ)\operatorname{id}(\ell) to the taint set of context cc 13: end if 14: return handle id⁡(ℓ)\operatorname{id}(\ell) to the agent

Algorithm 2 EnforceCritical (in the MCP layer, at a sink)

Require: tool gg, context cc, argument handles HH, ledger L\mathcal{L}, set C\mathcal{C}, key kk

1: if g∉Cg \notin\mathcal{C} then 2: return Allow 3: end if 4: resolve HH via L\mathcal{L}; let SS be their transitive dependency closure 5: for all ℓ=(p,t,τ,π,δ,σ)∈S\ell= (p,t,\tau,\pi,\delta,\sigma) \in S do 6: if σ≠HMAC⁡k(canonical⁡(p,t,τ,π,δ))\sigma\ne\operatorname{HMAC}_k(\operatorname{canonical}(p,t,\tau,\pi,\delta)) then 7: return Block {forged or stripped} 8: end if 9: if some d∈δd \in\delta is unresolved in L\mathcal{L} then 10: return Block {incomplete lineage} 11: end if 12: if τ=Untrusted\tau= \text{Untrusted} then 13: return Block {untrusted data lineage} 14: end if 15: end for 16: if taint⁡(c)∖promoted⁡(c)≠∅\operatorname{taint}(c) \setminus\operatorname{promoted}(c) \ne\varnothing then 17: return Block {untrusted context lineage} 18: end if 19: return Allow

Under the assumptions that (i) the signing key kk is confined to the MCP layer, (ii) every concealment-reversing tool is registered in D\mathcal{D}, (iii) the layer mediates every critical call, and (iv) within a fully mediated execution context the layer records the complete lineage of each invocation—its resolved argument dependencies and the decode origins entering the context, including across mediated inter-agent messages—the mechanism enforces:

In a fully mediated execution context, no critical tool call executes whose transitive lineage—data or context—includes an Untrusted decode origin, unless an audited trusted promotion cleared that specific origin.

The HMAC delivers data-provenance security: a relaying agent cannot promote Untrusted →\to Trusted, and a remote verifier in another domain can check trust from the signature alone. The ledger delivers context-influence containment: trust is decided on lineage the layer holds, not on a label an agent presents, which is what defeats valid-label substitution. The ablation in Section VI shows these two are necessary and non-interchangeable. Assumption (iv) is the mechanism’s load-bearing obligation and its honest boundary: influence that leaves the mediated path—a decoded instruction an agent paraphrases into free text delivered out of band—is not recorded, so the guarantee is scoped to fully mediated contexts and we measure the boundary directly (Section VI, Table V).

Channel from A to BB’s critical call
Mediated inter-agent message (in scope)block (taint propagated)
Unmediated side channel (outside the model)not covered

Table V. Cross-context propagation: an untrusted decode in Agent A reaches a critical call in Agent B’s context.

Adversary model

We model the adversary A\mathcal{A} as controlling all externally-supplied content and the behavior of every agent in the pipeline except the MCP layer and the verifier. Formally, A\mathcal{A} may (a) choose the carrier image and payload, (b) read any binding ℓ\ell in transit, (c) replace a binding with any value of its choice before it reaches the verifier, and (d) choose which handles to present at a critical call, including omitting or substituting them—this captures a compromised or injection-steered worker that relays, rewrites, fabricates, or selectively presents labels. A\mathcal{A} does not obtain the signing key kk, cannot execute code inside the MCP layer, cannot edit the layer’s ledger or context taint, and cannot bypass the verifier at the critical-tool boundary. These trusted components, the ledger, and kk are the trusted computing base. A\mathcal{A} wins if a critical tool g∈Cg \in\mathcal{C} executes whose true lineage includes an Untrusted decode origin with no audited promotion.

Proof sketch

Suppose A\mathcal{A} wins. By mediation (iii) the call passed EnforceCritical. Let oo be an Untrusted decode origin in the call’s true lineage, which exists because A\mathcal{A} wins. By (iv) oo was minted Untrusted (Algorithm 1) and recorded by the layer either in the resolved argument closure SS or in the context taint of cc. Three cases. (1) Data lineage: o∈So \in S. Then EnforceCritical recomputed oo’s HMAC, saw τ=Untrusted\tau= \text{Untrusted}, and blocked—a contradiction—unless A\mathcal{A} presented a variant o′o' with τ=Trusted\tau= \text{Trusted} that verifies under kk; but o′o' was never minted by the layer, an existential forgery against HMAC [41], with probability negligible in the key length. (2) Context lineage (valid-label substitution): oo is in taint(c)(c) and A\mathcal{A} attached only a benign Trusted binding as the argument. EnforceCritical still blocks on the nonempty context taint; evading this requires editing the layer’s ledger, excluded by (iv). (3) The decode tool is not in D\mathcal{D}: this violates (ii)—an unregistered decoder, not a defeat of the mechanism. Hence, with a complete decode set, a confined key, and layer-maintained lineage, A\mathcal{A}’s winning probability is negligible. The argument is information-flow, not content: it never inspects what pp says, which is why the guarantee is wording- and carrier-independent.

Evaluation

Our evaluation targets the security mechanism directly. The attack bank is a curated, adaptive set chosen to defeat text-channel defenses, and our experiments stress the assumptions on which the information-flow guarantee of § 5 rests—a complete decode set, a tamper-evident HMAC binding, boundary mediation, and layer-maintained lineage. On a real MCP testbed we ask: does the binding stop the attack where text-channel defenses do not (attack success by defense); does it resist valid-label substitution by a compromised agent; which of its four components are necessary (ablation); does it hold through the pre/post/defended lifecycle; does it survive relay tampering and multi-hop handoffs; what happens when the decode set is incomplete or over-broad; does it preserve legitimate-task utility; are the carriers imperceptible; and what does it cost?

Testbed

Agents are driven by Qwen/Qwen2.5-0.5B-Instruct locally; the security decision is made by the deterministic layer and does not depend on the model. The MCP server is a real FastMCP process accessed over stdio; decode tools mint bindings per Algorithm 1 and the layer maintains the ledger of § 5. The attack bank is 24 payloads—three carriers (LSB, DCT, metadata) ×\times eight evasions (plain, benign-worded, Base64, token-split, Cyrillic homoglyph, zero-width, Unicode-confusable, and HTML-comment wrapping)—designed to defeat keyword and regex matching. Each attack is delivered in an HTML signature email, decoded by Worker1_1 via a live MCP call, and the signed binding is relayed across peer hops before the verifier decides. We compare five configurations: undefended; a keyword/data-loss-prevention (DLP) content scanner; a regex intent parser; an in-process data-flow taint tracker—an information-flow baseline that labels decode output untrusted but carries no cross-domain cryptographic binding and trusts agent-presented labels; and our decode-time provenance binding. All tables and figures are reproduced by the released notebook.

Attack success by defense

Table II reports attack success rate (ASR) over the 24-payload bank. The undefended pipeline leaks on every attack. The keyword scanner and the regex parser each block only the payloads whose sensitive terms survive Unicode normalization (plain, HTML-comment, and some confusable variants) and fail on the benign-worded, Base64, token-split, homoglyph, and zero-width evasions—62.5% ASR each. The taint baseline and our mechanism both reach 0% within a single trust domain, because both treat decode output as untrusted at the source. We are explicit about what this baseline is: an unsigned, agent-mediated taint design—it trusts agent-presented labels and has no cross-domain cryptographic binding—not a state-of-the-art provenance system. The comparison therefore isolates the two design properties our mechanism adds (cryptographic authentication and layer-maintained lineage), not a claim to beat a specific published defense; where published systems sit on those two axes is summarized in Table I. The baseline and our mechanism diverge under adversarial relaying, isolated in the ablation and cross-context subsections below.

DefenseLeaksnnASR
Undefended (no checks)2424100%
Content scanner (keyword/DLP)152462.5%
Regex intent parser152462.5%
Data-flow taint (IFC baseline)0240%
Decode-time provenance (ours)0240%

Table II. Attack success rate by defense over 24 payloads (lower is better).

The two text-channel baselines inspect the decoded text, so each new wording or carrier reopens the gap; Unicode normalization recovers the plain, comment-wrapped, and confusable variants but not the homoglyph, zero-width, Base64, or token-split ones. Provenance binding does not read the payload at all—it blocks on lineage—so none of these evasions change its outcome. Figure 4 renders this as a step from full compromise down to zero that the lineage-based defenses reach; the distinction between the taint baseline and our mechanism is not ASR within one domain but tamper-resistance across an untrusted relay, isolated next.

ASR by defense over 24 payloads (lower is better)

Figure 4. Attack success rate by defense across the 24-payload bank.

Resisting valid-label substitution

We test the reviewer-critical case directly. A compromised orchestrator holds a legitimately signed Trusted binding from a benign read_config call and attaches it as the argument of export_secrets, while the decision to call the sink derives from an Untrusted extract_stego output that it omits from the presented lineage. A verifier that trusts the agent-supplied binding Allows the call. The layer-maintained check Blocks it: the omitted decode origin is still in the context taint the layer recorded, so trust is decided on lineage the agent does not control (Table III). A clean context, with no decode origin, still allows a legitimate critical call. This is the concrete difference between verifying a label and maintaining lineage—the distinction on which the central guarantee rests.

EnforcementDecision
Agent-supplied binding only (naive)allow (leaks)
Layer-maintained, dependency omittedblock
Layer-maintained, dependency in argumentsblock
Layer-maintained, clean contextallow

Table III. Valid-label substitution: enforcement that trusts the agent-supplied binding vs. layer-maintained lineage.

Component ablation

The mechanism has four components—decode marking, cryptographic authentication (the HMAC), trusted lineage tracking (the layer’s ledger and context taint), and sink mediation—and each defends a distinct attack. Table IV disables one component at a time in the full implementation and measures three attacks: the honest in-domain attack, valid-label substitution (in-domain), and a forged Trusted label carried across an untrusted relay to a remote verifier that holds only the presented binding (cross-domain). The full mechanism blocks all three. Removing marking leaks everything (nothing is flagged untrusted). Removing mediation leaks everything (no enforcement point). The two middle rows are the ones that disambiguate the design: removing the HMAC still blocks the in-domain attacks, because the ledger decides, but leaks the cross-domain forged relay, because a remote verifier without the ledger has only the signature to trust; removing lineage tracking (reverting to deciding on the agent-presented binding) still blocks forgery via the HMAC but leaks valid-label substitution, because a genuine Trusted binding from an unrelated tool passes an HMAC check. Cryptographic authentication and layer-maintained lineage are therefore both necessary and non-interchangeable: the HMAC alone does not stop substitution, and the ledger alone does not survive a cross-domain relay. The taint baseline of Table II corresponds to the “— cryptographic auth” row.

ConfigurationHonestSubstitutionForged relay
Full mechanismblockedblockedblocked
— decode markingLEAKLEAKLEAK
— cryptographic auth (HMAC)blockedblockedLEAK
— trusted lineage trackingblockedLEAKblocked
— sink mediationLEAKLEAKLEAK

Table IV. Four-component ablation: effect of disabling each component on three attacks (blocked vs. leak).

Cross-context influence propagation

A natural question is whether taint survives an inter-agent message boundary, not just a tool-return handle. It does: Table V shows Agent A decoding an untrusted instruction and handing it to Agent B in a separate execution context. When the message is carried on a mediated channel—through the layer, as assumptions (iii) and (iv) require of inter-agent communication—the layer binds it to its source and propagates the taint, so B’s critical call is blocked (UNTRUSTED CONTEXT LINEAGE). This is the result: context taint crosses every mediated boundary, agent-to-agent messages included. The second row marks the edge of the model rather than a result: a channel the layer does not mediate (A paraphrasing into free text on a side path) is outside assumptions (iii) and (iv) by construction—in a fully mediated deployment no such channel exists, and a deployment that leaves one unmediated has simply not placed the control on it. Cryptographic authenticity cannot stand in for a dependency that was never recorded, so the scope is stated plainly with the invariant: the guarantee is for fully mediated execution contexts. Extending capture into in-model paraphrase is discussed in § 9.

State transitions

Table VI walks one benign-worded payload through three system states. Pre-attack, the clean logo yields a normal summary and no critical call. Post-attack undefended, the payload decodes and the critical sink executes, leaking secrets. Post-attack defended, the payload decodes identically but the verifier blocks the sink; no secrets leave. The decoded instruction is present in the agent’s context in both post-attack rows—the defense does not try to keep it out—so the only difference between a breach and a safe run is whether the critical call is permitted to fire, which is precisely the boundary the binding governs.

StateCritical callSecrets leaked
Pre-attack (clean logo)noneno
Post-attack (undefended)export_secrets executedyes
Post-attack (defended)blockedno

Table 6. System state across clean, undefended, and defended runs.

Tamper-resistance across handoffs

Table 7 evaluates a malicious relaying agent. A genuine Untrusted binding is blocked at a critical sink; an attempt to forge a Trusted label or to strip the HMAC fails verification and is also blocked; a genuinely trusted origin (a non-decode tool such as authenticated user input) is allowed. The binding therefore survives relaying intact.

Relay actionVerifier decision
Genuine Untrusted labelblock
Forged Trusted labelblock (HMAC fails)
Stripped HMACblock (HMAC fails)
Honest Trusted originallow

Table 7. Verifier decision under relay tampering.

Carrier distortion

Table VIII reports peak signal-to-noise ratio (PSNR) and structural similarity (SSIM) between cover and stego logos. The metadata carrier is lossless (the pixels are unchanged); the LSB carrier is near-lossless (≈76\approx76 dB); the DCT carrier trades a lower PSNR (≈18\approx18 dB, SSIM ≈0.94\approx0.94) for robustness to the pixel round-trip. We stress that PSNR and SSIM bound pixel-level distortion and do not by themselves establish perceptual imperceptibility, particularly for the DCT carrier at ≈18\approx18 dB; we therefore treat these as distortion metrics, offer the amplified pixel-difference visualization (Figure 2) as the perceptual check, and leave a formal subjective study to future work. The security guarantee does not depend on imperceptibility: containment blocks the payload whether or not a human would notice the carrier.

Cover logo, stego logo, and amplified pixel difference

Figure 2. Cover logo, stego logo, and amplified pixel difference.

CarrierPSNR (dB)SSIM
LSBhigh (≈76\approx76)≈1.000\approx1.000
DCTmoderate (≈18\approx18)≈0.94\approx0.94
Metadatalossless (pixels unchanged)1.000

Table 8. Carrier distortion between cover and stego logos (distortion metrics, not a perceptual claim).

A defender nonetheless cannot rely on visual inspection or a perceptual-hash gate to catch the metadata and LSB carriers, which sit at or near the lossless ceiling; the DCT carrier is the one a perceptual gate might flag, which is why we do not claim it is imperceptible. Figure 5 renders the per-carrier PSNR and SSIM, with the lossless metadata bar capped so the axis stays readable.

Per-carrier distortion chart showing PSNR and SSIM for LSB, DCT, and EXIF

Figure 5. Per-carrier distortion (PSNR and SSIM).

Overhead

Table 9 reports the cost of the mechanism, measured on commodity hardware over 2×1042 \times10^{4} iterations after warm-up. Minting a binding and verifying it are pure HMAC-SHA256 operations over a short canonical string, each under 10 μs10\ \mu\mathrm{s}; their combined cost of ≈17 μs\approx17\ \mu\mathrm{s} is added once per critical call. For reference, a single decode tool call over the MCP stdio transport (warm session) takes a median of ≈11\approx11 ms, so the binding adds about 0.16% to a tool invocation and is negligible beside model inference, which is orders of magnitude larger. These figures are for the cryptographic operations; the full enforcement path, which also inserts into the ledger and traverses the dependency closure, is characterized separately below and is what a deployment should budget for.

OperationCost
MintBinding (HMAC sign)≈8.3 μs\approx8.3\ \mu\mathrm{s}
EnforceCritical (HMAC verify)≈8.7 μs\approx8.7\ \mu\mathrm{s}
Combined per critical call≈17 μs\approx17\ \mu\mathrm{s}
MCP decode round-trip (warm)≈11\approx11 ms
Added overhead vs. one decode call≈0.16%\approx0.16\%

Table 9. Mechanism overhead per operation.

The revised mechanism does more than sign: MintBinding inserts into the ledger and EnforceCritical walks the dependency closure and checks context taint. We therefore benchmark the complete path as these grow (Table X). Minting stays near 11 μs11\ \mu\mathrm{s} regardless of chain depth (ledger insertion is amortized O(1)O(1)). Enforcement is linear in the size of the dependency closure it traverses: ≈10 μs\approx10\ \mu\mathrm{s} at depth 1, rising to ≈0.68\approx0.68 ms at depth 100 and ≈6.6\approx6.6 ms at depth 1000—the last comparable to a single decode round-trip and reached only by pathologically deep lineage. It is effectively flat (≈6 μs\approx6\ \mu\mathrm{s}) in the number of concurrent tainted contexts, since the taint lookup is keyed by context. For realistic lineages (closure depth in the tens) the full path stays well under 0.1 ms.

Operation1101001000
\multicolumn{4}{c}{closure depth}
MintBinding (μ\mus)10.712.012.910.9
EnforceCritical (μ\mus)9.572.66806605
11001000
EnforceCritical vs. contexts (μ\mus)6.26.46.3

Table 10. Full enforcement-path cost vs. dependency-closure depth and number of concurrent tainted contexts.

Decode-set completeness

The security invariant assumes every concealment-reversing tool is registered in the decode set DD. Because this is the assumption a reviewer will press, we exercise it directly. Table XI reports three configurations against the same stego attack and a legitimate critical call. With the correct DD the attack is blocked and the legitimate call is allowed. If the attacker reaches the payload through a decoder that is missing from DD (e.g. an unregistered audio or document extractor), its output is minted Trusted and the attack leaks—the failure is an unregistered decoder, not a defeat of the mechanism. Conversely, an over-broad DD that labels a benign non-decode tool Untrusted falsely blocks a legitimate critical call. The set is thus the single knob that trades missed-decoder risk against false blocks, which is why we recommend it be a small, audited allow-list fixed at tool registration.

Decode set DDStego attackLegitimate critical call
Correctblockedallowed
Missing decoder (unregistered)leaksallowed
Over-broad (benign tool included)blockedfalse block

Table XI. Decode-set completeness: outcome vs. configuration.

Label integrity across handoffs

We next stress the binding under relaying. Table XII shows the verifier decision after honest relays and under a compromised worker. A genuine binding verifies and is correctly blocked after 1, 3, 5, and 10 honest hops—the label travels intact. A compromised worker that rewrites the decoded text, promotes the label to Trusted, or strips the binding entirely always fails verification and is blocked, because none of these can reproduce the server-held HMAC. This complements Table VII by showing integrity is preserved across depth, not just at a single hop.

Relay scenarioVerifier decision
Honest relay, 1 / 3 / 5 / 10 hopsverifies; critical call blocked
Compromised: rewrite payload, keep HMACblock (HMAC mismatch)
Compromised: forge Trusted labelblock (HMAC mismatch)
Compromised: strip bindingblock (no valid label)

Table XII. Label integrity across relay hops and under a compromised worker.

Legitimate-task utility

A containment control is only deployable if it does not block legitimate work. Table XIII reports three legitimate critical tasks, one of which—an authorized payment that uses an optical-character-recognition (OCR)’d invoice number—legitimately derives from a decode tool. Without the trusted-promotion path, that task is falsely blocked (67% completion, one false block), the expected cost of treating every decode origin as untrusted. With an audited promotion that re-labels the specific OCR’d value Trusted, all three tasks complete (100%, zero false blocks) while an unauthorized attack from the same decode origin remains blocked, because the attacker cannot invoke the promotion. Promotion is thus the deployable complement to containment: it restores utility at a controlled, logged point without reopening the vector.

RegimeCompletionFalse blocksAttack blocked
No promotion2/3 (67%)1yes
Trusted promotion3/3 (100%)0yes

Table XIII. Legitimate-task completion and false blocks, with and without the audited trusted-promotion path.

Realistic decode trigger

Section III assumes a worker invokes a decode step on a signature logo; a reviewer may reasonably ask why an ordinary summarizer would do so. We separate realistic preconditions from the controlled proof-of-concept. The metadata, Base64, and OCR carriers need no bespoke decoder: a summarizer that extracts text from an image (OCR) or parses embedded metadata to caption or describe an attachment surfaces these payloads as a side effect of normal multimodal handling, and contemporary agents routinely route images to exactly such tools. We model this in the testbed with a content-type router that dispatches an inline image to an image-analysis tool, which in turn invokes the registered extractor; the decoded text then enters the agent’s context. The LSB and DCT carriers are stronger-attacker variants that require a decoder matching the concealment scheme; we include them to stress the mechanism across the spatial and frequency branches, not as claims about default summarizer behavior. In every case the defense acts identically, because registration in DD—not the reason the tool ran—determines the label.

Deployment

The mechanism is a drop-in addition to an MCP server and its tool-call boundary; it requires no change to the agent model or the orchestration logic. Where it lives. MintBinding runs inside each tool handler at return time and writes to the layer’s ledger; EnforceCritical runs in the client’s tool-dispatch path immediately before a call executes and reads that ledger. Both are a few lines over a standard HMAC library plus an in-memory ledger keyed by execution context. The signing key kk is generated once per server process and never leaves it; bindings travel with tool results as an extra signed field, transparent to agents that do not inspect it, while the ledger and context taint stay inside the layer and are never exposed to agents.

Configuring DD and CC. The decode set DD enumerates tools that reverse a concealment transform (stego and metadata extractors, Base64 decoders, OCR); the critical set CC enumerates side-effecting sinks (secret export, outbound email, file write, payment). Both are short, server-authored allow/deny lists reviewed at tool registration—the same point at which a tool’s schema is already vetted—so no runtime classification is needed.

Trusted promotion. When a decoded artifact must legitimately drive an action (e.g. an OCR’d invoice number the operator asked to pay), an explicit, audited promotion step re-labels that specific value Trusted under human or policy authorization and records the clearance in the context ledger. The promotion is logged with the original binding, so the provenance trail is preserved. We implement and evaluate this path rather than leaving it as a proposal: it raises legitimate-task completion to 100% with no loss of protection (Table XIII).

Distributed enforcement. When tools span multiple hosts, verification uses either a shared key over a secured channel or a public-key signature in place of the HMAC; the algorithms are unchanged apart from the sign/verify primitive.

Design Trade-offs

Containment vs. detection. Binding contains rather than detects, so it is robust to unseen carriers and wording, but it cannot recover the benign information a decoded artifact might also carry: a legitimately hidden watermark read by a decode tool is labeled Untrusted like any other. Deployments that need such content must add an explicit, audited trusted-promotion path.

Scope of protection. The mechanism guards actions, not summary text. A laundered instruction can still corrupt the natural-language summary the agent returns; binding prevents it from reaching a critical tool, not from influencing prose. This bounds the defense to the excessive-agency and disclosure harms, which is the right scope for a tool-boundary control.

Decode-set completeness. Security rests on every concealment-reversing tool being registered in D\mathcal{D}. An unregistered decoder is a gap; conversely, over-broad registration (labeling non-decoding tools Untrusted) raises false blocks. The set is small and auditable in practice, but its maintenance is an operational cost.

Key management. Tamper-evidence depends on confining the HMAC key to the MCP layer. Distributing enforcement across hosts requires a shared-key or signature-verification deployment, trading simplicity for scalability.

Lineage capture. Soundness against valid-label substitution rests on the layer maintaining the complete lineage of each invocation (assumption iv): the resolved argument dependencies and the decode origins entering each context. This requires the layer to mediate tool I/O and keep a per-context ledger—more than a stateless signature check, though still far cheaper than inference. Its residual is influence the layer cannot observe: if decoded text leaves the mediated path entirely (e.g. an agent paraphrases it out of band into a context the ledger does not cover), context taint cannot record it. We therefore treat context taint as a conservative over-approximation that errs toward blocking, and note that completeness of lineage capture, not the cryptography, is the property a deployment must get right.

Granularity. We bind at message/tool-result granularity, not at token granularity inside model reasoning. This is simple and model-agnostic but cannot express partial trust within a single decoded blob.

Limitations

Our evaluation remains a controlled testbed: 24 payloads across three carriers and eight evasions, one cover logo, one small local model, and a keyword/regex scanner and an in-process taint tracker as baselines. This is broader than a single attack bank—it adds a label-substitution stress test, a four-component ablation, a legitimate-task evaluation, and an information-flow baseline—but it is still not a production-scale measurement: larger and more varied payload banks, multiple cover images and model families, a modern learned or provenance-aware detector as a baseline, and—most important for practical impact—a demonstration inside an existing production email-agent workflow rather than our controlled summarizer, all remain future work, and operational-stealth measurement frameworks [43] suggest one axis for that expansion. Our proof sketch reduces security to two properties: the infeasibility of forging the HMAC under key confinement, and the completeness of lineage capture by the layer (assumption iv). The former is standard; the latter is an implementation obligation, and we are explicit that the guarantee is scoped to fully mediated execution contexts. Within that scope, taint propagates across every mediated boundary, including inter-agent messages (Table V). A channel the layer does not mediate is outside the model by construction; the one substantive extension it points to is in-model influence—an agent paraphrasing a decoded instruction into its own output—which a mediated side channel would not capture and which tainting an agent’s output whenever its input context is tainted would address. We leave that, a fully machine-checked proof, and a formal treatment of lineage completeness to future work. Finally, the defense protects actions, not summary integrity: a laundered instruction it blocks at the sink can still skew the natural-language summary the agent returns. We bound this harm (no critical action executes) but do not eliminate it; quantifying the residual summary-corruption rate requires running the agent model and is a measurement the released notebook supports and that we leave to future work.

Conclusion

Provenance defenses for LLM agents have assumed that untrusted content arrives through a text channel, but a hidden instruction can ride into a multi-agent MCP pipeline inside a benign-looking email-signature logo, pass text content scanners that see only pixels, and become instructions only when a tool decodes it — at which point, in an undefended pipeline, it is laundered into the trusted control flow and drives a critical tool call; we characterized this cross-modal trust-laundering vector, proposed decode-time provenance binding in which the MCP layer mints a cryptographically signed untrusted label at the concealment-reversal boundary, and independently maintains the provenance lineage of each critical call, enforcing at the critical tool boundary that no call with untrusted lineage executes. We showed on a real MCP testbed with three carriers and 24 adaptive payloads that the mechanism reduces attack success from 100% (undefended) and 62.5% (keyword scanner and regex parser) to 0%, resists valid-label substitution by a compromised agent because trust is decided on layer-held lineage rather than an agent-presented label, survives label forgery and stripping across agent handoffs, and — via an audited trusted-promotion path — preserves 100% of legitimate-task completion; together these demonstrate that, within a fully mediated MCP execution environment, containment at the decode boundary backed by layer-maintained lineage — rather than detection of the carrier — is the property that holds, with all code and data released for reproduction.

References

References

  1. [1]Anthropic, “Model context protocol specification,” https://modelcontextprotocol.io, 2024, accessed 2026.
  2. [2]OWASP Foundation, “OWASP top 10 for large language model applications (LLM01:2025 prompt injection),” https://genai.owasp.org, 2025.
  3. [3]A. Vassilev, A. Oprea, A. Fordyce, and H. Anderson, “Adversarial machine learning: A taxonomy and terminology of attacks and mitigations,” National Institute of Standards and Technology, Tech. Rep. NIST AI 100-2e2025, 2025.
  4. [4]Forcepoint X-Labs, “HTML payload hijacks email summarizer via prompt injection,” https://www.forcepoint.com/blog/x-labs/html-payload-hijacks-email-summarizer, 2026.
  5. [5]Immersive Labs, “Weaponizing LLMs: Bypassing email security products via indirect prompt injection,” https://www.immersivelabs.com, 2026.
  6. [6]Proofpoint, “How threat actors weaponize AI assistants with indirect prompt injection,” https://www.proofpoint.com, 2026.
  7. [7]Y. Cai, W. Tang, C. Wen, and S. Qin, “Ghost in the agent: Redefining information flow tracking for LLM agents,” arXiv preprint arXiv:2604.23374, 2026.arxiv.org/abs/2604.23374
  8. [8]Y. She, Y. Liang, and E. Kang, “Safeguarding LLM agents from misalignment through provenance analysis,” arXiv preprint arXiv:2607.01236, 2026.DOI
  9. [9]S. Wang, S. Zhu, and R. Li, “Runtime policy enforcement for MCP-based LLM agents,” Electronics, vol. 15, no. 13, p. 2829, 2026.DOI
  10. [10]H. Dai, Z. Ying, W. Li, X. Wu, Y. Xiao, T. Zhang, J. Lin, L. Wei, G. Dong, X. Ling, X. Lin, Q. Zou, and X. Zhang, “SafeFlow: Semantic information-flow control for blocking malicious propagation in multi-agent systems,” arXiv preprint arXiv:2607.25255, 2026.arxiv.org/abs/2607.25255
  11. [11]P. Y. Zhong, S. Chen, R. Wang, M. McCall, B. L. Titzer, H. Miller, and P. B. Gibbons, “RTBAS: Defending LLM agents against prompt injection and privacy leakage,” arXiv preprint arXiv:2502.08966, 2025.
  12. [12]K. Greshake, S. Abdelnabi, S. Mishra, C. Endres, T. Holz, and M. Fritz, “Not what you’ve signed up for: Compromising real-world LLM-integrated applications with indirect prompt injection,” in Proc. ACM Workshop on Artificial Intelligence and Security (AIsec), 2023, arXiv:2302.12173.arxiv.org/abs/2302.12173
  13. [13]Y. Liu, Y. Jia, R. Geng, J. Jia, and N. Z. Gong, “Formalizing and benchmarking prompt injection attacks and defenses,” in Proc. USENIX Security Symposium, 2024, arXiv:2310.12815.arxiv.org/abs/2310.12815
  14. [14]F. Perez and I. Ribeiro, “Ignore previous prompt: Attack techniques for language models,” arXiv preprint arXiv:2211.09527, 2022.arxiv.org/abs/2211.09527
  15. [15]Q. Zhan, Z. Liang, Z. Ying, and D. Kang, “InjecAgent: Benchmarking indirect prompt injections in tool-integrated large language model agents,” in Findings of the Association for Computational Linguistics (ACL), 2024, arXiv:2403.02691.arxiv.org/abs/2403.02691
  16. [16]E. Debenedetti, J. Z. Shamoi, M. Balunović, L. Beurer-Kellner, M. Fischer, and F. Tramèr, “AgentDojo: A dynamic environment to evaluate prompt injection attacks and defenses for LLM agents,” in Advances in Neural Information Processing Systems (NeurIPS), 2024, arXiv:2406.13352.arxiv.org/abs/2406.13352
  17. [17]Y. Ruan, H. Dong, A. Wang, S. Pitis, Y. Zhou, J. Ba, Y. Dubois, C. J. Maddison, and T. Hashimoto, “Identifying the risks of LM agents with an LM-emulated sandbox,” in Proc. International Conference on Learning Representations (ICLR), 2024, arXiv:2309.15817.
  18. [18]S. Baluja, “Hiding images in plain sight: Deep steganography,” in Advances in Neural Information Processing Systems (NeurIPS), 2017.
  19. [19]J. Zhu, R. Kaplan, J. Johnson, and L. Fei-Fei, “HiDDeN: Hiding data with deep networks,” in Proc. European Conference on Computer Vision (ECCV), 2018, arXiv:1807.09937.arxiv.org/abs/1807.09937
  20. [20]I. J. Cox, M. L. Miller, J. A. Bloom, J. Fridrich, and T. Kalker, Digital Watermarking and Steganography, 2nd ed. Morgan Kaufmann, 2007.
  21. [21]C. Pathade, “Invisible injections: Exploiting vision-language models through steganographic prompt embedding,” arXiv preprint arXiv:2507.22304, 2026.arxiv.org/abs/2507.22304
  22. [22]M. Sinha and S. Chavan, “Hiding in plain floats: Steganographic carriers for indirect prompt and content injection,” arXiv preprint arXiv:2606.08403, 2026.arxiv.org/abs/2606.08403
  23. [23]Cloud Security Alliance, “Image-based prompt injection: Hijacking multimodal LLMs through visually embedded adversarial instructions,” CSA Research Note, Tech. Rep., 2026.
  24. [24]Z. Wang, H. Wang, C. Tian, and Y. Jin, “Implicit jailbreak attacks via cross-modal information concealment on vision-language models,” arXiv preprint arXiv:2505.16446, 2025.arxiv.org/abs/2505.16446
  25. [25]S. Li, J. Cheng, Y. Li, X. Jia, and D. Tao, “Odysseus: Jailbreaking commercial multimodal LLM-integrated systems via dual steganography,” arXiv preprint arXiv:2512.20168, 2026.arxiv.org/abs/2512.20168
  26. [26]X. Qi, K. Huang, A. Panda, P. Henderson, M. Wang, and P. Mittal, “Visual adversarial examples jailbreak aligned large language models,” in Proc. AAAI Conference on Artificial Intelligence, 2024, arXiv:2306.13213.arxiv.org/abs/2306.13213
  27. [27]Y. Gong, D. Ran, J. Liu, C. Wang, T. Cong, A. Wang, S. Duan, and X. Wang, “FigStep: Jailbreaking large vision-language models via typographic visual prompts,” in Proc. AAAI Conference on Artificial Intelligence, 2025, arXiv:2311.05608.arxiv.org/abs/2311.05608
  28. [28]K. Cabaj, L. Caviglione, W. Mazurczyk, S. Wendzel, A. Woodward, and S. Zander, “The new threats of information hiding: The road ahead,” IT Professional, vol. 20, no. 3, pp. 31–39, 2018, arXiv:1801.00694.arxiv.org/abs/1801.00694
  29. [29]National Security Agency, “Model context protocol (MCP): Security design considerations,” https://www.nsa.gov, NSA Cybersecurity Information Sheet, Tech. Rep., 2026.
  30. [30]H. Jing, H. Li, W. Hu, Q. Hu, H. Xu, T. Chu, P. Hu, and Y. Song, “MCIP: Protecting MCP safety via model contextual integrity protocol,” in Proc. Conference on Empirical Methods in Natural Language Processing (EMNLP), 2025, arXiv:2505.14590.arxiv.org/abs/2505.14590
  31. [31]Y. Wang, H. Du, G. Shi, J. Zhang, H. Cheng, Y. Yao, K. Guo, and X.-Y. Li, “MindGuard: Intrinsic decision inspection for securing LLM agents against metadata poisoning,” arXiv preprint arXiv:2508.20412, 2025.arxiv.org/abs/2508.20412
  32. [32]A. Sabelfeld and A. C. Myers, “Language-based information-flow security,” IEEE Journal on Selected Areas in Communications, vol. 21, no. 1, pp. 5–19, 2003.DOI
  33. [33]A. Kravchenko, V. Liventsev, I. Konstantinov, I. Ishakhanov, and M. Kukuy, “APPA: Recoverable information-flow control for real-world LLM agents,” arXiv preprint arXiv:2607.24625, 2026.arxiv.org/abs/2607.24625
  34. [34]C. Ouyang and R. Hou, “MemLineage: Lineage-guided enforcement for LLM agent memory,” arXiv preprint arXiv:2605.14421, 2026.arxiv.org/abs/2605.14421
  35. [35]E. Debenedetti, I. Shumailov, T. Fan, J. Hayes, N. Carlini, D. Fabian, C. Kern, C. Shi, A. Terzis, and F. Tramèr, “Defeating prompt injections by design,” arXiv preprint arXiv:2503.18813, 2025.arxiv.org/abs/2503.18813
  36. [36]K. Zhu, X. Yang, J. Wang, W. Guo, and W. Y. Wang, “MELON: Provable defense against indirect prompt injection attacks in AI agents,” in Proc. International Conference on Machine Learning (ICML), 2025, arXiv:2502.05174.arxiv.org/abs/2502.05174
  37. [37]S. M. A. Hossain, R. K. Shayoni, M. R. Ameen, A. Islam, M. F. Mridha, and J. Shin, “A multi-agent LLM defense pipeline against prompt injection attacks,” arXiv preprint arXiv:2509.14285, 2025.arxiv.org/abs/2509.14285
  38. [38]Y. Zeng, Y. Wu, X. Zhang, H. Wang, and Q. Wu, “AutoDefense: Multi-agent LLM defense against jailbreak attacks,” arXiv preprint arXiv:2403.04783, 2024.arxiv.org/abs/2403.04783
  39. [39]Y. Wang, J. Zhang, Z. Wu, T. Cai, Z. Liu, Q. Sun, Z. Sun, M. Dong, M. Zheng, X. Yin, and Y. Zhu, “From agent traces to trust: A survey of evidence tracing and execution provenance in LLM agents,” arXiv preprint arXiv:2606.04990, 2026.arxiv.org/abs/2606.04990
  40. [40]G. Shi, H. Du, Z. Wang, X. Liang, W. Liu, S. Bian, and Z. Guan, “SoK: Trust-authorization mismatch in LLM agent interactions,” arXiv preprint arXiv:2512.06914, 2026.arxiv.org/abs/2512.06914
  41. [41]H. Krawczyk, M. Bellare, and R. Canetti, “HMAC: Keyed-hashing for message authentication,” Internet Engineering Task Force, Tech. Rep. RFC 2104, 1997.DOI
  42. [42]OWASP Agentic Security Initiative, “OWASP top 10 for agentic applications (ASI01–ASI10),” https://genai.owasp.org, 2026.
  43. [43]A. Dawson and A. Wood, “StealthBench: Measuring operational stealth in autonomous offensive-security agents,” arXiv preprint arXiv:2607.26314, 2026.arxiv.org/abs/2607.26314

Paper details

vlnc:W_zgnreavj
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 4

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents