Key Takeaways
- Independent researcher Syed Anas Mohiuddin demonstrated the same class of vulnerability across AI agents at five unrelated organizations—Google, JP Morgan Chase, Weviate, Rapid7, France’s Interministerial Digital Directorate (DINUM), and the U.S. federal government
- The attacks are a variant of prompt injection that targets special-purpose agents (such as translation or data analysis) rather than the LLM itself, bypassing the LLM’s built-in guardrails
- MCP servers store credentials for each agent, and agents are designed to trust other agents on the same internal network by default, so malicious instructions injected through the first agent execute as-is in the second agent
MCP made inter-agent delegation convenient, but the implicit trust assumption that “internal agents are safe” has created a new attack surface. Unless two-decade-old defense principles like SSRF and injection prevention are reapplied at every hop boundary between agents, the structural weakness will persist.
Table of Contents
Independent researcher Syed Anas Mohiuddin sequentially demonstrated the same class of MCP vulnerability in AI agents at five largely unrelated organizations in September 2026. According to Ars Technica’s report, Google’s mcp-toolbox, JP Morgan Chase’s internal financial agent, Weviate, Rapid7, France’s DINUM, and U.S. federal government systems were all defenseless against the same attack pattern. This is not the result of a single product flaw, but reads as the consequence of missing trust boundaries inherent to the MCP (Model Context Protocol) architecture itself.
The Attack Targets the ‘Neighboring Agent,’ Not the LLM
Most existing discussions of agent security have focused on LLM guardrails. The vector Syed exploited, however, was different. Instead of directly bypassing the LLM through user input, malicious instructions flow in through the tool-call paths of special-purpose agents for translation, data analysis, or document summarization. The LLM simply receives and forwards a normal request like “translate this text,” but the internal MCP tool used by the translation agent automatically reuses another agent’s credentials, effectively escalating privileges legitimately.
Syed describes this process as follows: “When MCP re-delegates work via A2A (Agent-to-Agent) or ANP (Agent Network Protocol), authorization is effectively erased at every intermediate hop.” From the attacker’s perspective, only the first agent’s input needs to be poisoned. The remaining delegation chain operates under the belief that it is internal communication, so arbitrary code executes in the second and third agents. SSRF (Server-Side Request Forgery) filters are applied strictly to external user traffic, but requests originating from internal hops are left almost entirely open—and that is the essence of this attack.
The Same Wound in Five Places: Proof-of-Concept Cases
| Organization | Vulnerable Component | CVE/Severity | Patch Approach |
|---|---|---|---|
| googleapis/mcp-toolbox | CVSS 8.0 | Reject unsafe base URLs at bootstrap + IP range whitelist | |
| Rapid7 | Internal MCP gateway | CVE-2026-97228 (2.7) | Hotfix within one month |
| JP Morgan Chase | Financial data analysis agent | Undisclosed | Credential separation + short-lived token rotation |
| France’s DINUM | Public service agent | Undisclosed | Guardrails introduced for special-purpose agents |
| U.S. Federal Government | Document processing agent | Undisclosed | Mandatory logging of delegation chains |
As the table shows, Google’s case was the most technically urgent. mcp-toolbox did not apply a CheckRedirect policy when initializing the HTTP client, and after DNS resolution it did not verify whether the destination IP fell within private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) or the metadata endpoint (169.254.169.254). The attacker induced the translation agent to send an HTTP request to a host under their control; that request followed a redirect all the way to the IMDS path, enabling the exfiltration of cloud credentials. The patch was applied not at the first request point, but at the bootstrap stage to reject unsafe base URLs.
Why MCP Was Deployed with Zero Trust Effectively Abandoned
MCP stores each agent’s credentials on the MCP server side and is designed to trust other agents on the same internal network by default. From a convenience standpoint, this is a reasonable choice. In a multi-hop delegation graph, forcing OAuth token reissuance and authorization checks at every hop would collapse agent responsiveness by seconds at a time. Yet the accumulated debt from that choice has now surfaced in the form of this incident.
From the author’s hands-on experience operating agent infrastructure, the most dangerous point is the in-house consensus that “the MCP server is safe.” An MCP server is, by its nature, a credential vault. If even a single token stored in plaintext inside it is exposed, the privileges of every agent to which that token has been delegated leak at once. In a typical web application, tokens would be encrypted via HSM or AWS Secrets Manager and operated with short-lived tokens and scope restrictions, but in the rapid-prototyping phase of MCP implementations, in-memory plaintext storage is still common. The most frequently missed trap in practice is the tentative agreement that “because these are internal agents, it’s fine to keep credentials in plaintext.”
‘Protocol Pivot’ or Just a New Name for Indirect Prompt Injection?
Syed named this technique protocol pivoting. Markus Vervier of X41 D-Sec raised objections to the naming itself, saying it is “still merely a subclass of indirect prompt injection.” Douglas McKee of Rapid7 offered a more fundamental view: “Every value passed from the LLM to a tool should be treated as untrusted external input. The injection and SSRF defense principles that have not changed in 20 years are still valid.”
What matters more than the naming debate is the attack’s blast radius. A typical indirect prompt injection ends at the single hop where the LLM invokes a tool, but in an MCP environment that tool invocation wakes up another agent, which in turn uses different credentials to generate additional requests. A single input poisoning multiplies privilege expansion by the depth of the delegation graph. The structural question of who vouches for a protocol that has not yet been standardized is the essence of this incident, and the same boundary question underlies the backdrop against which Google has begun reconsidering how it runs its OSS bug bounty program.
Defense Lines You Can Apply Tomorrow
Implementing perfect hop-by-hop authorization requires a full organizational redesign. However, the following four measures alone can block most of this class of MCP vulnerability.
First, add an explicit CheckRedirect policy and post-DNS IP verification to every HTTP client used by MCP servers. In a Go-based implementation, the CheckRedirect callback of net/http.Client should return an error after calling resp.Body.Close(), and if net.LookupIP results include private ranges, link-local addresses, or 169.254.169.254, block the request immediately. If you internalize this as a standard library, you can add a Semgrep rule to automatically detect the http.Client{CheckRedirect: nil} pattern. In Python, it is safer to wrap requests.Session with max_redirects=0 and to verify the host via urlparse at every hop.
Second, verify at bootstrap time. As in the mcp-toolbox patch, reject unsafe hosts not at the first request, but at the moment the base URL is determined. In a Kubernetes environment, configure a ValidatingAdmissionPolicy that checks whether the BASE_URL among the env variables of an MCP server Deployment points only to public IP ranges. Reject any appearance of https://169.254.169.254 or private CIDRs, and enforce this organization-wide via an OPA/Gatekeeper ConstraintTemplate.
Third, separate credentials from the MCP server. Issue short-lived tokens with 5-minute rotations using Vault’s Kubernetes auth method or an AWS Secrets Manager + IRSA (IAM Roles for Service Accounts) combination, and have the MCP server load tokens into memory only at boot without persisting them to disk or environment variables. Configure a Falco rule that triggers an immediate alert when a syscall event such as read_sensitive_file_untrusted occurs in the MCP process context.
Fourth, write SIEM rules to detect anomalous patterns in the delegation graph. If a data analysis agent suddenly generates HTTP requests to external hosts, or if a delegation chain exceeds a hop depth of 3 and surpasses 2σ above baseline traffic, Splunk/Elastic rules should block it. This can be combined with Envoy’s RBAC filter or Istio AuthorizationPolicy to re-verify the caller identity at every inter-agent hop boundary.
Implications: The Debt Created by a Pre-Standardization Protocol
MCP appears to have been deployed across enterprise and government infrastructure before being sufficiently tested and hardened. The investment flow accelerating the shift toward agent swarms creates pressure to defer security to “later,” and as successor protocols such as A2A and ANP emerge, delegation graphs are growing more complex. Unless trust propagation rules are agreed upon at the specification stage for compatibility reasons, the same debt will repeat in the next protocol.
Cases from other domains share the same thread. As in the case where a single point of failure in an identity system is the product of accumulated debt, MCP’s trust boundaries will continue to carry the same debt unless they are redesigned at every hop. Reapplying the 20-year-old injection and SSRF defense principles as-is to inter-agent hop boundaries—that is the smallest unit of solution this incident demands of us. As long as the standardization race outpaces security hardening, vulnerabilities of this class are likely to keep being reported on a quarterly basis.
Frequently Asked Questions
Where should I start when separating credentials from an MCP server?
Issue short-lived tokens via Vault’s Kubernetes auth method or an AWS Secrets Manager + IRSA combination, and set the token TTL to 5 minutes or less. Load secrets into memory only at MCP server boot, and prohibit permanent storage to disk or environment variables by policy. Monitoring read_sensitive_file_untrusted events in the MCP process context with Falco can enforce the separation.
What immediate-impact measure can I take without redesigning the entire existing agent delegation graph?
The most immediate step is adding a CheckRedirect policy and private-IP/IMDS range blocking to your HTTP client. A single Semgrep rule can be applied across the entire repository, and a ValidatingAdmissionPolicy that validates the MCP Deployment’s base URL at bootstrap time will stop leaks from new deployments onward.
How do I break the in-house consensus that “MCP is on the internal network, so it’s safe”?
The most effective approach is to reproduce the IMDS exfiltration scenario from the Google case within your own environment as a PoC. Submit a penetration test report that documents who is responsible for blocking SSRF the moment it crosses an internal network boundary, and quantify the cost-versus-risk trade-off of hop-by-hop authorization for the CISO layer. This flow is typically the shortest path to breaking the consensus.
Source
This article was written after verifying the following original source: Ars Technica — MCP for agent-to-agent comms may be the riskiest protocol you’ve never heard of
Leave a Reply