Back to Intelligence

CVE-2026-66804: Windows Dangling COM Object Elevation of Privilege — Detection and Remediation Guide

SA
Security Arsenal Team
September 22, 2026
12 min read

Microsoft has patched CVE-2026-66804, a local elevation-of-privilege vulnerability in Windows rooted in a dangling COM object registration — a class of defect that is deceptively simple in origin and highly reliable in exploitation. The bug was disclosed by James Forshaw of Google Project Zero, credited alongside 14 other reporters, and is notable for a second reason: it is an incomplete fix for CVE-2026-50343, the privilege escalation bug dubbed "Dark Elevator" by security researcher Calif.

For defenders, this story carries two urgent lessons. First, patch verification matters — a vendor fix that addresses only one instantiation of a vulnerable pattern leaves a residual attack surface that researchers will find. Second, dangling COM registrations represent a systemic Windows hygiene problem: a registry entry pointing at a non-existent server binary is a pre-built privilege escalation primitive waiting for a local attacker to populate it.

Any Windows environment where users or low-privileged services can execute code locally — which is to say, essentially all of them — should treat this as a priority patch cycle item.

Technical Analysis

What is a dangling COM registration?

A functional in-process COM registration has two parts:

  1. A CLSID entry under HKEY_CLASSES_ROOT\CLSID (backed by HKLM\SOFTWARE\Classes\CLSID for system-wide registrations) that identifies the component.
  2. A server executable — for in-process servers, a DLL referenced by the InprocServer32 value under that CLSID key.

In this case, the CrossDevice COM object with CLSID {E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496} was registered in the system-wide classes key, making it visible to every user and every service on the machine — but the server executable it pointed to was missing. The registration existed; the binary did not.

Why that is exploitable

A dangling registration is dangerous because of how COM activation and registry virtualization interact:

  • Because the CLSID is registered system-wide, privileged services and processes can attempt to activate it — for example, through CrossDevice-related functionality invoked via inter-process communication.
  • When the system-wide InprocServer32 path is missing, an attacker with the ability to influence the activation context — classically via a per-user COM registration in HKCU\SOFTWARE\Classes\CLSID that shadows the system entry, or by planting a DLL at a location the activation sequence will load — can get their own arbitrary DLL loaded into a privileged process.
  • The result is a local privilege escalation: code execution in the context of a high-integrity or SYSTEM-level process, from an unprivileged starting position.

This is the same fundamental pattern as CVE-2026-50343 ("Dark Elevator"). Microsoft's original fix addressed that specific bug but left this dangling CrossDevice registration in place — an incomplete mitigation that Forshaw and the other reporters demonstrated was still exploitable via CVE-2026-66804.

Affected platforms

The vulnerable component is the Windows CrossDevice COM infrastructure, so supported Windows client and server builds that shipped this registration prior to the September 2026 security updates should be considered affected. Consult the Microsoft Security Response Center advisory for CVE-2026-66804 for the exact build-level affected product matrix, and patch to the September 2026 (or later) cumulative update for your SKU.

Exploitation requirements and status

  • Attack vector: Local. The attacker needs the ability to execute code as a low-privileged user (or low-privileged service account) on the target host.
  • Complexity: Low-to-moderate. COM activation hijacking is a well-documented, well-tooled technique class; public research from Project Zero substantially lowers the bar.
  • Exploitation status: Public technical write-up exists via Google Project Zero. At time of writing, there are no confirmed reports of mass in-the-wild exploitation, but privilege-escalation bugs of this class are routinely folded into post-exploitation toolkits and ransomware intrusion chains within weeks of disclosure. Monitor the CISA Known Exploited Vulnerabilities catalog — if added, federal remediation deadlines will apply and your SLAs should tighten accordingly.
  • CVSS: Confirm the score and vector in the official MSRC advisory; local EoP bugs of this type typically rate Important/High and should be prioritized on any multi-user or tier-jump-relevant host (VDI, jump boxes, terminal servers, developer workstations).

Why defenders should care beyond the CVE

Even fully patched against CVE-2026-66804, the technique survives. Dangling COM registrations are an entire bug class. A hunt capability that answers "which registered CLSIDs on my fleet point to non-existent binaries, and has anyone planted per-user shadow registrations?" will outlive this patch cycle and catch the next one.

Detection & Response

The most reliable detection surface is the registry: an attacker exploiting this class of bug must either create a per-user InprocServer32 registration shadowing the target CLSID, or write a DLL to a location referenced during activation. Both are observable with registry telemetry (Sysmon Event ID 12/13, Microsoft Defender for Endpoint DeviceRegistryEvents, or Windows Security Event 4657 with registry auditing enabled).

YAML
---
title: Per-User COM Registration Shadowing CrossDevice CLSID
id: 3f7a2b91-6c4e-4d28-9a15-8e2c0b1d4f67
status: experimental
description: Detects creation or modification of a per-user COM InprocServer32 registration for the CrossDevice CLSID {E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}, which shadows the system-wide dangling registration and is consistent with exploitation of CVE-2026-66804 / dangling COM object privilege escalation.
references:
  - https://projectzero.google/2026/09/windows-dangling-com.html
  - https://attack.mitre.org/techniques/T1546/015/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.privilege_escalation
  - attack.persistence
  - attack.t1546.015
logsource:
  category: registry_set
  product: windows
detection:
  selection:
    TargetObject|contains:
      - 'HKU\\Classes\\CLSID\\{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}'
      - 'HKCU\\SOFTWARE\\Classes\\CLSID\\{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}'
      - 'SOFTWARE\\Classes\\CLSID\\{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}\\InprocServer32'
  filter_system_key:
    TargetObject|startswith: 'HKLM\\SOFTWARE\\Classes\\CLSID\\{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}'
    Image|endswith:
      - '\\svchost.exe'
      - '\\TiWorker.exe'
      - '\\msiexec.exe'
  condition: selection and not filter_system_key
falsepositives:
  - Rare; per-user registration of a system-shipped CrossDevice CLSID is not expected from legitimate software
level: high
---
title: Suspicious DLL Load Referenced By User-Writable InprocServer32 Path
id: 91c4e6a2-3b7d-4f18-a652-0d9e1c8b2a34
status: experimental
description: Detects DLL image loads from user-writable locations (AppData, Temp, Public, user profile) by high-integrity Windows service processes, consistent with a planted COM server DLL being activated in a privileged context via a dangling or hijacked COM registration.
references:
  - https://projectzero.google/2026/09/windows-dangling-com.html
  - https://attack.mitre.org/techniques/T1546/015/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.privilege_escalation
  - attack.t1546.015
logsource:
  category: image_load
  product: windows
detection:
  selection_paths:
    ImageLoaded|contains:
      - '\\AppData\\'
      - '\\Users\\Public\\'
      - '\\Temp\\'
      - '\\Downloads\\'
  selection_hosts:
    Image|endswith:
      - '\\svchost.exe'
      - '\\dllhost.exe'
      - '\\explorer.exe'
  condition: selection_paths and selection_hosts
falsepositives:
  - Legitimate per-user applications loading plugins; tune by excluding known-signed paths in your environment
  - Some enterprise software installs per-user COM servers legitimately — baseline before enforcing
level: medium
---
title: Registry Write To Dangling COM CLSID InprocServer32 By Non-Installer Process
id: 5b8d3f07-2a49-4e61-b734-c1a6f0e9d2b8
status: experimental
description: Detects any InprocServer32 value write under a CLSID key performed by a process that is not a known installer or servicing binary. Generic detection for the dangling COM registration bug class that produced CVE-2026-66804 and CVE-2026-50343.
references:
  - https://projectzero.google/2026/09/windows-dangling-com.html
  - https://attack.mitre.org/techniques/T1546/015/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.privilege_escalation
  - attack.persistence
  - attack.t1546.015
logsource:
  category: registry_set
  product: windows
detection:
  selection:
    TargetObject|contains:
      - '\\CLSID\\{'
      - '\\InprocServer32'
    TargetObject|endswith: '(Default)'
  filter_installers:
    Image|endswith:
      - '\\msiexec.exe'
      - '\\TiWorker.exe'
      - '\\TrustedInstaller.exe'
      - '\\svchost.exe'
      - '\\regsvr32.exe'
      - '\\setup.exe'
  condition: selection and not filter_installers
falsepositives:
  - Software development activity (building/registering COM components on dev workstations) — scope exclusions by host group
  - Line-of-business apps that self-register COM components at runtime
level: medium

The first rule is the highest-fidelity of the three: a per-user registration of this specific system CLSID has essentially no legitimate purpose. The third rule is deliberately broader — it targets the bug class, so deploy it in audit posture first and tune installer exclusions to your software inventory.

KQL — Microsoft Sentinel / Defender for Endpoint

KQL — Microsoft Sentinel / Defender
// Hunt for registry manipulation of the CrossDevice dangling CLSID or per-user COM shadow registrations
let TargetClsid = "E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496";
let InstallerProcs = dynamic(["msiexec.exe","TiWorker.exe","TrustedInstaller.exe","svchost.exe","regsvr32.exe"]);
union isfuzzy=true
(DeviceRegistryEvents
 | where RegistryKey has TargetClsid
 | where InitiatingProcessFileName !in~ (InstallerProcs)
 | project TimeGenerated, DeviceName, InitiatingProcessAccountName, InitiatingProcessFileName,
           InitiatingProcessCommandLine, ActionType, RegistryKey, RegistryValueName, RegistryValueData
 | extend HuntReason = "Write to CrossDevice CLSID registration"),
(DeviceRegistryEvents
 | where RegistryKey has @"SOFTWARE\Classes\CLSID" and RegistryKey endswith @"InprocServer32"
 | where InitiatingProcessFileName !in~ (InstallerProcs)
 | where RegistryKey startswith @"HKEY_CURRENT_USER" or RegistryKey has @"HKEY_USERS\S-1-5-21"
 | project TimeGenerated, DeviceName, InitiatingProcessAccountName, InitiatingProcessFileName,
           InitiatingProcessCommandLine, ActionType, RegistryKey, RegistryValueName, RegistryValueData
 | extend HuntReason = "Per-user COM server registration by non-installer process")
| order by TimeGenerated desc

Follow-up pivot: for any host with hits, run the VQL artifact below (or an MDE Advanced Hunting query against DeviceImageLoadEvents filtered to loads from user-writable paths into svchost.exe/dllhost.exe) within the same time window to confirm whether a planted DLL was actually activated by a privileged process.

Velociraptor VQL — Fleet-Wide Dangling COM Hunt

This artifact enumerates all system-wide in-process COM registrations and flags any whose referenced DLL does not exist on disk or lives in a user-writable location — surfacing both the residual CVE-2026-66804 condition on unpatched hosts and any attacker-planted shadow registrations.

VQL — Velociraptor
-- Hunt: Dangling or hijacked InprocServer32 COM registrations (CVE-2026-66804 bug class)
LET regs = SELECT Key.FullPath AS ClsidKey,
                  Data.value AS ServerDll
           FROM read_reg_key(glob='HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\CLSID\\*\\InprocServer32',
                             accessor='registry')
           WHERE Data.value

SELECT ClsidKey,
       ServerDll,
       expand(path=ServerDll) AS ExpandedDll,
       stat(filename=expand(path=ServerDll)) IS NOT NULL AS DllExists,
       ExpandedDll =~ '(?i)\\\\(users|programdata)\\\\.*(appdata|temp|public|downloads)' AS UserWritablePath
FROM regs
WHERE DllExists = FALSE
   OR UserWritablePath = TRUE
ORDER BY DllExists ASC

Note: on a patched September-2026+ system, the CrossDevice CLSID should either be absent or resolve to an existing, Microsoft-signed binary. A result showing {E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496} with DllExists = FALSE means the host is unpatched; a result showing it with UserWritablePath = TRUE means investigate immediately.

Verification & Remediation Script

PowerShell
# CVE-2026-66804 verification and audit script
# Run as Administrator. Checks patch state, audits the CrossDevice CLSID,
# and scans for per-user shadow registrations across all loaded user hives.

$Clsid = '{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}'
$report = [ordered]@{}

# 1. Check OS build against September 2026 security update baseline.
#    Confirm the exact minimum build for your SKU in the MSRC advisory for CVE-2026-66804.
$os = Get-CimInstance Win32_OperatingSystem
$build = [version]"$($os.BuildNumber).$((Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').UBR)"
$report['OSBuild'] = $build.ToString()
Write-Host "[*] OS Build: $build  -- verify against MSRC CVE-2026-66804 minimum patched build" -ForegroundColor Cyan

# 2. Check installed hotfixes from Sept 2026 onward
$hotfixes = Get-HotFix | Where-Object { $_.InstalledOn -ge (Get-Date '2026-09-01') }
$report['Sept2026Hotfixes'] = ($hotfixes | ForEach-Object { $_.HotFixID }) -join ', '
if (-not $hotfixes) { Write-Host '[!] No hotfixes installed since 2026-09-01 — host likely UNPATCHED' -ForegroundColor Red }

# 3. Audit the system-wide CrossDevice CLSID registration
$sysKey = "HKLM:\SOFTWARE\Classes\CLSID\$Clsid\InprocServer32"
if (Test-Path $sysKey) {
    $dll = (Get-ItemProperty $sysKey).'(default)'
    $expanded = [Environment]::ExpandEnvironmentVariables($dll)
    $exists = Test-Path $expanded
    $report['SystemRegistration'] = "Present -> $dll (Exists: $exists)"
    if (-not $exists) {
        Write-Host "[!] DANGLING registration present: $dll does not exist on disk." -ForegroundColor Red
        Write-Host '    Host is vulnerable or incompletely patched. Apply the Sept 2026+ cumulative update.' -ForegroundColor Red
    } else {
        $sig = Get-AuthenticodeSignature $expanded
        Write-Host "[+] Server DLL exists. Signature status: $($sig.Status) ($($sig.SignerCertificate.Subject))" -ForegroundColor Green
        if ($sig.Status -ne 'Valid' -or $sig.SignerCertificate.Subject -notmatch 'Microsoft') {
            Write-Host '[!] WARNING: non-Microsoft-signed DLL in system COM registration — investigate for hijack.' -ForegroundColor Red
        }
    }
} else {
    Write-Host '[+] System-wide CrossDevice CLSID not present (expected on patched systems).' -ForegroundColor Green
}

# 4. Scan all user hives for per-user shadow registrations of this CLSID
Write-Host '[*] Scanning user hives for shadow COM registrations...' -ForegroundColor Cyan
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList' | ForEach-Object {
    $sid = $_.PSChildName
    $userKey = "Registry::HKEY_USERS\$sid\SOFTWARE\Classes\CLSID\$Clsid"
    if (Test-Path $userKey) {
        $dll = (Get-ItemProperty "$userKey\InprocServer32" -ErrorAction SilentlyContinue).'(default)'
        Write-Host "[!] SHADOW REGISTRATION FOUND: SID $sid -> $dll" -ForegroundColor Red
        Write-Host '    Preserve evidence (export key, hash DLL) before removal. Treat as potential compromise.' -ForegroundColor Red
    }
}

# 5. Optional hardening: enable Sysmon registry events (12/13/14) and forward to SIEM
#    if not already collecting — these power the Sigma rules in this post.
Write-Host '[*] Ensure Sysmon registry-set telemetry and MDE registry events are enabled fleet-wide.' -ForegroundColor Cyan

$report | Format-List

Remediation

  1. Patch immediately. Apply the September 2026 (or later) Windows cumulative update that resolves CVE-2026-66804 across all supported client and server SKUs. Pull the exact KB and minimum build numbers from the MSRC Security Update Guide entry for CVE-2026-66804 — do not assume your standard patch ring has covered it; verify build numbers, because this CVE exists precisely because the prior fix for CVE-2026-50343 was incomplete.

  2. Prioritize multi-user and privilege-boundary hosts. Local EoP bugs are force multipliers in intrusion chains. Patch terminal servers, VDI, jump boxes, build agents, and developer workstations first — anywhere a low-privileged foothold can be converted into SYSTEM.

  3. Hunt the bug class, not just the CVE. Deploy the VQL dangling-registration sweep above as a recurring fleet hunt. Any system-wide InprocServer32 pointing at a missing or user-writable DLL is either a patching gap or an intrusion artifact.

  4. Enable and centralize registry telemetry. Sysmon Event IDs 12/13 (registry create/set) or MDE registry events are prerequisites for the detections above. If your SIEM is not ingesting registry telemetry today, that gap is bigger than this one CVE.

  5. Constrain per-user COM where feasible. Per-user COM registration is a legitimate Windows feature, but on servers and high-value hosts, application control policies (WDAC/AppLocker DLL rules) that block unsigned DLL loads from user-writable paths blunt the entire activation-hijack technique class.

  6. Check CISA KEV weekly. If CVE-2026-66804 is added to the Known Exploited Vulnerabilities catalog, remediation deadlines become binding for federal environments and should trigger escalation in commercial ones.

  7. If you find a shadow registration: treat it as a suspected compromise, not a cleanup task. Export the registry keys, preserve and hash the referenced DLL, image memory, and review the timeline for initial access — a dangling-COM hijack is a post-exploitation step, which means something got the attacker code execution first.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.