SignDrop Windows Zero-Day: CLFS Privilege Escalation Mechanics

A disgruntled researcher has publicly disclosed SignDrop, a Windows zero-day vulnerability in the Common Log File System that leverages Windows Defender to achieve local privilege escalation to SYSTEM rights.

TL;DR

  • What happened: Security researcher Nightmare Eclipse publicly disclosed SignDrop, an unpatched Windows zero-day vulnerability allowing arbitrary local privilege escalation to NT AUTHORITY\SYSTEM.
  • Who is affected: Systems running Windows 11 26H2, Windows 11 26H2 Experimental, and Windows Server 2025 Experimental that have been operational for more than 90 days and have CLFS authentication configured in mode 0 or 1.
  • Impact and mechanism: The exploit coerces Windows Defender’s signature update function (ServerMpUpdateEngineSignature) into opening a crafted CLFS container, triggering an automated authentication file creation step that inherits attacker-controlled permissions.
  • What to do now: Audit enterprise fleets for Windows 11 26H2 builds, inspect the HKLM\SYSTEM\CurrentControlSet\Services\CLFS\Authentication\Mode registry key, and monitor Object Manager symbolic link manipulation in user directories.

In November 2026, security researcher Nightmare Eclipse publicly released details and proof-of-concept code for a zero-day local privilege escalation flaw dubbed SignDrop. The signdrop windows zero-day targets the Common Log File System (CLFS) driver and manipulates native antimalware update workflows to bypass kernel-level access controls. By abusing interaction patterns between CLFS, Windows Object Manager symbolic links, and Microsoft Defender, unprivileged local attackers can elevate execution rights directly to NT AUTHORITY\SYSTEM.

The flaw is technically notable because it turns a native defensive mechanism into an exploitation vector. Rather than relying on traditional kernel memory corruption primitives, SignDrop forces Windows Defender’s signature update service (ServerMpUpdateEngineSignature) to process a malformed log container. This triggers automatic file creation logic inside CLFS under Defender’s execution context, bypassing antimalware self-defence and EDR tamper protection controls.

According to public analysis reported by Ars Technica, the flaw originates from a security hardening mitigation introduced by Microsoft in October 2025. While intended to prevent historical CLFS container tampering, the logic introduced in that update created a logic inversion trap when privileged processes interact with user-controlled log files.

Anatomy of the SignDrop Zero-Day Disclosure

The public release of SignDrop occurred on Tuesday, 10 November 2026, when researcher Nightmare Eclipse published proof-of-concept exploit code without prior private coordination with Microsoft. Nightmare Eclipse has previously disclosed several other unpatched Windows zero-day vulnerabilities in recent months. While public reporting references an ongoing disagreement between the researcher and Microsoft, the exact underlying drivers of this dispute remain undisclosed.

The target surface for SignDrop spans specific modern Windows builds, specifically:

  • Windows 11 26H2
  • Windows 11 26H2 Experimental
  • Windows Server 2025 Experimental

The security impact of the exploit is high: it enables any unprivileged local execution context—such as a low-rights domain user or an initial access shell—to achieve arbitrary SYSTEM rights escalation. Once execution at NT AUTHORITY\SYSTEM is achieved, local access controls, security agent monitoring, and administrative boundaries on the local machine can be completely bypassed.

At the time of public disclosure, Microsoft had not confirmed an emergency out-of-band security patch or assigned a formal Common Vulnerabilities and Exposures (CVE) tracking identifier. Furthermore, because Microsoft employs staged rollouts for feature updates like Windows 11 26H2, the precise total of vulnerable enterprise endpoints across global networks remains unconfirmed. Administrators must verify exposure empirically using host configuration audits rather than relying solely on globalpatch deployment reports.

Under the Hood: CLFS Architecture and Design Flaws

To understand how SignDrop operates, system architects must examine the design of the Common Log File System. Introduced in Windows Server 2003 R2 and integrated deeply into the kernel with Windows Vista, CLFS is implemented primarily through the CLFS.sys driver. It functions as a general-purpose logging service utilized by both kernel-mode drivers (such as KTM, the Kernel Transaction Manager) and user-mode applications requiring high-performance transactional logging.

Architecturally, a CLFS log consists of two primary components:

  1. Base Log File (BLF): A master control file containing metadata structures, sector headers, container maps, user record control structures, and log layout definitions.
  2. Log Containers: Physical container files (typically formatted with numeric extensions or .rcv designations) that hold the actual log records allocated by the base log file.

CLFS Architecture Structure

The CLFS.sys driver manages the layout of Base Log Files and Container files directly on disk. Because kernel-mode logging APIs parse these complex binary structures directly, any logic flaw in file handling or access control validation exposes a direct path to kernel-level escalation.

+---------------------------------------------------------------------------------+
|                                USER SPACE                                       |
|                                                                                 |
|   +-----------------------+                    +----------------------------+   |
|   | Unprivileged Attacker |                    | Windows Defender Service   |   |
|   | Process               |                    | (MsMpEng.exe - SYSTEM)     |   |
|   +-----------+-----------+                    +--------------+-------------+   |
|               |                                               |                 |
|               | 1. Creates Symlinks                           | 2. Triggers     |
|               v & Container Redirection                       v  Update API     |
|   +-------------------------------------------------------------------------+   |
|   | Object Manager Directory (\RPC Control\ redirection target)             |   |
|   +-------------------------------------------------------------------------+   |
+------------------------------------------------|--------------------------------+
                                                 |
                                                 | 3. Opens Container
                                                 v
+---------------------------------------------------------------------------------+
|                               KERNEL SPACE                                      |
|                                                                                 |
|   +-------------------------------------------------------------------------+   |
|   | CLFS.sys (Common Log File System Driver)                                |   |
|   |                                                                         |   |
|   | 4. Detects Missing Authentication File                                  |   |
|   | 5. Creates File under SYSTEM Security Context                           |   |
|   | 6. Applies Attacker-Defined DACL from Original Container                |   |
|   +-------------------------------------------------------------------------+   |
+---------------------------------------------------------------------------------+

Because CLFS services both user-mode applications and kernel-mode subsystems, it bridges complex security boundaries. When a user-mode process requests a log operation via APIs like CreateLogFile or AddLogContainer, CLFS.sys must validate structural headers, Sector Signatures, and Dump Block structures. Over the past decade, this complex binary parsing logic has made CLFS a frequent vector for kernel memory corruption bugs.

However, SignDrop exposes a different architectural vulnerability: a logic flaw in access control inheritance during automated file creation operations. When a privileged service opens a CLFS container file on behalf of an operational workflow, CLFS.sys processes the file system interactions within the security context of the caller. If that service fails to enforce client impersonation, the kernel driver operates under full elevated privileges while applying file properties inherited from unprivileged structures.

Weaponising Windows Defender for Privilege Escalation

The SignDrop exploit chain combines Windows Object Manager manipulation, privileged service execution, and CLFS access control inheritance. Rather than injecting code directly into a target process, the attacker leverages Windows Defender as an unwitting proxy to execute file system primitives.

Step 1: Ingestion via Defender Signature Updates

The entry point relies on a legitimate Windows Defender administrative function: ServerMpUpdateEngineSignature. This function is invoked during antimalware signature and engine update procedures to process update packages and associated log telemetry. An unprivileged local user can trigger or influence this routine, directing Defender to inspect specific log containers located on the file system.

To redirect Defender’s file operations, the attacker populates the Windows Object Manager directory (specifically utilizing \RPC Control\) with custom symbolic links and directory junctions. By placing symbolic links in paths accessed during signature updates, the attacker forces the Windows Defender antimalware engine (running as NT AUTHORITY\SYSTEM inside MsMpEng.exe) to open an attacker-crafted CLFS container file instead of standard system update files.

Step 3: Missing Authentication File Condition

When Windows Defender opens the manipulated CLFS container, the request enters CLFS.sys under Defender’s privileged security context. The crafted container is intentionally configured without its corresponding authentication file. Detecting the absent file, CLFS.sys executes an automated fallback routine designed to generate the missing authentication file on disk.

Step 4: DACL Inheritance and Arbitrary File Creation

Here lies the core logic failure in the CLFS exploit mechanism: CLFS.sys creates the missing authentication file using Defender’s elevated SYSTEM privileges. However, when setting permissions on the newly created file, CLFS copies the Discretionary Access Control List (DACL) from the original attacker-supplied container file. Because the attacker created the original container, they hold full read, write, and control permissions over its DACL.

Consequently, the newly generated authentication file is created in a privileged system path under full SYSTEM ownership, but its DACL explicitly grants full access to the unprivileged local user. The attacker can then use this arbitrary privileged file creation primitive to overwrite sensitive binaries, place malicious DLLs in system search paths, or modify system configuration files, culminating in complete SYSTEM rights escalation.

Bypassing EDR and Antimalware Tamper Protection

Modern Endpoint Detection and Response (EDR) agents and antimalware drivers enforce kernel-level tamper protection to block unauthorized modification of security files. Because SignDrop coerces Defender’s native process (MsMpEng.exe) into initiating the file creation request, the antimalware driver identifies the calling Process ID (PID) as legitimate and allows the operation to proceed.

When Mitigations Backfire: The October 2025 Security Context

The existence of SignDrop highlights a recurring challenge in security engineering: structural mitigations introduced to resolve one attack class inadvertently introducing new logic surfaces. In October 2025, Microsoft deployed a series of security updates across the Windows kernel and CLFS subsystem. These updates were designed to harden CLFS against off-line container tampering and header manipulation vulnerabilities that had been heavily exploited in previous privilege escalation attacks.

The October 2025 mitigation introduced an authentication verification layer. Under this design, CLFS log containers require an associated authentication file to verify the container’s integrity before parsing its records. If a valid container is opened without an authentication file, the driver automatically creates one to establish an authenticated baseline.

The defensive logic assumed that any process opening a CLFS container would either be operating within its own security boundary or properly impersonating the client that requested the operation. However, when integrated with complex multi-threaded system services like Windows Defender, this logic broke down:

  • Expected Security Model: Service receives file path -> Impersonates client user context -> Calls CLFS.sys -> Driver checks permissions under client token -> Operations restricted to client rights.
  • Actual SignDrop Execution Model: Attacker triggers service API -> Service opens path under primary SYSTEM token -> Calls CLFS.sys -> Driver creates missing file as SYSTEM -> Driver copies DACL from container -> Attacker obtains full control over SYSTEM-created file.

As researcher Nightmare Eclipse observed during disclosure, the individual components operated as engineered, but the combination created a logic flaw. By utilizing the legitimate mitigation routine against itself, the exploit converts an administrative integrity check into an elevated file-writing engine.

Prerequisites, Constraints, and Reproduction Realities

Following the public disclosure, independent security researcher Will Dormann conducted empirical testing to verify the bounds and reproduction requirements of the SignDrop vulnerability. Dormann confirmed that while the exploit functions as described, it does not apply universally to all installations of Windows 11 or Windows Server.

Reproduction depends on three strict environment prerequisites:

  1. Operating System Build: Target system must run Windows 11 26H2, Windows 11 26H2 Experimental, or Windows Server 2025 Experimental. Earlier production builds (such as Windows 11 23H2 or 24H2) do not exhibit the specific interaction flow required for exploitation.
  2. System Installation Age (>90 Days): Testing demonstrated that newly provisioned or freshly updated 26H2 systems cannot be exploited immediately. The host OS instance must have existed for more than 90 days. This operational boundary is likely connected to background telemetry tasks, state migration routines, or deferred configuration switches executed by the OS after a specific runtime threshold.
  3. Registry Authentication Mode: The system’s CLFS authentication configuration must be explicitly configured in learning or enforcement mode.

The registry key controlling this behaviour is located at:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CLFS\Authentication\Mode

For a host to be vulnerable, the DWORD value of Mode must equal 0 (Learning Mode) or 1 (Enforcement Mode). If this value is absent, set to 2, or otherwise uninitialized, the automated authentication creation logic does not trigger in a manner that yields the privilege escalation primitive.

During testing across multiple lab environments, Dormann noted that out of numerous test systems, only a single host met all three conditions simultaneously. This indicates that while the vulnerability is critical on affected machines, its current exposure across typical enterprise environments is constrained by build deployment states and system age requirements.

Defensive Triage and Verification for Systems Administrators

Enterprise platform teams, SREs, and security analysts should conduct systematic triage across host fleets to identify exposed endpoints. Triage involves verifying OS build versions, evaluating installation age, and inspecting CLFS registry configurations.

Fleet Evaluation Matrix

Evaluation Criterion Vulnerable Configuration Non-Vulnerable Configuration Triage Action
OS Build Version Windows 11 26H2, Server 2025 Exp. Windows 11 23H2 / 24H2, Server 2022 Verify build via winver or CIM query.
System Age Installation age > 90 days Fresh install / update < 90 days Check InstallDate on OS instance.
CLFS Auth Mode Registry value set to 0 or 1 Registry value set to 2 or missing Query CLFS\Authentication\Mode key.

Automated Triage Script

Administrators can execute the following read-only PowerShell script across endpoints to evaluate vulnerability status without making system changes. Test all scripts in a staging environment prior to broad execution.

# SignDrop Vulnerability Triage Script
# Test in staging before executing across production systems

$ErrorActionPreference = "SilentlyContinue"

# 1. Check OS Build
$osInfo = Get-CimInstance -ClassName Win32_OperatingSystem
$caption = $osInfo.Caption
$version = $osInfo.Version
$build = $osInfo.BuildNumber
$installDate = $osInfo.InstallDate

# Calculate System Age in Days
$systemAgeDays = (Get-Date) - $installDate

# 2. Query CLFS Registry Mode
$regPath = "HKLM:\SYSTEM\CurrentControlSet\Services\CLFS\Authentication"
$authMode = (Get-ItemProperty -Path $regPath -Name "Mode").Mode

Write-Host "=== Host Triage Summary ==="
Write-Host "OS Caption     : $caption"
Write-Host "Version/Build  : $version (Build $build)"
Write-Host "Install Date   : $installDate ($([math]::Floor($systemAgeDays.TotalDays)) days old)"

if ($authMode -ne $null) {
    Write-Host "CLFS Auth Mode : $authMode"
} else {
    Write-Host "CLFS Auth Mode : Not Configured / Key Missing"
}

# 3. Evaluate Exposure Logic
$isVulnerableBuild = $version -like "*26H2*" -or $build -ge 26100 # Adjust build threshold for 26H2
$isAged = $systemAgeDays.TotalDays -gt 90
$isVulnerableMode = ($authMode -eq 0 -or $authMode -eq 1)

if ($isVulnerableBuild -and $isAged -and $isVulnerableMode) {
    Write-Warning "[!] HOST EXPOSED: System meets OS build, age, and CLFS authentication mode criteria for SignDrop."
} else {
    Write-Host "[+] HOST NOT EXPOSED: Criteria for SignDrop exploitation not fully met." -ForegroundColor Green
}

Alternatively, the registry state can be queried directly from the command prompt using standard administrative tools:

reg query "HKLM\SYSTEM\CurrentControlSet\Services\CLFS\Authentication" /v Mode

Monitoring Object Manager Link Creation

To detect potential exploitation attempts in real time, configure Sysmon or enterprise EDR tools to monitor file creation events originating from MsMpEng.exe in user-writable directories (such as C:\Users\Public\ or AppData\Local\Temp\), alongside Symbolic Link creation events in \RPC Control\.

Common Triage Mistakes

  • Assuming Fresh Deployments are Vulnerable: IT teams often prioritize patching newly deployed machines. However, because SignDrop requires a build age exceeding 90 days, newly installed 26H2 machines will fail to reproduce the vulnerability, potentially leading to false negatives during patch validation testing.
  • Over-relying on Standard Antivirus Signatures: Because SignDrop abuses the execution flow of Defender itself (MsMpEng.exe), static signature scanning cannot detect the underlying logic bypass during execution. Detection strategies must focus on behavioral file creation auditing and Object Manager link tracking.
  • Modifying Low-Level Kernel Driver Keys Without Testing: Manually force-altering the CLFS\Authentication\Mode registry key across live production servers without testing can impact transactional logging services, leading to system instability or bugchecks.

Architectural Takeaways and Future Kernel Hardening

The SignDrop zero-day demonstrates the operational risks of cross-context file system operations. When privileged system services process requests originating from unprivileged security principals, enforcing client identity context at every layer is essential.

From an architectural standpoint, OS design teams and driver developers must consider several key principles:

1. Strict Impersonation Token Enforcement

When a privileged service (such as an antimalware engine running as SYSTEM) accesses disk artifacts on behalf of a routine triggered by an unprivileged user, it must explicitly impersonate the calling user context using APIs such as ImpersonateLoggedOnUser or SetThreadToken. If CLFS.sys had executed file creation checks under an impersonated low-privilege token, the privileged creation primitive would have been blocked by normal NTFS permission checks.

2. DACL Propagation Boundaries

Automated driver fallback logic should never copy discretionary access control lists from untrusted user-created files onto system-generated control files without rigorous sanitisation. Assigning unprivileged user ownership or full control flags to files generated inside system-owned directories breaks security trust boundaries.

3. Self-Defense vs Kernel Operations

Modern endpoint security solutions rely on process identity to grant bypass privileges for self-defense filter drivers. When a security process acts as an automated parser for untrusted inputs, its process identity becomes a vector for abuse. Designing defensive components requires separating core file-parsing routines into isolated, low-privilege sandboxes (such as AppContainers) rather than executing parsing logic directly inside high-privilege service processes.

Frequently asked questions

What is the SignDrop vulnerability?

SignDrop is an unpatched Windows zero-day vulnerability residing in the Common Log File System (CLFS). It enables an unprivileged local user to obtain full NT AUTHORITY\SYSTEM execution rights by forcing Windows Defender to open a crafted CLFS container and trigger an automated file creation routine that inherits attacker-controlled permissions.

Which operating system versions are affected by SignDrop?

The vulnerability specifically affects installations of Windows 11 26H2, Windows 11 26H2 Experimental, and Windows Server 2025 Experimental. Furthermore, the system must have been operational for more than 90 days and have its CLFS authentication mode registry key configured to mode 0 or mode 1.

How does the exploit leverage Windows Defender?

The exploit calls ServerMpUpdateEngineSignature, a legitimate Defender signature update function. By manipulating Windows Object Manager symbolic links, the attacker causes Defender to open a malformed CLFS container under its privileged process context, coercing the CLFS driver into creating a missing authentication file with elevated privileges and user-controlled access rights.

What registry setting indicates that a system is vulnerable to SignDrop?

A system is vulnerable if the registry value HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CLFS\Authentication\Mode is set to 0 (Learning Mode) or 1 (Enforcement Mode). If this value is missing or configured differently, the exploit cannot execute successfully.

Can a freshly installed and updated Windows 11 26H2 machine be exploited immediately?

No. Independent research by Will Dormann confirmed that SignDrop requires a target Windows 11 26H2 system to have existed for more than 90 days. Freshly installed or updated systems do not satisfy the environmental state conditions required for the exploit chain to complete.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.