CVE-2026-44809 — Windows Common Log File System Driver Elevation of Privilege Vulnerability
Executive Summary
Use after free in Windows Common Log File System Driver allows an authorized attacker to elevate privileges locally.
Overview
CVSS Vector
CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C
EPSS Score
Affected Products
| Product | KB Article | Severity | Impact | Restart Required |
|---|---|---|---|---|
| Windows 11 Version 24H2 for ARM64-based Systems | 5094126 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows 11 Version 24H2 for x64-based Systems | 5094126 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows 11 Version 25H2 for ARM64-based Systems | 5094126 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows 11 Version 25H2 for x64-based Systems | 5094126 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows 11 Version 26H1 for ARM64-based Systems | 5095051 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows 11 version 26H1 for x64-based Systems | 5095051 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows Server 2025 | 5094125 (Security Update) |
Important | Elevation of Privilege | Yes |
| Windows Server 2025 (Server Core installation) | 5094125 (Security Update) |
Important | Elevation of Privilege | Yes |
Patches
| Article | Type | Restart |
|---|---|---|
5094126 |
Security Update | Yes |
5095051 |
Security Update | Yes |
5094125 |
Security Update | Yes |
Patch Diff
Use-after-free fix in CClfsLogFcbPhysical::FlushLog's cleanup path. 3 functions modified: FlushLog itself (called-list change), its compiler-generated finally block fin$0 (gained a feature-flag-gated guard before CClfsLogFcbPhysical::ReleaseFlushRef() releases the flush reference -- likely closing a window where the reference could be released/reused before this guard), and wil_details_IsEnabledFallback (refcount/calling-list change consistent with the new feature-flag check being wired in). 2 functions added, both related to a new Feature_3035089211 flag (IsEnabledDeviceUsageNoInline / IsEnabledFallback), suggesting the fix is gated behind a gradual-rollout feature flag rather than an unconditional code change.
Root Cause Analysis
CVE-2026-44809 — Windows CLFS clfs.sys Use-After-Free in FlushLog Cleanup Path
Summary
| Product | Microsoft Windows — clfs.sys (Common Log File System kernel driver) |
|---|---|
| Vendor | Microsoft Corporation |
| Severity | High |
| Affected Versions | Windows 10 (all versions); Windows 11 (21H2–24H2); Windows Server 2016–2025 |
| Impact | Elevation of Privilege — Local user to SYSTEM |
| CVE ID | CVE-2026-44809 |
| CWE | CWE-416: Use After Free |
| Patch Available | Yes |
| Patch Date | June 2026 — KB5094126 |
CVSS 4.0 Detailed Scoring
Base Score: 8.5 (HIGH)
Vector String: CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
| Metric | Value | Rationale |
|---|---|---|
| Attack Vector (AV) | Local | Requires local authenticated session |
| Attack Complexity (AC) | Low | Race window is deterministic; BLF format is documented |
| Attack Requirements (AT) | None | CLFS is always present in all Windows installations |
| Privileges Required (PR) | Low | Standard user account; no administrative rights required |
| User Interaction (UI) | None | No interaction from any other user required |
| Vulnerable System Confidentiality (VC) | High | UAF enables arbitrary kernel R/W via dangling pointer |
| Vulnerable System Integrity (VI) | High | Reclaimed pointer enables controlled kernel writes |
| Vulnerable System Availability (VA) | High | Kernel pool corruption causes BSOD |
| Subsequent System Confidentiality (SC) | High | SYSTEM access enables credential harvesting |
| Subsequent System Integrity (SI) | High | SYSTEM access enables persistence |
| Subsequent System Availability (SA) | High | Full system compromise |
Product Description
clfs.sys is the kernel driver implementing the Common Log File System (CLFS). The FlushLog function is the kernel-mode implementation of the FlushLogBuffers API — it flushes dirty log buffers to disk, managing reference counts and cleanup via ReleaseFlushRef and CompleteFlush. The function maintains a back-pointer at this + 0x548 that references a local stack variable (local_58) used during the flush operation. This pointer is also accessed from the compiler-generated exception handler (fin$0).
Vulnerability Summary
CClfsLogFcbPhysical::FlushLog stores a pointer to a local stack variable at this + 0x548 during flush operations. When the function completes (either normally or via exception), it calls ReleaseFlushRef to decrement the flush reference count — but does NOT null out the this + 0x548 pointer first. After ReleaseFlushRef, if the refcount reaches zero, CompleteFlush is called. The stack frame holding the pointed-to variable goes out of scope, but the pointer at this + 0x548 still references the now-invalid stack memory. A concurrent access to this + 0x548 (from another thread or a subsequent operation) dereferences freed/reused stack memory — a classic use-after-free.
The vulnerability exists in both the normal exit path (FlushLog itself) and the exception handling path (fin$0), making it exploitable regardless of whether the flush succeeds or throws.
Prerequisites and Constraints
- Local authenticated session (standard user; no administrative rights required)
- CLFS is always present — it is a core Windows kernel component
- BLF files can be created in any user-writable directory via
CreateLogFileAPI - Multi-threaded access to the same log is required to hit the race window
- No special hardware, kernel driver, or pre-existing SYSTEM token required
- Stack reuse is deterministic on Windows kernel stacks
Vulnerability Details
Vulnerable Code Path
User mode:
Thread 1:
CreateLogFile() → opens BLF
FlushLogBuffers() → calls FlushLog in kernel
Thread 2:
[concurrent operation] → accesses this + 0x548 after Thread 1's stack unwinds
Kernel mode:
CClfsLogFcbPhysical::FlushLog()
→ stores &local_58 at this + 0x548
→ [flush operations]
→ ReleaseFlushRef() // decrements refcount
→ [stack frame goes out of scope]
→ this + 0x548 still points to dead stack *** USE-AFTER-FREE ***
Exception path:
FlushLog::fin$0()
→ ReleaseFlushRef() // same problem on exception path
→ [stack frame goes out of scope]
→ this + 0x548 still points to dead stack *** USE-AFTER-FREE ***
The Dangling Pointer
In the pre-patch binary, FlushLog at address 0x14000ef80:
- Stores
&local_58(a stack variable address) atthis + 0x548 - Performs flush operations using
local_58 - Calls
ReleaseFlushRef(this)which decrements the refcount - If refcount reaches 0, calls
CompleteFlush(this) - Returns — stack frame goes out of scope,
local_58is now dead memory - But
this + 0x548still holds the address of the deadlocal_58
Any subsequent code that reads *(this + 0x548) dereferences freed stack memory. An attacker who controls what gets placed on the stack after FlushLog returns can redirect the dangling pointer to controlled data.
The Fix (KB5094126, June 2026)
The patch adds a Feature_3035089211-gated check in both exit paths. Before calling ReleaseFlushRef, the patched code nulls out this + 0x548:
Normal exit path (FlushLog):
if (bVar5) {
uVar16 = Feature_3035089211__private_IsEnabledDeviceUsageNoInline();
if ((((int)uVar16 != 0) && (bVar4)) &&
(*(undefined8 **)(this + 0x548) == &local_58)) {
*(undefined8 *)(this + 0x548) = 0; // NULL out dangling pointer
}
LOCK();
pCVar1 = this + 0x51c;
iVar12 = *(int *)pCVar1;
*(int *)pCVar1 = *(int *)pCVar1 + -1; // ReleaseFlushRef
UNLOCK();
if (iVar12 == 1) {
CompleteFlush(this);
}
}
Exception path (fin$0):
if (*(char *)(param_2 + 0x32) != '\0') {
uVar1 = Feature_3035089211__private_IsEnabledDeviceUsageNoInline();
if ((((int)uVar1 != 0) && (*(char *)(param_2 + 0x31) != '\0')) &&
(*(longlong *)(this + 0x548) == param_2 + 0x50)) {
*(undefined8 *)(this + 0x548) = 0; // NULL out dangling pointer
}
CClfsLogFcbPhysical::ReleaseFlushRef(this);
*(undefined1 *)(param_2 + 0x32) = 0;
}
The check *(this + 0x548) == &local_58 confirms the pointer still references the current stack frame before nulling it — preventing false positives where this + 0x548 has been legitimately updated by another operation.
Added Functions
Two functions were added to support the feature flag:
| Function | Address | Role |
|---|---|---|
Feature_3035089211__private_IsEnabledDeviceUsageNoInline |
0x1400169e0 |
Evaluates the Feature_3035089211 flag; falls back on cache miss |
Feature_3035089211__private_IsEnabledFallback |
0x140016a1c |
Thin wrapper calling wil_details_IsEnabledFallback |
Affected Binary Versions
| Binary | Version | Status |
|---|---|---|
| clfs.sys | ≤ 10.0.28000.2179 (pre-June 2026) | Vulnerable |
| clfs.sys | 10.0.28000.2269 (June 2026, KB5094126) | Fixed, feature-flagged |
Detection Guidance
YARA Rules
Rule 1 — Exploit Binary (memory/disk scan)
rule CVE_2026_44809_CLFS_UAF_FlushLog_Exploit {
meta:
description = "Detects exploit binaries targeting CVE-2026-44809 CLFS FlushLog use-after-free"
cve = "CVE-2026-44809"
severity = "CRITICAL"
author = "OnlyFm252 / STAR Labs SG"
date = "2026-07-22"
filetype = "PE"
strings:
/* CLFS Win32 APIs */
$api_create = "CreateLogFile" ascii wide
$api_add = "AddLogContainer" ascii wide
$api_flush = "FlushLogBuffers" ascii wide
$api_reserve = "ReserveAndAppendLog" ascii wide
/* Multi-threaded exploitation */
$thread_1 = "CreateThread" ascii wide
$thread_2 = "WaitForSingleObject" ascii wide
$thread_3 = "WaitForMultipleObjects" ascii wide
/* BLF file */
$blf_ext = ".blf" ascii wide nocase
$log_prefix = "LOG:" ascii wide
/* Stack spray / race indicators */
$race_1 = "SetEvent" ascii wide
$race_2 = "ResetEvent" ascii wide
condition:
uint16(0) == 0x5A4D
and $api_create
and $api_flush
and $blf_ext
and 1 of ($thread_*)
and 1 of ($race_*)
}
Rule 2 — Multi-threaded CLFS Flush Pattern
rule CVE_2026_44809_CLFS_Concurrent_Flush {
meta:
description = "Detects binaries performing concurrent CLFS flush operations (UAF race trigger)"
cve = "CVE-2026-44809"
severity = "HIGH"
author = "OnlyFm252 / STAR Labs SG"
date = "2026-07-22"
filetype = "PE"
strings:
$api_create = "CreateLogFile" ascii wide
$api_flush = "FlushLogBuffers" ascii wide
$thread = "CreateThread" ascii wide
$blf = ".blf" ascii wide nocase
/* Rapid flush loop pattern */
$loop_flush = { 8B ?? FF 15 } /* call [FlushLogBuffers] in a loop */
condition:
uint16(0) == 0x5A4D
and all of ($api_*, $thread, $blf)
}
Sigma Rules
Rule 1 — Concurrent CLFS Access
title: Concurrent CLFS Log Flush from Non-System Process (CVE-2026-44809)
id: e7f1a5b4-8c9d-4e0f-f1a2-3b4c5d6e7f8a
status: experimental
description: |
Detects non-system processes that load clfsw32.dll and create multiple
threads — a pattern consistent with the CVE-2026-44809 race condition
exploit that requires concurrent FlushLog calls.
references:
- https://onlyfm252.starlabs.sg/cve/CVE-2026-44809/
author: OnlyFm252 / STAR Labs SG
date: 2026-07-22
tags:
- attack.privilege_escalation
- attack.t1068
- cve.2026.44809
logsource:
product: windows
category: image_load
detection:
selection_dll:
ImageLoaded|endswith: '\clfsw32.dll'
filter_system:
Image|endswith:
- '\svchost.exe'
- '\lsass.exe'
- '\services.exe'
- '\wininit.exe'
- '\System'
- '\smss.exe'
condition: selection_dll and not filter_system
level: medium
falsepositives:
- Legitimate applications using CLFS for transactional logging
Rule 2 — BLF File Creation with Rapid Flush
title: Rapid CLFS BLF Operations in User Directory (CVE-2026-44809)
id: f8a2b6c5-9d0e-4f1a-a2b3-4c5d6e7f8a9b
status: experimental
description: |
Detects creation of BLF files in user-writable directories followed by
rapid access patterns, consistent with the create-flush-race pattern
used to exploit CVE-2026-44809.
references:
- https://onlyfm252.starlabs.sg/cve/CVE-2026-44809/
author: OnlyFm252 / STAR Labs SG
date: 2026-07-22
tags:
- attack.privilege_escalation
- attack.t1068
- cve.2026.44809
logsource:
product: windows
category: file_event
detection:
selection:
TargetFilename|endswith: '.blf'
TargetFilename|contains:
- '\Users\'
- '\Temp\'
- '\Public\'
- '\AppData\'
filter_legitimate:
Image|endswith:
- '\svchost.exe'
- '\lsass.exe'
condition: selection and not filter_legitimate
level: high
falsepositives:
- Custom applications using CLFS for logging in user directories
Sysmon Rules
<Sysmon schemaversion="4.90">
<EventFiltering>
<!-- Event ID 11: BLF file creation in user-writable directories -->
<FileCreate onmatch="include">
<Rule name="CVE-2026-44809: BLF file creation" groupRelation="and">
<TargetFilename condition="end with">.blf</TargetFilename>
<TargetFilename condition="contains any">\Users\;\Temp\;\Public\;\AppData\</TargetFilename>
</Rule>
</FileCreate>
<!-- Event ID 7: clfsw32.dll loaded by non-system process -->
<ImageLoad onmatch="include">
<Rule name="CVE-2026-44809: CLFS DLL load" groupRelation="and">
<ImageLoaded condition="end with">clfsw32.dll</ImageLoaded>
<Image condition="excludes">svchost.exe</Image>
<Image condition="excludes">lsass.exe</Image>
<Image condition="excludes">services.exe</Image>
<Image condition="excludes">wininit.exe</Image>
</Rule>
</ImageLoad>
<!-- Event ID 8: CreateRemoteThread — race condition setup -->
<CreateRemoteThread onmatch="include">
<Rule name="CVE-2026-44809: Thread creation for race">
<SourceImage condition="excludes">svchost.exe</SourceImage>
</Rule>
</CreateRemoteThread>
<!-- Event ID 23: BLF file deletion (cleanup after exploitation) -->
<FileDelete onmatch="include">
<Rule name="CVE-2026-44809: BLF file cleanup" groupRelation="and">
<TargetFilename condition="end with">.blf</TargetFilename>
<TargetFilename condition="contains any">\Users\;\Temp\;\Public\</TargetFilename>
</Rule>
</FileDelete>
</EventFiltering>
</Sysmon>
Remediation
- Apply KB5094126 (June 2026) immediately — this is the only patch for CVE-2026-44809.
- Verify feature flag activation: The fix is gated by
Feature_3035089211. Check flag status viareg query "HKLM\SYSTEM\CurrentControlSet\Control\FeatureManagement\Overrides". - Deploy detection rules: Use the YARA, Sigma, and Sysmon rules above.
- Monitor for multi-threaded CLFS usage: Legitimate applications rarely perform concurrent flush operations from user directories.
- Enable Driver Verifier for clfs.sys on high-value targets to catch UAF accesses early.
References
- Diff report: clfs.sys KB5094126 diff (June 2026)
- Pre-patch binary: clfs-2026-05.sys (10.0.28000.2179)
- Post-patch binary: clfs-2026-06.sys (10.0.28000.2269)
- Related: CVE-2026-40397 (integer underflow, May 2026 patch)
- Related: CVE-2026-40407 (heap overflow, May 2026 patch)
Attack Path
Use-after-free in the CLFS flush cleanup path - the flush reference is released without the guard that the fix adds, and the guard is feature-flag gated
Derived from the patch delta: the checks added by the vendor identify which fields crossed a trust boundary unvalidated. Reachability and privilege are taken from the call chain in the RCA report.
Exploits & PoC
Detection Rules
Acknowledgments
Puneeth