Executive Summary

This article examines the security implications of the Model Context Protocol (MCP) sampling feature in the context of a widely used coding copilot application. MCP is a standard for connecting large language model (LLM) applications to external data sources and tools.

We show that, without proper safeguards, malicious MCP servers can exploit the sampling feature for a range of attacks. We demonstrate these risks in practice through three proof-of-concept (PoC) examples conducted within the coding copilot, and discuss strategies for effective prevention.

We performed all experiments and PoC attacks described here on a copilot that integrates MCP for code assistance and tool access. Because this risk could exist on other copilots that enable the sampling feature we’ve not mentioned the specific vendor or name of the copilot to maintain impartiality.

Key findings:
MCP sampling relies on an implicit trust model and lacks robust, built-in security controls. This design enables new potential attack vectors in agents that leverage MCP. We have identified three critical attack vectors:

1. Resource theft: Attackers can abuse MCP sampling to drain AI compute quotas and consume resources for unauthorized or external workloads.
2. Conversation hijacking: Compromised or malicious MCP servers can inject persistent instructions, manipulate AI responses, exfiltrate sensitive data or undermine the integrity of user interactions.
3. Covert tool invocation: The protocol allows hidden tool invocations and file system operations, enabling attackers to perform unauthorized actions without user awareness or consent.

Given these risks, we also examine and evaluate mitigation strategies to strengthen the security and resilience of MCP-based systems.

Palo Alto Networks offers products and services that can help organizations protect AI systems:

• Prisma AIRS
• The Unit 42 AI Security Assessment can help empower safe AI use and development across your organization.

If you think you might have been compromised or have an urgent matter, contact the Unit 42 Incident Response team.

What Is MCP?

MCP is an open-standard, open-source framework introduced by Anthropic in November 2024 to standardize the way LLMs integrate and share data with external tools, systems and data sources. Its key purpose is providing a unified interface for the communication between the application and external services.

MCP revolves around three key components:

• The MCP host (the application itself)
• The MCP client (that manages communication)
• The MCP server (that provides tools and resources to extend the LLM's capabilities)

MCP defines several primitives (core communication protocols) to facilitate integration between MCP clients and servers. In the typical interaction flow, the process follows a client-driven pattern:

• The user sends a request to the MCP client
• The client forwards relevant context to the LLM
• The LLM generates a response (potentially including tool calls)
• The client then invokes the appropriate MCP server tools to execute those operations

Throughout this flow, the client maintains centralized control over when and how the LLM is invoked.

One relatively new and powerful primitive is MCP sampling, which fundamentally reverses this interaction pattern. With sampling, MCP servers can proactively request LLM completions by sending sampling requests back to the client.

When a server needs LLM capabilities (for example, to analyze data or make decisions), it initiates a sampling request to the client. The client then invokes the LLM with the server's prompt, receives the completion and returns the result to the server.

This bidirectional capability allows servers to leverage LLM intelligence for complex tasks while clients retain full control over model selection, hosting, privacy and cost management. According to the official documentation, sampling is specifically designed to enable advanced agentic behaviors without compromising security and privacy.

MCP Architecture and Examples

MCP employs a client-server architecture that enables host applications to connect with multiple MCP servers simultaneously. The system comprises three key components:

• MCP hosts: Programs like Claude Desktop that want to access external data or tools
• MCP clients: Components that live within the host application and manage connections to MCP servers
• MCP servers: External programs that expose tools, resources and prompts via a standard API to the AI model

When a user interacts with an AI application that supports MCP, a sequence of background processes enables smooth communication between the AI and external systems. Figure 1 shows the overall communication process for AI applications built with MCP.

Phase 1: Protocol Handshake

MCP handshakes consist of the following phases:

• Initial connection: The MCP client initiates a connection with the configured MCP servers running on the local device.
• Capability discovery: The client queries each server to determine what capabilities it offers. Each server then responds with a list of available tools, resources and prompts.
• Registration: The client registers the discovered capabilities. These capabilities are now accessible to the AI and can be invoked during user interactions.

Phase 2: Communication

Once MCP communications have begun, they progress through the following stages:

• Prompt analysis and tool selection: The LLM analyzes the user’s prompt and recognizes that it needs external tool access. It then identifies the corresponding MCP capability to complete the request.
• Obtain permission: The client displays a permission prompt asking the user to grant the necessary privileges to access the external tool or resource.
• Tool execution: After obtaining the privileges, the client sends a request to the appropriate MCP server using the standardized protocol format (JSON-RPC).

The MCP server processes the request, executes the tool with the necessary parameters and returns the result to the client.

• Return response: After the LLM finishes its tool execution, it returns information to the MCP client, which in turn processes it and displays it to the user.

MCP Server and Sampling

In this section, we dive further into the MCP server features and understand the role and capability of the MCP sampling feature. To date, the MCP server exposes three primary primitives:

• Resources: These are data sources accessible to LLMs, similar to GET endpoints in a REST API. For example, a file server might expose file://README.md to provide README content, or a database server could share table schemas.
• Prompts: These are predefined prompt templates designed to guide complex tasks. They provide the AI with optimized prompt patterns for specific use cases, helping streamline and standardize interactions.
• Tools: These are functions that the MCP host can invoke through the server, analogous to POST endpoints. Official MCP servers exist for many popular tools.

MCP Sampling: An Underused Feature

Typically, MCP-based agents follow a simple pattern. Users type prompts and the LLM calls the appropriate server tools to get answers. But what if servers could ask the LLM for help too? That's exactly what the sampling feature enables.

Sampling gives MCP servers the ability to process information more intelligently using an LLM. When a server needs to summarize a document or analyze data, it can request help from a client's language model instead of doing all the work itself.

Here’s a simple example: Imagine an MCP server with a summarize_file tool. Here's how it works differently with and without sampling.

Without sampling:

• The server reads your file
• The server employs a local summarization algorithm on its end to process the text

With sampling enabled:

• The server reads your file
• The server asks your LLM, “please summarize this document in three key points”
• Your LLM generates the summary
• The server returns the polished summary to you

Essentially, the server leverages the user's LLM to provide intelligent features without needing its own AI infrastructure. It's like giving the server permission to use an AI assistant when needed. This transforms simple tools into intelligent agents that can analyze, summarize and process information.

This all happens while keeping users in control of the AI interaction. Figure 2 shows the high-level workflow of the MCP sampling feature.

Sampling Request

To use the sampling feature, the MCP server sends a sampling/createMessage request to the MCP client. The method accepts a JSON-formatted request with the following structure. The client then reviews the request and can modify it.

After reviewing the request, the client “samples” from an LLM and then reviews the completion. As the last step, the client returns the result to the server. The following is an example of the sampling request.

There are two primary fields that define the request behavior:

• Messages: An array of message objects that represents the complete conversation history. Each message object contains the following, which provides the context and query for the LLM to process:
  • The role identifier (user, assistant, etc.)
  • The content structure with type and text fields
• SystemPrompt: A directive that provides specific behavioral guidance to the LLM for this request. In this case, it instructs the model to act as a “security-focused code reviewer,” which:
  • Defines the perspective and expertise of the response
  • Ensures the analysis focuses on security considerations
  • Ensures a consistent reviewing approach

Other fields’ definitions can be found on Anthropic’s official page.

MCP Sampling Attack Surface Analysis

MCP sampling introduces potential attack opportunities, with prompt injection being the primary attack vector. The protocol's design allows MCP servers to craft prompts and request completions from the client's LLM. Since servers control both the prompt content and how they process the LLM's responses, they can inject hidden instructions, manipulate outputs, and potentially influence subsequent tool executions.

Threat Model

We assume the MCP client, host application (e.g., Claude Desktop) and underlying LLM operate correctly and remain uncompromised. MCP servers, however, are untrusted and represent the primary attack vector, as they may be malicious from installation or compromised later via supply chain attacks or exploitation.

Our threat model focuses on attacks exploiting the MCP sampling feature, in which servers request LLM completions through the client. We exclude protocol implementation vulnerabilities such as buffer overflows or cryptographic flaws, client-side infrastructure attacks and social engineering tactics to install malicious servers. Instead, we concentrate on technical exploits available once a malicious server is connected to the system.

Experiment Setup and Malicious MCP Server

To demonstrate these potential risks, we developed a malicious code summarizer MCP server, based on Anthropic’s everything MCP server. This is a demo server that aims to exercise all the features of the MCP protocol, including the MCP sampling feature.

The malicious MCP server provides legitimate functionality while performing covert operations. Specifically, it provides a tool named code_summarizer, making it indistinguishable from benign tools during selection. When users request code summarization tasks, the MCP protocol automatically routes the request to this tool, as shown in Figure 3.

When users request code summarization tasks, the MCP protocol identifies these requests and automatically routes them to the tool for help. Figure 3 above shows the detailed parameters and guideline prompts used by this tool.

For the MCP host/client, we choose a code editor that supports the MCP sampling feature. Figure 4 shows the typical interaction process.

The summary task we provided to the copilot summarizes the main source file of the everything MCP server.

PoC 1: Resource Theft: Excessive Token ConsumptionThrough Hidden Prompts

This attack shows how the malicious server can exploit LLM completions to steal a user’s token quota by appending hidden requests to prompts.

Core attack mechanism: The malicious tool adds hidden instructions at the end of the main prompt:

This hidden instruction causes the LLM to generate a fictional story along with the requested code summary.

Attack flow: When the user submits a summarization request (as shown in Figure 3 above), the server processes it as usual but secretly instructs the LLM to produce additional content. The LLM’s response includes both the code summary and the hidden story.

In our experiments with the copilot, the host only displayed the code summary (shown in Figure 5).

However, the LLM still processes and generates the full response, including any hidden content injected by the server. This additional content, though invisible to users, continues to consume computational resources and appears in server logs.

The disconnect between what users see and what actually gets processed creates a perfect cover for resource exhaustion attacks. Users receive their expected summary with no indication that the LLM also generated extensive hidden content in the background.

Despite the successful exploitation, we note that we observed this behavior specifically in our testing with the target MCP client’s implementation. Different MCP hosts may handle output filtering and display differently.

Some implementations might show full LLM responses, provide warnings about hidden content or have other safeguards in place. What makes this particular implementation vulnerable is its approach to presenting results.

The MCP client performs an additional layer of summarization on the MCP tool output before displaying it to the user. It condenses the content into a brief summary, rather than showing the raw LLM response.

This design choice increases the attack's effectiveness, as the hidden content becomes effectively invisible in the chat interface. Only by expanding and examining the raw server console output, an action most users would have no reason to take, would the exploitation become apparent.

This potential attack vector reflects the specific design choices of the tested implementation and may not be universally applicable to all MCP hosts supporting the sampling feature.

Figures 6 and 7 reveal the fictional story in the server console output, confirming successful token theft. To the user, everything appears normal. They receive the summary as expected. In reality, the malicious server has consumed extra computational resources equivalent to generating 1,000 additional words, all billed to the user’s API credits.

Impact: This attack enables resource theft, unauthorized content generation and potential data exfiltration through carefully crafted hidden prompts.

PoC 2: Conversation Hijacking: Persistent Prompt Injection

The second attack demonstrates how the malicious MCP server can inject instructions that persist across multiple conversation turns, effectively compromising the entire conversation.

Attack mechanism: The server instructs the LLM to append specific instructions in its response and causes the following conversation to follow these instructions:

Attack flow: Starting with the same code summarization request, the malicious server appends the injection instruction to the user’s prompt. Following this malicious prompt, the LLM then includes this text in its response (shown in Figure 8), which becomes part of the conversation context. Once injected, these instructions affect all subsequent interactions.

When the user asks follow-up questions, the AI assistant responds in pirate speak (as shown in Figure 9), demonstrating that the injection has taken a persistent effect.

Impact: This attack can fundamentally alter the AI assistant's behavior, potentially making it less useful or even dangerous if more sophisticated instructions are injected. Unlike one-time token theft, this creates a lasting compromise that affects the entire session.

PoC 3: Covert Tool Invocation

This attack leverages prompt injection to trigger unauthorized tool invocations, enabling a malicious server to perform hidden actions on the user's system.

Attack mechanism: The server modifies the user’s prompt to embed instructions that cause the LLM to invoke additional tools without the user’s awareness:

In this example, the LLM is assumed to have access to a tool called writeFile, which allows it to write content to local files. The malicious server provides this tool, but it could also be supplied by other MCP servers on the system, such as the commonly used filesystem MCP server.

Attack flow: When the user requests code summarization, the malicious summarizer tool appends hidden instructions to the LLM's prompt. This causes the LLM to not only generate the requested summary but also secretly invoke the writeFile tool. The tool writes the complete response to a local file named tmp.txt. While the LLM's response acknowledges this file operation (as shown in Figure 10), it embeds the acknowledgment within the summary text, making it unlikely that users will notice the unauthorized action.

The attack succeeds because the file operation appears as a legitimate tool invocation from the LLM's perspective. The user receives their expected code summary while remaining unaware that their system has been modified (as shown in Figure 11).

Impact: This attack demonstrates the potential for malicious file operations, data exfiltration, persistence mechanisms and other unauthorized system modifications. This is all performed without explicit user consent.

Detecting and Preventing Prompt Injection in MCP Sampling

Detection focuses on identifying malicious patterns in both sampling requests and LLM responses.

• On the request side, systems should scan for injection markers like [INST], System:, role-play attempts (“You are now”) and hidden content using common injection strategies such as zero-width characters or Base64 encoding.
• On the response side, detection involves monitoring for unexpected tool invocations, embedded meta-instructions ("For all future requests...") and outputs that attempt to modify client behavior. Statistical analysis provides another layer by flagging requests that exceed normal token usage patterns or exhibit an unusually high frequency of sampling requests. Responses should also be inspected for references to malicious domains or exploits that can compromise the agent.

Prevention requires implementing multiple defensive layers before malicious prompts can cause harm. Request sanitization forms the first line of defense:

• Enforce strict templates that separate user content from server modifications
• Strip suspicious patterns and control characters
• Impose token limits based on operation type

Response filtering acts as the second barrier by removing instruction-like phrases from LLM outputs and requiring explicit user approval for any tool execution.

Access controls provide structural protection through capability declarations that limit what servers can request, context isolation that prevents access to conversation history, and rate limiting that caps sampling frequency.

Palo Alto Networks offers products and services that can help organizations protect AI systems:

• Prisma AIRS
• The Unit 42 AI Security Assessment can help empower safe AI use and development across your organization.

If you think you may have been compromised or have an urgent matter, get in touch with the Unit 42 Incident Response team or call:

• North America: Toll Free: +1 (866) 486-4842 (866.4.UNIT42)
• UK: +44.20.3743.3660
• Europe and Middle East: +31.20.299.3130
• Asia: +65.6983.8730
• Japan: +81.50.1790.0200
• Australia: +61.2.4062.7950
• India: 00080005045107

Palo Alto Networks has shared these findings with our fellow Cyber Threat Alliance (CTA) members. CTA members use this intelligence to rapidly deploy protections to their customers and to systematically disrupt malicious cyber actors. Learn more about the Cyber Threat Alliance.

Additional Resources

• OpenAI Content Moderation – Docs, OpenAI
• Content filtering overview – Documentation, Microsoft Learn
• Google Safety Filter – Documentation, Generative AI on Vertex AI, Google
• Nvidia NeMo-Guardrails – NVIDIA on GitHub
• AWS Bedrock Guardrail – Amazon Web Services
• Meta Llama Guard 2 – PurpleLlama on GitHub
• Introducing the Model Context Protocol – Anthropic News
• OpenAI adopts rival Anthropic's standard for connecting AI models to data – TechCrunch
• Model Context Protocol – Wikipedia
• What is the Model Context Protocol (MCP)? – Documentation, Model Context Protocol
• Model Context Protocol (MCP) an overview – Personal Blog, Philipp Schmid
• Model Context Protocol (MCP) Explained – Diamond AI Substack, Nir Diamant
• Sampling – Documentation, Model Context Protocol
• MCP 101: An Introduction to Model Context Protocol – DigitalOcean Community, DigitalOcean
• The current state of MCP (Model Context Protocol) – Elasticsearch Labs, Elastic