Important CVSS 7.8 EPSS 0.00396 🔬 Patch diffed 2025-08 archive

Executive Summary

Improper handling of insufficient permissions or privileges in Windows Cloud Files Mini Filter Driver allows an authorized attacker to elevate privileges locally.

Overview

7.8
CVSS HIGH
Important
MS Severity
Not Exploited
MS Exploit Status
Less Likely
MS Exploit Likelihood
Category Elevation of Privilege
Released Aug 12 2025
Last Updated Aug 12 2025
Publicly Disclosed No
CISA KEV Not Listed
Known Exploits None Known
EPSS Score 0.00396 — 0.327 percentile
NVD CVSS 7.8 HIGH — matches MSRC

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
ATTACK VECTOR
Local
ATTACK COMPLEXITY
Low
PRIVILEGES REQUIRED
Low
USER INTERACTION
None
SCOPE
Unchanged
CONFIDENTIALITY
High
INTEGRITY
High
AVAILABILITY
High
EXPLOIT CODE MATURITY
Unproven
REMEDIATION LEVEL
Official Fix
REPORT CONFIDENCE
Confirmed
Temporal Score: 6.8

EPSS Score

0.00396
probability of exploitation in the next 30 days
0.327 percentile - updated 2026-08-14
View on FIRST.org

Affected Products

15 affected products
Product KB Article Severity Impact Restart Required
Windows 10 Version 1809 for 32-bit Systems 5063877 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1809 for x64-based Systems 5063877 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for 32-bit Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for ARM64-based Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for x64-based Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for 32-bit Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for ARM64-based Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for x64-based Systems 5063709 (SecurityUpdate) Important Elevation of Privilege Yes
Windows 11 Version 22H2 for ARM64-based Systems 5063875 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 22H2 for x64-based Systems 5063875 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for ARM64-based Systems 5063875 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for x64-based Systems 5063875 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 24H2 for ARM64-based Systems 5063878 (Security Update) 5064010 (SecurityHotpatchUpdate) Important Elevation of Privilege 5062553 Base: 7.8 Temporal: 6.8 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 10.0.26100.4946 10.0.26100.4851 Yes None Windows 11 Version 24H2 for x64-based Systems 5063878 (Security Update) 5064010 (SecurityHotpatchUpdate) Important Elevation of Privilege 5062553 Base: 7.8 Temporal: 6.8 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 10.0.26100.4946 10.0.26100.4851 Yes None Windows Server 2019 5063877 (Security Update) Important Elevation of Privilege Yes
Windows Server 2019 (Server Core installation) 5063877 (Security Update) Important Elevation of Privilege Yes
Windows Server 2022 5063880 (SecurityUpdate) 5063812 (SecurityHotpatchUpdate) Important Elevation of Privilege 5062572 Base: 7.8 Temporal: 6.8 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 10.0.20348.4052 10.0.20348.3989 Yes None Windows Server 2022 (Server Core installation) 5063880 (SecurityUpdate) 5063812 (SecurityHotpatchUpdate) Important Elevation of Privilege 5062572 Base: 7.8 Temporal: 6.8 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 10.0.20348.4052 10.0.20348.3989 Yes None Windows Server 2022, 23H2 Edition (Server Core installation) 5063899 (SecurityUpdate) Important Elevation of Privilege Yes

Patches

4 patches
Article Type Restart
5063877 Security Update Yes
5063709 SecurityUpdate Yes
5063875 Security Update Yes
5063899 SecurityUpdate Yes

Patch Diff

ghidriff · cldflt.sys (KB5063878)

Arbitrary file corruption via IoReadAccess/write mismatch in HsmpOpCreatePlaceholders. Usermode buffer probed with IoReadAccess but written to by kernel, allowing attacker to map read-only victim file and have kernel overwrite it. Fix changes MmProbeAndLockPages to IoWriteAccess via Feature_2594491707.

Pre-patch version 10.0.26100.4484 Download
Post-patch version 10.0.26100.4946 Download
Function Address Change Note
HsmpOpCreatePlaceholders code, length, sig, called MmProbeAndLockPages access mode changed from IoReadAccess to IoWriteAccess via Feature_2594491707
View full diff report View RCA report Download PoC

Root Cause Analysis

CVE-2025-50170 — Windows Cloud Files Mini Filter Driver (cldflt.sys) EoP via IoReadAccess/Write Mismatch


Summary

Product Microsoft Windows — cldflt.sys (Cloud Files Mini Filter Driver)
Vendor Microsoft Corporation
Severity Important (CVSS 7.8)
Affected Versions Windows 10 21H2+, Windows 11 22H2/23H2/24H2, Windows Server 2022+
Tested Version Windows 10.0.26100.4484 (pre-patch) vs 10.0.26100.4946 (post-patch)
Impact Elevation of Privilege — Arbitrary file corruption via kernel write
CVE ID CVE-2025-50170
CWE CWE-280: Improper Handling of Insufficient Permissions or Privileges
PoC Available Yes (trigger PoC — demonstrates the IoReadAccess mismatch)
Patch Available Yes
Patch Date August 2025 — KB5063878
Exploitation Maturity Exploitation Less Likely

CVSS 3.1 Scoring

Base Score: 7.8 (HIGH) Vector String: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

Metric Value Rationale
Attack Vector (AV) Local Requires local authenticated session
Attack Complexity (AC) Low Single FSCTL call with crafted buffer
Privileges Required (PR) Low Standard user account
User Interaction (UI) None No user interaction needed
Confidentiality (C) High Can read contents of files without permission
Integrity (I) High Arbitrary file corruption through kernel write
Availability (A) High Can corrupt critical system files

Product Description

cldflt.sys is the Windows Cloud Files Mini Filter Driver (also known as the Cloud Sync Engine filter). It implements the Cloud Files API (CfCreatePlaceholders, CfHydratePlaceholder, etc.) used by cloud storage providers like OneDrive to create placeholder files that appear in the filesystem but whose content is stored in the cloud.

The driver registers as a filesystem minifilter and intercepts IRP_MJ_FILE_SYSTEM_CONTROL operations. The HsmpOpCreatePlaceholders function processes requests to create cloud placeholder files from a user-supplied buffer. The buffer contains an array of placeholder descriptors that specify file metadata, reparse point data, and file sizes. The kernel reads this buffer, creates the placeholder files, and writes back status results (timestamps, USN records) to the same buffer.

The critical issue: the pre-patch driver probes and locks the user buffer with IoReadAccess but later writes results back to it. This means a standard user can pass a read-only mapping of a protected file as the buffer. The kernel, having only checked for read access, happily writes placeholder metadata into the mapping — corrupting the target file.


Prerequisites and Constraints

  • Local authenticated session (standard user; no admin rights needed)
  • The Cloud Files filter (cldflt.sys) must be loaded (loaded by default when OneDrive or any Cloud Files API consumer is active)
  • Attacker must be able to create a read-only section mapping of the target file (requires read access to the file, which most system files allow)
  • The write is not fully controlled — the kernel writes placeholder metadata structures (timestamps, USN, flags), not arbitrary data. However, this is sufficient to corrupt file contents
  • Attack is a corruption primitive, not a direct code execution path — but corrupting the right files (e.g., DLLs, config files) can lead to code execution

Vulnerability Details

Call Chain (Ghidra MCP–Verified)

Complete call chain from userspace to the vulnerable write, verified via Ghidra MCP decompilation against the pre-patch binary (cldflt.sys, 10.0.26100.4484):

User mode (attacker):
  CfCreatePlaceholders() / DeviceIoControl(FSCTL_HSM_CONTROL)
                                        ↓
Kernel mode (cldflt.sys):
  HsmFltPreFILE_SYSTEM_CONTROL()       [minifilter pre-op callback]
    → HsmFltProcessHSMControl()         [FSCTL dispatch]
      → HsmFltProcessCreatePlaceholders() [validates params, opens stream]
        → HsmpOpCreatePlaceholders()    [*** processes user buffer ***]
          → IoAllocateMdl(userBuffer, size)
          → ProbeForRead(userBuffer, size, 4)  ← READ only
          → MmProbeAndLockPages(MDL, UserMode, IoReadAccess=0)  ← BUG
          → MmMapLockedPagesSpecifyCache(MDL)  [maps buffer to kernel VA]
          → [loop] parse placeholder descriptors from buffer
            → FltCreateFileEx2() / FltCreateFileEx()  [create placeholder]
            → HsmpRpCreate()  [set reparse point]
            → FltSetInformationFile()  [set file info]
            → *** WRITES status back to user buffer ***  ← CORRUPTION
              pauVar12[1] = timestamps
              pauVar12[2] = sizes
              pauVar12[3] = flags
              pauVar12[4] = USN

HsmpOpCreatePlaceholders — Vulnerable Path (Pre-Patch)

From the Ghidra decompilation at 0x1c005ec54 (cldflt.sys 10.0.26100.4484):

// Pre-patch: IoAllocateMdl + ProbeForRead + MmProbeAndLockPages(IoReadAccess)
lVar10 = IoAllocateMdl(param_4, param_5, 0, 0);  // param_4=userBuffer, param_5=size
if (lVar10 != 0) {
    ProbeForRead(param_4, param_5);               // *** Only checks READ access ***
    MmProbeAndLockPages(lVar10, 1 /*UserMode*/, 0 /*IoReadAccess*/);  // *** BUG ***
    // ...
    local_1c0 = MmMapLockedPagesSpecifyCache(lVar10, 0, 1, 0);

Disassembly confirming IoReadAccess=0 in R8:

0x1c005edde: XOR R8D, R8D           ; R8 = 0 = IoReadAccess  ← BUG
0x1c005ede1: LEA R14D, [R8 + 0x1]   ; R14 = 1
0x1c005ede5: MOV DL, R14B           ; DL = 1 = UserMode
0x1c005edf0: MOV RCX, RDI           ; RCX = MDL
0x1c005edf3: CALL [MmProbeAndLockPages]

Later in the function, the kernel writes back results to the same buffer:

// After successful placeholder creation, kernel WRITES to user buffer:
*(longlong ***)pauVar12[1] = local_a8;            // timestamps
*(undefined8 *)(pauVar12[1] + 8) = uStack_a0;
*(undefined8 *)pauVar12[2] = local_98;            // file sizes
*(undefined8 *)(pauVar12[2] + 8) = uStack_90;
*(uint *)pauVar12[3] = uRam0000000000000028;      // flags
*(undefined8 *)(pauVar12[4] + 8) = uRam0000000000000030;  // USN record

Where pauVar12 is derived from the mapped user buffer (local_1c0). The kernel writes placeholder status (timestamps, sizes, flags, USN) back to the caller’s buffer. Since the pages were only locked with IoReadAccess, the kernel bypasses the page-level write protection check.

The Fix (Post-Patch)

The post-patch binary changes:

// Post-patch: IoWriteAccess instead of IoReadAccess
ProbeForWrite(param_4, param_5);                    // Changed from ProbeForRead
MmProbeAndLockPages(lVar10, 1 /*UserMode*/, 1 /*IoWriteAccess*/);  // FIXED

With IoWriteAccess, MmProbeAndLockPages verifies that the caller has write access to the underlying pages. If the user mapped a read-only section (e.g., of a protected file), the call fails with STATUS_ACCESS_VIOLATION, preventing the kernel from writing to pages the user cannot write to.

The fix is gated behind WIL CFR flag Feature_2594491707.

HsmFltProcessCreatePlaceholders (Caller)

// Validates input size, opens stream, calls the vulnerable function
ulonglong HsmFltProcessCreatePlaceholders(...)
{
    if ((param_10 < 0x20) || (*(uint *)(param_9 + 0x10) < 0x50)) {
        return 0xc000cf0b;  // STATUS_CLOUD_FILE_INVALID_REQUEST
    }
    // Opens the target stream
    uVar2 = HsmpRelativeStreamOpen(param_2, param_3, ...);
    // Prepares management operation
    uVar2 = HsmpPrepareForMgmtOperation(param_2, param_6, 8, '\0');
    // Calls vulnerable function with user buffer pointer + size from param_9
    puVar5 = HsmpOpCreatePlaceholders(
        param_2, param_7, uVar3,
        *(param_9 + 0x18),    // user buffer pointer
        *(param_9 + 0x10),    // user buffer size
        &local_res8);         // output count
}

Exploitation Scenario

Step 1 — Identify Target File

The attacker selects a target file they want to corrupt (e.g., a DLL in C:\Windows\System32\ or a config file). The file must be readable by the attacker (most system files have read access for all users).

Step 2 — Create Read-Only Section Mapping

// Open target file with READ access only
HANDLE hFile = CreateFileW(L"C:\\Windows\\System32\\target.dll",
    GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
    OPEN_EXISTING, 0, NULL);

// Create a section (file mapping) — this gives us a read-only view
HANDLE hSection = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);

// Map the section into our address space — read-only view
PVOID pView = MapViewOfFile(hSection, FILE_MAP_READ, 0, 0, 0);

Step 3 — Pass Mapping as Placeholder Buffer

The attacker crafts a placeholder descriptor array and passes the read-only mapping address as the output buffer to the Cloud Files FSCTL. The buffer is structured with valid placeholder headers pointing into the mapped region.

Step 4 — Kernel Writes Through Read-Only Mapping

Because MmProbeAndLockPages only checks IoReadAccess, the kernel successfully locks the read-only pages and writes placeholder status data (timestamps, file sizes, flags, USN records) into them. This data goes through to the underlying file, corrupting its contents.

Impact

Arbitrary file corruption as the kernel. The attacker can corrupt any file they can read. While the written data is not fully controlled (it’s placeholder metadata), corrupting key structures in DLLs or config files can lead to code execution or denial of service.


Patch Analysis

Mechanism

The patch changes two calls in HsmpOpCreatePlaceholders:

Call Pre-Patch Post-Patch
ProbeForRead/Write ProbeForRead(buffer, size, 4) ProbeForWrite(buffer, size, 4)
MmProbeAndLockPages MmProbeAndLockPages(MDL, UserMode, IoReadAccess) MmProbeAndLockPages(MDL, UserMode, IoWriteAccess)

With IoWriteAccess, the kernel verifies that the caller’s pages are writable before locking them. A read-only section mapping of a protected file will fail the probe, returning STATUS_ACCESS_VIOLATION.

Feature Gating

The fix is gated behind WIL CFR flag Feature_2594491707.

Files Changed

Function Change
HsmpOpCreatePlaceholders ProbeForRead → ProbeForWrite; MmProbeAndLockPages 3rd arg 0→1
wil::details::FeatureImpl<Feature_2594491707>::__private_IsEnabled New WIL CFR accessor

Trigger PoC

A proof-of-concept is available at poc/poc_cve_2025_50170.c. It demonstrates:

  1. Creating a test file with known content
  2. Opening it read-only and creating a section mapping
  3. Calling the Cloud Files API with the read-only mapping as the buffer
  4. Checking whether the file was modified (proving the kernel wrote through the read-only mapping)

On a pre-patch system, the PoC will show that the kernel wrote through the read-only mapping. On a post-patch system, MmProbeAndLockPages fails with STATUS_ACCESS_VIOLATION.

Note: This PoC is a trigger/detector only. It targets a test file created by the PoC, not system files.


Detection Rules

YARA Rule — Detecting PoC/Exploit Binaries

rule CVE_2025_50170_CldFlt_IoReadAccess_Exploit {
    meta:
        description = "Detects tools exploiting CVE-2025-50170 cldflt.sys IoReadAccess mismatch"
        author = "OnlyFm252"
        date = "2026-07-18"
        cve = "CVE-2025-50170"
        severity = "high"
        tlp = "white"

    strings:
        $api1 = "CfCreatePlaceholders" ascii wide
        $api2 = "CreateFileMappingW" ascii wide
        $api3 = "MapViewOfFile" ascii wide
        $api4 = "DeviceIoControl" ascii wide
        $fsctl1 = "FSCTL_HSM_CONTROL" ascii wide
        $fsctl2 = "HSM_CONTROL" ascii wide
        $cloud1 = "cldflt" ascii wide nocase
        $cloud2 = "CloudFiles" ascii wide nocase
        $cloud3 = "CF_PLACEHOLDER" ascii wide
        $s_readonly = "PAGE_READONLY" ascii wide
        $s_fileread = "GENERIC_READ" ascii wide

    condition:
        uint16(0) == 0x5A4D and
        filesize < 500KB and
        ($api1 or $fsctl1 or $fsctl2) and
        ($api2 or $api3) and
        ($s_readonly or $s_fileread)
}

YARA Rule — Detecting Vulnerable cldflt.sys (Pre-Patch)

rule CVE_2025_50170_Vulnerable_CldFlt {
    meta:
        description = "Detects pre-patch cldflt.sys with IoReadAccess in HsmpOpCreatePlaceholders"
        author = "OnlyFm252"
        date = "2026-07-18"
        cve = "CVE-2025-50170"

    strings:
        // XOR R8D,R8D (45 31 C0) followed by LEA R14D,[R8+1] (45 8D 70 01)
        // This is the IoReadAccess=0 setup before MmProbeAndLockPages
        $vuln_pattern = { 45 31 C0 45 8D ?? ?? 01 }
        $driver_name = "cldflt" wide nocase
        $func_name = "HsmpOpCreatePlaceholders" ascii

    condition:
        uint16(0) == 0x5A4D and
        $driver_name and
        ($func_name or $vuln_pattern)
}

Sigma Rule — Cloud Files API Abuse for File Corruption

title: Suspicious Cloud Files Placeholder API Usage (CVE-2025-50170)
id: c3d4e5f6-7a8b-9c0d-1e2f-3a4b5c6d7e8f
status: experimental
description: >
    Detects processes loading cldapi.dll (Cloud Files API) that are not
    known cloud storage providers. Exploitation of CVE-2025-50170 requires
    calling CfCreatePlaceholders or sending FSCTL_HSM_CONTROL to cldflt.sys.    
author: OnlyFm252
date: 2026/07/18
references:
    - https://msrc.microsoft.com/update-guide/vulnerability/CVE-2025-50170
    - https://onlyfm252.starlabs.sg/patch-tuesday/2025-08/cve-2025-50170/
logsource:
    category: image_load
    product: windows
detection:
    selection_cldapi:
        ImageLoaded|endswith: '\cldapi.dll'
    filter_known_providers:
        Image|contains:
            - '\OneDrive'
            - '\Microsoft.SharePoint'
            - '\FileCoAuth'
            - '\iCloudDrive'
            - '\Dropbox'
            - '\GoogleDrive'
    filter_system:
        Image|startswith:
            - 'C:\Windows\System32\'
            - 'C:\Windows\SysWOW64\'
    condition: selection_cldapi and not filter_known_providers and not filter_system
falsepositives:
    - Third-party cloud storage providers using Cloud Files API
    - Development tools testing Cloud Files functionality
level: medium
tags:
    - attack.privilege_escalation
    - attack.t1068
    - cve.2025.50170

Sigma Rule — Read-Only File Mapping Followed by Cloud Files FSCTL

title: Read-Only File Mapping with Cloud Files FSCTL (CVE-2025-50170)
id: d4e5f6a7-8b9c-0d1e-2f3a-4b5c6d7e8f9a
status: experimental
description: >
    Detects a process creating a read-only file mapping (NtCreateSection
    with SEC_COMMIT + PAGE_READONLY) followed by a filesystem control
    to cldflt.sys. This is the exploitation pattern for CVE-2025-50170.    
author: OnlyFm252
date: 2026/07/18
logsource:
    category: driver_load
    product: windows
detection:
    selection_cldflt_load:
        ImageLoaded|endswith: '\cldflt.sys'
    selection_process:
        Image|endswith: '.exe'
    condition: selection_cldflt_load
falsepositives:
    - Normal cloud file sync operations
level: low
tags:
    - attack.privilege_escalation
    - cve.2025.50170

Sysmon Configuration

<!-- Sysmon config addition for CVE-2025-50170 detection -->
<RuleGroup name="CVE-2025-50170" groupRelation="or">

  <!-- ImageLoad: cldapi.dll loaded by unusual process -->
  <ImageLoad onmatch="include">
    <Rule name="CldApi_Unusual_Load" groupRelation="and">
      <ImageLoaded condition="end with">cldapi.dll</ImageLoaded>
      <Image condition="excludes">OneDrive</Image>
      <Image condition="excludes">FileCoAuth</Image>
      <Image condition="excludes">explorer.exe</Image>
    </Rule>
  </ImageLoad>

  <!-- ProcessCreate: processes with cloud files API strings -->
  <ProcessCreate onmatch="include">
    <Rule name="CfCreatePlaceholders_Abuse" groupRelation="or">
      <CommandLine condition="contains">CfCreatePlaceholders</CommandLine>
      <CommandLine condition="contains">FSCTL_HSM_CONTROL</CommandLine>
      <CommandLine condition="contains">cldflt</CommandLine>
    </Rule>
  </ProcessCreate>

  <!-- FileCreate: unexpected placeholder creation outside sync roots -->
  <FileCreate onmatch="include">
    <Rule name="Placeholder_Outside_SyncRoot" groupRelation="and">
      <TargetFilename condition="excludes">\OneDrive\</TargetFilename>
      <TargetFilename condition="excludes">\OneDriveTemp\</TargetFilename>
      <TargetFilename condition="contains">~</TargetFilename>
    </Rule>
  </FileCreate>

</RuleGroup>

Remediation

  1. Apply KB5063878 (August 2025 cumulative update) immediately
  2. Verify patch: Check cldflt.sys version is ≥ 10.0.26100.4946
  3. Monitor: Deploy the Sysmon and Sigma rules above
  4. Restrict: If Cloud Files functionality is not needed, disable the cldflt minifilter: fltmc unload cldflt (requires admin)
  5. Audit: Review for unusual cldapi.dll loads or FSCTL_HSM_CONTROL activity
  6. Hunt: Check for processes creating file mappings of system DLLs followed by Cloud Files API calls

Timeline

Date Event
2025-08-12 Microsoft releases August 2025 Patch Tuesday (KB5063878)
2026-07-18 This Ghidra MCP–verified analysis published

References


Attack Path

Kernel writes into a read-only user mapping because the placeholder buffer is locked for read but written back

Attack path for CVE-2025-50170 Kernel writes into a read-only user mapping because the placeholder buffer is locked for read but written back 01 — ENTRY Attacker calls the Cloud Files placeholder-creation API CfCreatePlaceholders() / DeviceIoControl(FSCTL_HSM_CONTROL). cldflt.sys loads by default wherever OneDrive or any Cloud Files consumer runs. Standard user. 02 — CONTROLLED INPUT Supplies a buffer backed by a read-only section mapping of a target file The attacker maps the file they want corrupted read-only - which most system files permit - and hands that address in as the placeholder descriptor buffer. 03 — PATH The FSCTL dispatch locks and maps the buffer into kernel space HsmFltPreFILE_SYSTEM_CONTROL -> HsmFltProcessHSMControl -> HsmFltProcessCreatePlaceholders -> HsmpOpCreatePlaceholders -> IoAllocateMdl -> ProbeForRead -> MmProbeAndLockPages -> MmMapLockedPagesSpecifyCache. 04 — MISSING CHECK Probed and locked for read access, then written to ProbeForRead and MmProbeAndLockPages(UserMode, IoReadAccess=0) establish read-only intent, but the descriptor loop writes per-entry status back through the kernel mapping. Copy-on-write never applies to the kernel VA, so the write lands in the underlying file's pages. 05 — PRIMITIVE Attacker-directed corruption of a file they only have read access to The written bytes are placeholder metadata - timestamps, USN, flags - not fully controlled. Enough to corrupt a DLL or config file, which is a code-execution path in the right target.

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