April 23, 2026
AuthorAdrián DíazRead time14 minPublishedApr 23, 2026TopicsWindows InternalsEDR Evasion Table of Contents The previous post covered call stack spoofing: how an implant makes its call stack
For modern defenders, Event Tracing for Windows (ETW) is the source of truth. It is the nervous system of the Windows endpoint, providing the telemetry that EDRs rely on to detect process injection, .NET abuse, and malicious network connections.
But from a Red Team perspective, ETW is just another software component. And like any software component, it can be manipulated, suppressed, or blinded.
In this post, we will dissect ETW from an attacker’s viewpoint. We will explore how the kernel generates these events, how we dismantle the logging pipeline during engagements, and, most importantly, how you can detect these evasion attempts to build a more resilient defense.
To blind the system, we first have to understand how it sees. ETW isn’t a single monolith; it is a pipeline composed of four distinct components. If an attacker breaks any link in this chain, the defensive tools at the end go blind.
Providers: The components generating the events. This can be user-mode applications (like the CLR) or the Windows Kernel itself.
Sessions: The kernel objects that act as buffers, collecting events from providers and relaying them.
Controllers: The management layer (e.g., logman.exe) that starts, stops, and configures trace sessions.
Consumers: The end destination. In most environments, your EDR agent is the primary real-time consumer.
The Red Team Takeaway: We don’t need to destroy the whole system. We just need to stop the Session or silence the Provider, and the Consumer (your EDR) will simply stop receiving data.
Before we discuss breaking it, it is crucial to appreciate what we are up against. The Windows Kernel (ntoskrnl.exe) has embedded sensors that are incredibly difficult to bypass without high privileges. These sensors are divided into two categories: Threat Intelligence (Ti) and Security Mitigations (Tim).
These are the “high fidelity” sensors that Microsoft added to catch advanced tradecraft. They hook directly into critical kernel functions.
EtwTiLogReadWriteVm: Triggered by MiReadWriteVirtualMemory. This catches us when we try to read/write to another process’s memory (e.g., dumping LSASS).
EtwTiLogSetContextThread: Triggered by PspSetContextThreadInternal. This is the primary indicator for Thread Hijacking injection techniques.
EtwTiLogDeviceObjectLoad: Triggered when a driver is loaded.
These sensors fire when a security control blocks an operation.
EtwTimLogBlockNonCetBinaries: Fired when a binary is blocked because it doesn’t comply with Control-Flow Enforcement Technology (CET).
EtwTimLogProhibitDynamicCode: Triggered by functions like MiArbitraryCodeBlocked. This alerts you when a process tries to execute code in a way that violates Arbitrary Code Guard (ACG).
Defensive Note: These kernel-level events are generated inside Ring 0. Unlike user-mode logs, we cannot simply “patch” them from a standard process. However, we can stop the sessions that listen to them.
During a Red Team engagement, we cannot afford to let these sensors report back to the SIEM. Here are the three primary techniques we use to neutralize ETW.
The most straightforward way to blind an EDR is to attack the Controller. Windows includes a built-in utility called logman.exe designed to manage traces. An attacker with administrative privileges can list all active sessions and simply kill the one belonging to the security product.
# List all active ETW sessions
logman query -ets
# Stop the specific session (e.g., "Circular Kernel Context Logger" or a vendor-specific session)
logman stop "Session-Name" -ets
Why this works: The EDR agent is often a Consumer. If we kill the Session at the kernel level, the EDR process keeps running, but the data hose is disconnected. The dashboard shows “Healthy,” but the sensor is deaf.
Sometimes we don’t want to kill a session; we want to own it. Tools like Process Monitor (Procmon) rely on specific trace sessions (e.g., PROCMON TRACE).
By querying the providers, we can see exactly what a tool is listening to. During our research, we found we could effectively “hijack” these sessions or flood them. For example, by flooding the .NET CLR Provider with register/unregister events, we attempted to overflow the buffers used by analysis tools. While Windows is resilient, this highlights that the consumption of events is finite. If we generate noise faster than the consumer can parse it, we create gaps in visibility.
This is the most common technique used by modern malware to hide user-land activity (like .NET assembly execution).
Most user-mode applications (including PowerShell and the .NET runtime) generate events by calling the Win32 API EtwEventWrite. This function resides in ntdll.dll. Since ntdll.dll is loaded into the memory space of every process, it is accessible to that process.
The Attack Chain:
Locate: The malware finds the memory address of the EtwEventWrite function within its own process.
Unlock: It uses VirtualProtect to change the memory permissions of that function to PAGE_EXECUTE_READWRITE.
Patch: It overwrites the very first instruction of the function with 0xC3 (the assembly opcode for RET or “Return”).
Lock: It restores the memory permissions.
The Result: Now, whenever the CLR tries to log “Suspicious Assembly Loaded,” it calls EtwEventWrite. The CPU sees the RET instruction immediately and returns “Success” to the caller. No event is sent to the kernel. No log is generated. To the EDR, the process is silent.
If ETW can be patched, killed, or flooded, how can defenders trust their data? The answer lies in Detection-in-Depth. We must stop treating ETW as infallible and start detecting the attempts to tamper with it.
Attacking ETW via logman.exe is noisy. It leaves a distinct process execution artifact. You should have high-severity alerts for any usage of logman stopping a tracing session, especially if the target session name matches your security tooling.
DeviceProcessEvents
| where FileName =~ "logman.exe"
| where ProcessCommandLine has "stop" or ProcessCommandLine has "delete"
| where ProcessCommandLine has "-ets"
| project Timestamp, DeviceName, AccountName, ProcessCommandLine
The “Surgical Strike” (patching ntdll.dll) leaves a forensic scar in memory. The ntdll.dll loaded in memory should be identical to the file on disk. If an attacker patches it, the memory page containing EtwEventWrite will be marked as Private/Commit rather than Image/Shared.
Tools for this:
Moneta / PE-sieve: These tools scan processes for “unbacked code” or modified system DLLs.
Elastic EDR: Has specific capabilities to detect when system DLLs are hooked or patched in memory.
User-mode patching only blinds user-mode telemetry. It does not blind the kernel. EDRs should utilize Kernel Callbacks (PsSetCreateProcessNotifyRoutine, ObRegisterCallbacks) for critical events like process creation and handle manipulation. These operate at a layer below ntdll.dll and are significantly harder for standard malware to tamper with.
Finally, use anomaly detection. A process that is performing complex actions (network connections, high CPU usage, file IO) but generating zero ETW events is highly suspicious.
Example: If powershell.exe is making network connections but hasn’t generated a single ScriptBlock log or CLR load event, it has likely been blinded.
Here is a Sigma rule for one concrete, high-fidelity way this blinding is done: disabling the .NET Framework ETW provider through its registry value before running managed tooling.
title: DotNet ETW Disabled via ETWEnabled Registry Value
id: a90f1d0c-91fa-4fc4-905e-52d53d85ac5e
status: experimental
description: Detects the .NET Framework ETW provider being disabled through the ETWEnabled registry value, a known technique for blinding CLR telemetry before running in-memory tooling.
references:
- https://valhguard.com/2025/11/14/etw-blind-spot-evasion-detection/
author: Adrian Diaz, Valhguard
date: 2025-11-14
tags:
- attack.stealth
- attack.t1685
logsource:
category: registry_set
product: windows
detection:
selection:
TargetObject|endswith: '\.NETFramework\ETWEnabled'
Details: 'DWORD (0x00000000)'
condition: selection
falsepositives:
- Unknown
level: high
It validates clean and compiles to Splunk, Sentinel (KQL), Elastic and CrowdStrike. It catches the registry route specifically; the in-process EtwEventWrite patch leaves a different artefact (a modified prologue) that needs memory-integrity scanning rather than a log rule.
ETW is a masterpiece of engineering, but in the cat-and-mouse game of cybersecurity, it is not a silver bullet. Attackers view it as a constraint to be bypassed, not a law of physics.
By understanding the mechanics of Session Killing and Function Patching, defenders can move beyond blind trust in their logs and start hunting for the absence of evidence.
Red Team: We will keep finding ways to turn off the lights.
Blue Team: Your job is to notice when the room goes dark.
AuthorAdrián DíazRead time14 minPublishedApr 23, 2026TopicsWindows InternalsEDR Evasion Table of Contents The previous post covered call stack spoofing: how an implant makes its call stack
How three generations of call stack spoofers defeat the x64 unwinder, and where the detection still holds.
Both techniques make a process lie about itself, and both are on nearly every engagement. But they fail differently under scrutiny: one leaves a clean mechanical tell the spoof cannot erase, the other leaves nothing to compare against. Where the truth actually lives.
Patch ETW and the CLR goes dark, load from a byte array and you dodge AMSI, Sysmon catches the DLL load anyway. Two of those are wrong on modern .NET and the third is structurally impossible. Where the telemetry for in-memory .NET really is, and which signals survive an operator inside the process.
Virtualization is not just infrastructure; it is a weapon. Red Teams leverage portable QEMU instances to bypass host-based EDRs and evade behavioral analysis. We analyze how attackers deploy these “invisible machines” without administrative privileges and provide the KQL hunting queries defenders need to detect unauthorized virtualization on their networks.
Loading kernel drivers is a “Holy Grail” operation for attackers, granting Ring 0 privileges for persistence or EDR blinding. We analyze the forensic difference between the loud method (sc.exe) and the stealthy method (devcon.exe) to help Blue Teams build resilient detections.