Back to Intelligence

Nightmare Eclipse Releases Unpatched Privilege Escalation Exploits for CrowdStrike, Nvidia, and Avast — Defender's Detection and Hardening Guide

SA
Security Arsenal Team
September 7, 2026
12 min read

A threat research collective operating under the name Nightmare Eclipse has publicly released proof-of-concept (PoC) exploit code targeting previously unpatched vulnerabilities in products from CrowdStrike, Nvidia, and Avast. Per reporting from SecurityWeek, the released PoCs enable unauthorized privilege escalation — culminating in the attacker spawning a shell with NT AUTHORITY\SYSTEM privileges on a compromised host.

Let me be blunt about why this matters: when exploit code targeting your EDR agent, your GPU driver stack, or your antivirus engine lands in public hands, the window between publication and weaponization by ransomware affiliates and initial access brokers is measured in days, not months. I have watched this exact pattern play out repeatedly — a public privilege-escalation PoC gets folded into post-exploitation toolkits, and suddenly every commodity intrusion becomes a full domain compromise because the attacker can now run as SYSTEM and tamper with the very security controls meant to stop them.

The irony is sharp: two of the three affected vendors are the security controls. A privilege escalation inside an EDR or AV process is not just another local privilege escalation (LPE) — it is a potential path to security tool tampering, sensor disablement, and blind-spot creation. If you run any of these products, treat this as an active exposure requiring immediate compensating controls and heightened detection coverage, even before vendor patches ship.

Technical Analysis

Affected Products

Based on the reporting, the Nightmare Eclipse release targets three distinct product families:

  • CrowdStrike Falcon sensor — the endpoint detection and response agent deployed on Windows endpoints and servers across most enterprise environments.
  • Nvidia driver software — GPU driver components (kernel-mode driver stack) present on virtually every workstation and server with Nvidia hardware, including data center GPU nodes.
  • Avast antivirus — consumer and business AV engines with a large global installed base.

How the Exploits Work

No CVE identifiers have been published in the initial reporting for these issues — the vendors have not yet shipped advisories, which is consistent with a non-coordinated public disclosure. What we know from the disclosure:

  1. Local privilege escalation is the payload. The PoCs require an attacker to already have code execution on the host (low-privileged user context), then abuse the vulnerable component to escalate to SYSTEM.
  2. The end state is an interactive SYSTEM shell. This is a classic post-exploitation primitive: once the attacker has SYSTEM, they can attempt to terminate or blind the security product itself, dump credentials from LSASS, install persistent drivers, or stage ransomware with kernel-adjacent privileges.
  3. The vulnerable components live in kernel or highly privileged contexts. GPU drivers and security product minifilter/kernel drivers are high-value LPE targets because a flaw in the IOCTL handling or validation logic of a kernel driver gives ring-0 execution — exactly the class of bug that has fueled the BYOVD (Bring Your Own Vulnerable Driver) ecosystem for years.

Exploitation Status

  • Public PoC available: Yes — this is a published, functional proof-of-concept release.
  • Vendor patches available: Not at time of disclosure. These are unpatched/zero-day-class issues.
  • Confirmed in-the-wild exploitation: Not yet confirmed in the initial reporting, but public PoCs for privilege escalation in widely deployed drivers and security products are historically absorbed into attacker tooling within days.
  • CISA KEV: Not listed at time of writing; monitor the KEV catalog as vendor CVEs are assigned.

The practical defensive posture: assume weaponization is imminent or already occurring in targeted intrusions, and shift to behavior-based detection of the exploitation outcome (a shell or child process running as SYSTEM spawned from or adjacent to these product components), since signature-based detection of a specific PoC binary is a losing game against trivial recompilation.

Detection & Response

The highest-fidelity detection strategy here focuses on the post-exploitation outcome, not the PoC itself: security product processes and GPU driver service processes should essentially never spawn interactive shells, script interpreters, or LOLBins. Any such process tree is either exploitation or a severely broken deployment — both warrant immediate investigation.

Sigma Rules

YAML
---
title: Security Product or Nvidia Component Spawning Shell or Script Interpreter
id: 3f8a2c1d-9b47-4e56-a12c-8d0e5f7a9b31
status: experimental
description: Detects cmd.exe, PowerShell, or other script interpreters spawned by CrowdStrike Falcon, Avast, or Nvidia processes. Security products and GPU service components should never launch interactive shells — this is a strong indicator of privilege escalation exploitation such as the Nightmare Eclipse PoCs yielding SYSTEM shells.
references:
  - https://www.securityweek.com/nightmare-eclipse-drops-crowdstrike-nvidia-avast-zero-day-exploits/
  - https://attack.mitre.org/techniques/T1068/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.privilege_escalation
  - attack.t1068
  - attack.execution
  - attack.t1059.001
  - attack.t1059.003
logsource:
  category: process_creation
  product: windows
detection:
  selection_parents:
    ParentImage|endswith:
      - '\CSFalconService.exe'
      - '\CSFalconContainer.exe'
      - '\AvastSvc.exe'
      - '\AvastUI.exe'
      - '\aswVmm.exe'
      - '\nvcontainer.exe'
      - '\NVDisplay.Container.exe'
      - '\nvtelemetrycontainer.exe'
  selection_children:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\wmic.exe'
  condition: selection_parents and selection_children
falsepositives:
  - Rare vendor self-update or telemetry mechanisms — validate against vendor documentation before tuning
level: critical
---
title: Interactive Shell Running as SYSTEM via Unusual Parent
id: 6c1e9d04-2f83-4a7b-b91d-4e6f8a2c5d07
status: experimental
description: Detects interactive command shells executing as NT AUTHORITY\SYSTEM where the parent process is not a known system component. Public LPE exploits such as the Nightmare Eclipse releases produce a SYSTEM shell whose parent lineage is abnormal.
references:
  - https://www.securityweek.com/nightmare-eclipse-drops-crowdstrike-nvidia-avast-zero-day-exploits/
  - https://attack.mitre.org/techniques/T1068/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.privilege_escalation
  - attack.t1068
logsource:
  category: process_creation
  product: windows
detection:
  selection_shell:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
  selection_system:
    User: 'NT AUTHORITY\SYSTEM'
  filter_parents:
    ParentImage|endswith:
      - '\services.exe'
      - '\svchost.exe'
      - '\wininit.exe'
      - '\winlogon.exe'
      - '\MsMpEng.exe'
      - '\msiexec.exe'
      - '\TiWorker.exe'
      - '\smss.exe'
      - '\csrss.exe'
      - '\spoolsv.exe'
      - '\wmiprvse.exe'
      - '\taskeng.exe'
      - '\taskhostw.exe'
  condition: selection_shell and selection_system and not filter_parents
falsepositives:
  - Legitimate administrative tooling (SCCM, PSExec-style remote management, EDR response shells) — tune per environment by parent process and command line
level: high
---
title: Suspicious Kernel Driver Load from User-Writable Path
id: 9d4b7e21-6a35-4c18-f2a9-7b3e0d8c1a46
status: experimental
description: Detects service creation or driver load attempts where the driver image resides in a user-writable or temp directory — consistent with exploitation staging for driver-based privilege escalation and potential follow-on BYOVD activity after gaining SYSTEM.
references:
  - https://www.securityweek.com/nightmare-eclipse-drops-crowdstrike-nvidia-avast-zero-day-exploits/
  - https://attack.mitre.org/techniques/T1068/
  - https://attack.mitre.org/techniques/T1543.003/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.privilege_escalation
  - attack.t1068
  - attack.persistence
  - attack.t1543.003
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|endswith: '\sc.exe'
    CommandLine|contains:
      - 'create'
      - ' type= kernel'
  selection_path:
    CommandLine|contains:
      - '\Temp\'
      - '\AppData\'
      - '\Users\Public\'
      - '\ProgramData\'
      - '\Downloads\'
      - 'Desktop'
  condition: selection and selection_path
falsepositives:
  - Legitimate driver installation by IT — correlate with software inventory and change tickets
level: high

KQL — Microsoft Sentinel / Defender

This query hunts for the exploitation outcome — shells and script interpreters launched by or near the affected product processes — across both Defender for Endpoint telemetry and forwarded Windows events.

KQL — Microsoft Sentinel / Defender
// Hunt for privilege-escalation indicators tied to CrowdStrike, Avast, or Nvidia exploitation
// Focus: shells/script interpreters spawned by security-product or Nvidia components, and SYSTEM shells with anomalous parents
let Lookback = 7d;
let SuspiciousChildren = dynamic(["cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","rundll32.exe","wmic.exe"]);
let AffectedParents = dynamic(["CSFalconService.exe","CSFalconContainer.exe","AvastSvc.exe","AvastUI.exe","aswVmm.exe","nvcontainer.exe","NVDisplay.Container.exe","nvtelemetrycontainer.exe"]);
union isfuzzy=true
(
  DeviceProcessEvents
  | where TimeGenerated > ago(Lookback)
  | where InitiatingProcessFileName in~ (AffectedParents)
  | where FileName in~ (SuspiciousChildren)
  | project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256, ReportId
),
(
  SecurityEvent
  | where TimeGenerated > ago(Lookback)
  | where EventID == 4688
  | where ParentProcessName has_any (AffectedParents)
  | where NewProcessName has_any (SuspiciousChildren)
  | project TimeGenerated, Computer, SubjectAccount, ParentProcessName, NewProcessName, CommandLine
)
| order by TimeGenerated desc;

// Secondary hunt: SYSTEM shells with unusual parent processes
DeviceProcessEvents
| where TimeGenerated > ago(Lookback)
| where FileName in~ ("cmd.exe","powershell.exe","pwsh.exe")
| where AccountName =~ "system"
| where InitiatingProcessFileName !in~ ("services.exe","svchost.exe","wininit.exe","winlogon.exe","MsMpEng.exe","msiexec.exe","TiWorker.exe","smss.exe","csrss.exe","spoolsv.exe","wmiprvse.exe","taskhostw.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256
| order by TimeGenerated desc;

Velociraptor VQL

Use this hunt to sweep the fleet for live evidence of the exploitation outcome — shells parented to affected product processes — plus recently dropped driver files in user-writable locations.

VQL — Velociraptor
-- Hunt: Privilege escalation outcome — shells parented to CrowdStrike/Avast/Nvidia processes
-- plus suspicious driver staging in user-writable paths
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE (Name =~ '(?i)cmd\.exe|powershell\.exe|pwsh\.exe|mshta\.exe|wscript\.exe'
   AND Username =~ '(?i)SYSTEM')
   OR Exe =~ '(?i)CSFalconService|AvastSvc|nvcontainer'

-- Follow-up: hunt for recently created driver files outside System32\drivers
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=['C:/Users/*/AppData/**/*.sys',
                 'C:/Windows/Temp/*.sys',
                 'C:/ProgramData/**/*.sys',
                 'C:/Users/Public/*.sys'])
WHERE Mtime > (timestamp(epoch=now() - 7*24*3600))
ORDER BY Mtime DESC

Remediation and Hardening Script

Since vendor patches are not yet available, the immediate defensive play is hardening: enforce the Microsoft vulnerable driver blocklist, verify EDR self-protection/tamper protection, restrict local admin surface, and audit for exploitation artifacts.

PowerShell
# Nightmare Eclipse Exposure — Compensating Controls & Audit Script
# Run elevated. Review output before enforcing changes in production.

# 1) Verify Microsoft Vulnerable Driver Blocklist is enforced (blocks known-abused drivers)
$msipath = 'HKLM:\SYSTEM\CurrentControlSet\Control\CI\Config'
$vdl = Get-ItemProperty -Path $msipath -Name 'VulnerableDriverBlocklistEnable' -ErrorAction SilentlyContinue
if ($vdl.VulnerableDriverBlocklistEnable -ne 1) {
    Write-Host '[!] Vulnerable Driver Blocklist NOT enforced — enabling (requires reboot)' -ForegroundColor Yellow
    Set-ItemProperty -Path $msipath -Name 'VulnerableDriverBlocklistEnable' -Value 1
} else {
    Write-Host '[+] Vulnerable Driver Blocklist is enforced.' -ForegroundColor Green
}

# 2) Confirm HVCI / Memory Integrity status (blocks unsigned/vulnerable kernel drivers)
$hvci = Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard -ErrorAction SilentlyContinue
if ($hvci.SecurityServicesRunning -contains 2) {
    Write-Host '[+] Memory Integrity (HVCI) is running.' -ForegroundColor Green
} else {
    Write-Host '[!] Memory Integrity (HVCI) not running — enable via GPO/Intune: Device Guard > Hypervisor-Protected Code Integrity' -ForegroundColor Yellow
}

# 3) Enumerate unsigned or suspicious kernel drivers currently loaded
Write-Host '`n[*] Scanning loaded drivers for unsigned / non-standard images...'
Get-CimInstance Win32_SystemDriver | Where-Object { $_.State -eq 'Running' -and $_.PathName } | ForEach-Object {
    $path = $_.PathName -replace '\\??\\',''
    $sig = Get-AuthenticodeSignature -FilePath $path -ErrorAction SilentlyContinue
    if ($sig.Status -ne 'Valid') {
        Write-Host ("[!] Unsigned/invalid driver: {0} -> {1} (Status: {2})" -f $_.Name, $path, $sig.Status) -ForegroundColor Red
    }
}

# 4) Audit for exploitation outcome: driver files dropped in user-writable paths in last 14 days
$cutoff = (Get-Date).AddDays(-14)
$searchPaths = @("$env:SystemDrive\Users", "$env:ProgramData", "$env:SystemRoot\Temp")
foreach ($p in $searchPaths) {
    Get-ChildItem -Path $p -Recurse -Filter *.sys -ErrorAction SilentlyContinue |
        Where-Object { $_.CreationTime -gt $cutoff } |
        ForEach-Object { Write-Host ("[!] Recent driver file: {0} (Created: {1})" -f $_.FullName, $_.CreationTime) -ForegroundColor Red }
}

# 5) Verify tamper protection posture (Defender) — third-party AV/EDR equivalents must be checked in their consoles
$mp = Get-MpPreference -ErrorAction SilentlyContinue
if ($mp) {
    Write-Host ('[*] Defender Tamper Protection state (check Get-MpComputerStatus for IsTamperProtected):')
    Get-MpComputerStatus | Select-Object IsTamperProtected, RealTimeProtectionEnabled, AntivirusEnabled | Format-List
}

# 6) Inventory affected product versions for patch-readiness tracking
Write-Host '`n[*] Installed versions of affected product families:'
Get-CimInstance Win32_Product -ErrorAction SilentlyContinue |
    Where-Object { $_.Name -match 'CrowdStrike|Falcon|Avast|NVIDIA' } |
    Select-Object Name, Version | Format-Table -AutoSize
# Faster alternative if Win32_Product is too slow:
Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
                 'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*' -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName -match 'CrowdStrike|Falcon|Avast|NVIDIA' } |
    Select-Object DisplayName, DisplayVersion | Format-Table -AutoSize

Remediation

There is no vendor patch yet — your remediation plan is compensating controls plus readiness for rapid patch deployment. Prioritize in this order:

  1. Enforce the Microsoft Vulnerable Driver Blocklist on all supported Windows 11 / Server 2022+ systems, and enable HVCI (Memory Integrity) wherever hardware compatibility allows. This is the single most effective systemic control against the class of post-exploitation driver abuse that follows an LPE to SYSTEM.
  2. Verify tamper protection is on and alerting is tuned. For CrowdStrike environments, confirm sensor tamper protection policies and ensure your SOC is watching for sensor service stop/unload attempts. For Defender environments, confirm Tamper Protection via Get-MpComputerStatus. Any attempt to stop, uninstall, or downgrade a security agent should page someone.
  3. Reduce local privilege surface. An LPE PoC requires the attacker to run code first. Enforce least privilege (no standing local admin), application control (WDAC or AppLocker), and attack surface reduction rules to raise the bar on the initial execution the exploit depends on.
  4. Lock down driver installation. Audit and restrict which accounts can install drivers/services; alert on sc.exe create with kernel type and on service creation events (Event ID 7045) pointing at non-standard image paths.
  5. Track vendor advisories aggressively. Monitor CrowdStrike, Nvidia (nvidia.com/security), and Avast/Gen Digital security advisories daily. When CVEs and patches drop, treat them as emergency-change candidates — public PoC means you should assume the patch diffing race is already underway. Check the CISA Known Exploited Vulnerabilities catalog as CVEs are assigned; KEV additions carry mandated remediation deadlines for federal agencies and are a reliable severity signal for everyone else.
  6. Hunt retroactively. Run the VQL and KQL content above across at least 30 days of telemetry. If the PoCs or close variants were tested against your environment before disclosure, the exploitation outcome (anomalous SYSTEM shells, security-product parent-child anomalies) is what will surface.
  7. Brief your IR retainer/playbooks. Add a scenario: "EDR/AV agent compromised via public LPE PoC." The response path — isolate host, capture memory before sensor degradation, verify sensor integrity from the vendor console side — is materially different from a standard malware triage.

The uncomfortable truth in this disclosure is that your security stack is part of your attack surface. Organizations that treat EDR and AV agents as trusted black boxes with no behavioral monitoring of the agents themselves will miss the exact moment these exploits succeed. Watch the watchers.

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.