TL;DR
- What happened: Security researcher MSNightmare published a public proof-of-concept (PoC) local privilege escalation exploit named SignDrop targeting the Windows Common Log File System driver (
clfs.sys). - Who is affected: Systems running Windows 11 25H2, 26H1, and Windows Server 2025 where CLFS log authentication is configured in Mode 0 (enforced) or Mode 1 (learning).
- Impact & Severity: Unpatched zero-day vulnerability allowing an authenticated local user with standard privileges to escalate to
NT AUTHORITY\SYSTEM. Microsoft has not assigned a CVE identifier or released a security patch as of publication. - What to do now: Do not disable CLFS authentication globally in the Windows registry. Instead, deploy endpoint detection rules to monitor Object Manager symbolic link creation targeting
.cnpffiles and track anomalous file operations initiated byMsMpEng.exe.
On 10 November 2026, security researcher MSNightmare published a public proof-of-concept repository demonstrating the signdrop windows clfs exploit, an unpatched local privilege escalation zero-day affecting recent builds of Windows 11 and Windows Server 2025. The flaw resides within the Windows Common Log File System driver (clfs.sys) and directly targets architectural companion file creation logic introduced to enforce log authentication checks. By manipulating Object Manager symbolic links during privileged log parsing operations, an authenticated attacker holding standard user permissions can gain arbitrary file write capabilities and escalate privileges to NT AUTHORITY\SYSTEM.
The public disclosure came alongside Microsoft’s November security release, though the vendor has not yet confirmed the flaw, assigned a Common Vulnerabilities and Exposures (CVE) identifier, or issued an official advisory or out-of-band fix. Independent verification by researcher Heewon Song of the PurpleHound offensive content team at 78researchlab confirmed that the exploit mechanics function as claimed, though operational reliability remains variable and execution generates visible artifacts on the target system.
SignDrop illustrates an inherent architectural challenge in operating system driver hardening. The underlying log authentication feature was introduced specifically to block memory corruption attacks by validating log file signatures. However, the companion recovery file mechanism designed to support this validation introduced a security context mismatch. System administrators and platform engineers must evaluate their registry configurations and endpoint telemetry to manage exposure without re-exposing their fleets to legacy kernel parsing bugs.
The SignDrop Zero-Day: Unpatched Escalation in Windows Infrastructure
The release of the SignDrop repository on GitHub on 10 November 2026 introduced an unpatched local privilege escalation (LPE) vector against modern Windows kernel environments. As reported by The Hacker News, the vulnerability targets logic added to clfs.sys in platform updates shipped in October 2025. The affected OS baseline includes Windows 11 25H2, Windows 11 26H1, and Windows Server 2025. MSNightmare confirmed functional testing against Windows 11 26H2, Windows 11 26H2 Experimental builds, and Windows Server 2025 Experimental builds.
Unlike classic kernel vulnerabilities that rely on complex heap manipulation, pool corruption, or race conditions within memory structures, SignDrop operates entirely at the logic level. It exploits the boundary where kernel-mode driver file operations interact with user-mode security contexts. Because Microsoft has not assigned a CVE identifier or provided a timeline for a software update, security operations teams must rely on behavioral detection and configuration auditing rather than standard patch management workflows.
Independent analysis published by Sungyup Nam, head of research at 78researchlab, validated the vulnerability logic. Testing performed by Heewon Song confirmed that an unprivileged user process can leverage SignDrop to acquire SYSTEM execution boundaries. However, 78researchlab noted that the exploit’s execution dynamics make it somewhat unstable for stealthy red-team operations due to visible desktop artifacts and reliance on specific service execution paths.
Understanding CLFS Log Authentication and Companion Files
The Common Log File System (clfs.sys) is a high-performance, general-purpose logging subsystem integrated into the Windows kernel. It provides dedicated API boundaries for both kernel-mode components (such as the Kernel Transaction Manager) and user-mode applications to create, stream, and flush transactional log structures. CLFS relies on Base Log Files (BLF) containing metadata headers and sequence array pointers, backed by physical container files that hold raw log data records.
Historically, the complexity of parsing untrusted BLF structures made clfs.sys a target for offensive security researchers and threat actors. Ten distinct CLFS vulnerabilities have been cataloged in CISA’s Known Exploited Vulnerabilities (KEV) list, including memory corruption flaws heavily exploited in enterprise ransomware operations. Because standard users can create and submit custom BLF structures to system services, driver parsing bugs frequently became high-reliability privilege escalation primitives.
To systematically mitigate log-structure tampering, Microsoft implemented an HMAC-based log authentication mechanism in October 2025 for Windows 11 25H2, 26H1, and Windows Server 2025. Under this model, clfs.sys appends a Hash-based Message Authentication Code to log structures using a host-unique key. When opening a log file, the driver verifies this signature to ensure the file was generated on the local machine and has not been altered offline.
To support this authentication flow during recovery and state synchronization operations, clfs.sys relies on companion parameter recovery files bearing the .cnpf extension. When an authenticated log file is accessed, the driver creates or updates a corresponding .cnpf companion file in the same directory path as the target log. According to Microsoft’s log file authentication specification, this companion file is intended to inherit the exact security attributes of the original log file to maintain identical access restrictions.
Anatomy of the SignDrop Vulnerability Logic
The root cause of the SignDrop vulnerability lies in a security context mismatch combined with permissive Access Control List (ACL) inheritance during companion file creation. Rather than executing file creation under the security context of the user who owns or authored the original log file, clfs.sys handles companion file generation under the security context of whichever thread or process initiates the file open handle.
This architectural behavior creates an exploitable trust boundary when an unprivileged user prepares a malicious log environment and subsequently tricks a privileged system service into processing it:
- Log Preparation: An unprivileged local user creates a custom CLFS log file (
.blf) and associated container files inside a directory structure fully controlled by the user account. The standard user holds explicit Read, Write, and Modify permissions on these objects. - Privileged Handle Invocation: The attacker triggers a privileged system service running as
NT AUTHORITY\SYSTEMto open or scan the prepared log file. - Companion File Generation: Upon opening the log,
clfs.sysdetermines that a companion.cnpfrecovery file must be created alongside the log. Because the request originates from the privileged service thread, the I/O request packet (IRP) issued byclfs.systo create the.cnpffile executes within theSYSTEMsecurity context. - Inheritance Abuse: Following its architectural design,
clfs.syscopies the explicit security attributes and ACLs of the original user-controlled.blflog file onto the newly created.cnpffile. - Privileged File Ownership with User Write Access: The resulting
.cnpffile is instantiated on disk as a system-created artifact, but its inherited security descriptor grants full write access back to the standard user.
+-----------------------------------------------------------------------------------+
| Attacker (Standard User) |
| 1. Prepares malicious .blf log and container in user-controlled directory. |
| 2. Retains full explicit ACL permissions (Read/Write) on initial .blf file. |
+-----------------------------------------------------------------------------------+
|
v (Triggers Service Open Handle)
+-----------------------------------------------------------------------------------+
| Privileged Service Context (SYSTEM) |
| 3. Opens user-controlled .blf log file (e.g. via Defender scan/update trigger). |
+-----------------------------------------------------------------------------------+
|
v (Invokes Driver Recovery Logic)
+-----------------------------------------------------------------------------------+
| Kernel Driver (clfs.sys) |
| 4. Evaluates log authentication structures. |
| 5. Generates companion file (.cnpf) under caller's context (SYSTEM). |
| 6. Inherits original ACLs from user-owned .blf file. |
+-----------------------------------------------------------------------------------+
|
v (Exploit Redirection Matrix)
+-----------------------------------------------------------------------------------+
| Target Arbitrary File Path |
| Result: SYSTEM creates file, but Standard User maintains Write access handle. |
+-----------------------------------------------------------------------------------+
Because the driver executes file system creation requests on behalf of a SYSTEM thread while trusting user-defined file ACLs, the standard user gains a primitive that allows them to manipulate files created by privileged driver logic. As MSNightmare noted in the public repository, the driver’s structural validation functions operate correctly according to specification, but the design permits privilege context confusion during companion file instantiation.
Object Manager Symbolic Link Redirection via Microsoft Defender
To turn the companion file creation logic into an arbitrary file write primitive, SignDrop relies on Windows Object Manager symbolic link redirection. In Windows, the Object Manager manages system resources—including files, devices, and symbolic links—within a hierarchical namespace. Standard users possess full permissions to create object symbolic links inside their local, unprivileged session namespaces (such as \RPC Control or session-specific object directories).
In the published proof of concept, MSNightmare chains this symbolic link capability with the Microsoft Defender Antimalware Service (MsMpEng.exe). The attack vector proceeds through a structured sequence:
- The attacker creates an Object Manager symbolic link inside
\RPC Control, mapping the expected companion file path (e.g.,C:\UserDir\TargetLog.blf.cnpf) to an arbitrary target location on the filesystem where a system file or privileged configuration resides. - The attacker invokes the Microsoft Defender update interface or command-line utility (
MpCmdRun.exe), passing parameters that force the elevatedMsMpEng.exeprocess (running asSYSTEM) to parse the directory containing the custom CLFS log. - When
MsMpEng.exeopens the.blffile,clfs.sysattempts to create the.cnpfcompanion file at the target path. - The kernel resolves the Object Manager symbolic link during path lookup, redirecting the file creation call away from the user directory and onto the protected arbitrary target path specified by the attacker.
- The target file is created or modified under the elevated security descriptor of
MsMpEng.exe, while inheriting the permissive write ACLs defined on the original user log.
Once arbitrary file write capability is achieved over a target path, the attacker overwrites a critical system configuration, DLL load path, or service binary to achieve code execution. Detailed technical breakdowns of CLFS privilege escalation mechanics demonstrate how standard users can convert such file overwrite primitives directly into an interactive SYSTEM shell.
Exploit Reliability, Artifacts, and Operational Constraints
While the architectural flaw in clfs.sys is valid, operational testing by security firm 78researchlab indicates that the current SignDrop PoC code exhibits specific constraints that affect its reliability in live environments. The assessment conducted by researcher Heewon Song highlighted key operational characteristics:
Operational Viability Assessment
Independent testing confirms that SignDrop successfully achieves privilege escalation from standard user to SYSTEM. However, timing constraints during symbolic link resolution and dependency on specific service handles render the current public exploit code unreliable for automated red-team deployments.
The primary constraint in the public PoC is its reliance on the default Microsoft Defender service execution chain. Because the exploit uses Defender’s update and scanning routines to force MsMpEng.exe into opening the prepared log structure, systems running third-party Endpoint Detection and Response (EDR) or Antivirus (AV) agents where Defender is disabled or running in passive mode may not trigger the payload path without modification.
Additionally, execution generates high-visibility visual and behavioral artifacts on the interactive desktop session:
- UAC Prompt Interception: The exploit code alters the standard User Account Control (UAC) prompt flow during execution.
- Dual Shell Spawning: Successful execution spawns both a standard user command prompt and an elevated
SYSTEMcommand shell simultaneously. - Desktop Session Interference: Interactive UAC dialog boxes freeze or fail to clear correctly while the exploit holds target handles, rendering the attack immediately noticeable to an active logged-in user.
MSNightmare claimed in the project documentation that the core technique could theoretically target any third-party antimalware or security service running with elevated privileges, provided the target service can be induced to parse a local CLFS log file. However, this generalized attack surface has not been publicly verified or demonstrated across third-party endpoint security products.
Evaluating Registry Configurations and Security Trade-Offs
The vulnerability scope of SignDrop is directly tied to the CLFS driver’s authentication registry configuration. Microsoft controls the operational behavior of clfs.sys log authentication through a specific registry key under the system configuration hive:
HKLM\SYSTEM\CurrentControlSet\Services\CLFS\Authentication
The operational state is defined by the Mode DWORD value within this key. The security posture and exploit susceptibility vary across these configuration states:
| Registry Mode Value | Operational State | SignDrop Attack Surface | Legacy Memory Corruption Exposure | Default System Behaviour |
|---|---|---|---|---|
0 |
Enforced Mode | Vulnerable | Protected | Default on systems installed > 90 days. HMAC verified; companion .cnpf logic fully active. |
1 |
Learning Mode | Vulnerable | Protected (Logged) | Default on fresh installations. Logs auth failures; companion .cnpf logic active. Auto-transitions to Mode 0 after 90 days. |
2 |
Disabled Mode | Not Vulnerable | Highly Exposed | Disables log signature validation and companion file logic. Reopens legacy parsing bugs. |
3 |
Disabled Mode (Verbose) | Not Vulnerable | Highly Exposed | Disables log signature validation with extended diagnostic logging. Reopens legacy parsing bugs. |
Systems running in Mode 0 (enforced) or Mode 1 (learning) fall squarely within the attack surface targeted by SignDrop. Windows installations automatically transition from learning mode (1) to enforcement mode (0) after 90 days of operational uptime. As a result, almost all enterprise fleets running updated builds of Windows 11 25H2, 26H1, or Windows Server 2025 operate in Mode 0 by default.
Critical Architectural Dilemma
Setting the CLFS Authentication Mode registry key to 2 or 3 removes the companion .cnpf file logic and eliminates the SignDrop attack surface. However, doing so disables HMAC validation entirely. This exposes the kernel to classic log-parsing memory corruption vulnerabilities—the exact attack vector exploited in ten historical CISA KEV entries. System administrators should NOT disable authentication mode globally.
Defensive Guidance: Detection Engineering and Mitigation Playbook
Because disabling driver log authentication exposes systems to severe legacy memory corruption bugs, defensive strategy must focus on auditing fleet configurations, deploying high-confidence EDR telemetry rules, and monitoring Object Manager manipulation.
1. Enterprise Fleet Audit
Administrators can execute the following PowerShell command to query the current CLFS authentication state across endpoints. Test state-changing scripts in a staging environment prior to mass deployment.
# Diagnostic query for CLFS Log Authentication Mode
$ClfsKeyPath = "HKLM:\SYSTEM\CurrentControlSet\Services\CLFS\Authentication"
if (Test-Path $ClfsKeyPath) {
$AuthMode = (Get-ItemProperty -Path $ClfsKeyPath -Name "Mode" -ErrorAction SilentlyContinue).Mode
[PSCustomObject]@{
ComputerName = $env:COMPUTERNAME
CLFSAuthMode = $AuthMode
VulnerableToSignDrop = if ($AuthMode -eq 0 -or $AuthMode -eq 1) { $true } else { $false }
}
} else {
[PSCustomObject]@{
ComputerName = $env:COMPUTERNAME
CLFSAuthMode = "Key Not Present (Default / Legacy OS)"
VulnerableToSignDrop = $false
}
}
2. Object Manager Symbolic Link Redirection Detection
Security operations teams should configure EDR solutions or Windows Event Forwarding to flag standard user processes creating symbolic links inside \RPC Control or session object directories that point to system paths or target .cnpf file extensions.
Example logic for detection rules (Sysmon Event ID 7 / EDR File/Directory Link creation):
TargetFilename ENDS WITH ".cnpf"
AND TargetFilename CONTAINS "\RPC Control\"
AND User NOT EQUAL TO "NT AUTHORITY\SYSTEM"
3. Privileged Process File Write Telemetry
Monitor elevated processes—specifically MsMpEng.exe—performing file creation operations in non-standard user directories or writing files that inherit non-standard permissions. Under normal operations, MsMpEng.exe should not generate .cnpf companion files inside arbitrary staging directories controlled by standard user accounts.
# Query Event Log for suspicious Defender file operations (Sysmon Event ID 11)
Get-WinEvent -FilterHashtable @{
LogName = 'Microsoft-Windows-Sysmon/Operational'
Id = 11
} | Where-Object {
$_.Properties[4].Value -like "*MsMpEng.exe*" -and
$_.Properties[5].Value -like "*.cnpf*"
} | Select-Object TimeCreated, Message
4. Anomalous Shell Execution Tracking
Implement process-creation monitoring (Event ID 4688 or Sysmon Event ID 1) to detect command shells (cmd.exe, powershell.exe) executing as SYSTEM where the parent process tree shows anomalous origins, such as unexpected invocation adjacent to UAC consent processes (consent.exe) or antimalware updates.
Common Mistakes when Remediating CLFS Driver Exposures
Enterprise engineering teams responding to zero-day disclosures often make architectural missteps during mitigation efforts:
- Globally Setting Registry Mode to 2 or 3: Disabling CLFS authentication globally to mitigate SignDrop immediately neutralizes driver signature checks. This exposes the system to malformed BLF log files capable of triggering kernel pool corruptions.
- Relying Solely on Static File Hash Signatures: Because SignDrop is an operational logic exploit rather than a static malware binary, relying on AV signatures for the PoC code leaves environments vulnerable to compiled variants or modified execution wrappers.
- Ignoring Object Manager Telemetry: Filtering endpoint detection rules strictly at the filesystem layer often misses symbolic link redirection. Telemetry rules must observe kernel object creation events within
\RPC Controlbefore path resolution occurs.
MSNightmare Research Lineage and the History of CLFS Exploitation
The SignDrop release represents a continuing line of offensive security research published by MSNightmare targeting critical Windows subsystem boundaries. The researcher has repeatedly focused on the interaction between Windows administrative boundaries and endpoint security services:
- RoguePlanet (CVE-2026-50656): Confirmed by Microsoft in June 2026 and patched in July 2026, RoguePlanet exploited a race condition in Microsoft Defender’s temporary file parsing routines to elevate privileges.
- ShieldBreak (CVE-2026-69414): Discovered and patched in August 2026, ShieldBreak targeted file-handling logic bypasses inside Defender’s scan routines. Three earlier Defender vulnerabilities discovered by the researcher were subsequently observed in real-world exploitation.
- SignDrop (Unpatched): Marks a strategic pivot from file race conditions within user-mode AV routines to driver-level logic flaws inside
clfs.sysauthentication features.
This progression highlights how hardening features implemented within core kernel drivers can inadvertently expand the attack surface if security context boundaries are not strictly preserved throughout secondary file operations.
Key Takeaways for Enterprise Systems Management
Managing the risk posed by SignDrop requires a balanced approach to kernel security and detection engineering:
- Maintain Registry Authentication Protection: Do not change
HKLM\SYSTEM\CurrentControlSet\Services\CLFS\Authentication\Modeto 2 or 3. Preserve HMAC integrity checks to protect against memory corruption attacks. - Deploy Symlink Telemetry Rules: Ensure EDR agents actively monitor Object Manager link creation targeting
\RPC Controland companion log extensions (.cnpf). - Monitor Elevated Service Behavior: Instrument process and file-creation monitoring around
MsMpEng.exeand privileged antimalware components to detect anomalous file creation handles. - Track MSRC Updates: Watch Microsoft Security Response Center releases for an official out-of-band fix or Patch Tuesday deployment addressing
clfs.syscompanion file security context handling.
Frequently asked questions
Has Microsoft assigned a CVE or released a security patch for SignDrop?
No. As of publication, Microsoft has not confirmed the vulnerability, assigned an official CVE identifier, or issued a security patch or advisory for SignDrop. Enterprise administrators must rely on behavioral EDR telemetry and process auditing to detect potential exploitation attempts.
Should enterprise administrators disable CLFS log authentication to block SignDrop?
No. Setting the CLFS authentication registry mode to 2 or 3 removes the companion file logic and blocks SignDrop, but it disables HMAC validation entirely. This exposes the system to legacy log-parsing memory corruption bugs, which are historically heavily targeted in ransomware campaigns.
Which Windows versions are affected by the SignDrop zero-day exploit?
The exploit affects Windows 11 25H2, Windows 11 26H1, and Windows Server 2025 running CLFS authentication in Mode 0 (enforced) or Mode 1 (learning). MSNightmare confirmed functional testing on Windows 11 26H2 and Server 2025 Experimental builds.
Does SignDrop require local interactive access or can it be executed remotely?
SignDrop is a local privilege escalation (LPE) vulnerability. It requires an attacker to already possess authenticated code execution on the target host as a standard user. It cannot be executed remotely across the network without an initial access vector.
How does SignDrop differ from previous Defender exploits like RoguePlanet and ShieldBreak?
RoguePlanet and ShieldBreak targeted file handling race conditions within Microsoft Defender’s user-mode service routines. SignDrop targets a logic flaw within the kernel driver clfs.sys, specifically abusing how companion .cnpf files inherit permissions during authenticated log processing.
Sources and further reading
- New SignDrop Zero-Day Exploit Turns Windows CLFS Security Feature Into SYSTEM Access (The Hacker News)
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.