Signed, Sealed, Leaked: Trust Beyond Signature for MCP Toolchains

arXiv:2611.06585 · cs.CR, cs.AI, cs.MA · Submitted 2026-11-04 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: I'm Nadia.

Elias: And I'm Elias, here with Priya.

Nadia: We're looking at the paper: "Signed, Sealed, Leaked".

Elias: Here's the gist of the paper. AI agents frequently rely on third-party tools, such as Model Context Protocol (MCP) servers, introducing a trust failure where a legitimate signature does not guarantee benign behavior; a signed tool might conceal malicious code that leaks confidential information to policy-allowed destinations.

Nadia: The paper addresses this by introducing germline execution, which limits information disclosure without requiring inspection or trust in the tool implementations.

Elias: Each tool invocation runs in an ephemeral copy forked from a data-free germline process, receiving only data authorized for its destination.

Nadia: This mechanism proves sink noninterference for every signed release under explicit assumptions on copy confinement and a data-free germline, demonstrating that even malicious code execution is bounded by the data available to its specific copy.

Title and authors: Nadia: Let's talk about the title and who wrote this paper, "Signed, Sealed, Leaked: Trust Beyond Signature for MCP Toolchains." It’s a pretty direct title that signals we need to look past just checking the digital signature on something.

Elias: The authors are Aun Yichiet, Mohammed Alhartomi, Tan Jing Jie, Waqas Nadeem, Adeb Salh, Shankar Karuppayah, and Tan Sin Chee. They bring different expertise to this problem of agent toolchains and security policies.

Priya: From a privacy perspective, I’m interested in how this relates to the data flow control they are discussing; it sounds like they are trying to get granular about where information goes.

Nadia: Right, and what I find interesting is how they set up their initial scenario using Meta's MCPGuard-Dynamic as an example. They show that even a state-of-the-art defense mechanism can fail when facing this kind of subtle data leakage through a signed tool.

Elias: They use the comparison table in page two to show how different configurations, including their own release and others, behave under attack scenarios like smuggling or laundering text <ref:2611.06585#pg2>. The results show that the germline execution variant prevents disclosure in three out of three trials for some specific configurations.

Priya: That's interesting because it shows that even if a tool is signed and subject to runtime defense policies, there are still paths for data to leak if the mechanism isn't designed carefully.

Nadia: Precisely, and what this paper does is introduce germline execution as a solution that limits disclosure without needing to inspect or trust the underlying implementation of those third-party tools at all.

Elias: So, they're shifting the security focus from trusting the tool itself to controlling the data boundaries around each individual call. That’s a big conceptual move for how we think about agent security.

The paper's summary: Nadia: The summary of "Signed, Sealed, Leaked: Trust Beyond Signature for MCP Toolchains" boils down to this: AI agents use third-party tools that have signatures, but those signatures don't guarantee the tool won't leak data to a destination it shouldn't.

Elias: They demonstrate this failure with a signed tool that purposefully sends sensitive data out to an allowed location, and they show how existing defenses like MCPGuard-Dynamic can miss this in every trial.

Priya: It highlights that the problem isn't just about unauthorized access; it’s about a signed tool doing exactly what it was *supposed* to do in a way that violates the intended data flow policy.

Nadia: Germline execution is their answer: every single tool invocation runs in a fresh, isolated copy forked from a clean, data-free germline process. This copy only receives the exact pieces of information needed for its specific destination.

Elias: The key result they prove is sink noninterference for every signed release under the stated assumptions about this copy confinement and that initial data-free germline. It means if you use this mechanism, even malicious code execution is bounded by the data available to that specific copy.

Priya: So, if a tool tries to leak something, it’s like having a tiny sandbox for every single action it takes, and that sandbox only has what it needs for that exact moment.

Nadia: That's right; they are tying verified flow violations directly to the exact release at three milliseconds per single-copy call, which is incredibly fast performance-wise. They show this mechanism enforces obligations like germline holding no user data and models dampening policies after BGP route flaps.

The paper's improvements: Elias: One of the most important conceptual improvements they make is identifying invocation purity as the assumption that separates two different ways of labeling output and reading destination confinement.

Nadia: That separation is what lets them tackle both per-call output labeling and item-level readings of destination-based confinement at once, which was a challenge before.

Priya: From my side, I wonder how they managed to define this purity in a way that holds up when you're dealing with complex agent interactions involving multiple tools and destinations.

Elias: They use something called Plan to manage consumers and destinations by view, splitting any group if their final destinations differ in clearance. This ensures that every reply received by a copy is cleared for all members of its group, which is crucial for maintaining data isolation across calls.

Nadia: So Plan acts like a traffic controller, grouping things together but splitting the flow whenever the required permissions for where the data goes are different between those groups.

Elias: And they show how a verified witness can expose these releases where requests diverge, which is a way to prove that a policy violation actually happened in the system.

Priya: That verification step seems very strong because it moves beyond just saying "this is safe" and gives us concrete evidence of where the flow went wrong.

Conclusion: Nadia: So, to wrap up, this paper introduces germline execution as a way to limit information disclosure by bounding what each tool invocation can send based only on what its destination allows it to see.

Elias: They successfully prove sink noninterference for every signed release under their stated assumptions about the data-free germline and copy confinement, showing that data isolation protects agent toolchains against concealed malicious code.

Priya: It seems like the big implication is that signatures are not a complete security guarantee; you still need mechanisms like this to control the actual runtime behavior of the software.

Nadia: Exactly, and their prototype results show this works on unmodified Python MCP servers, detecting no canary disclosure across one hundred fifty-three attack runs, with some performance being five point nine to seventy-four point five percent slower than baselines depending on what you're measuring.

Elias: The final message is that a signature only tells you who published the tool and the policy only specifies where it can connect; neither of those things guarantees which data each call carries. Germline execution runs calls in copies forked from a data-free germline, providing sink noninterference for every signed release under stated assumptions.

Priya: I just want to say that seeing that performance figure, even with the overhead of germline execution, shows it's practical enough for real-world agent workflows to consider.

Nadia: It is a practical step forward because it provides verifiable evidence of flow violations tied directly to the exact release time, which is useful for debugging these kinds of issues.

Elias: So, we’re moving from trusting the seal to controlling the execution environment itself with mechanisms like germline execution and Plan. That’s what this paper on "Signed, Sealed, Leaked: Trust Beyond Signature for MCP Toolchains" shows us today.

Aun Yichiet, Mohammed A. Alhartomi, Tan Jing Jie, Waqas Nadeem, Adeb Salh, Shankar Karuppayah, Tan Sin Chee

Universiti Tunku Abdul Rahman University of Tabuk National University of Singapore Bitranger Universiti Sains Malaysia ABLEs

cs.CR, cs.AI, cs.MA

Submitted: 2026-11-04

Updated: 2026-11-04

Comments: 24 pages, 5 figures, 15 tables

Code: https://github.com/facebook/mcpguard-dynamic

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 100/100

The gist: AI agents frequently rely on third-party tools, such as Model Context Protocol (MCP) servers, introducing a trust failure where a legitimate signature does not guarantee benign behavior…

Key concepts

Germline Execution
Tool calls run in temporary copies forked from a data-free germline process. This limits information disclosure because what a specific tool invocation can reveal is strictly bounded by the data available to its unique copy, preventing cross-call state leakage.
Sink Noninterference
This property is proven for every signed release. It means that when a tool requests data from a destination, it only depends on the data that destination can see in the current call, its stored state up to a certain horizon, admissible replies, and public inputs.
Invocation Purity
This is the key assumption separating two failure modes: per-call output labeling and item-level readings of destination confinement. It enforces an invariant where a request to a destination depends only on data the destination can see in the current call, its horizon state, replies it may receive, and public inputs.
Plan Mechanism
This mechanism groups consumers and declared destinations based on their 'view.' It splits any group if their destinations have different clearance levels. This ensures that every reply received by a copy is cleared for all members of its group.

Terminology

Summary

AI agents frequently rely on third-party tools, such as Model Context Protocol (MCP) servers, introducing a trust failure where a legitimate signature does not guarantee benign behavior; a signed tool might conceal malicious code that leaks confidential information to policy-allowed destinations. p. 0 The paper addresses this by introducing germline execution, which limits information disclosure without requiring inspection or trust in the tool implementations. p. 0 Each tool invocation runs in an ephemeral copy forked from a data-free germline process, receiving only data authorized for its destination. p. 0 This mechanism proves sink noninterference for every signed release under explicit assumptions on copy confinement and a data-free germline, demonstrating that even malicious code execution is bounded by the data available to its specific copy. p. 0

The core contribution is identifying invocation purity as the assumption underpinning both per-call output labeling and item-level readings of destination-based confinement, thereby separating two distinct failure modes. p. 1 Germline execution enforces an invariant: a request to a destination depends only on data that destination may see in the current call, state kept for its clearance horizon, replies it may receive, and public inputs. p. 1 The mechanism relies on Plan, which groups consumers and declared destinations by view, splitting any group whose destinations differ in clearance. This ensures every reply received by a copy is cleared for all members of its group. p. 3 A verified witness can expose releases where requests diverge, proving a flow violation. p. 0

The authors' contributions include:

  • The Gap: Identifying invocation purity as the assumption separating per-call output labeling and item-level readings of destination-based confinement, and demonstrating this separation against MCPGuard-Dynamic.

  • Germline Execution Guarantees: Proving sink noninterference for every signed release under stated assumptions, showing that data-isolated execution protects agent toolchains against malicious code concealed within authenticated software.

  • Prototype and Evaluation: Implementing GERMLINE on unmodified Python MCP servers and answering five research questions. The prototype demonstrates that data-isolated execution protects agent toolchains against malicious code concealed within authenticated software, with no canary disclosure detected across 153 attack runs (baselines and an ablation: 5. p. 09–74.5%). Single-copy calls complete in 10–49 ms, significantly faster than restarting the tool for every invocation. p. 0

The key mechanism involves Plan to manage groups and splits based on destination clearance differences, ensuring reply clearance across group members. p. 3 The results confirm that MCPGuard confines destinations as designed, while germline execution binds authority to the items each copy may see. p. 8 The final conclusion is that a signature only identifies the publisher and a confinement policy only specifies where it may connect; neither guarantees which data each call carries. p. 4 Germline execution runs calls in copies forked from a data-free germline, providing sink noninterference for every signed release under stated assumptions, tying verified flow violations to the exact release at 10–49 ms per single-copy call. p. 0 The prototype enforces obligations O1–O5 (e. p. 6g., germline holding no user data), and the dampening policy is modeled on BGP route-flap damping. p. 1

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Germline execution limits information disclosure by ensuring what it can disclose is bounded by the data available to its copy, as each tool invocation runs in ephemeral copies forked from a data-free germline process.

  2. Sink noninterference is proven for every signed release, meaning a request to destination d depends only on d’s cleared current items, d’s horizon state, admissible replies and public inputs.

  3. The system can prevent cross-call state leakage by using germline execution, where nothing an execution acquires flows back to the process from which later executions start.

  4. The AI system can maintain data isolation across calls by ensuring that a request to destination d depends only on d’s cleared current items, d’s horizon state, admissible replies and public inputs through the mechanism of Plan.

  5. The system can provide verifiable evidence of flow violations using verified witnesses, where a verified witness establishes a flow violation for tools deterministic within the replay model.

  6. It can achieve high performance by reducing overhead with germline execution, as Invocations served by a single copy completed in 10–49 ms, 2–28× faster than restarting the tool for every invocation.

Sources

Related papers