Showing posts with label Zero-Day. Show all posts
Showing posts with label Zero-Day. Show all posts

Monday, November 16, 2026

A Windows Feature Built to Stop Attacks Is Now the Way to SYSTEM

On November 10, 2026, the same day Microsoft shipped its monthly security updates, a researcher using the handle MSNightmare posted a working exploit to GitHub. It is written in C++, it comes with a Visual Studio project, and according to its author it spawns a shell running as SYSTEM, the highest privilege level on a Windows machine. The exploit is called SignDrop, and the part that makes it worth your attention is not that it reaches SYSTEM. Plenty of Windows bugs do that. It is that SignDrop reaches SYSTEM by abusing a feature Microsoft built specifically to stop this kind of attack.

There is no CVE number yet, no patch, and no public comment from Microsoft. The November update did not address it, and Microsoft has not validated the researcher's claims one way or the other. No attacks in the wild have been reported. So this is not a fire alarm in the way an actively exploited flaw would be. It is something slower and, in its own way, more instructive: a public demonstration that a security mitigation can become the attack surface it was meant to shrink.

The feature it turns against you

The Common Log File System, or CLFS, is a general-purpose logging engine built into Windows. Applications and parts of the operating system use it to write transaction logs, the kind of record that lets software recover cleanly after a crash. CLFS has also been one of the most reliably exploited corners of Windows. By Microsoft's own accounting, cited in the SignDrop write-up, 19 of the 24 CLFS vulnerabilities disclosed over five years came down to the same root problem: the code trusted log data it should have validated.

Microsoft's response was sensible. If attackers keep feeding CLFS malformed log files that it parses too trustingly, make CLFS verify that a log file is genuine before trusting it. So recent Windows added authentication codes, HMACs in the technical shorthand, to CLFS log files. An HMAC is a short cryptographic signature that proves a file was produced by the system and has not been tampered with. The idea is that a forged or corrupted log fails the signature check and gets rejected before it can do harm.

That protection runs in two phases. For a 90-day learning period, CLFS signs log files as they are opened, building up valid signatures for the logs already on the machine. After that window, it switches to enforcement, where it checks those signatures and refuses logs that do not match. Learning mode and enforcement mode are both, according to the SignDrop research, exposed to the technique.

How the trick works, in concept

SignDrop does not go back to corrupting memory the old way. It attacks the signing logic itself. The exploit forges the privileged signature files that CLFS relies on to decide a log is trustworthy, so the system accepts attacker-controlled log data as legitimate. The design, in the researcher's framing, moves the focus from memory corruption to the authentication layer that was supposed to end the memory-corruption era. Once CLFS trusts a log it should have rejected, a standard user account can ride that trust to run code as SYSTEM.

I am deliberately not walking through the steps, and the point does not need them. What matters for a defender is the shape of the problem. The mitigation added a new thing the system has to trust, the signature on a log file, and trust is exactly what attackers look for. A feature that validates data is only as strong as its own validation, and SignDrop is a claim that this particular validation can be faked.

A safeguard is just more code. More code is more to get wrong.

The timing is its own small lesson. Dropping a working exploit on Patch Tuesday, the day Microsoft ships its fixes, guarantees the longest possible gap before the next scheduled update. Microsoft's regular cadence is monthly, so absent an out-of-band patch, a flaw disclosed on update day has roughly four weeks of daylight. That does not mean an in-the-wild wave is coming. It does mean the people who track public proof-of-concept code now have a tested tool and a known window, and the defenders who ignore anything without a CVE number are the ones most likely to be surprised by it.

The researcher says the technique was tested on Windows 11 version 26H2 and on experimental builds of Windows 11 and Windows Server 2025. They also estimate that around 80 percent of Windows installations worldwide are vulnerable, particularly machines that have been running more than 90 days. Treat that number with skepticism. It comes with no data behind it, and a researcher's estimate of global exposure is one of the softest figures you will find in any disclosure. The tested builds are concrete. The 80 percent is a guess.

Why this matters even without a patch

SignDrop is a local privilege escalation, not a way in from the internet. An attacker needs to already be on the machine with a normal user account before SignDrop does anything. That sounds reassuring until you remember how most intrusions actually unfold. The phishing email, the stolen credential, the malicious package all tend to land an attacker as an ordinary user. Privilege escalation is the step that turns a foothold into full control of the box, and from there into the ability to disable defenses. The SignDrop write-up says the same access can be used to turn off antivirus and EDR, the endpoint detection tools defenders rely on to see what is happening.

There is an obvious temptation to simply switch the CLFS authentication mitigation off and make the whole problem disappear. Don't. The researcher is explicit that disabling it would re-expose the machine to the older CLFS memory-corruption bugs the mitigation was built to block. You would be trading a public proof-of-concept with no in-the-wild activity for a stack of previously patched flaws that attackers know well. That rule sounds harsh until you count the 19 old CVEs waiting on the other side of that switch.

So the practical posture is containment and visibility while Microsoft works out a response. Limit who has interactive local access to sensitive systems, because every account that can log in locally is an account that could launch a local escalation. That is a worthwhile audit on its own, independent of SignDrop, and most environments have more standing local access than anyone remembers granting. Watch for the aftermath rather than the exploit: unexpected processes running as SYSTEM, privilege changes that nobody requested, and above all any tampering with or sudden silence from your endpoint security tools. An EDR agent that goes quiet is not a minor event on a machine where this technique is possible. Treat it as an incident until proven otherwise.

What I would do first is make sure the SYSTEM-level telemetry you are counting on is actually being collected somewhere the attacker cannot reach. If SignDrop's selling point is that it can switch off the very tools that would catch it, then logs shipped off the host in real time are worth more than any single agent sitting on it. The exploit is public and unpatched, which means the window between now and Microsoft's fix belongs to whoever is paying closer attention. Right now that can still be the defenders.

References

Do Son. (2026, November 11). SignDrop Windows CLFS zero-day details and proof-of-concept exploit published. Security Online. https://securityonline.info/signdrop-windows-clfs-zero-day-poc/

Daily Security Review. (2026, November). SignDrop Windows CLFS zero-day exploit published, no patch. Daily Security Review. https://dailysecurityreview.com/resources/signdrop-windows-clfs-zero-day-exploit-published-no-patch/

Kumar, A. (2026, November 9). Weekly recap: SSHole exploited, APT root, and more. The Hacker News. https://thehackernews.com/2026/11/weekly-recap-sshole-exploited-apt-root.html