Skip to content
EclipticLink

AI Security

MCP Security Risks: Server Risks and a Checklist

The Model Context Protocol makes it easy to give AI assistants new tools. It also makes it easy to give an attacker a path into your data. Here are the risks, and a checklist to use before you connect.

EclipticLink Security TeamUpdated 9 min read

The Model Context Protocol (MCP) is an open standard for connecting AI applications to external tools and data. An MCP server can give an assistant access to your file system, GitHub, Slack, a database, a CRM, or almost anything else with an API. Developers and business users are connecting servers at a remarkable pace, often by pasting a few lines into a config file.

That convenience is the problem. Every MCP server you connect is code you are trusting, with access to data and actions, and with a direct line into your model's context. This guide explains the main MCP security risks and gives you a practical checklist to work through before you connect a new server.

How MCP works, briefly

An MCP client (for example a desktop AI assistant, an IDE, or your own agent) connects to one or more MCP servers. Each server advertises capabilities, mainly tools the model can call, resources it can read, and prompts. The model sees each tool's name, description, and input schema, and decides when to call it.

Servers can run locally on a user's machine, communicating over standard input and output, or remotely over HTTP. Local servers run with the user's own operating-system permissions. Remote servers usually hold credentials, such as OAuth tokens, for the services they connect to.

The model reads tool descriptions and tool results as text. Anything an attacker can put into that text can influence what the model does next.

The main MCP security risks

1. Tool poisoning

Tool descriptions are written by the server author and are passed to the model, but users rarely see them in full. A malicious server can hide instructions in a description, for example telling the model to read a sensitive file and include its contents in a tool argument. The user sees an innocent-looking tool name; the model sees the hidden instructions.

2. Rug pulls: definitions that change after approval

A server can behave well when you review it and change later. Because tool definitions are fetched at runtime, an update to the server, or a compromised maintainer account, can silently swap a harmless description or behavior for a malicious one after you have approved it.

3. Cross-server interference (tool shadowing)

When several servers are connected to the same client, they share the same model context. A malicious server's descriptions can instruct the model to change how it uses tools from a different, trusted server, for instance redirecting the recipient of emails sent through your legitimate email tool.

4. Prompt injection through tool results

Even a perfectly honest server returns data from the outside world: web pages, issue comments, emails, documents, database rows. If an attacker controls any of that content, they can plant instructions that the model reads when the tool returns. This is indirect prompt injection, and MCP makes it much more powerful because the model has more tools to act with.

5. Over-privileged tokens and credential exposure

Remote servers often hold broad OAuth tokens or API keys, which makes them attractive targets. Local server configs frequently contain API keys in plain text. A single compromised server, or a stolen config file, can expose access to many systems at once.

6. Command injection and unsafe local execution

Many local servers wrap shell commands, file operations, or scripts. If a server passes model-generated arguments into a shell or file path without validation, the model, or an attacker steering it, can run arbitrary commands with the user's privileges.

7. Supply chain and impersonation

Servers are commonly installed from public package registries and community lists. Typosquatted package names, abandoned projects, and unofficial servers that claim to represent a well-known product are all realistic ways for malicious code to end up on developer machines.

The combination that causes breaches

Security researcher Simon Willison describes a "lethal trifecta" for AI agents: access to private data, exposure to untrusted content, and the ability to communicate externally. When one agent has all three, an attacker who can get text in front of the model can potentially get your data out. MCP makes it very easy to assemble all three by accident, for example by connecting an email server, a file system server, and a web-fetch server to the same assistant.

CapabilityExample MCP serversWhy it matters
Private dataFile system, database, CRM, driveSomething worth stealing
Untrusted contentWeb fetch, email, issue trackers, chatA way for attackers to inject instructions
External communicationEmail send, HTTP requests, messagingA way to exfiltrate data

Checklist: before you connect an MCP server

Vet the source

  • Prefer official servers published by the vendor of the service you are connecting to.
  • Check the publisher, repository activity, maintainers, and install counts, and watch for look-alike names.
  • Read the tool descriptions in full, not just the tool names, and look for instructions aimed at the model.
  • Pin a specific version and review changes before upgrading, so definitions can't change underneath you.

Limit what it can reach

  • Grant the narrowest OAuth scopes and API permissions that still work, and prefer read-only where possible.
  • Run local servers in a container or sandbox with access only to the directories they need.
  • Restrict outbound network access from servers that don't need the internet.
  • Keep secrets in a secrets manager or OS keychain rather than plain-text config files.

Control what the model can do with it

  • Require human approval for tools that send data out, change records, spend money, or delete anything.
  • Avoid connecting servers that complete the lethal trifecta to the same agent; split workloads across separate agents instead.
  • Disable tools you don't need. Many servers expose far more tools than your use case requires.

Monitor and govern

  • Log tool calls, arguments, and results centrally, and alert on unusual patterns.
  • Keep an inventory of which MCP servers are approved, who uses them, and what they can access.
  • For organizations, route remote servers through a gateway that enforces authentication, allow-lists, and logging.

For teams building MCP servers

  1. Treat every argument from the model as untrusted input: validate types, allow-list values, and never build shell commands by string concatenation.
  2. Implement proper authorization for remote servers, following the authorization guidance in the MCP specification, and never pass a client's token through to downstream APIs unchecked.
  3. Keep tool descriptions short, factual, and free of instructions.
  4. Return only the data the task needs, and mark content from external sources as untrusted.
  5. Publish signed releases and a changelog so users can review what changed.

Key takeaways

  • An MCP server is third-party code with access to your data and a direct line into your model's context. Vet it like any other dependency.
  • Tool descriptions and tool results are both attack surfaces.
  • The biggest risk comes from combining private data, untrusted content, and external communication in one agent.
  • Least privilege, human approval for high-impact actions, version pinning, and logging remove most of the risk.

EclipticLink's AI and LLM security team reviews MCP servers and agent architectures, tests them for tool poisoning and prompt injection, and helps you set up governance for which servers your organization can use.

Frequently asked questions

What is the Model Context Protocol (MCP)?

MCP is an open protocol that lets AI assistants connect to external tools and data sources through MCP servers. It standardizes the connection, so a model can read files, query systems or take actions without a custom integration for each tool.

Are MCP servers safe to use?

They can be, but only with controls around them. An MCP server runs with whatever access you give it, so a malicious or compromised server, or a prompt injection that reaches it, can misuse that access. Vet the source, pin versions, grant least privilege, and require human approval for sensitive actions.

What is tool poisoning in MCP?

Tool poisoning is when a tool's description or metadata contains hidden instructions that the model reads and follows. Because models treat tool descriptions as trusted context, a poisoned tool can steer the assistant into leaking data or calling other tools.

How do I secure an MCP integration?

Inventory every server, install only from sources you trust, pin and review versions, scope credentials per tool, isolate servers from sensitive networks, log every tool call, and require confirmation before actions that change or send data.

Sources and further reading

  • MCP security
  • Model Context Protocol
  • MCP server security
  • tool poisoning
  • AI agent security
  • prompt injection
  • AI supply chain

Next step

Find out where you're exposed before an attacker does

Start with a free 30-minute assessment call with a security specialist. We'll review your setup, flag your highest-risk gaps, and outline a prioritized plan, whether or not you work with us afterwards.