Repository navigation
Description
Introduction of ourselves
We are the security team from Alibaba Cloud. We have identified a security design flaw in the OAuth mechanism of the MCP protocol. After coordination and confirmation with Anthropic, we are disclosing this type of risk to the community. We hope to reach a consensus with the community on the mitigation approach before finalizing the remediation plan.
Basic knowledge
Glossary of Terms
To avoid confusion in this report, the following key terms are defined:
- MCP Client
A client application that implements the MCP protocol. It may exist in desktop or web form (e.g., Claude for Desktop, VS Code, Cursor, etc.). - OAuth Client Template
In AWS Identity Center, an OAuth client template is a predefined configuration used to set restrictions on actual OAuth applications — such as limiting the scope of permissions granted during authorization. - OAuth Client
The actual OAuth client used during the authorization flow when a user authenticates via an MCP client product. - Bad MCP Server
A malicious MCP server forged by an attacker. All data passing through this server can be intercepted or tampered with. - Bad OAuth Server
A malicious OAuth server forged by an attacker. All data flowing through this server can also be intercepted or altered. - Metadata
Refers to the data returned by accessing the .well-known/oauth-authorization-server endpoint, which includes fields such as issuer, authorization_endpoint, token_endpoint, and registration_endpoint.
MCP Protocol Workflow
Note: The following discussion is based on the latest version(draft) of the MCP OAuth protocol: https://modelcontextprotocol.io/specification/draft/basic/authorization
Come from this issue
#205

Impact Description:
Clients implementing the current MCP protocol — such as Claude for Desktop, VS Code, Cursor, Cline, ChatMCP, Cherry Studio (most of which do not natively support OAuth yet and rely on mcp-remote for integration) — are vulnerable to ultra-low-cost phishing attacks that are difficult for users with average security awareness to detect or defend against. This flaw can lead to the theft of OAuth access tokens by attackers, enabling them to gain unauthorized benefits.
Scope of Impact on Product:
- Services that implement a Remote MCP Server, such as PayPal.
- Services that provide a public OAuth client, such as Google Cloud Platform (GCP) and Amazon Web Services (AWS).
Summary of Impact:
Extraction of A account accesstoken, and unauthorized access to PayPal invoices and transaction data.The severity of the risk will increase as the MCP protocol becomes more widely adopted.
Attack Scenario:
- The attacker publishes a malicious article claiming to be the "MCP Configuration Best Practices from XXX Company," luring users into configuring a malicious MCP server address in their client application.
- After the user configures the malicious server, the OAuth authorization flow is triggered. Since all entities displayed during the authorization process appear legitimate, the user cannot distinguish whether the flow is part of an attack. Upon completing the authorization, the client obtains an access token.
- The client then sends the access token to the remote Bad MCP Server. Once the attacker-controlled MCP server receives the token, it uses it to exfiltrate the user’s sensitive data.
The normal service workflow is as follows:

However, the attack flow logic during a malicious attack is as follows (the diagram below illustrates the scenario where only the MCP server is spoofed, and the OAuth server remains legitimate):

Root Cause of the Issue:
MCP clients such as VS Code allow users to configure the MCP Server address. The MCP Server can in turn specify the OAuth Server address. During the authorization flow, the client sends sensitive data — including the auth_code and access_token — to the server address configured by the user.
Within the MCP protocol environment, there is a lack of necessary authentication interaction between the MCP client and the authorization server. As a result, the MCP client effectively creates a data exfiltration channel for public clients in the OAuth protocol. Once a user configures a spoofed MCP Server address, an attack can be triggered.
Considering that a Bad MCP Server can use special characters, suffixes, or other domain manipulation techniques to mimic legitimate domains, the phishing risk introduced by this workflow becomes extremely difficult to control effectively.
Attack Cases
Attack Case:PayPal Remote MCP Server
This section demonstrates the attack flow in a reproduction scenario involving a Remote MCP Server integrated with PayPal .
Reproduction Video
Attack Case: Google Cloud Platform (GCP)
Although GCP does not implement a Remote MCP Server, it provides a Public OAuth Client to support use cases where developers can access cloud services without storing long-term credentials (such as permanent access keys) locally.
An attacker can publish a phishing article claiming that GCP supports the MCP protocol. Based on this false premise, users may configure a malicious MCP server address in their client application. As a result, the MCP-based workflow can be exploited to steal the user's OAuth access token.
During this phishing flow, aside from entering the initial forged server address, the user has almost no way of detecting the anomaly. Attackers can easily forge highly realistic domain names, such as: mcp.console.googlecloid.com.
In the past, it was extremely rare for client applications to send an obtained access token to an untrusted remote server after authentication. However, the MCP protocol introduces a large number of such potentially dangerous clients.
Attack Case: AWS
Content returned by the malicious .well-known/oauth-authorization-server path (the Auth Server address can also be intercepted via man-in-the-middle here, though it is not required — using a legitimate Auth Server address achieves the same effect):
{
"issuer": "https://ssoins-72234a1798bd17b3.aws.catgg.com",
"authorization_endpoint": "https://ssoins-72234a1798bd17b3.aws.catgg.com/authorize",
"token_endpoint": "https://ssoins-72234a1798bd17b3.aws.catgg.com/token",
"registration_endpoint": "https://ssoins-72234a1798bd17b3.aws.catgg.com/register",
"response_types_supported": [
"code"
],
"response_modes_supported": [
"query"
],
"grant_types_supported": [
"authorization_code",
"refresh_token"
],
"token_endpoint_auth_methods_supported": [
"none"
],
"code_challenge_methods_supported": [
"S256"
]
}
Note: AWS's SSO URL includes an Identity Center ID , so a phishing attack must also trick the user into entering this ID. However, for services like PayPal and Google Cloud, the SSO URLs are generic and do not require users to input additional information, making the phishing attack significantly easier and more cost-effective.
The attacker successfully obtains the user’s credentials.

Reproduction Video
Severity Analysis
We believe that the increase in phishing risk introduced by the MCP protocol is significant and severe. The main reasons are as follows:
Based on our hands-on attack-defense experience, if a successful phishing attack only requires a user to enter or click on a single link, this should be considered a flaw in the protocol or product design — not something that should be mitigated solely through user security awareness. Most users without background knowledge in network security or offensive/defensive techniques will be unable to distinguish between a legitimate MCP instance and a malicious MCP server.
Shifting the burden of identification onto end users will inevitably lead to large-scale phishing attacks. To illustrate with an analogy: if simply entering or clicking a URL in Exchange could result in the leakage of sensitive email information, it would undoubtedly be classified as a critical defect in the Exchange server itself.
Within the community, this type of security concern has been previously discussed in #265. While we strongly support adding user warnings or notifications as part of the mitigation, we believe that relying solely on alerts is insufficient and irresponsible .
Due to the open nature of the MCP protocol, there is currently no enforcement mechanism to prevent duplication of MCP server names. As a result, victims still face significant difficulty in distinguishing between legitimate and malicious MCP servers.
If this issue is not addressed at the protocol level , and instead shifts the burden of detection onto end-user security awareness, all services implementing OAuth Public Clients and Remote MCP Servers will remain vulnerable. Based on historical precedent, when a security flaw offers sufficient potential gain, attackers will inevitably exploit it at scale.
Given the long-term and often irreversible impact of protocol and client design decisions, failing to address this issue early in the design phase may lead to real-world user compromises in the future — ultimately eroding community confidence in the validity and safety of the MCP protocol.
Within the community, there is another related discussion (which we became aware of through coordination with the Anthropic Security Team): #387
However, based on the proposed solutions in that thread — if mitigation only follows the recommendations from OAuth RFC 0807 by using resource and scope for validation, without imposing restrictions on the callback URL — the fix can still be bypassed.
A fully controlled Bad OAuth Server acting as a man-in-the-middle can forge itself as a legitimate client to the real OAuth server, and simultaneously impersonate a legitimate OAuth server to the client — by manipulating the issuer field and tampering with the callback endpoint.
See also:
#387
#408
So how to fix it?
So here, we have two solutions, and we recommend the first solution.
(Recommended)Solution 1:
It includes two parts:
- Add
resourceparameter - Strict verification
Part 1, add resource parameter
Implementation
Based on the standard definition of the OAuth protocol, and in response to access token leakage scenarios, the MCP protocol should require MCP client implementations to include the user-configured MCP server address in the resource parameter when making requests to the OAuth server (e.g., api.example.com, as shown below).
GET /as/authorization.oauth2?response_type=token
&client_id=example-client
&state=XzZaJlcwYew1u0QBrRv_Gw
&redirect_uri=https%3A%2F%2Fclient.example.org%2Fcb
&resource=https%3A%2F%2Fapi.example.com%2Fapp%2F HTTP/1.1
Host: authorization-server.example.com
For details, please refer to:
https://datatracker.ietf.org/doc/html/rfc9700#name-access-token-leakage-at-the
https://datatracker.ietf.org/doc/html/rfc8707
We are unsure whether the resource field has other intended uses in the standard protocol. If there is a conflict, we recommend that the OAuth protocol extend an audience field to specifically restrict the scope of parties (e.g., MCP servers) that are allowed to use the obtained token.
The OAuth authorization server should display the resource field (or a similar parameter) on the consent page, clearly indicating which MCP server is requesting access — serving as a security warning to the user.
In-depth analysis
If the MCP server and the OAuth server are operated by the same entity, the desktop MCP client should be strictly validated to ensure it provides a legitimate MCP server address. If the provided address does not match the expected one, the authorization request should be denied.
In cases where the MCP server and the OAuth server are operated by different entities — meaning the OAuth server supports third-party client registration — the MCP server address should be required at the time of OAuth client registration. The OAuth server should validate that this address is legitimate and consistent with the one used during the authorization flow. Authorization requests from mismatched or unverified MCP servers should be rejected.
Benefit
This restriction can effectively mitigate the scenario in which an attacker tricks the user into configuring a Bad MCP server address, while the authorization server displayed during the OAuth flow remains legitimate.
Part 2, Strict verification
Why?
To address the more advanced attack scenario — where an attacker not only tricks the user into configuring a malicious MCP server address, but also provides a rogue OAuth server that acts as a man-in-the-middle between the user and the legitimate authorization server — we recommend introducing two additional security controls :
Implementation
- Verify whether the Authorization Server is trusted. There are two alternative approaches here, choose either one:
a. (Method A) The MCP client verifies if the issuer value in the redirect URL after OAuth callback matches the Authorization Server address specified by the MCP Server in /.well-known/oauth-protected-resource. If inconsistent, terminate the flow.
b. (Method B) The MCP client verifies if the issuer value in the redirect URL after OAuth callback matches the authorization_endpoint returned by the Authorization Server in .well-known/oauth-authorization-server. Additionally, ensure that the authorization_endpoint and token_endpoint in .well-known/oauth-authorization-server share the same domain. If not, terminate the flow. - OAuth servers should enforce restrictions on the allowed callback URLs when registering a Public OAuth Client for an MCP server:
a. For dynamically registered clients (e.g., desktop apps), the allowed callback URL should be restricted to loopback addresses such as http://127.0.0.1.
b. For web-based MCP client applications, the callback URL should be limited to pre-registered, trusted web domains or paths.
This is intended to prevent a malicious OAuth server from tampering with the callback URL and stealing the authorization code.
In-depth analysis
For OAuth service providers that allow public registration (e.g., Okta), if they intend to support third-party MCP server registration while minimizing the impact of "name spoofing," they can implement enterprise verification during the registration process and display risk warnings during the authorization flow to mitigate potential abuse.
These validation mechanisms do not violate the OAuth standard; rather, they align with recommended security practices outlined in the protocol. Since the risk stems from the interaction model specific to the MCP protocol, we believe that MCP can introduce additional requirements for clients and authorization servers — mandating stricter validation and user warnings beyond the baseline OAuth specification.
We assess that the implementation cost for these enhancements on both client applications and AuthServers is acceptable and feasible. These measures can fundamentally address the flaw through systemic controls, rather than placing the burden of detection on end users, whose security awareness is often limited.
Solution 2:
Establish a centralized authority for certification. However, this would compromise the flexibility of the MCP protocol, so this is provided only as a reference and not recommended.
We prefer to adopt the first solution to address this issue. Given that MCP is an open-source protocol, we highly value reaching a consensus with the open-source team, and we welcome discussions on whether the proposed fix is appropriate. Ultimately, we hope to resolve this flaw through standardized means.
Summary
We believe that security should be the top priority in the design of the MCP protocol, to avoid long-term negative impacts on user data privacy and security as AI Agents and related protocols become more widely adopted. As AI becomes increasingly prevalent, overlooking such issues could lead to catastrophic consequences.
Given the far-reaching and often irreversible impact of protocol-level design decisions, we hope to work together with you to design a secure version of the MCP protocol and contribute back to the community. We look forward to further discussion with you.
Metadata
Metadata
Labels
Type
Projects
- StatusShow more project fieldsIn Review
Activity
azraelxuemo commentedon May 18, 2025
Cool!!
firesunCN commentedon May 18, 2025
mark
azraelxuemo commentedon May 20, 2025
Let me briefly explain the issues here.
I’ve recently researched quite a few vendors that provide remote MCP services, which supports OAuth authentication.
The first issue is that the generated client_id is not bound to the callback address. For example, when I dynamically register a client, the callback address is originally set to localhost:6274, but I can simply change it to a remote address like exp.attacker.com:6274. An attacker could then craft a malicious authentication link, send it to the victim, obtain the code and finally gain the victim's permissions to access the MCP server and use its tools to access the victim's resources.
The first issue can be fixed by binding the client_id to the callback address, but this mitigation has its own flaw—I could simply register a malicious Client with a remote callback address bound to it, achieving the same effect as the first attack. (A demo MCP Server is https://mcp.asana.com/sse)
After this, I also considered a solution: restrict callback addresses to only allow localhost (which fits many client-side scenarios, a demo MCP Server is https://mcp.atlassian.com/v1/sse ). At first glance, this seems to fix the issue—but an attacker could still use the malicious MCP server to hijack the flow and steal the code.
Therefore, we need to adopt the comprehensive solution proposed to address this issue, which can better safeguard the security of the MCP protocol.
localden commentedon May 20, 2025
Thanks for the in-depth investigation. Lots to digest here. Some clarifying questions.
This at least in part tackles the "confused deputy" problem here - Cloudflare also tackled it. At the server SDK components, this likely needs to be formalized somehow to make sure that developers have a way to do this validation out-of-the-box.
One challenge with the
resourceparameter is that the authorization server must support it. If they don't, then it's irrelvant. Do we know if most common authorization servers support RFC 8707?I am curious on the strict verification part:
What is the issuer in the redirect URI?
Also, on this part:
How would you know what is a desktop vs. web client in the DCR registration flow?
Ph0rse commentedon May 21, 2025
First Issue:
This is not merely a proxy confusion issue. As shown in cloudflare/ai#99, simply adding warnings — whether displaying the proxy like
mcp-remoteor showing information about the configured MCP server — does not effectively mitigate phishing risks. From the victim’s perspective, it remains difficult to distinguish whether the entity they are authorizing is legitimate or forged.Second Issue:
RFC 8707 already has some level of ecosystem support. For example, Okta (link) and IBM (link) both support resource parameter validation. Although not all OAuth servers may currently support this, similar limitations exist for features like
.well-known/oauth-authorization-server, which are only available when dynamic client registration is supported.For OAuth servers that aim to integrate with MCP, we believe it is reasonable to require them to implement necessary security checks to ensure the overall safety of the ecosystem.
We are not entirely certain whether the
resourceparameter is the most appropriate field for this purpose. There may be other more suitable parameters (e.g.,scope, or even a newly introduced one). This is exactly the kind of technical decision we hope to discuss with the community. Notably,scopeappears to have broader support across identity providers.Third Issue:
The "issuer in the redirect URI" refers to the service that triggers the redirection. In a normal authorization flow, this should be the legitimate OAuth server. However, in a spoofing scenario, it could be a Bad OAuth Server.
In such cases, the Bad OAuth Server can intercept the user's request and forward it to the real OAuth server while modifying the callback URL to point back to itself. After the user completes authorization on the legitimate OAuth server, they are redirected back to the malicious OAuth server. The attacker then redirects the user back to the MCP client with a forged
issuer.Fourth Issue:
"How would you know what is a desktop vs. web client in the DCR registration flow?"
Actually, no explicit distinction is needed. In Google’s case, the OAuth server comes pre-configured with an official public OAuth Client ID. Similarly, AWS provides a built-in public OAuth client template. These clients are used during the authorization flow, and users are expected to authorize them.
However, in the attack scenario, it is precisely this same public OAuth client that is abused by the attacker, making it hard for users to identify whether the authorization request is malicious.
Therefore, when an MCP server intends to use an OAuth server for authentication, it should register with the platform (as is also required in Okta) or reach an agreement on trusted client configurations. This expectation is also reflected in Atlassian’s configuration guide:
Atlassian MCP Configuration Example
Look forward to more contributors joining this discussion and helping shape a secure future for the MCP protocol. @localden
Ph0rse commentedon May 21, 2025
I believe this is more of a bug than an enhancement discussion. The design of an authentication protocol is a one-way door decision — once implemented incorrectly, it becomes extremely difficult to roll back.
If the official documentation provides misleading guidance, more and more MCP server implementers may end up implementing flawed authentication mechanisms. In the foreseeable future, this could lead to real-world security incidents, causing privacy data leaks for both MCP server providers and the users who rely on them.
Given the potential impact, I believe it would be important to prioritize the resolution of this issue.
BlackKD commentedon May 21, 2025
I agree with Ph0rse's point of view.
The promotion of a set of protocols and frameworks should consider their security architecture design and security scenario design as much as possible during design.
Since it is called MCP server, it is necessary to consider the security design of remote server scenarios. Otherwise, a large number of MCP scenarios currently require MCP server localization due to authentication and credential security issues, and cannot be effectively expanded.
It is recommended to consider fixing it as a design defect as soon as possible.
3 remaining items
aaronpk commentedon Jun 12, 2025
I believe this recommendation is already described in RFC9728:
https://datatracker.ietf.org/doc/html/rfc9728#section-7.4
Ph0rse commentedon Jun 16, 2025
The key issue is that users have no reliable information to verify whether an MCP link is legitimate. Once the malicious MCP server address is configured, all subsequent steps in the authorization flow appear valid and trustworthy.
Imagine a typical user reading an article on a technical forum claiming that mcp.googlecloud.vip/mcp is the official Remote MCP Server address for Google Cloud. The user has no means to verify the authenticity of this claim. After entering the forged address into the MCP client and completing the OAuth authorization flow, their cloud credentials can be stolen.
This is analogous to clicking a link in an email — if simply following the link leads to a security breach, then the system design itself is flawed.
Ph0rse commentedon Jun 16, 2025
good. This is necessary!
lirc572 commentedon Jun 16, 2025
Thank you for the detailed reply. I agree that configuring the URL of an MCP server is analogous to clicking a link in an email, but this action alone does not have security issues unless the user then explicitly authorizes the MCP server / opened website. Therefore I would not consider it a flaw of MCP / email.
Anyone is able to register a legitimate OAuth client for google cloud APIs and perform such phishing attacks. I'm not sure what we can do about it besides educating users that they should verify the legitimacy of apps / websites / MCP servers they use before giving authorization consent.
Ph0rse commentedon Jun 19, 2025
For the scenario where an attacker registers an OAuth client on the Google Cloud platform, when a victim performs OAuth authorization, they can see information about the malicious OAuth client. Google Cloud can independently enhance the victim's ability to distinguish between different OAuth clients through various mechanisms, such as enterprise verification or prohibiting duplicate names for OAuth clients.
However, in MCP, the OAuth authorization information seen by the victim is presented as: "The official Google Cloud / AWS OAuth client is requesting authorization from you—do you agree?" Even if Google Cloud or AWS wants to implement additional security measures, they cannot do so independently, because the MCP client does not provide any verifiable information to the OAuth page.
To summarize, within the context of MCP:
All information that users see on the authorization page is trusted.
All information received by Google Cloud / AWS's OAuth server is trusted.
Therefore, the responsibility of preventing attacks falls entirely on the user—to determine whether the URL they clicked on or entered into the MCP client is trustworthy. This level of difficulty is similar to the challenge of determining whether a link in an email is trustworthy.
Thus, we still believe this is a security issue that needs to be addressed by the MCP protocol. We're glad that there has already been progress in this area from the community:
https://modelcontextprotocol.io/specification/2025-06-18/changelog
chadparry commentedon Jul 25, 2025
This continues to be a problem even with the recent changes to the specification. Here is the attack scenario that concerns me.
https://evil.example/mcpin their client application.https://evil.example/oauth2, and the authorization server publishes that its authorization endpoint ishttps://evil.example/oauth2/authorize.https://somesite.example/oauth2/authorize. It crafts a valid request with a new challenge code. It can optionally add a “state” parameter that identifies the victim and their original request.Is there any ongoing work to mitigate this scenario? For example, is the following recommendation being pursued?
aaronpk commentedon Jul 25, 2025
This is just OAuth phishing. It happens outside of MCP as well.
The consent screen is the "real" or "upstream" OAuth server's consent screen, which should be doing everything it can to ensure the user is informed of what service the access token is being issued to.
If the upstream service is not an MCP server, it likely requires manual registration of the client. The attacker would have previously had to manually register for credentials. The consent screen would show the app name the attacker entered. It's up to the legitimate service to prevent people from putting in fake app names. For example, Google has a whole review process required in order to get access tokens for "sensitive" scopes.
If the upstream service is MCP, and supports open Dynamic Client Registration, this is more of a problem because there is not an easy way to detect these "fake" names and ensure the consent screen is showing legitimate information. This is actually one of the things that the URL-based Client IDs can help with (#991), as then there is an actual domain name that is part of the flow that the user could see at the upstream service. The user would see
evil.examplewhich could be a clue that something is amiss.All that said, since this is ultimately a phishing attack, there is very little that can be done at a protocol level to prevent it. If a user is tricked into authorizing an app that impersonates another app, that isn't really a protocol issue.
chadparry commentedon Jul 25, 2025
Yes, agreed. Although, my interpretation of this entire ticket is that we want to make phishing harder in the MCP use cases than for many of the other older OAuth use cases:
To put it another way, what was the point of mandating the
resourceparameter (Solution 1 Part 1 above) if we aren't going to finish closing the hole by mandating strict verification of the callback URLs (Solution 1 Part 2 above)?That would be a reasonable mitigation. I'll keep an eye on #991.
azraelxuemo commentedon Sep 5, 2025
Today I have tried the notion MCP Server, and I think this may be a good example. Users can clearly see where they will be redirected to. This is also one of the solutions I've observed among companies that provide remote MCP services. Another approach is to impose strict restrictions on the redirect_uri during dynamic registration, allowing only those registered from a predefined allowlist.

dend commentedon Mar 5, 2026
Given that this issue hasn't seen activity in some time, I am closing it as
dormant- if there are any specific changes that we can introduce in the protocol, please follow the SEP guidelines to create a new PR with concrete suggestions for changes.Raja549h commentedon Oct 27, 2026
Beyond OAuth consent-screen phishing, even after an MCP server is connected, the client/host runtime faces confused-deputy tool invocation, multi-hop SSRF redirects to cloud metadata (
169.254.169.254), and covert exfiltration in tool outputs.We built a deterministic host-side containment layer for MCP tool calls (ASL — Agent Safety Layer,
2,998LOC stdlib-only TCB,97.7%AST mutation kill rate) and published a standalone conformance kit covering:(agent_id, run_id, action, canonical_args_hash)so an injected MCP response cannot swap tool arguments or replay a token across turns.urlguard/ipguard): Blocks decimal/hex/octal/IPv6-mapped IP literals and re-validates + pins the resolved IP on every HTTP redirect hop.OutputChannelScrubbing: Enforces strict JSON schemas and strips zero-width/bidi/homoglyph covert channels before tool results re-enter the model context.X-ASL-Attestation): Cryptographic wire token attesting the active policy hash, sandbox backend class, and audit chain head.Standalone zero-dependency verifier (
python conformance/verify_vectors.py), JSON test vectors, and signed benchmark receipts across 250 public exploit payloads (250/250contained):https://github.com/Raja549h/asl-conformance-kit