Signed MCP tools can still leak: what the germline execution paper shows
A November paper shows a signed MCP tool leaking data to a destination its policy allows. Why signatures and egress allowlists miss it, and what to add.
A signature on an MCP server tells you who published it. It does not tell you what the code does with the data your agent hands it. A paper published on arXiv on 4 November 2026, Signed, Sealed, Leaked, turns that well-known caveat into a measured result: a signed tool that does its advertised job, passes signature checks and runs under a strict egress policy, yet still leaks confidential items by tucking them into requests to a destination it is allowed to reach. For teams building their MCP security around signed releases and network allowlists, it marks where those controls stop.
What the researchers tested
The authors, from Universiti Tunku Abdul Rahman and other institutions in Malaysia, Saudi Arabia and Singapore, built a testbed of five MCP servers (documents, SQL, web, lint and mail). Each ships a clean release 1.0.0 and signed updates with hidden code, 59 signed releases in all, every one of which verifies against the pinned key and completes its advertised function. The test data is one user's home directory with PDFs labelled HR, board, finance and public, two databases, a code repository, mail drafts and credential files, each carrying a random marker so any leak can be detected.
They then compared runtimes that bind trust to different things: signature and key pinning alone, per-call output labels in the style of published agent information-flow control systems, confinement with filesystem and egress allowlists, a fresh process per call, and their own design.
The central result: the allowed destination is the leak
The headline comparison uses MCPGuard-Dynamic, which the paper describes as Meta's open-source, kernel-level runtime defence for MCP tool calls. With least-privilege policies for a six-call session over HR, board, finance and public items, its egress control worked as designed: a raw-socket transfer to an unlisted host was blocked in every trial.
But a signed release of an OCR tool, which the authors call pool, kept items from earlier calls and disclosed them inside its next request to the authorised OCR destination. That happened in 3 of 3 trials under all seven MCPGuard configurations. The authors are careful to say this is not an implementation flaw in MCPGuard: it decides where a process may send data, and the content of a request to an allowed host is outside its design.
The same boundary showed up at scale. Using a locally run model, they generated 91 validated malicious variants of one signed tool. An egress allowlist of this kind stopped all 71 that sent to an attacker-owned host and none of the 20 that sent to a policy-allowed host.
Across the scripted matrix of 153 attack runs, the share of runs with a detected leak ranged from 74.5% to 5.9% across the baseline runtimes and a cut-down version of the authors' design, against none detected under the full design. The authors note that every zero is scoped to their corpus and their leak detector.
What germline execution does
The proposed mechanism, germline execution, does not try to inspect or trust the tool's code. Each tool call runs in short-lived copies forked from a "data-free" starting process, and each copy receives only the data authorised for the destination it talks to. If malicious code runs, it can only disclose what its copy holds. State that a tool legitimately needs across calls passes through a broker, and state kept only in process memory does not carry over.
The authors report 10 to 49 milliseconds per single-copy call, which they put at 2 to 28 times faster than restarting the tool for every call. They also state the limits plainly:
- Remote tools that you don't host cannot be forked, so they get only coarser protection.
- Timing and hardware side channels are out of scope.
- Harmful actions without data, such as a delete command, need separate action controls.
- Labels and clearances have to be written by someone, which is the main policy burden.
This is a research prototype with formal guarantees under stated assumptions, not a product you can switch on. Its value for most teams is the threat model.
What it means for engineering and security leaders
Most MCP hardening advice focuses on three things: where a server came from, what it can reach, and what its tool descriptions say. The MCP security best practices recommend running local servers in a sandbox with minimal default privileges and restricted access to the filesystem and network. The OWASP Secure Coding with AI cheat sheet adds pinning tool definitions and detecting changes after approval. All of that remains correct. The paper's point is that these controls answer "who published this?" and "where can it connect?", but not "which data does each call carry?"
In practice, the most dangerous case is a tool with a legitimate need to send data out: an OCR service, a translation API, a ticketing integration, an analytics endpoint. Its destination will be on every allowlist. If the same process sees sensitive data in one call and talks to that destination in the next, signatures and network policy cannot tell a normal request from one carrying extra items.
That shifts some attention to data scoping. Which data reaches which tool, whether tools that talk to outside services ever see confidential material, and whether a long-running server process accumulates data across calls and users are questions that can be answered today, without new research.
Practical takeaways
- Map tools with outbound destinations. For each MCP server, note whether it sends data to a third party as part of its normal job. Those are the ones where an allowlist does not limit disclosure.
- Keep confidential data away from those tools. Don't let the same agent session hand HR, legal or board material to a tool that posts to an external service.
- Prefer per-call or per-user processes for servers that handle sensitive data, so state from one call or person does not sit in memory for the next.
- Keep the basics. Pin versions, review updates, sandbox local servers and restrict egress; the paper shows those stop the direct variants.
- Redact before the tool sees it. Removing secrets and personal data from arguments limits what any tool, honest or not, can pass on.
SpanDock's MCP gateway, on the Premium and Enterprise plans, puts these decisions on your server rather than on each computer. Every connector starts read-only for everyone, access can be allowed or denied per tool by name for a person, group or user type, and secrets (on by default), email addresses, phone numbers and card numbers can be redacted in arguments before they reach the connector. It does not inspect a connector's code, so the data scoping above still applies. For a related research result on tools that change after approval, see our article on the tool update gap.