A public exploit called SignDrop lets a standard local user obtain SYSTEM privileges on Windows, and Microsoft has not released a patch. The flaw lies in the CLFS authentication mechanism Microsoft added in October 2025 to protect the clfs.sys driver against memory-corruption attacks.
- SignDrop abuses a logic flaw in the CLFS authentication mechanism. When a privileged process opens a log file prepared by a standard user, the
clfs.sysdriver creates the.cnpfcompanion file in the SYSTEM context, with the ACLs of the original file. - The exploit forces the Defender antimalware engine (running as SYSTEM) to open a booby-trapped CLFS log through a
ServerMpUpdateEngineSignatureRPC call. Object-manager symbolic links redirect the creation of the.cnpftohid.dllin theinkdirectory. - An oplock (opportunistic lock) on a fake
MpEngine.dllacts as the synchronisation point: when Defender touches the file, the oplock breaks and the exploit retargets the symbolic links before CLFS creates the authentication file. - The planted
hid.dllis then loaded byconsent.exe(the Windows UAC process) during an elevation request, which runs the payload as SYSTEM (DLL sideloading). - No CVE has been assigned and no patch is available. Independent validations confirm that the exploit works and produces a SYSTEM shell on Windows 11 25H2/26H1/26H2 and Windows Server 2025.
MITRE ATT&CK mapping
The exploit chains several MITRE ATT&CK techniques. At its core is exploitation for privilege escalation (T1068) through the CLFS driver. It is triggered by abusing a system service (T1569.002) via the RPC call to Defender. The redirection phase relies on Windows object-manager native APIs (T1106) such as NtCreateSymbolicLinkObject. The final payload uses DLL sideloading (T1574.002) of hid.dll by consent.exe, which is also a UAC bypass (T1548.002). The planted file carries a legitimate name (T1036.005) in a system directory.
Background: CLFS and its authentication mechanism
The Common Log File System (CLFS) is a logging subsystem built into the Windows kernel since Vista. Its clfs.sys driver has long been a favourite target for privilege-escalation attackers: ten CLFS vulnerabilities are listed in the CISA KEV catalog, one of them exploited in ransomware campaigns in April 2025.
In response, Microsoft took a major preventive step: starting with the October 2025 updates for Windows 11 25H2, 26H1 and Windows Server 2025, the driver includes a log-file authentication mechanism. Each log file (.blf) receives a hash-based message authentication code (HMAC) computed from the log content and a machine-specific key. The driver refuses to parse any log file it did not write itself, which blocks memory-corruption attacks.
A companion file with the .cnpf extension is created automatically when a log is opened and that file is missing. The driver creates it in the security context of the calling process, with the ACLs (security descriptor) of the original log file. This creation step is what SignDrop hijacks.
Why Microsoft’s protection can be abused
The CLFS authentication mechanism is cryptographically sound. The problem is the logic that creates the .cnpf file, found in the CclfsContainer::Create routine of clfs.sys:
- Created in the caller’s context: when a privileged process (here Defender, running as SYSTEM) opens a log file tied to a container, the driver creates the matching
.cnpfin that process’s security context. The file is therefore created as SYSTEM. - Inherited ACLs: the
.cnpfinherits the security descriptor of the original log file. If the user created that log, they keep full control over the resulting.cnpf. - Redirectable path: the associated container path is stored in the
.blffile itself. If that path points to an object-manager symbolic link, the driver follows it without further checks.
A standard user can therefore prepare a CLFS log whose container points to a symbolic link they control, then force a SYSTEM process to open it. The driver creates a .cnpf file as SYSTEM, at a location chosen by the attacker, with ACLs that leave them full control. That is an arbitrary file-write primitive as SYSTEM.
The attack chain
The chain runs in five steps, with no special privileges and no kernel code. It uses only documented Windows APIs, combined to turn the creation of the .cnpf into an arbitrary DLL write.
Setting up the CLFS environment
T1106 T1068
The exploit starts by killing and relaunching osk.exe (the on-screen keyboard) hidden. This process is used later for cleanup. A temporary working directory %TEMP%\SigDrop_<GUID> is created with the FILE_DELETE_ON_CLOSE flag (deleted automatically on close).
A CLFS log file is created through the \CLFS prefix in the kernel namespace. Two symbolic links are placed in \BaseNamedObjects\Restricted\: the first (<GUID>) points the container to a file in the working directory; the second (<GUID>.cnpf) points the authentication file to the same directory. The exploit then calls DeviceIoControl with IOCTL code 0x8007A808 to create the CLFS container.
A vulnerability check follows: if the .cnpf file does not exist after this step, the machine is not vulnerable (CLFS authentication disabled) and the exploit stops.
Placing the bait and the oplock
T1036.005
An empty file named MpEngine.dll, the name of Defender’s scanning engine, is created in the working directory. The exploit places an RWH-level (Read + Write + Handle) oplock on it through FSCTL_REQUEST_OPLOCK. The oplock works as a tripwire: when Defender accesses the file, it breaks and the exploit is notified.
A third symbolic link (<GUID3>) is created in \BaseNamedObjects\Restricted\, pointing to the working directory. It is used to steer Defender to the fake MpEngine.dll.
In parallel, the exploit opens a watch handle on C:\Program Files\Common Files\microsoft shared\ink with ReadDirectoryChangesW, waiting for a hid.dll file to appear.
Triggering through Defender’s RPC interface
T1569.002
A worker thread connects to the Defender antimalware service RPC interface using UUID c503f532-443a-4c69-8300-ccd1fbdb3839 and endpoint IMpService77BDAF73-B396-481F-9042-AD358843EC24 over ncalrpc.
The exploit calls Proc42_ServerMpUpdateEngineSignature, passing \\.\GlobalRoot\BaseNamedObjects\Restricted\<GUID3> as the update directory. Defender, running as SYSTEM, follows the symbolic link and tries to access MpEngine.dll in the working directory.
That access breaks the oplock set in step 2. The exploit receives the notification and moves to the redirection phase.
Retargeting the symbolic links
T1068 T1106
As soon as the oplock notification arrives, the exploit runs a fast retargeting sequence:
a) The fake MpEngine.dll is deleted (via FileDispositionInfo).
b) The <GUID3> symbolic link is closed and recreated to point to \BaseNamedObjects\Restricted (the parent object directory), so Defender resolves mpasbase.vdm and the CLFS container through this new entry point.
c) A new mpasbase.vdm symbolic link is created in \BaseNamedObjects\Restricted\, pointing to the CLFS log file created in step 1.
d) The .cnpf symbolic link is closed and recreated to point to \??\C:\Program Files\Common Files\microsoft shared\ink\hid.dll.
Still in its update sequence, Defender follows the links and opens the CLFS log. The clfs.sys driver sees that the .cnpf is missing and creates it as SYSTEM, following the symbolic link. hid.dll is thus created in the ink directory with SYSTEM privileges and ACLs the user can write to.
DLL sideloading and a SYSTEM shell
T1574.002 T1548.002
The watch handle reports hid.dll in the ink directory. The exploit opens it with CREATE_ALWAYS and writes into it a DLL embedded as a resource (IDR_DLL1) that carries the payload.
It then calls ShellExecute with the "runas" verb on conhost.exe. The elevation request starts consent.exe (the Windows UAC process), which runs as SYSTEM. consent.exe loads hid.dll from C:\Program Files\Common Files\microsoft shared\ink (DLL sideloading), executing the payload as SYSTEM.
The result is a SYSTEM shell. The exploit finishes by killing osk.exe and deleting hid.dll through an NTFS transaction (DeleteFileTransacted + CommitTransaction) to reduce traces.
Attack chain diagram
VirusTotal analysis of the published binary
The published SigDrop.exe binary is widely detected by the antivirus industry: 42 of 71 engines flag it as malicious, with a community score of −1.
Notable detections: AliCloud identifies the exploit by name (Exploit:Win/SignDrop.DM8PHU), CrowdStrike Falcon rates it 100% malicious confidence, ESET-NOD32 classifies it as Win64/Exploit.Agent.DP Trojan and Kaspersky as HEUR:Exploit.Win64.LegacyHive.a. With a detection rate above 59%, most EDR and antivirus products will flag the raw binary. A motivated attacker can still recompile the published source code to evade static signatures.
Independent validations
Sungyup Nam (78researchlab) confirmed that the exploit works on Windows 11 26H2 and produces a SYSTEM shell. Howler Cell (Cyderes) reproduced the chain on Windows 11 25H2 (Defender engine 1.1.26080.3) and confirmed all five steps run to completion. The published PoC works on the tested versions.
What is exposed
The impact is a full operating-system compromise: any local user (including on multi-user systems, shared workstations or Terminal Server sessions) can raise their rights to SYSTEM.
- Any local access control is bypassed: an attacker with physical or RDP access on a restricted account gets full administrative access.
- Easier persistence: with SYSTEM rights, installing backdoors, changing security policies or disabling an EDR no longer requires another vulnerability.
- Risk for VDI and terminal environments: architectures where several users share the same Windows host are especially exposed.
- Chaining with other vectors: an attacker who gained a foothold through phishing or an application flaw can use SignDrop as the second stage for escalation.
- Tamper-protection bypass: the file is created in the context of the antimalware process itself. From the EDR kernel driver’s point of view, the request comes from the legitimate Defender process, which sidesteps tamper protection.
Affected systems run Windows 11 25H2, 26H1, 26H2 or Windows Server 2025 with the CLFS authentication mode set to 0 (enforced) or 1 (learning). Installations older than 90 days automatically switch from learning to enforced mode, the default target configuration in production.
Three flaws that add up
The most severe incidents rarely come from a single vulnerability. They come from independent decisions that each look reasonable on their own. SignDrop is a good example.
- A defence mechanism that creates a new attack primitive
CLFS authentication did stop memory corruption. But by requiring a
.cnpfcompanion file to be created in the caller’s context, with the ACLs of the original log, it introduced a privileged file-write primitive that did not exist before. Every new protection that touches the file system must be modelled as a new attack surface. - An easily triggered SYSTEM service used as a relay
Defender’s RPC interface (
ServerMpUpdateEngineSignature) is reachable from a standard user account. By passing an attacker-controlled path as the update directory, an unprivileged process forces Defender to open a booby-trapped CLFS log. The antimalware engine becomes an unwitting relay for file creation as SYSTEM. The pattern generalises: any SYSTEM service that accepts a file path from a standard user is a potential vector. - The object-manager namespace as a defensive blind spot
Windows object-manager symbolic links (placed in
\BaseNamedObjects\Restricted\) are the cornerstone of the exploit. They redirect the CLFS container path, the.cnpfpath and the update path presented to Defender. Any file creation in a privileged context that relies on a user-influenced path should be treated as vulnerable unless explicitly protected.
Recommendations
Until Microsoft ships a fix, security teams have to act on configuration and detection.
Immediate: check each host’s exposure
Read the registry value HKLM\SYSTEM\CurrentControlSet\Services\CLFS\Authentication → Mode.
- Mode 0 or 1: the system is within the exploit’s claimed scope. High priority
- Mode 2 or 3: CLFS authentication is disabled, so the system is outside SignDrop’s scope but exposed to memory-corruption vulnerabilities. Do not disable CLFS authentication as a workaround.
Immediate: monitor indicators of compromise
The published code leaves observable, distinctive artefacts. Indicators to monitor, mapped to the corresponding MITRE ATT&CK techniques:
- Temporary directory
SigDrop_<GUID>: a directory created in%TEMP%with theFILE_DELETE_ON_CLOSEflag by a non-admin process, namedSigDrop_followed by a GUID. T1106 - CLFS log via
\CLFS: a.blffile created through the\CLFSprefix in the kernel namespace, followed by IOCTL0x8007A808to create a container. T1068 - Symbolic links in
\BaseNamedObjects\Restricted\: three or more symbolic links created in this namespace, with targets changing quickly (retargeting). T1106 ServerMpUpdateEngineSignatureRPC call: a call to procedure 42 of interfacec503f532-443a-4c69-8300-ccd1fbdb3839from a process other thanMsMpEng.exe. T1569.002- Fake
MpEngine.dllwith an oplock: an emptyMpEngine.dllcreated outside the Defender tree, with an active RWH oplock. T1036.005 hid.dllwritten to theinkdirectory:C:\Program Files\Common Files\microsoft shared\ink\hid.dllappearing with an abnormal security descriptor (standard-user ACLs on a system file). T1574.002consent.exeloadinghid.dll: the UAC process loads an unsigned DLL from theinkdirectory instead of a legitimate system DLL. T1548.002- Transactional deletion:
DeleteFileTransactedfollowed byCommitTransactiononhid.dllin theinkdirectory (an attempt to clear traces).
Short term: reduce local exposure
Multi-user environments (VDI, Terminal Server, shared workstations) are the most exposed. Assess whether access to Defender’s ServerMpUpdateEngineSignature RPC interface can be restricted for standard accounts (through the RPC endpoint security descriptors). Step up monitoring of symbolic-link creation in \BaseNamedObjects\Restricted\ and of oplocks on files named MpEngine.dll outside the Defender tree.
Medium term: model defence mechanisms as attack surfaces
SignDrop is a reminder that every protection that touches the file system or adds new privileged execution flows needs its own threat model. CLFS authentication stopped memory corruption, but the creation of the .cnpf file introduced an exploitable privileged write primitive. This should be part of security reviews of system updates, especially those that add new authentication mechanisms to the kernel.
Follow-up: check Microsoft’s Security Update Guide for a CVE assignment and a patch.
SignDrop is a working, public exploit that produces a SYSTEM shell on the tested versions. It is not a theoretical PoC: independent validations confirm it.
The flaw is not a coding bug but an architectural decision. Microsoft added an authentication mechanism to the CLFS driver to block memory corruption, but the .cnpf file is created in the caller’s context, with the ACLs of the original log. The exploit forces Defender (SYSTEM) to open a booby-trapped log over RPC, redirects the .cnpf creation to hid.dll in a system directory, then abuses consent.exe DLL sideloading to run code as SYSTEM.
Until a patch ships, detection is the main lever. Our Audit & Offensive Security teams test this kind of scenario during internal penetration tests. Our SOC, Detection & Response offering deploys detection rules for SignDrop artefacts (symbolic links, RPC calls, oplock on MpEngine.dll, hid.dll writes) and provides continuous monitoring.
- SignDrop proof-of-concept, GitHub
- CLFS Log File Authentication, Microsoft Learn
- Common Log File System CLFS Authentication Mitigation, Microsoft Support
- Microsoft Security Update Guide, MSRC
- MITRE ATT&CK, Exploitation for Privilege Escalation (T1068)
- MITRE ATT&CK, Hijack Execution Flow: DLL Side-Loading (T1574.002)
- MITRE ATT&CK, Abuse Elevation Control Mechanism: Bypass UAC (T1548.002)
- SignDrop, Cyderes Howler Cell (technical analysis and PoC reproduction)
- BleepingComputer, New Windows SignDrop zero-day gives hackers SYSTEM privileges, 12 November 2026
- The Hacker News, New SignDrop Zero-Day Exploit, 12 November 2026
