WalledAI enterprise logo
Back to blog
AI Agent SecurityOctober 6, 20266 min read

How Did MCP Vulnerability Let Attackers Pivot Across AI Agents?

A class of SSRF and trust-boundary flaws in the Model Context Protocol allowed malicious instructions to pivot across AI agents at Google, JPMorgan and government agencies. CISOs must treat every agent-to-agent handoff as an untrusted boundary.

WA

Walled AI Research Team

On this page›

The MCP vulnerability is not a single CVE but a recurring class of implementation flaws that lets attackers bounce malicious instructions from one AI agent to another through trusted connections. Independent researcher Syed Anas Mohiuddin demonstrated that weak trust boundaries and server-side request forgery in Model Context Protocol deployments at Google, JPMorgan Chase and government agencies could be chained into cross-agent attacks he calls protocol pivoting. Because the protocol has grown to roughly half a billion Tier-1 SDK downloads per month, these implementation gaps create systemic rather than isolated risk that demands enterprise attention.

What happened in the MCP protocol pivoting findings?

Ars Technica reported that Mohiuddin tested AI-agent deployments associated with Google, JPMorgan Chase, Weaviate, Rapid7, France's interministerial digital directorate and U.S. government systems. The common weakness was excessive trust between agents and MCP-mediated tools. Rather than exploiting one universal code defect, Mohiuddin showed how malicious content could reach an initial agent through indirect prompt injection and then be passed as an apparently legitimate delegated task to a second agent that trusted the first. He calls this cross-protocol technique protocol pivoting: an attacker enters through one protocol, exploits trust assumptions between protocols, and reaches capabilities available through another that would otherwise be unreachable.

The Next Web consolidated the individual disclosures and revealed the systemic technical pattern. An MCP server often accepts a URL, path or endpoint supplied by an agent and makes an outbound request without adequately validating where the destination resolves. At JPMorgan Chase, a documentation-search MCP server had one function protected by a domain allowlist while a sibling function fetched caller-supplied URLs without equivalent restrictions. The city government of Tangerang, Indonesia ran a Wazuh MCP server whose SSRF protection rejected literal IP addresses but did not resolve hostnames, leaving a DNS-based bypass. France's DINUM hardened its open-data MCP server after a URL-fetching path could potentially reach internal or cloud-metadata addresses. At the time of reporting, five U.S. federal MCP servers, including a Veterans Affairs claims-related server, still had open findings.

Google's MCP Toolbox issue, tracked as CVE-2026-14540 and rated CVSS 8.0 by NIST, was a conventional SSRF delivered through an AI context. The HTTP client lacked a restrictive CheckRedirect policy and did not validate destination IP addresses, meaning a malicious path parameter or data-driven prompt could cause the toolbox to make unauthorized requests to internal endpoints. Rapid7's CVE-2026-97228 was lower severity at 2.7 and involved GraphQL injection in its Bulk Export MCP server; Rapid7 fixed it in September. Weaviate disclosed a high-severity credential-disclosure issue in which an unvalidated apiEndpoint could redirect an outbound request to an arbitrary host while attaching the operator's Google OAuth token. Where Google Cloud authentication was enabled, the leaked credential could be a live OAuth token scoped to cloud-platform, potentially granting broad access to Google Cloud APIs. Weaviate has stated it has no indication the issue was exploited.

It is important to stress that these were proof-of-concept vulnerabilities and patched findings. There is no evidence that attackers successfully compromised Google, JPMorgan, Weaviate or the named government bodies in the real world. The systemic finding is that unrelated organizations repeatedly made similar mistakes.

Why does this matter for enterprise AI governance?

The National Security Agency's Artificial Intelligence Security Center warned about these risks months before the October disclosures. In a May 2026 guidance document, the NSA identified serialization risks, trust boundaries and agent misuse as significant concerns and noted that dynamic tool invocation, implicit trust relationships and context sharing create novel risks that traditional cybersecurity controls do not fully address. The agency stressed that these problems are not isolated issues that can be patched at the interface or endpoint level; organizations should treat the agentic environment as a continuum. The NSA specifically highlighted that MCP adoption had accelerated across business, finance, legal and software development environments, including systems handling personally identifiable information.

Rapid7 vulnerability-intelligence director Douglas McKee summarized the architectural problem bluntly: AI agents give attackers a fresh set of connections to walk across. The MCP project's own security guidance now explicitly discusses SSRF and the confused-deputy problem, warning that MCP servers must not accept or forward tokens that were not explicitly issued for them. With the protocol's TypeScript and Python SDKs each exceeding one billion cumulative downloads according to the July 2026 specification, a recurring implementation weakness is no longer a niche concern. It is infrastructure risk.

Perhaps most importantly, the Weaviate finding shows that the danger is not simply an agent executing an unwanted HTTP request. MCP-connected components can accidentally turn AI-controlled input into credential exfiltration, granting access to broad cloud API scopes. For governance teams, this means AI supply-chain risk now overlaps directly with identity and access management. Security teams should also review whether their AI data loss prevention strategy covers agent-to-agent token movement, not just human-to-AI prompts.

What are the practical controls for CISOs?

The immediate imperative is to inventory every AI agent-to-agent connection and enforce independent authorization at each handoff rather than trusting instructions simply because they originated inside the enterprise. CISOs should apply the following measures based on the disclosed findings.

  • Validate every destination. MCP servers must not accept URLs, paths or endpoints from an agent without resolving and validating the destination. Google's flaw stemmed from a missing CheckRedirect policy and absent target-IP validation. Implement strict allowlists and verify that resolved IPs are not inside private ranges or cloud metadata addresses.
  • Close hostname bypasses. SSRF filters that block literal IPs but fail to resolve hostnames are trivially bypassed via DNS, as seen in Tangerang's deployment. Resolve names before enforcement and reject internal addresses regardless of how they are supplied.
  • Narrow credential scope. Weaviate's leak was worsened by broad cloud-platform permissions. Service accounts tied to MCP tools should have the minimum necessary scope, and endpoints should be restricted to known-good hosts. OAuth tokens should be bound to specific audiences and issuers.
  • Adopt specification-level hardening. The July 2026 MCP specification requires clients to validate authorization-server issuer information and bind credentials to the issuer that minted them. It also made MCP easier to place behind gateways, WAFs and rate limiters because method and tool information now travels in HTTP headers. Organizations should upgrade to current SDKs, enable issuer validation and use these gateway-friendly features to inspect agent traffic.
  • Govern user-facing AI channels. Organizations should also monitor where employee-facing AI tools can send data. Platforms like Walled AI that govern employee AI use across browsers, desktop apps and APIs can complement these network-layer controls by preventing unauthorized agent invocations.

Internal audit and GRC teams should map these controls to their AI governance frameworks. For ongoing situational awareness, security leaders can follow developments through a daily AI governance and security briefing.

What is the bigger picture for agentic security?

The October disclosures are best understood as a composition risk. The individual bugs are familiar categories such as SSRF, prompt injection and credential exposure, but their placement inside an agent-to-agent trust model makes them exponentially more dangerous. As MCP is combined with other agent protocols such as A2A, the attack surface expands beyond single-tool exploitation to multi-hop protocol pivoting. An attacker who can inject a malicious instruction into one agent may soon be able to reach internal services, databases or cloud control planes through a chain of trusted handoffs.

The MCP project recognized this in its July 2026 specification by introducing a stateless protocol core, header-based routing and stronger authorization binding that requires clients to validate authorization-server issuer information. Yet the specification is only a foundation. The repeated mistakes across Google, JPMorgan, Weaviate, Rapid7 and multiple government bodies show that implementers are still treating agent connections as internal and therefore implicitly trustworthy. That assumption is the real vulnerability.

For the foreseeable future, enterprise AI security will depend less on patching a single interface and more on architecting zero-trust handoffs between autonomous systems. The CISO's job is to ensure that every agent-to-agent conversation is authorized, validated and logged like any other cross-domain API call. If governance teams treat agent mesh networks as trusted internal infrastructure, they risk giving attackers exactly the fresh set of connections McKee warned about.

Frequently asked questions

What is protocol pivoting in MCP?

Protocol pivoting is a technique discovered by researcher Syed Anas Mohiuddin where an attacker injects malicious content into one AI agent, which then forwards it as a legitimate task through the Model Context Protocol to another agent or internal service. It exploits trust assumptions between connected systems rather than relying on a single software bug.

Is the MCP vulnerability a single CVE?

No. The October 2026 findings describe a recurring class of implementation failures including SSRF, prompt injection and weak trust boundaries across multiple organizations. While individual issues such as CVE-2026-14540 at Google and CVE-2026-97228 at Rapid7 were patched, the systemic risk stems from repeated architecture mistakes.

Which organizations were affected by MCP protocol pivoting?

Disclosed proof-of-concept findings involved deployments associated with Google, JPMorgan Chase, Weaviate, Rapid7, France's DINUM, the city government of Tangerang and U.S. federal agencies including a Veterans Affairs server. There is no evidence these were exploited in real-world attacks; they were disclosed and patched.

How should CISOs defend against MCP cross-agent attacks?

CISOs should inventory all agent-to-agent connections, enforce independent authorization at every handoff, validate URLs and IP destinations before MCP servers fetch them, resolve hostnames to prevent DNS bypasses, narrow OAuth token scope and place MCP traffic behind gateways and WAFs with strict rate limiting.

Sources

Part of our daily Briefing Analysis, built on the AI Governance & Security Briefing.

MCPAI agentsSSRFAI governanceprotocol pivotingenterprise security
Share LinkedIn X

Get audit-ready before August 2026.

See how WalledAI operationalises Articles 9–15 and Article 50 obligations as a runtime governance layer.