LetterMCP

Enterprise Defense Patterns Against MCP Prompt Injection and Tool Abuse at Scale

Authentication alone won't stop MCP attacks, so enforce policy per call.

· 9 min read
Cover illustration for “Enterprise Defense Patterns Against MCP Prompt Injection and Tool Abuse at Scale”
Agent Security · November 14, 2026 · 9 min read · 1,966 words

Enterprise defense against Model Context Protocol (MCP) prompt injection and tool abuse requires coordinated controls across identity, tool access, server integrity, detection, and audit. An enterprise MCP security and governance platform must enforce policy on every tool call and preserve the identity and context behind it. Authentication alone cannot stop an agent that has access from following malicious instructions.

Why MCP creates a fundamentally different attack surface than traditional API security

Traditional API security assumes a deterministic caller. Known code calls a known endpoint with parameters set by that code, and authorization governs what the caller can access. MCP changes that relationship because an LLM reads natural-language tool descriptions at runtime, chooses tools, and builds arguments from conversation context. It may then chain several tools together without a human approving each step. The system is no longer just answering questions.

That shift changes what must be trusted. The security boundary includes the user, MCP client, server, token, resource, and requested action, but also the text influencing the model’s choice. A firewall can restrict network access without stopping instructions hidden in a tool result. Rate limits and static CORS rules do little to stop that manipulation. The model can be persuaded to misuse access it already has.

MCP’s own security guidance treats this as an implementation problem across clients, servers, tools, and authorization flows. Enterprises are moving beyond experiments and connecting agents to business systems. A trust gap that seemed tolerable in a pilot becomes a breach path when thousands of tool calls pass through it daily.

The five attack classes enterprises are actually seeing in production

Prompt injection is the first attack class. It places hostile instructions in text the model reads, including tool results, turning data to interpret into a direction to act. Tool poisoning is the second, and it targets the tool’s description or schema. That text, typically hidden from the user, can tell the model to favor a particular tool, put sensitive data into arguments, or conceal actions from the user.

The DuneSlide pair, CVE-2026-50548 and CVE-2026-50549, both CVSS 9.8, shows how injected text can exploit either of two independent sandbox flaws to escape Cursor’s terminal sandbox and execute arbitrary commands. The danger lies in the chain of failures.

Rug pulls are the third class. A server behaves properly during review, then changes its descriptions or behavior after approval. The August 2026 Deadbugz campaign distributed a server called “productivity-suite” through public GitHub pull requests and switched its instructions after three ordinary tool calls. Lateral movement chains are the fourth class, using injected instructions to discover tools and reach sensitive services through excessive permissions. The Grafana MCP session spoofing incident, CVE-2026-19516, CVSS 9.1, illustrates this escalation pattern.

Sampling abuse is the fifth class. MCP sampling lets a server ask the client LLM to generate a completion, which a malicious server can exploit to consume compute quota, extract context, or poison reasoning with fabricated tool results. These classes can operate separately, but they also reinforce one another. Treating each as an isolated vulnerability leaves the transitions between them unguarded.

Why authentication and authorization at the protocol level are necessary but not sufficient

The Enterprise-Managed Authorization (EMA) extension is stable and lets organizations provision MCP server access centrally through their identity provider. Anthropic, Microsoft, and Okta are adopting it. EMA governs whether a user can connect a client to a server and at what scope. It does not inspect traffic after issuing the token.

The authorization specification explicitly forbids token passthrough, which accepts a token issued for another service and forwards it downstream. That practice bypasses validation and rate limits while breaking the audit trail. It is not a valid shortcut around OAuth. Correct authentication elsewhere does not make it safe.

A server may use its own broad privileges for a user who lacks them, or a proxy may be tricked into giving an attacker a valid authorization code. Azure API Management provides a concrete mitigation by validating Entra tokens and checking issuer, audience, and expiry before a request reaches a tool. Those checks show whether the credential belongs at that boundary.

They do not secure every implementation behind it. OX Security’s April 2026 disclosure described an official MCP SDK STDIO transport flaw that exposed server instances to remote code execution despite working authentication. Many large enterprises also give AI systems access to ERP, CRM, and financial platforms without enough control over how they use that access. The missing link is accountability for each action after connection.

Binding every tool call to a verifiable enterprise identity

Uber’s MCP Gateway anchors that accountability in production across 800+ servers and a large tool library. It relays the caller’s user token so calls retain the invoking engineer’s identity, with authorization at both server and tool level. That makes the audit record attributable to a person. Every tool also starts disabled. Its owning team must review and enable it before an agent can use it.

Preserving identity must not become forbidden token passthrough. The recommended approach uses SPIFFE/SPIRE-issued SVIDs or federated identity tokens rather than shared API keys, with credentials appropriate to the receiving service. For multi-step delegation, OAuth 2.0 Token Exchange (RFC 8693) and the act claim keep track of the chain of actors. The distinction is essential for enforcement. A downstream service needs to know both whose authority is being exercised and which agent is acting.

Agents also need identities of their own. IBM’s Think 2026 sessions argued for governed agent identities with owners, lifecycles, attestation, and revocation paths, rather than anonymous processes borrowing human credentials. SCIM provisioning and SSO bring those identities into existing creation and deprovisioning workflows. Sensitive systems should use just-in-time credentials lasting minutes to hours, with automatic rotation for longer-lived credentials. A credential proxy can inject authentication server-side so raw secrets never enter the agent’s context, where logs, traces, or prompt injection could expose them.

Tool-call-level policy enforcement and least-privilege access as runtime controls

Identity establishes who is acting, but policy decides whether a particular action may proceed. A traditional gateway’s API-key-and-URL checks are too coarse for that decision. An MCP gateway must inspect the tool, arguments, caller identity, and policy that applies to their combination.

For sensitive actions, the operational rule is explicit human approval before an irreversible step. Pinterest’s high-volume invocation pattern includes this approval stage. The reviewer should see the full tool call, including consequential arguments that a friendly summary can hide. Descriptions and outputs must remain untrusted input. Checking the full schema before approving a server helps uncover instructions that the tool’s name alone would not reveal.

Least privilege must also apply to each resource and each call. A server holding credentials for several systems can turn one compromise into access across all of them, especially when it requests full mailbox access where read-only access would suffice. Narrow OAuth scopes, short-lived tokens, and per-resource grants reduce that reach. Wildcard permissions defeat the purpose of precise identity checks.

Data exposure needs equally narrow limits. Uber’s LLM gateway redacts PII before requests reach external model providers, applying least privilege to what leaves the enterprise as well as what an agent can access. Server placement adds a separate boundary. Sensitive servers should stay apart from general-purpose servers so a poisoned tool cannot reach across without further safeguards, even when the compromised component had been approved.

Detecting and containing supply chain compromise and rug-pull attacks

Deadbugz shows why approval cannot remain a one-time event. After its initial normal behavior, the server instructed the agent to seek SSH keys, AWS credentials, shell history, and Kubernetes configuration while hiding the activity from the user. Authentication could establish which server was responding without establishing that its behavior remained acceptable.

The defensive pattern starts with a secure-by-design registry. A design-time catalog keeps each server’s known-good baseline, and pinned tool definitions give teams a reference they can check for changes. Any schema drift after approval should prompt a review. Azure API Center’s server inventory capability is one implementation of the catalog layer. The inventory and the monitoring serve different purposes, because a list of approved servers alone cannot reveal a changed tool definition.

The gateway must also re-check identity and policy on every call after session establishment. The 2026-07-28 MCP specification change makes requests include what they need for per-call inspection. Pinning and hash verification apply to typosquatted packages, compromised dependencies, and changes of ownership behind an unchanged URL.

Deployment configuration requires review as well. NeighborJack describes servers binding to 0.0.0.0 rather than 127.0.0.1, exposing tools intended to be local-only to other machines or processes on the same network segment. No malicious package is necessary for that exposure. The fix is a single configuration line, but its prevalence across hundreds of implementations shows why reviewing tool definitions alone is insufficient.

Real-time detection for MCP-specific threats that policy enforcement cannot prevent

An authorized call can still serve a malicious purpose. Static policy cannot catch all intent drift, data exfiltration through legitimate tools, or sampling requests that misuse what the system allows. Detection therefore has to examine sequences and data flow alongside individual permission decisions. Escalating privilege requests, tools outside an agent’s established scope, and suppressed output can signal that injected instructions have redirected a session.

The May 2025 GitHub MCP prompt injection demonstrates that distinction. It extracted private repository data through tool results without needing an authentication vulnerability. Detection must inspect what leaves through arguments and responses, while connecting those transfers to the context that caused them.

The June 2025 Asana MCP cross-tenant authorization failure affected thousands of organizations and involved a 12-day outage. Unlike the GitHub case, it involved an authorization boundary failing, reinforcing the need for visibility beyond successful access checks. Sampling needs its own behavioral monitoring. Changes in how many requests arrive or what they contain can reveal attempts to use up compute or extract context, and the protocol has no corresponding control to prevent them.

Investigation requires more than an alert. Uber’s gateway generates an audit log for every call, and identity binding makes each record attributable. Tamper-proof audit preserves evidence, while OpenTelemetry (OTEL) tracing connects a suspicious action to its upstream prompt, tool result, and session. The specification’s per-request identity model supports that level of logging and enforcement.

How do enterprises coordinate MCP security and governance across the AI stack?

An enterprise MCP security and governance platform needs to share identity and event context across enablement, control, and security. Agent setup, server access, and credential handling must connect to per-call policy, the server registry, behavioral detection, and audit. Each layer depends on the others. Detection without identity gives teams alerts with no actor to hold accountable, while identity without policy may only show who was manipulated after the harm is done.

The same dependency applies to server trust. When a server changes without review, policy approvals no longer rest on what was reviewed, and drift monitoring needs a registry baseline to tell approved definitions from unexpected ones. Detection also needs evidence it can preserve and explain. Tamper-proof audit supports compliance investigation and legal hold, while tracing supplies the context needed to reconstruct the chain of actions.

If the gateway lacks the agent’s SSO identity, it cannot enforce identity-aware policy. If detection receives no OTEL traces from the gateway, it cannot correlate behavioral signals with their causes. Audit records must use the same identity context as well. These are concrete evaluation criteria to apply before deployment.

Uber’s gateway approximates this coordinated architecture, and MCP’s per-request identity model supports its direction. The deployment goal is a single platform where enablement, control, and security share the evidence needed to govern each action. That changes the security team’s role. Security and IT make company-wide adoption possible by defining policies, registries, and detection rules that make the approved path safe by default, freeing them from manually reviewing every agent request.

Sources

  1. The state of MCP security in 2026
  2. Enterprise-Managed Authorization: Zero-touch OAuth for MCP
  3. ext-auth/specification/stable/enterprise-managed-authorization/2026-07-28/enterprise-managed-authorization.mdx at main · modelcontextprotocol/ext-auth · GitHub
Filed underAgent Security

More in Agent Security