Your AI Agents May Be Intelligent. But Are the Systems They Connect to Secure?
The Model Context Protocol (MCP) is changing how AI applications interact with enterprise systems, APIs, databases, development environments, and external tools. By providing a standardized way for AI applications to connect with external capabilities and information, MCP makes it easier to build AI-powered workflows that can retrieve data and perform actions across business environments.
But every new connection introduces a security consideration.
An MCP server with excessive permissions, an exposed access token, a manipulated tool description, or inadequate authorization controls can create pathways to sensitive enterprise information and business-critical systems. As organizations move from AI experimentation to production deployments, securing MCP servers, clients, tools, and connected resources must become part of their broader AI security strategy.
MCP security is the practice of identifying, assessing, and mitigating vulnerabilities across Model Context Protocol clients, servers, tools, authorization mechanisms, and connected systems.
It focuses on preventing unauthorized access, data exposure, malicious tool execution, prompt injection, identity misuse, and other attacks that can compromise MCP-enabled environments.
For enterprises deploying AI agents or connecting large language models (LLMs) to internal systems, an MCP security assessment can help identify weaknesses before attackers exploit them.
This guide explains what MCP security means, how MCP attacks work, the 10 critical risks enterprises should understand, and the security controls organizations should validate before deploying MCP in production.
What Is MCP (Model Context Protocol)?
The Model Context Protocol (MCP) is an open protocol that standardizes how AI applications connect to external systems and access capabilities such as tools, resources, and prompts. In a typical MCP architecture, three components work together:
- MCP Host: The AI application that manages the overall interaction, such as an AI assistant or agent-enabled application.
- MCP Client: The component within the host that establishes and manages connections to MCP servers.
- MCP Server: The component that exposes capabilities, including tools, resources, and prompts, to the AI application.
An MCP server can connect an AI application to a wide range of enterprise systems, including:
- Internal databases and data warehouses
- Cloud infrastructure and storage platforms
- Customer relationship management (CRM) systems
- Enterprise resource planning (ERP) applications
- Source code repositories and development environments
- Identity and access management systems
- Internal APIs and business applications
For example, an organization may deploy an AI assistant that retrieves customer information from a CRM, queries internal documentation, and creates tickets in a service management platform. MCP can provide the standardized connection layer through which these capabilities are exposed.
This creates significant opportunities for automation. However, it also expands the environment that security teams must protect.
Why Does MCP Introduce New Security Considerations?
Traditional application security typically evaluates how users, applications, and services access data and execute operations. MCP adds an AI-driven interaction layer in which a model can interpret instructions, select available tools, process external context, and initiate actions through connected systems.
This means security teams must evaluate not only whether an MCP server is technically secure, but also whether the AI application can invoke the right tools, with the right identity, permissions, context, and authorization. An MCP connection should never be treated as inherently trusted simply because it is part of an approved AI workflow.
Why Is MCP Security Important for Enterprises?
MCP can make AI applications more useful by giving them access to enterprise information and operational capabilities. However, those capabilities can also increase the impact of a compromised AI workflow.
Consider an AI agent connected to an organization’s internal systems. It may have access to customer records, financial information, source code, cloud resources, or employee data. If the agent is manipulated through malicious instructions or an insecure MCP tool, the consequences may extend beyond an inaccurate AI response. Depending on the permissions and controls in place, an attacker may be able to access restricted information, invoke unauthorized operations, or manipulate connected systems. MCP security is particularly important for enterprises because:
- AI agents can interact with sensitive enterprise systems.
MCP connections may expose tools and resources that access confidential information or perform business-critical operations. - Authorization mistakes can expand the attack surface.
If permissions are not appropriately restricted, an AI application or user may gain access to tools and data beyond what they require. - Prompt injections can influence tool usage.
Malicious instructions embedded in external content may manipulate an AI model into selecting tools or performing unintended actions. - Third-party MCP servers introduce supply chain risks.
An organization may inherit vulnerabilities or malicious functionality through external servers, connectors, packages, and dependencies. - Limited visibility can delay threat detection.
Without appropriate logging and monitoring, security teams may struggle to identify unauthorized tool calls, suspicious data access, or compromised integrations.
The OWASP MCP Top 10 identifies risks such as token mismanagement, privilege escalation, tool poisoning, command injection, prompt injection, insufficient authorization, inadequate telemetry, shadow MCP servers, and context over-sharing. These risks make MCP security an important consideration throughout the AI deployment lifecycle.
What Are the 10 Critical MCP Security Risks Every Enterprise Should Address?
MCP security risks extend across authentication, authorization, tool execution, data handling, infrastructure, and AI behavior. The following are 10 areas organizations should evaluate before connecting MCP servers to enterprise systems.
1. Shadow MCP Servers and Unapproved AI Integrations
What is the risk?
Shadow MCP servers are unauthorized or unmanaged MCP deployments operating outside an organization’s established security governance. Development teams, data scientists, and individual employees may deploy MCP servers to connect AI applications with internal tools, databases, repositories, or cloud services without involving security teams.
These deployments may use default configurations, weak authentication, excessive permissions, or exposed endpoints. The problem is not simply that an organization has additional MCP servers. It is that security teams may not know those servers exist or understand what information and capabilities they expose.
How can attackers exploit this?
An attacker who discovers an exposed or poorly secured MCP server may attempt to:
- Access internal resources without appropriate authorization.
- Exploit misconfigured endpoints.
- Retrieve sensitive information through exposed tools.
- Abuse permissions granted to connected services.
- Use the server as an entry point to other enterprise systems.
How can enterprises mitigate this risk?
- Maintain a centralized inventory of approved MCP servers and clients.
- Identify AI applications and integrations operating outside approved environments.
- Enforce security reviews before new MCP servers are deployed.
- Disable unused servers, tools, and endpoints.
- Apply secure configuration baselines and restrict network exposure.
- Include MCP deployments in asset discovery and vulnerability management programs.
What security teams should validate: Can your organization identify every active MCP server, its owner, its connected systems, its exposed tools, and the permissions it holds?
2. Weak Authentication, Authorization, and Excessive Permissions
What is the risk?
MCP security depends on correctly identifying users, clients, and services and enforcing what each is allowed to access. Weak authentication or authorization controls can allow an MCP client, AI agent, or unauthorized user to invoke tools or retrieve information beyond their intended privileges.
One particularly important concern is privilege escalation through permission scope creep. An MCP server may gradually accumulate permissions as new tools and integrations are introduced, eventually giving an AI agent access to capabilities it does not need.
For example, an AI assistant designed to retrieve customer information may also receive permission to modify records, export data, or access unrelated customer accounts.
How can attackers exploit this?
- Abuse overly broad permissions assigned to an AI agent.
- Exploit weak identity validation.
- Invoke administrative tools using a lower-privileged identity.
- Access resources belonging to another user or tenant.
- Exploit authorization checks that rely on user-supplied identifiers.
How can enterprises mitigate this risk?
- Enforce role-based or attribute-based access controls.
- Apply least-privilege permissions to every MCP client, agent, and tool.
- Separate read, write, administrative, and destructive capabilities.
- Validate authorization for every sensitive operation.
- Bind access decisions to verified identities rather than model-generated context.
- Review permissions periodically and remove unnecessary scopes.
- Require explicit approval for high-impact actions where appropriate.
What security teams should validate: Can an AI agent access or modify resources that fall outside the permissions of the authenticated user or its approved operational role?
3. Token Mismanagement, Credential Exposure, and Token Passthrough
What is the risk?
MCP environments rely on credentials and authorization mechanisms to establish trusted connections between clients, servers, and downstream services.
Poor credential management can expose access tokens, API keys, refresh tokens, and other secrets through application logs, debugging information, environment variables, configuration files, or insecure storage. Another critical issue is token passthrough.
Token passthrough occurs when an MCP server accepts an access token from an MCP client without validating that the token was specifically issued for that MCP server and then forwards it to a downstream service. This can undermine authorization boundaries and allow credentials to be used in unintended contexts.
The official MCP authorization security guidance explicitly requires MCP servers to validate that tokens are intended for them and prohibits accepting tokens issued for other resources.
How can attackers exploit this?
- Retrieve credentials exposed in logs or configuration files.
- Reuse stolen tokens to access protected resources.
- Exploit inadequate token audience validation.
- Abuse long-lived credentials that remain valid after exposure.
- Use a compromised MCP server to access downstream APIs.
How can enterprises mitigate this risk?
- Store secrets in approved secrets-management systems.
- Avoid hardcoding credentials in source code or configuration files.
- Use short-lived, appropriately scoped access tokens.
- Validate token signatures, expiry, issuer, and audience.
- Never blindly forward client tokens to downstream APIs.
- Use separate, appropriately issued credentials for downstream services.
- Rotate exposed credentials and revoke compromised tokens.
- Prevent sensitive tokens from appearing in application logs.
What security teams should validate: Does every MCP server verify that an access token was issued specifically for it, and are downstream services accessed using separately authorized credentials?
4. Prompt Injection Through Untrusted Context
What is the risk?
Prompt injection is one of the most important AI security risks affecting MCP-enabled environments. An attacker may embed malicious instructions in content that an AI application retrieves from external sources, documents, websites, databases, or connected tools.
When an AI model processes that content, it may interpret the embedded instructions as directions to follow, rather than untrusted information to analyze.
In an MCP environment, the consequences can be more serious because the model may have access to tools that retrieve sensitive data or execute operations.
For example, an attacker could place instructions in a document that an AI assistant retrieves. Those instructions may attempt to persuade the assistant to disclose confidential information, invoke an unauthorized tool, or send data to an external destination.
How can attackers exploit this?
- Embed malicious instructions in retrieved documents.
- Manipulate AI agents through external content.
- Influence tool selection and execution.
- Attempt to extract confidential information.
- Trigger unauthorized operations through connected MCP tools.
How can enterprises mitigate this risk?
- Treat external content and tool outputs as untrusted input.
- Separate system instructions from retrieved information.
- Implement authorization checks outside the model.
- Restrict which tools can be invoked in response to untrusted context.
- Require approval for sensitive or irreversible operations.
- Test direct and indirect prompt injection scenarios.
- Validate that sensitive data cannot be disclosed through manipulated model responses.
What security teams should validate: Can an attacker influence an AI agent through retrieved content and cause it to invoke a tool or disclose information that the user is not authorized to access?
5. MCP Tool Poisoning and Malicious Tool Updates
What is the risk?
Tool poisoning occurs when malicious or manipulated tool descriptions, metadata, schemas, outputs, or updates influence how an AI model interacts with an MCP server. AI applications often rely on tool descriptions and schemas to understand what a tool does and when it should be used.
If those descriptions are manipulated, an AI model may be misled into invoking tools in unintended ways or disclosing information through malicious workflows. A related attack is a rug pull, in which a previously trusted tool is modified after it has been approved or deployed.
For example, an MCP tool that originally retrieves approved business information could be updated to include instructions that encourage the model to expose sensitive context or invoke an additional operation.
How can attackers exploit this?
- Modify tool descriptions to influence model behavior.
- Introduce malicious instructions into tool metadata.
- Replace legitimate tools with malicious versions.
- Alter tool schemas to manipulate how parameters are interpreted.
- Exploit unreviewed updates to trusted MCP integrations.
How can enterprises mitigate this risk?
- Review and approve MCP tool definitions before deployment.
- Maintain trusted registries of approved MCP servers and tools.
- Verify tool provenance and package integrity.
- Monitor changes to tool descriptions, schemas, and permissions.
- Require security reviews for tool updates.
- Restrict tools to clearly defined business functions.
- Test whether manipulated tool metadata can influence AI behavior.
What security teams should validate: Can a change to an approved tool’s description, schema, or implementation cause the AI application to perform an unauthorized action?
6. Command Injection and Unsafe Tool Execution
What is the risk?
MCP tools can expose capabilities that execute commands, interact with files, query databases, call APIs, or perform operations within enterprise environments. If these capabilities process untrusted input without adequate validation, attackers may exploit command injections or unsafe execution vulnerabilities. The risk increases when an AI agent constructs commands or tool arguments using information from user prompts, retrieved documents, or external data sources.
For example, an agent connected to a development environment may have access to tools that execute shell commands. If the implementation fails to validate input and restrict execution, malicious content could influence the commands being executed.
How can attackers exploit this?
- Inject malicious parameters into tool inputs.
- Abuse shell or script execution capabilities.
- Manipulate file paths or database queries.
- Trigger unintended operations through crafted prompts.
- Exploit tools that execute commands with excessive system privileges.
How can enterprises mitigate this risk?
- Validate and sanitize all inputs before execution.
- Avoid constructing shell commands directly from untrusted model output.
- Use parameterized queries and safe execution interfaces.
- Restrict filesystem and process access.
- Run MCP servers in appropriately isolated environments.
- Apply resource limits and execution timeouts.
- Require explicit authorization for high-impact operations.
What security teams should validate: Can untrusted prompts or retrieved content influence the execution of commands, scripts, queries, or API operations through MCP tools?
7. Confused Deputy Vulnerabilities and Broken Tenant Isolation
What is the risk?
A confused deputy vulnerability occurs when a system with legitimate privileges is manipulated into using those privileges on behalf of an unauthorized party.
MCP servers may act as intermediaries between AI clients and downstream services. If authorization and consent are not correctly enforced, an MCP server may unintentionally use its own permissions to perform actions that the requesting client should not be allowed to perform.
Tenant isolation is another important consideration. In multi-tenant environments, an MCP server must verify that every requested resource belongs to the authenticated user or tenant. It should never trust tenant identifiers supplied by the AI agent or client without independently validating them.
For example, an AI agent authorized to access one customer’s records should not be able to retrieve another customer’s data simply by changing a tenant ID or resource identifier in a tool request.
How can attackers exploit this?
- Manipulate an MCP proxy into using its privileges for unauthorized requests.
- Bypass user consent in insecure authorization flows.
- Change tenant or account identifiers in tool arguments.
- Reuse identifiers associated with another user’s resources.
- Exploit weak object-level authorization.
How can enterprises mitigate this risk?
- Enforce authorization checks on every tool invocation.
- Bind resource ownership to verified identities.
- Validate tenant ownership server-side.
- Separate user authorization from the MCP server’s service permissions.
- Implement explicit consent in delegated authorization flows.
- Test cross-tenant access and object-level authorization.
- Prevent clients from supplying trusted identity or ownership information.
What security teams should validate: Can one user, agent, or tenant use an MCP tool to access another user’s resources or exploit the MCP server’s privileges?
8. Server-Side Request Forgery (SSRF) and Unsafe Network Access
What is the risk?
Server-Side Request Forgery (SSRF) occurs when an attacker manipulates a server or application into making requests to unintended destinations.
MCP clients and servers may interact with URLs, APIs, authorization metadata, and external resources. If these requests are not appropriately validated, an attacker may attempt to direct an MCP component toward internal network services or protected endpoints.
For example, a malicious MCP server could provide an authorization metadata URL that points to an internal network address. If an MCP client fetches that URL without appropriate safeguards, it may expose internal services or cloud metadata endpoints.
The official MCP security best practices specifically identify SSRF as a risk during OAuth metadata discovery and recommend controls such as HTTPS enforcement, private IP range restrictions, redirect validation, and network-level egress protections.
How can attackers exploit this?
- Manipulate URL parameters to target internal services.
- Attempt to access cloud metadata endpoints.
- Abuse unvalidated redirects.
- Exploit weak DNS and IP validation.
- Use an MCP component to reach services that should not be externally accessible.
How can enterprises mitigate this risk?
- Validate URLs and destination addresses before making outbound requests.
- Block private, reserved, and link-local IP ranges where appropriate.
- Enforce HTTPS for production authorization endpoints.
- Validate redirect destinations.
- Restrict outbound network access using egress controls.
- Monitor unusual outbound requests.
- Apply DNS resolution safeguards to reduce validation bypasses.
What security teams should validate: Can an MCP client or server be manipulated into making requests to internal network resources or unauthorized external destinations?
9. Data Leakage, Context Over-Sharing, and State Handle Hijacking
What is the risk?
MCP-enabled AI applications may process sensitive information across users, agents, sessions, tools, and connected enterprise systems.
If context is not appropriately scoped, information retrieved for one user or task may become accessible to another.
Context over-sharing can occur when applications expose more information than required, retain sensitive data unnecessarily, or fail to isolate information across different workflows.
Another protocol-specific concern is state handle hijacking.
An MCP server may issue a handle representing a workflow, resource, or other stateful object. If the server relies on possession of that handle without verifying its association with the authenticated user, an attacker who obtains or guesses the handle may attempt to access or modify another user’s state.
How can attackers exploit this?
- Retrieve information belonging to another user or tenant.
- Exploit shared context between AI workflows.
- Abuse persistent context containing sensitive information.
- Guess or reuse state handles.
- Access confidential data through overly broad tool responses.
How can enterprises mitigate this risk?
- Enforce tenant and user-level data isolation.
- Minimize the data exposed to AI applications and tools.
- Bind state handles to verified identities.
- Use unpredictable, short-lived handles where appropriate.
- Apply data classification and access controls.
- Restrict sensitive information in model context and logs.
- Validate that tool responses contain only authorized information.
What security teams should validate: Can information or state associated with one user, agent, or tenant be accessed by another through shared context, tool responses, or manipulated state handles?
10. Insufficient Logging, Monitoring, and Incident Response
What is the risk?
Even when an organization implements authentication, authorization, and access controls, inadequate monitoring can make it difficult to identify suspicious activity across MCP-enabled environments.
Traditional application logs may not provide sufficient visibility into how AI agents interact with tools, what context influences their decisions, or which operations are initiated through MCP connections.
Without appropriate telemetry, security teams may struggle to determine whether an unusual tool invocation was legitimate, prompted by malicious content, or initiated through a compromised identity.
How can attackers exploit this?
- Perform unauthorized operations without triggering alerts.
- Abuse compromised credentials over extended periods.
- Exfiltrate data through legitimate-looking tool calls.
- Manipulate AI workflows without leaving sufficient audit evidence.
- Exploit gaps between AI application logs and downstream system logs.
How can enterprises mitigate this risk?
- Log MCP authentication and authorization events.
- Monitor tool discovery, invocation, and execution.
- Record relevant user, client, agent, and tool identities.
- Track sensitive data access and administrative operations.
- Correlate MCP activity with downstream application and infrastructure logs.
- Establish alerts for unusual access patterns and permission changes.
- Define incident response procedures for compromised MCP servers, tools, and credentials.
- Retain audit evidence in accordance with organizational requirements.
What security teams should validate: Can your security team reconstruct who invoked a particular MCP tool, what resource it accessed, which identity authorized the action, and what happened afterward?
MCP Security Checklist: 15 Controls to Validate Before Production Deployment
Identifying MCP vulnerabilities is only the first step. Organizations also need to verify that appropriate security controls are implemented across the MCP environment. Use the following checklist to evaluate your current MCP security posture.
MCP Asset Discovery and Governance
- Maintain an inventory of all approved MCP servers, clients, tools, and integrations.
- Identify shadow MCP deployments and unauthorized connections.
- Establish ownership and approval requirements for every MCP server.
Identity and Access Management
- Enforce authentication and authorization for protected MCP resources.
- Apply least-privilege permissions to users, agents, and service identities.
- Validate token audience, expiry, and authorization scope.
- Prevent token passthrough to downstream services.
AI and Tool Security
- Test for direct and indirect prompt injection.
- Review tool definitions, schemas, and updates for malicious changes.
- Validate inputs before executing commands or API operations.
- Require appropriate authorization for sensitive tool actions.
Infrastructure and Data Protection
- Restrict network access and validate outbound requests.
- Enforce tenant isolation and prevent unauthorized data access.
- Secure state handles and sensitive information across contexts.
Monitoring and Incident Response
- Maintain logs for tool invocations, authorization decisions, and sensitive operations.
- Establish monitoring and incident response procedures for MCP-related security events.
Important: This checklist is a practical starting point, not a substitute for a technical security assessment. The appropriate controls will depend on your MCP architecture, deployment model, connected systems, data sensitivity, and business requirements.
How Do You Conduct an MCP Security Assessment?
An MCP security assessment evaluates the security of the protocol implementation, connected systems, authorization mechanisms, tools, and AI-driven interactions. Unlike a conventional vulnerability scan, an effective MCP security assessment should examine how the AI application behaves when interacting with potentially malicious inputs, manipulated tools, unauthorized identities, and connected enterprise resources. A comprehensive assessment can include the following activities.
1. MCP Architecture and Attack Surface Discovery
Identify MCP hosts, clients, servers, exposed tools, resources, connected APIs, and downstream services. Review the architecture to understand trust boundaries, data flows, authentication mechanisms, and external dependencies.
2. Authentication and Authorization Testing
Evaluate identity validation, token handling, permission scopes, role enforcement, and resource-level authorization. Test whether users or agents can invoke tools beyond their approved permissions.
3. MCP Server and Configuration Security Review
Assess server configurations, endpoint exposure, transport security, input validation, dependency management, and network restrictions. Identify insecure defaults, unnecessary services, and configuration weaknesses.
4. Prompt Injection and Tool Manipulation Testing
Test how the AI application responds to malicious instructions embedded in prompts, retrieved documents, and tool outputs. Evaluate tool poisoning, schema manipulation, unauthorized tool invocation, and attempts to influence agent behavior.
5. Data Isolation and Exfiltration Testing
Validate tenant separation, resource ownership, context isolation, state handle security, and sensitive information exposure. Determine whether an attacker can access data outside the permissions of the authenticated identity.
6. Exploitation and Remediation Validation
Validate identified vulnerabilities through controlled testing and document their potential business impact. Provide actionable remediation recommendations and retest critical findings after corrective measures are implemented.
The objective is not simply to determine whether an MCP server is vulnerable. It is to understand whether an attacker can abuse the connection between AI applications and enterprise systems to compromise data, identities, or business operations.
When Should Your Organization Conduct an MCP Security Assessment?
Organizations should consider an MCP security assessment before production deployment and whenever significant changes are made to their MCP environment.
Important assessment triggers include:
- Before deploying a new MCP server: Validate the server’s configuration, authentication, authorization, exposed tools, and network access before connecting it to enterprise systems.
- Before connecting sensitive enterprise data: Assess access controls and data isolation before allowing AI applications to retrieve customer records, financial information, employee data, or confidential business information.
- When introducing new AI agents or tools: Evaluate whether new tools introduce excessive permissions, unsafe execution capabilities, or additional attack paths.
- After changes to MCP servers or tool definitions: Review changes to server implementations, schemas, dependencies, permissions, and connected services.
- When integrating third-party MCP servers: Validate the security of external integrations and their access to internal resources.
- As part of an ongoing AI security program: Reassess the environment as AI applications, agent capabilities, integrations, and threat scenarios evolve.
MCP security should be treated as an ongoing part of enterprise AI security governance, not a one-time deployment exercise.
Why Should You Choose Accorian for MCP Security Assessment?
Connecting AI applications to enterprise systems creates new security boundaries. Identifying weaknesses across those boundaries requires more than a conventional application security review.
Accorian brings cybersecurity assessment expertise and AI security capabilities together to help organizations evaluate how AI applications, agents, MCP servers, and connected systems behave under adversarial conditions.
Our AI security services can help organizations identify vulnerabilities across:
- MCP server and integration security: Evaluate server configurations, exposed tools, authentication, authorization, and connected resources.
- AI agent security: Assess agent identity, permissions, tool usage, and opportunities for unauthorized actions.
- Prompt injection and tool manipulation: Test direct and indirect prompt injection, malicious context, and tool poisoning scenarios.
- Data security and isolation: Identify weaknesses in tenant separation, access enforcement, context handling, and sensitive data exposure.
- API and application security: Evaluate connected APIs and applications for vulnerabilities that may affect the broader AI environment.
- AI Red Teaming: Simulate adversarial scenarios to understand how attackers could manipulate AI applications and exploit their connected capabilities.
Accorian’s approach is designed to go beyond identifying technical weaknesses. It focuses on understanding how vulnerabilities could affect enterprise data, business operations, and the security of AI-enabled workflows.
Is Your MCP Environment Ready for Production?
Your AI agents may have access to more than information. They may have access to actions, systems, identities, and sensitive enterprise data.
An overlooked authorization weakness, exposed credential, or manipulated tool can turn an otherwise useful AI integration into a security risk.
Before connecting more AI applications to your enterprise environment, validate the security of the connections they depend on.
Get your MCP environment assessed by Accorian.
Connect with our AI security specialists to evaluate your MCP servers, identify exploitable weaknesses, and strengthen the security of your AI integrations.
Request an MCP Security Assessment


