Soc Adventurez In TiETW
Luke Jones
Security BSides London 2023 · Day 1 · Track 3
Overview
In "Soc Adventurez In TiETW," Luke Jones, a seasoned blue teamer, delves into the intricate world of process injection detection, specifically focusing on the capabilities and limitations of Microsoft Defender for Endpoint (MDE). The talk aims to demystify how EDRs fundamentally operate, expose common userland evasion techniques employed by adversaries, and highlight the critical role of kernel-level telemetry, particularly Microsoft Windows Threat Intelligence Event Tracing for Windows (TIETW), in bolstering defensive postures. Jones challenges the conventional assumption that EDRs flawlessly detect advanced threats, revealing significant gaps that necessitate proactive, custom detection engineering from security operations centers (SOCs).

Key moments
- 0:00 Introduction and motivation for EDR research
- 8:00 Attacker techniques to bypass userland EDR
- 10:00 Unveiling kernel-mode Threat Intelligence ETW (TIETW)
- 16:00 MDE's anti-malware protection limits raw TIETW access
- 26:00 Crafting custom KQL detections for MDE blind spots
- 30:00 Bypassing MDE protection for raw TIETW data
- 46:00 Key takeaways for blue and red teams
Soc Adventurez In TiETW
Speakers: Luke Jones
Conference: BSides London
YouTube: https://www.youtube.com/watch?v=Tmr7OQkIDP0
Overview
In "Soc Adventurez In TiETW," Luke Jones, a seasoned blue teamer, delves into the intricate world of process injection detection, specifically focusing on the capabilities and limitations of Microsoft Defender for Endpoint (MDE). The talk aims to demystify how EDRs fundamentally operate, expose common userland evasion techniques employed by adversaries, and highlight the critical role of kernel-level telemetry, particularly Microsoft Windows Threat Intelligence Event Tracing for Windows (TIETW), in bolstering defensive postures. Jones challenges the conventional assumption that EDRs flawlessly detect advanced threats, revealing significant gaps that necessitate proactive, custom detection engineering from security operations centers (SOCs).
This presentation is particularly relevant for blue teams, incident responders, and detection engineers grappling with sophisticated adversaries who leverage process injection to hide their malicious activities within trusted processes. Jones unpacks the complexities of accessing and interpreting TIETW data, demonstrating how MDE's implementation often falls short in providing comprehensive visibility and triggering timely alerts, even when the underlying telemetry exists. By dissecting various process injection methods and MDE's response, he empowers defenders to go beyond out-of-the-box EDR capabilities, advocating for a deeper understanding of endpoint telemetry to build more robust and resilient detection strategies.
The talk underscores the ongoing cat-and-mouse game between attackers and defenders, emphasizing that while EDRs offer a foundational layer of security, they are not infallible. Jones's exploration of TIETW serves as a call to action for SOCs to actively explore their telemetry sources, develop custom alerts, and even push EDR vendors for greater transparency and data access. It’s a pragmatic guide for those seeking to enhance their ability to detect stealthy attacks that bypass conventional userland security controls, transforming raw, often overlooked, kernel events into actionable intelligence.
Background
▶ Watch: Introduction and motivation for EDR research (0:00)
The genesis of this talk stems from a real-world red team engagement in 2021 against Jones's organization, where the existing EDR predictably failed to detect malware leveraging process injection as part of its payload. This incident sparked a critical inquiry into the efficacy of EDRs against such techniques and the underlying data available for detection. Process injection, as Jones explains, is a fundamental method for attackers to introduce malicious code into legitimate, trusted processes, thereby evading detection by hiding the origin of their activities and avoiding disk-based indicators. This places the attacker squarely within the execution and installation phases of the attack kill chain.
Traditional EDR solutions typically rely on a combination of telemetry sources. These include kernel callbacks, which allow kernel-mode drivers to subscribe to events like process and thread creation or access; Event Tracing for Windows (ETW), a powerful debugging and application telemetry utility that can provide insights into function calls and class names, particularly for .NET applications; function hooking, where EDRs tamper with loaded libraries to redirect execution flow for inspection; and the Anti-Malware Scan Interface (AMSI), which allows applications to pass runtime data to an anti-malware provider for scanning. While these mechanisms offer broad visibility, they largely operate within userland.
The critical vulnerability of userland telemetry is that it can be bypassed by sophisticated attackers. Jones details several common evasion techniques:
- ETW Bypass: Attackers can tamper with the
EventWritefunction within loaded DLLs (e.g.,ntdll.dll) to prevent events from being written. - AMSI Bypass: Similarly, the
AmsiScanBufferfunction can be tampered with, allowing malicious code to execute without being flagged by the anti-malware provider. - Unhooking: If an EDR has hooked a function, attackers can overwrite the hook with the original function's code, effectively disabling the EDR's introspection. This can be achieved by loading a fresh copy of
ntdll.dllto restore original function pointers.
Once these userland defenses are bypassed, defenders are left with significantly fewer reliable telemetry sources. The remaining pillars are kernel callbacks and kernel-mode ETW providers. This is where Microsoft Windows Threat Intelligence Event Tracing for Windows (TIETW) becomes paramount. TIETW, operating at the kernel level, logs potentially abusable APIs used by applications. Unlike userland ETW, its kernel-mode nature makes it inherently more resistant to userland tampering, providing a critical source of truth for discerning malicious process behavior.
However, accessing and leveraging TIETW data presents its own set of challenges. While Microsoft Defender for Endpoint (MDE) does ingest some ETW events into its DeviceEvents table within the Advanced Hunting schema, this data is often incomplete. Crucially, MDE frequently omits extended details present in the raw TIETW stream, such as changes to remote memory protection, memory reads, or specific events related to process hollowing or thread hijacking. Furthermore, EDR vendors, including Microsoft, protect their processes using Anti-Malware Process Light (PPL) protection. This mechanism assigns a protection level that restricts access to the EDR's memory and data, preventing even administrative users from directly inspecting or extracting raw TIETW logs without a signed, Early Launch Anti-Malware (ELAM) driver—a capability generally reserved for AV vendors, not typical blue teams. This proprietary restriction, coupled with limited public documentation, creates a significant hurdle for defenders seeking to fully leverage this powerful kernel-level telemetry.
Key Findings
▶ Watch: Unveiling kernel-mode Threat Intelligence ETW (TIETW) (10:00)
Luke Jones's deep dive into TIETW and Microsoft Defender for Endpoint uncovered several critical findings regarding the detection of process injection techniques:
- MDE's Incomplete TIETW Exposure: While MDE ingests some TIETW events into its Advanced Hunting
DeviceEventstable, it frequently omits crucial details and specific event types. For instance, events likeAllocateVirtualMemoryRemote,MapViewOfSectionRemote,QueueUserApcRemote, andSetThreadContextRemoteare present, but granular information such as memory protection changes, memory reads/writes, or the fullProcessStartKeyfor correlation is often missing. This lack of detail hinders precise detection engineering.
- MDE's Alerting Gaps: Despite the presence of underlying TIETW telemetry, MDE often fails to generate alerts for sophisticated process injection techniques. A notable example involved MapView with Thread Hijack, where the raw
MapViewOfSectionRemoteandSetThreadContextRemoteevents were visible in MDE's telemetry (flagged as a "CyberDataTrue" event) but no alert was triggered. This suggests that MDE's internal logic, likely due to global customer tuning and optimization, prioritizes false positive reduction over comprehensive alerting for all detected malicious behaviors.
- Simple Evasion for Complex Detections: Jones demonstrated that a classic reflective injection using
CreateRemoteThreadcould bypass MDE's detection logic by simply introducing a 10-minute delay before issuing the thread creation. This highlights a vulnerability in MDE's time-based correlation or detection heuristics, allowing attackers to evade detection with minimal effort.
- Correlation Challenges Due to Missing Data: The absence of consistent
ProcessStartKeyor complete initiating process information in MDE logs significantly complicates the correlation of events, especially for multi-step injection techniques. For instance, correlatingAllocateVirtualMemoryRemotewithSetThreadContextRemotebecame a "nightmare" due to the latter often lacking initiating process IDs and precise timestamps, forcing defenders to rely on broader, less reliable time correlations (e.g., within a 30-minute window).
- High-Fidelity Detection Opportunities: Certain TIETW events proved to be exceptionally rare in legitimate environments, offering high-fidelity detection opportunities.
MapViewOfSectionRemote: In Jones's 800-endpoint environment, this event was almost exclusively observed from Firefox and its child processes. Any other occurrence is highly suspicious, allowing for straightforward custom detection.QueueUserApcRemote: This event was not observed at all in Jones's environment over 90 days. MDE actually caught and alerted on a test of this API call within 30 minutes, making it an excellent indicator of malicious activity.
- Signature-Based vs. Behavioral Detection: When testing Threadless Injection (a technique avoiding thread creation), MDE initially detected it. However, merely adding a NOP (No Operation) instruction into the shellcode successfully bypassed the detection, indicating that MDE's original detection was likely signature-based rather than a robust behavioral analysis of the injection mechanism itself.
- Accessing Raw TIETW Data: Jones showcased that while direct access to raw TIETW is restricted by Protected Process Light (PPL), tools like TIETW Agent, PPL Runner, or leveraging a vulnerable kernel driver utility can allow defenders to bypass PPL in lab or test environments to gain full visibility into the kernel-level telemetry for advanced detection engineering. This provides a way to understand what data is truly available, even if not directly exposed by MDE.
Technical Deep Dive
▶ Watch: MDE's anti-malware protection limits raw TIETW access (16:00)
The core of Luke Jones's presentation revolves around dissecting the mechanisms EDRs employ for detection and the sophisticated techniques attackers use for evasion, ultimately highlighting the pivotal role of Threat Intelligence Event Tracing for Windows (TIETW).
EDR Detection Mechanisms:
EDRs, such as Microsoft Defender for Endpoint, gather telemetry from various sources:
- Kernel Callbacks: These are highly privileged mechanisms where kernel-mode drivers register to be notified of critical system events. This includes process creation (
PsSetCreateProcessNotifyRoutineEx), thread creation (PsSetCreateThreadNotifyRoutineEx), and process access (PsSetLoadImageNotifyRoutine). Operating within the kernel, these are harder for userland malware to tamper with. - User-Mode Mechanisms:
- Event Tracing for Windows (ETW): A powerful, built-in Windows diagnostic and logging framework. EDRs can subscribe to ETW providers, particularly for .NET applications, to capture detailed events like function calls, class names, and method invocations. Tools like SilkETW allow defenders to inspect these streams.
- Function Hooking: EDRs often inject DLLs into new processes or modify legitimate system DLLs (e.g.,
ntdll.dll) to redirect calls to critical Windows APIs (likeCreateRemoteThread,OpenProcess,VirtualAllocEx) through their own monitoring code. This allows them to inspect parameters and execution flow. - Anti-Malware Scan Interface (AMSI): Introduced in Windows 10, AMSI provides a standard interface for applications (like PowerShell, scripting engines) to pass content to an installed anti-malware provider for scanning before execution. This is particularly effective against script-based attacks.
Userland Evasion Techniques:
Attackers are well-versed in bypassing these userland controls:
- ETW Bypass: The
EventWritefunction withinntdll.dllis often the lowest-level component responsible for writing ETW events. Attackers can patch this function in memory (e.g., by overwriting its first few bytes with aRETinstruction) to immediately return, effectively silencing ETW telemetry for their process. - AMSI Bypass: Similar to ETW, AMSI can be bypassed by patching the
AmsiScanBufferfunction inamsi.dllor by manipulating its return value to indicate "clean" even for malicious input. Tools like SharpUnhooker are designed to automate these bypasses for .NET applications. - Unhooking: If an EDR has hooked an API, attackers can restore the original function's bytes. This is commonly done by loading a fresh, untampered copy of
ntdll.dll(or other system libraries) into memory, reading the original function bytes, and then overwriting the EDR's hook in the target process's memory space.
Kernel-Level Telemetry and TIETW:
Once userland defenses are compromised, the remaining reliable telemetry sources operate in kernel mode. This includes kernel callbacks and Microsoft Windows Threat Intelligence Event Tracing for Windows (TIETW). TIETW, a kernel-mode ETW provider, is specifically designed to log potentially abusable APIs. The "threat intelligence" in its name refers to the intelligence derived from monitoring these low-level, often abused, API calls, not external threat intelligence feeds.
Key TIETW events relevant to process injection, as seen via tools like ETW Explorer, include:
- Memory Allocation:
AllocateVirtualMemoryRemote(allocating new memory in a remote process) andMapViewOfSectionRemote(mapping a shared memory section into a remote process). - Code Execution:
CreateRemoteThread(a kernel callback, but related),SetThreadContextRemote(modifying an existing thread's context to point to malicious code), andQueueUserApcRemote(queuing an Asynchronous Procedure Call to a thread, leading to execution). - Memory Protection Changes: Events detailing changes to memory protection (e.g., from
RWtoRX), crucial for detecting shellcode execution.
MDE's TIETW Implementation and Challenges:
MDE ingests a subset of TIETW events into its Advanced Hunting DeviceEvents table. While helpful, this ingestion is incomplete:
- Missing Details: MDE often lacks the granular parameters available in raw TIETW, such as the specific memory protection flags changed during an
NtProtectVirtualMemorycall. - Correlation Issues: The
ProcessStartKeyfeature in MDE aims to correlate events to a process's initial creation. However, Jones found inconsistencies, with some critical events (likeSetThreadContextRemote) frequently missing initiating process information, making precise correlation difficult and forcing reliance on broader time-based correlations. - Protected Process Light (PPL): MDE processes run with PPL protection (
AntiMalware-Light), which prevents non-signed processes from accessing or tampering with them. This restriction extends to directly accessing the raw TIETW streams that MDE itself consumes, forcing defenders to rely on MDE's filtered and potentially incomplete output.
Accessing Raw TIETW Data (for Detection Engineering):
To overcome PPL restrictions and gain full visibility for detection engineering, Jones explored advanced techniques:
- TIETW Agent & PPL Runner: TIETW Agent is an open-source tool that mimics EDR behavior by subscribing to TIETW events. To run it with the necessary privileges, PPL Runner can be used. This involves signing a custom driver and enabling Windows Test Mode, allowing processes to run with
AntiMalware-Lightprotection. While effective for labs, Test Mode is impractical for production. - Vulnerable Kernel Drivers: A more covert method involves leveraging known vulnerabilities in legitimate kernel drivers. Jones mentioned a fork of a tool by @itm4n that once exploited a Windows vulnerability to elevate its own process to
AntiMalware-Lightwithout Test Mode. Although that specific exploit was patched, the principle of using a vulnerable kernel driver (e.g., via the "kernel driver utility" with a feature added by that tool's author) can still be applied in environments without Hypervisor Code Integrity (HVCI) or Core Isolation to gain access to raw TIETW. This is a "gray area" and not recommended for production due to security risks.
MDE Timeline and "Defender++" Data:
For incident response, Jones noted that the MDE timeline in the portal often contains more detailed events than Advanced Hunting. This "Defender++" data can be programmatically accessed by making direct API calls to the MDE service API (identified by inspecting network traffic in the browser). While "dubious" due to a lack of explicit guidelines, tools like Windows Harvester (from Microsoft's MD internals team) can be used to pull this richer timeline information, enabling more granular analysis and enrichment for custom alerts.
Ultimately, the technical deep dive reveals that while MDE leverages powerful kernel-level telemetry, its implementation for defenders is bottlenecked by data filtering, correlation challenges, and proprietary restrictions, necessitating advanced techniques and custom engineering to achieve comprehensive detection against modern process injection attacks.
Demo / Proof of Concept
▶ Watch: Bypassing MDE protection for raw TIETW data (30:00)
Luke Jones conducted several proof-of-concept demonstrations to illustrate both the capabilities and limitations of Microsoft Defender for Endpoint (MDE) in detecting various process injection techniques, leveraging specialized tools to observe raw TIETW events.
Tools Used for Demonstrations:
- TIETW Agent: An open-source tool used to emulate EDR behavior and capture raw TIETW events for comparison with MDE's ingested telemetry.
- PPL Runner: Used in conjunction with TIETW Agent to sign custom drivers and run processes with AntiMalware-Light (PPL) protection in Windows Test Mode, allowing full access to TIETW streams.
- SharpUnhooker: A .NET tool specifically mentioned for its ability to bypass AMSI, ETW, and EDR hooks in .NET applications, validating the effectiveness of userland evasion techniques.
- Sysmon for ETW Research: A utility chosen for its efficiency in streaming processes and events, replacing PPL Runner for some tests to simplify the setup.
- itm4n tool fork / Kernel Driver Utility: Used to demonstrate bypassing PPL without Windows Test Mode, by leveraging a vulnerable kernel driver to elevate process protection levels.
Evasion Validation:
Before testing injection techniques, Jones validated userland EDR evasion. With AV real-time protection enabled, he showed that after patching AMSI and ETW (e.g., using SharpUnhooker), applications that would normally be blocked (like Mimikatz via PowerShell DownloadString) could execute freely, and no corresponding ETW events would be logged, confirming the effectiveness of these bypasses.
Test 1: Classical Reflective Injection (CreateRemoteThread)
- Technique: This involves allocating virtual memory in a target process, writing malicious shellcode to that memory, and then creating a remote thread (
CreateRemoteThread) to execute the shellcode. - Result: MDE successfully detected and alerted on this technique. This suggests that
CreateRemoteThread, being a kernel callback, is reliably monitored by MDE.
Test 2: MapView with Thread Hijack (MapViewOfSectionRemote + SetThreadContextRemote)
- Technique: A more convoluted method involving mapping a shared memory section into a target process (
MapViewOfSectionRemote) and then hijacking an existing thread's execution flow by modifying its context (SetThreadContextRemote) to point to the malicious code. - TIETW Agent Observation: The TIETW Agent successfully observed both
MapViewOfSectionRemoteandSetThreadContextRemoteevents. - MDE Observation: MDE's Advanced Hunting telemetry (
DeviceEvents) also showed these events (categorized asCyberDataTrueorCyberEventOne), indicating MDE was aware of the activity. - MDE Alerting: Crucially, MDE did not generate an alert for this specific combination, highlighting a gap in its default detection logic.
- Custom Detection: Jones demonstrated that a custom KQL query joining
MapViewOfSectionRemoteandSetThreadContextRemoteevents could reliably detect this. He noted thatMapViewOfSectionRemoteis extremely rare (only Firefox in his environment of 800 endpoints), making it a high-fidelity detection point.
Test 3: AllocateVirtualMemoryRemote with SetThreadContextRemote (Threadless/Asynchronous Queues)
- Technique: Similar to Test 2 but using
AllocateVirtualMemoryRemote(a more common API) instead ofMapViewOfSectionRemotefor memory allocation, combined withSetThreadContextRemote. - Result: MDE did not alert. Furthermore, the
SetThreadContextRemoteevent in MDE's telemetry often lacked the initiating process information, making precise correlation withAllocateVirtualMemoryRemotedifficult. Jones had to resort to a broader 30-minute time correlation and a "past 14-day trick" (looking for new occurrences) to build a custom detection.
Test 4: Threadless Injection (Saikoubon's "Threadless Inject")
- Technique: A method that manipulates memory processes to inject and execute code without explicitly creating new threads or manipulating existing thread contexts in a straightforward manner.
- Initial Result: MDE initially detected this technique.
- Evasion: By simply adding a NOP (No Operation) instruction into the shellcode, Jones successfully bypassed MDE's detection. This suggested MDE's detection was likely signature-based on the original shellcode rather than a robust behavioral analysis of the threadless injection mechanism.
Test 5: QueueUserApcRemote
- Technique: Queuing an Asynchronous Procedure Call to a thread, a legitimate but often abused method for code execution.
- Result: MDE caught and alerted on this technique within 30 minutes. Jones noted that this API call was exceptionally rare in his environment (not seen in 90 days), making it an excellent high-fidelity detection.
Test 6: Classical Reflective Injection with 10-Minute Delay
- Technique: Re-running Test 1 (
CreateRemoteThread) but introducing a 10-minute delay before the remote thread creation. - Result: MDE did not alert, successfully evading detection. This pointed to a potential time-based threshold in MDE's detection logic.
These demonstrations collectively underscored that while MDE collects a significant amount of kernel-level telemetry via TIETW, its default alerting mechanisms are not exhaustive. Defenders must understand these gaps and be prepared to implement custom detections, leveraging the available (or even hidden) telemetry to address specific, sophisticated process injection techniques.
Defensive Implications
▶ Watch: Key takeaways for blue and red teams (46:00)
The detailed analysis and proof-of-concept demonstrations presented by Luke Jones offer crucial defensive implications for security operations centers (SOCs) and detection engineers:
- Don't Over-rely on Out-of-the-Box EDR Alerts: The most significant takeaway is that EDRs, including Microsoft Defender for Endpoint, are not a silver bullet. They must strike a balance between comprehensive detection and minimizing false positives, leading to inherent gaps where sophisticated process injection techniques may be logged but not alerted upon. Defenders should assume that out-of-the-box alerts will miss certain attacks and proactively seek to fill these gaps.
- Leverage Kernel-Level Telemetry (TIETW): When userland EDR components are bypassed by attackers, kernel-level telemetry, particularly TIETW, becomes the most reliable source of truth. Defenders need to understand what TIETW events MDE ingests into Advanced Hunting and, more importantly, what details are missing compared to the raw TIETW stream. This knowledge is fundamental for building robust detections against advanced threats.
- Prioritize Custom Detection Engineering:
- High-Fidelity Events: Focus on rare TIETW events like
MapViewOfSectionRemoteandQueueUserApcRemote. As demonstrated, these are almost non-existent in typical environments, making any occurrence a strong indicator of malicious activity. Building alerts around these can yield high-fidelity detections with low false positives. - Event Correlation: Develop custom KQL (or similar query language) queries to correlate multiple TIETW events that, individually, might not trigger an alert but together signify process injection (e.g.,
MapViewOfSectionRemotefollowed bySetThreadContextRemote). Overcome MDE's correlation challenges by manually joining onProcessId,TargetProcessId,DeviceName, and time, potentially using broader time windows (e.g., 30 minutes) and "past 14-day" anomaly detection. - Network Activity Correlation: Enrich process injection detections by correlating them with immediate network callbacks (e.g., Sysmon Event ID 3 for network connections). An immediate network connection after a process injection event is a strong indicator of command and control (C2) or lateral movement.
- Behavioral Profiling: Baseline normal behavior in your environment. For instance, if only Firefox legitimately uses
MapViewOfSectionRemote, any other process exhibiting this behavior is suspicious. This reduces false positives and highlights anomalies.
- Consider "Defender++" Data for Incident Response: While hammering the MDE service API for real-time alerting is "dubious," accessing the richer timeline data (Defender++) via tools like Windows Harvester is invaluable for incident response. When investigating a compromise, pulling all available telemetry from the MDE timeline into a log analytics workspace provides a more comprehensive picture than Advanced Hunting alone, streamlining analysis that would otherwise be a "horrible" manual scroll through the MDE portal.
- Advocate for Better Vendor Transparency and Data Access: Jones explicitly calls for Microsoft to provide more granular and complete access to kernel-level TIETW data, including full
ProcessStartKeyinformation and details on memory protection changes. This would empower SOCs to develop more precise and effective detections, fostering a stronger defensive ecosystem. Defenders should actively engage with their EDR vendors to push for these capabilities.
- Understand Red Team Tactics: Blue teams should be aware of simple EDR evasion techniques, such as introducing delays (e.g., 10 minutes for
CreateRemoteThread) or minor shellcode modifications (e.g., a NOP instruction for Threadless Injection). This knowledge helps in designing more resilient detections that aren't easily bypassed by trivial changes.
- Lab Environments for Advanced Research: While using vulnerable kernel drivers to bypass PPL in production is ill-advised (especially if HVCI/Core Isolation are not enabled, indicating bigger problems), leveraging such techniques in a controlled lab environment can provide invaluable insights into raw TIETW streams. This enables detection engineers to understand exactly what telemetry is available at the kernel level, informing the development of custom rules for what MDE misses.
In conclusion, the talk serves as a powerful reminder that effective defense against advanced process injection techniques requires more than just deploying an EDR. It demands a deep understanding of underlying telemetry, proactive custom detection engineering, an awareness of EDR limitations and attacker evasion methods, and a continuous push for better tools and data access from vendors.
Key Takeaways
- EDRs are not infallible: Microsoft Defender for Endpoint, despite its capabilities, has gaps in detecting sophisticated process injection techniques, often logging events without generating alerts due to internal tuning.
- Kernel-level telemetry is paramount: When userland EDR components are bypassed, Threat Intelligence Event Tracing for Windows (TIETW) provides crucial, tamper-resistant kernel-level visibility into malicious activities.
- MDE's TIETW data is incomplete: MDE ingests TIETW events but frequently omits granular details and struggles with consistent event correlation, necessitating custom detection efforts.
- High-fidelity custom detections are achievable: Rare TIETW events like
MapViewOfSectionRemoteandQueueUserApcRemoteoffer excellent opportunities for high-fidelity custom alerts with low false positives. - Proactive detection engineering is essential: SOCs must actively profile their environments, correlate events across different data sources (including network telemetry), and leverage advanced techniques to fill EDR detection gaps and counter simple evasion tactics like time delays.
- Advocate for vendor improvement: Defenders should push EDR vendors for greater access to raw kernel-level telemetry and more complete event details to empower better custom detection capabilities.
About the Speaker(s)
Luke Jones is a dedicated blue teamer with approximately 3.5 years of experience in the cybersecurity field. His expertise spans security engineering, architecture, and operations. He is known for his pragmatic approach to understanding security tools and challenging conventional assumptions about their effectiveness in defending against real-world threats.
Reviews
Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT
Jones did the homework most SOC analysts won't do. He ripped open Microsoft Defender for Endpoint to prove that just because an EDR logs a kernel event in TIETW doesn't mean it will actually fire an alert. If you rely on out-of-the-box MDE rules to save you from process injection, you need to watch this.
Heather Calloway (CISO) — MUST SEE
This is a rigorous look at the gap between what Microsoft Defender logs and what it actually alerts on. It proves that buying top-tier EDR licenses does not automatically buy you comprehensive detection, making it required viewing for your SOC leadership.