Jul 17, 2026·5 min read·13 visits
Unauthenticated remote security feature bypass in Microsoft SharePoint Server allows full authentication bypass due to weak token validation logic.
CVE-2026-55040 is a critical security feature bypass vulnerability in Microsoft SharePoint Server arising from a weak authentication mechanism (CWE-1390). An unauthenticated remote attacker can exploit this security flaw over a network to bypass authentication validation routines, gaining unauthorized access to the application and complete control over sensitive enterprise data assets without any user interaction.
Microsoft SharePoint Server relies on IIS (Internet Information Services) and ASP.NET to process and authorize incoming HTTP requests. The framework utilizes a claims-based authentication architecture to transform identity assertions into security tokens, which are verified by backend modules. The security boundary depends on the cryptographic validation of these identity tokens before establishing an authenticated user session.
The attack surface for CVE-2026-55040 comprises exposed endpoints within SharePoint Web applications that handle user credentials or process session state. These endpoints, such as those exposed under the _vti_bin or _layouts virtual directories, are reachable remotely without authentication under default configurations.
The vulnerability is classified under CWE-1390 (Weak Authentication). Due to a logical flaw in how identity claims are processed, the application allows an unauthorized remote attacker to bypass verification boundaries and gain authenticated access to SharePoint resources.
The root cause of CVE-2026-55040 lies in the validation logic within SharePoint's token-parsing modules. During the authentication handshake, the server processes claims tokens containing user credentials and authorization levels. Typically, a FedAuth cookie or SAML token is decrypted and verified against cryptographic signatures to ensure its integrity and source authenticity.
In vulnerable versions of SharePoint Server, a logical check within the token validation routine fails to verify the signature of the claims token when specific HTTP headers or parameters are present in the request. The server-side logic mistakenly assumes that upstream reverse proxies or gateway components have already performed the necessary cryptographic validation.
Because of this weak validation, an attacker can submit a crafted token without a valid signature. The server accepts the unverified claims as authentic, parses the arbitrary identities defined inside the token, and initializes a fully privileged security context for the user session.
SharePoint Server is a closed-source product, meaning raw source code of the affected assemblies is not publicly available. However, reverse-engineering of the cumulative security patches reveals changes in assemblies responsible for federated authentication and token processing, such as SPFederationAuthenticationModule.
Below is a conceptual C# representation illustrating the vulnerable logic versus the patched verification routine:
// Conceptual representation of vulnerable validation logic
public class SPFederationAuthenticationModule
{
public ClaimsPrincipal ValidateToken(SecurityToken token, HttpRequest request)
{
// VULNERABILITY: Bypassing signature verification based on client-controlled or upstream proxy headers
if (request.Headers["X-Upstream-Verified"] == "true")
{
// Trusted gateway assumption leads to an authentication bypass
return CreatePrincipalFromTokenClaims(token);
}
if (!VerifyTokenSignature(token))
{
throw new SecurityTokenValidationException("Invalid token signature");
}
return CreatePrincipalFromTokenClaims(token);
}
}The corresponding patched code forces signature validation of all claims tokens, removing ambient validation assumptions:
// Conceptual representation of patched validation logic
public class SPFederationAuthenticationModule
{
public ClaimsPrincipal ValidateToken(SecurityToken token, HttpRequest request)
{
// FIX: Enforce cryptographic verification of the token signature in all cases
if (!VerifyTokenSignature(token))
{
throw new SecurityTokenValidationException("Invalid token signature");
}
return CreatePrincipalFromTokenClaims(token);
}
}The patch successfully eliminates the logical branch that allowed token signatures to bypass validation. This completely mitigates the weak authentication flaw by requiring cryptographic integrity verification for every incoming authentication payload.
Exploitation of CVE-2026-55040 requires network access to the target SharePoint Server instance but requires no privileges or credentials. The attacker interacts directly with the exposed IIS endpoints of the SharePoint application.
The attack is initiated by sending a crafted HTTP request with a malformed claims token accompanied by specific request headers designed to trigger the vulnerable validation path. When the request is received by the IIS worker process (w3wp.exe), the authentication pipeline parses the claims token but bypasses the signature checks.
Upon successful exploitation, the backend establishes an active session under the identity specified in the malicious claims token (e.g., SharePoint\System or another high-privilege account). The attacker is then granted unauthorized read and write access to the SharePoint farm APIs and content database. Security teams can look for anomalies in IIS logs, such as unexpected requests to authentication endpoints with administrative user-agents or suspicious header structures.
The CVSS base score of 9.1 reflects the critical nature of this security feature bypass. Successful exploitation leads to a total compromise of confidentiality and integrity within the affected SharePoint Server environment.
Attackers can read, modify, or delete sensitive business documents, proprietary data, and SharePoint site configurations. The compromise of SharePoint databases can also expose service account credentials stored in config files or memory, which can be leveraged for active lateral movement within the active directory domain.
While the CVSS vector designates no direct availability impact (A:N), the integrity compromise is severe enough to allow attackers to overwrite system configurations, indirectly impacting application availability and business continuity.
The absolute remediation for CVE-2026-55040 is the application of Microsoft's official cumulative updates (CUs). Administrators must identify and patch vulnerable versions of SharePoint Server 2016, 2019, and Subscription Edition as detailed in the vendor documentation.
If immediate patching is not possible, organizations should implement network-level segmentations. Restricting access to SharePoint virtual directories and limiting administrative portal access to trusted IP ranges will restrict external exploitation attempts.
Web Application Firewalls (WAFs) can also be configured to drop incoming external requests containing custom routing or upstream verification headers (such as X-Upstream-Verified or similar gateway assertions) that might target the weak validation logic. However, these temporary mitigations are not complete substitutes for applying the cumulative security updates.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
SharePoint Enterprise Server 2016 Microsoft | >= 16.0.0, < 16.0.5561.1001 | 16.0.5561.1001 |
SharePoint Server 2019 Microsoft | >= 16.0.0, < 16.0.10417.20175 | 16.0.10417.20175 |
SharePoint Server Subscription Edition Microsoft | >= 16.0.0, < 16.0.19725.20434 | 16.0.19725.20434 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-1390 (Weak Authentication) |
| Attack Vector | Network |
| CVSS Base Score | 9.1 (Critical) |
| EPSS Score | 0.00668 |
| Impact | Confidentiality: High, Integrity: High, Availability: None |
| Exploit Status | None (No public exploit or PoC available) |
| CISA KEV Status | Not listed |
The product uses an authentication mechanism that does not adequately verify the identity of the actor.
CVE-2026-52870 is a high-severity Broken Object-Level Authorization (BOLA) / Missing Authorization vulnerability (CWE-862) discovered in the experimental tasks feature of the Model Context Protocol (MCP) Python SDK. Under affected versions (< 1.27.2), default handlers registered via server.experimental.enable_tasks() allowed connected clients to enumerate, access, and terminate active tasks belonging to other user sessions due to a lack of session ownership validation. This compromised multi-tenant isolation, allowing authenticated users to extract execution data and cancel running jobs across concurrent connections. The vulnerability has been resolved in version 1.27.2 through session-scoping of task identifiers and transport session pinning.
A high-severity privilege escalation and sandbox escape vulnerability exists in ArcadeDB Server prior to version 26.7.1. This flaw permits an authenticated user with read-only privileges to execute arbitrary JVM code in a sandboxed JavaScript context via the API command endpoint. By utilizing reflection on bound Java objects, an attacker can bypass the GraalVM guest environment's whitelist, access the Java ClassLoader, and perform arbitrary file reads on the host filesystem.
CVE-2026-59950 is a high-severity security vulnerability in the Model Context Protocol (MCP) Python SDK. Prior to version 1.28.1, the SDK's deprecated WebSocket server transport accepted incoming connection handshakes without performing validation on the Host or Origin headers. Because web browsers do not restrict WebSocket connections using the Same-Origin Policy (SOP), this enables malicious third-party websites to perform a Cross-Site WebSocket Hijacking (CSWSH) attack, executing unauthorized commands on behalf of the local user.
CVE-2026-56271 represents a critical security flaw in Flowise, an open-source visual orchestration platform for Large Language Models (LLMs) and autonomous AI agents. The vulnerability occurs within the platform's enterprise passport authentication module, where default cryptographic parameters are used in the absence of explicit environment variables. Specifically, the middleware silently falls back to known, static hardcoded secrets ('auth_token' and 'refresh_token') and identifiers ('AUDIENCE' and 'ISSUER') to generate and verify session tokens. Consequently, remote unauthenticated attackers can construct arbitrary JSON Web Tokens (JWTs) signed with these hardcoded credentials to gain administrative entry to the application.
ArcadeDB is an open-source, multi-model database engine supporting graph, document, key-value, and vector models. In affected versions of ArcadeDB, the trigger script executor improperly configures GraalVM scripting engine permissions. By allowing the 'java.lang.*' package to be loaded within the scripting context, the sandbox environment can be bypassed. An authenticated user with schema administration privileges ('UPDATE_SCHEMA') can register a malicious script trigger that executes arbitrary Java host classes, leading to unauthenticated remote command execution under the context of the ArcadeDB server process.
A critical improper access control vulnerability (CWE-284) in the WebSocket upgrade endpoint of Le Circuit Électrique charging station backend allows remote, unauthenticated attackers to connect to the Charging Station Management System and impersonate charging stations.