May 3, 2026·6 min read·77 visits
Unauthenticated RCE in Windows LDAP requiring a Machine-in-the-Middle (MITM) position. A race condition triggers an integer underflow, leading to a heap buffer overflow. Patched in February 2025 updates.
CVE-2025-21376 is a high-severity unauthenticated remote code execution (RCE) vulnerability in the Microsoft Windows Lightweight Directory Access Protocol (LDAP) service. The vulnerability relies on a complex weakness chain consisting of a race condition (CWE-362), which triggers an integer underflow (CWE-191), ultimately resulting in a heap-based buffer overflow (CWE-122).
CVE-2025-21376 is a remote code execution vulnerability located within the Microsoft Windows Lightweight Directory Access Protocol (LDAP) implementation. The LDAP service is a core component of Windows infrastructure, responsible for facilitating directory queries and authentication requests. The vulnerability exposes a critical flaw in how the LDAP service manages concurrent network requests.
The vulnerability is classified as a weakness chain, involving three distinct failure conditions that must occur sequentially. The sequence begins with an improper synchronization of shared resources (CWE-362), leading to state corruption. This corruption subsequently forces an integer underflow (CWE-191) during buffer calculation, which finalizes the chain by causing a heap-based buffer overflow (CWE-122).
Exploitation requires the attacker to operate from a Machine-in-the-Middle (MITM) network position to intercept and modify LDAP traffic. Because of this prerequisite, the CVSS Attack Complexity metric is correctly rated as High (AC:H). Successful exploitation yields arbitrary code execution within the context of the vulnerable LDAP service without requiring authentication or user interaction.
The root cause of CVE-2025-21376 originates from a race condition (CWE-362) within the LDAP service's concurrent request handling logic. When multiple threads process intercepted or specifically timed LDAP requests and responses, the service fails to enforce proper synchronization over shared memory objects. This absence of mutually exclusive locks allows concurrent threads to read and write to the same state variables simultaneously.
This concurrency failure manifests directly as an integer underflow (CWE-191). The shared state variable, typically an offset tracker or buffer size counter, is decremented by overlapping threads without validation. When the value is decremented below zero, the unsigned integer representation wraps around to its maximum possible value.
The final stage of the weakness chain is the heap-based buffer overflow (CWE-122). The underflowed integer is utilized as the size parameter in a subsequent memory allocation or memory copy operation. The LDAP service attempts to copy a massive amount of data into a finite heap buffer, overwriting adjacent memory structures and corrupting the heap layout.
Due to the closed-source nature of the Windows LDAP implementation, the exact vulnerable code path requires conceptual analysis based on the verified weakness chain. The flaw exists in the functions responsible for parsing incoming LDAP Protocol Data Units (PDUs) where state is shared across asynchronous procedure calls. The vulnerable logic fails to lock the context structure before modifying length fields.
// Conceptual representation of the vulnerable state manipulation
void ProcessLdapRequest(LDAP_CONTEXT* ctx, DWORD bytesProcessed) {
// Vulnerable: No synchronization lock surrounding the state modification
// If two threads execute this simultaneously, bytesRemaining can underflow
ctx->bytesRemaining -= bytesProcessed;
// The underflowed value becomes 0xFFFFFFFF (or similar large unsigned integer)
if (ctx->bytesRemaining > 0) {
// CWE-122: Heap-based Buffer Overflow occurs here
memcpy(ctx->buffer, ctx->incomingData, ctx->bytesRemaining);
}
}The patched logic introduced in the February 2025 Cumulative Updates remediates the vulnerability by breaking the first link in the chain. The patch introduces proper synchronization primitives, likely utilizing SRWLOCK or similar lightweight locking mechanisms, to ensure atomic operations on the shared context. Additionally, explicit bounds checking is added to prevent integer wrap-around.
// Conceptual representation of the patched state manipulation
void ProcessLdapRequestPatched(LDAP_CONTEXT* ctx, DWORD bytesProcessed) {
AcquireSRWLockExclusive(&ctx->stateLock);
// Mitigation: Validate bounds before subtraction to prevent underflow
if (ctx->bytesRemaining >= bytesProcessed) {
ctx->bytesRemaining -= bytesProcessed;
memcpy(ctx->buffer, ctx->incomingData, ctx->bytesRemaining);
} else {
// Handle error state appropriately
ctx->bytesRemaining = 0;
}
ReleaseSRWLockExclusive(&ctx->stateLock);
}Exploiting CVE-2025-21376 requires a sophisticated attack methodology, fundamentally gated by the need for a Machine-in-the-Middle (MITM) position. The attacker must possess the ability to intercept, delay, and inject traffic between a legitimate LDAP client and the target server. This network positioning is necessary to manipulate the timing of LDAP responses and requests to induce the required state collision.
Once the MITM position is established, the attacker must reliably win the race condition. This involves flooding the LDAP service with specific, interleaved requests designed to force multiple worker threads to access the shared request context simultaneously. Winning this race condition is non-deterministic and highly dependent on network latency and server load, contributing to the high attack complexity.
Upon successfully triggering the integer underflow and the subsequent heap overflow, the attacker must control the heap layout to achieve arbitrary code execution. This requires precise memory manipulation to overwrite function pointers, vtables, or structured exception handling (SEH) records adjacent to the overflowed buffer. Currently, there are no publicly available proof-of-concept (PoC) exploits due to these stringent prerequisites.
The security impact of a successful CVE-2025-21376 exploitation is severe, granting the attacker arbitrary code execution on the target system. In the context of a Windows Domain Controller, the LDAP service operates with elevated system privileges (NT AUTHORITY\SYSTEM). Compromise of this service directly leads to total domain compromise, allowing the attacker to exfiltrate credential databases (NTDS.DIT) and deploy domain-wide persistence mechanisms.
The CVSS v3.1 vector string is CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, resulting in a base score of 8.1. The attack is network-based (AV:N) and requires no privileges (PR:N) or user interaction (UI:N). The confidentiality, integrity, and availability metrics are all evaluated as High due to the comprehensive system access granted by remote code execution.
Despite the high severity, the Exploit Prediction Scoring System (EPSS) calculates a low 1.44% probability of exploitation in the wild within the next 30 days (80.84th percentile). This relatively low probability reflects the prohibitive difficulty of satisfying the MITM requirement and reliably executing a remote heap-based race condition against modern Windows memory mitigations.
The primary and most effective remediation for CVE-2025-21376 is the application of the February 2025 Patch Tuesday updates. Organizations must deploy the Latest Cumulative Updates (LCU) to all affected Windows client and server environments. Specific fixed build versions include 10.0.10240.20915 for Windows 10 1507 and 10.0.26100.3194 for Windows 11 24H2 and Windows Server 2025.
If immediate patching is not feasible, organizations can disrupt the prerequisite attack vector by enforcing strict LDAP communication policies. Enabling and enforcing LDAP Signing and LDAP over SSL/TLS (LDAPS) prevents the MITM interception necessary to exploit this vulnerability. These configurations ensure channel binding and cryptographically verify the integrity of the LDAP traffic, rendering state manipulation impossible.
Defense-in-depth measures should include robust network segmentation to restrict LDAP access exclusively to authorized domain controllers and administrative workstations. Additionally, organizations utilizing intrusion prevention systems can deploy signatures, such as Fortinet's IPS Signature ID 57249 (MS.Windows.LDAP.CVE-2025-21376.Remote.Code.Execution), to detect anomalous LDAP traffic patterns indicative of exploitation attempts.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Windows 10 Microsoft | < 10.0.10240.20915 (1507 base) | 10.0.10240.20915 |
Windows 11 Microsoft | < 10.0.26100.3194 (24H2 base) | 10.0.26100.3194 |
Windows Server 2025 Microsoft | < 10.0.26100.3194 | 10.0.26100.3194 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-362, CWE-191, CWE-122 |
| Attack Vector | Network (MITM Required) |
| CVSS v3.1 Score | 8.1 (High) |
| EPSS Score | 0.01445 (1.44%) |
| Impact | Remote Code Execution |
| Exploit Status | None (No PoC) |
| CISA KEV | No |
Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition') leading to Integer Underflow and Heap-based Buffer Overflow.
A Stored Cross-Site Scripting (XSS) vulnerability exists in Silverstripe Framework versions prior to 6.2.13 within the SilverStripe\Core\XssSanitiser component. The HTML sanitizer fails to strip SVG data URIs (data:image/svg*) from dangerous HTML attributes such as href, src, lowsrc, and data. Authenticated CMS authors can persist crafted SVG data URIs in stored content, leading to arbitrary JavaScript execution in the browser context of users who view or interact with the rendered page.
CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.
Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.
A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.
CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.
CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.