SKILL: Endpoint Detection and Response
Metadata
Description
EDR evasion offensive checklist: hook unhooking (user/kernel), direct syscalls, PPID spoofing, process injection variants, AMSI bypass, ETW patching, memory encryption, and behavior-based evasion. Use when planning EDR bypass during red team engagements or researching AV/EDR evasion techniques.
Trigger Phrases
Use this skill when the conversation involves any of:
EDR evasion, EDR bypass, hook unhooking, direct syscalls, PPID spoofing, process injection, AMSI bypass, ETW patch, memory encryption, AV evasion, behavioral evasion, red team evasion
Instructions for Claude
When this skill is active:
- Load and apply the full methodology below as your operational checklist
- Follow steps in order unless the user specifies otherwise
- For each technique, consider applicability to the current target/context
- Track which checklist items have been completed
- Suggest next steps based on findings
Full Methodology
Endpoint Detection and Response
Fundamentals
AV vs EDR
Antivirus (preventive approach):
- Static Analysis: Matching known signatures in files
- Dynamic Analysis: Limited behavioral monitoring/sandboxing
- Effective against known threats, weaker against advanced attacks
EDR (proactive & investigative approach):
- Continuous endpoint monitoring
- Behavioral analysis at kernel level
- Anomaly detection and post-compromise visibility
- Prioritizes incident response and investigation
Windows Execution Flow
Windows program execution follows a hierarchical flow:
- Applications - User programs like firefox.exe
- DLLs - Libraries providing Windows functionality without direct low-level access
- Kernel32.dll - Core DLL for memory management, process/thread creation
- Ntdll.dll - Lowest user-mode DLL that exposes the NT API interface to the kernel
- Kernel - Core OS component with unrestricted hardware access
Example operation flow (creating a file):
- Application invokes
CreateFile function
- CreateFile forwards to
NtCreateFile
- Ntdll.dll triggers
NtCreateFile syscall
- Kernel creates the file and returns a handle
EDR Visibility
EDR Architecture & Components
EDR solutions consist of multiple components creating a complex attack surface:
Client-Side Components:
- User-space Applications - Main agent processes and UI components
- Kernel-space Drivers - Filter drivers, network drivers, software drivers
- Communication Interfaces - IOCTLs, FilterConnectionPorts, ALPC, Named Pipes
Component Communication Methods:
- Kernel-to-Kernel: Exported functions, IOCTLs
- User-to-Kernel: IOCTLs, FilterConnectionPorts (minifilter-specific), ALPC
- User-to-User: ALPC, Named Pipes, Files, Registry
Server-Side Components:
- Cloud services and management consoles
- On-premise servers (some vendors)
- Custom protocols for agent-to-cloud communication
EDR Visibility Methods
EDR solutions require extended visibility into system activities:
- Filesystem monitoring via mini-filter drivers
- Process/module loading via image load kernel callbacks
- Process/.NET modules/Registry/kernel object events via ETW Ti
- Network monitoring via NDIS and network filtering drivers
Static Analysis
- Extract information from binary
- Known malicious strings
- Threat actor IP or domains
- Malware binary hashes
Dynamic Analysis
- Execute binary in a sandbox environment and observe it
- Network connections
- Registry changes
- Memory access
- File creation/deletion
- AntiMalware Scan Interface
Behavioral Analysis
- Observe the binary as its executing, Hook into functions/syscalls
- User actions
- System calls
- Kernel callbacks
- Commands executed in the command line
- Which process is executing the code
- Event Tracing for Windows
Detection Methods
AV Signature Scanning
- Scans files using known signatures (YARA rules)
- Typically targets loaders and droppers
- Primarily static analysis of files on disk
AV Emulation
- Runs suspicious programs in a simulated environment
- Triggers on behaviors without executing real code
- Used to detect obfuscated malware
Usermode Hooks
- EDR hooks critical API calls in userspace (ntdll.dll)
- Monitors process creation, memory allocations, and network operations
- Allows for inspection before execution continues
Kernel Telemetry
- Monitors events directly from the kernel
- Captures file, registry, process, and network operations
- Difficult to bypass as it operates at a lower level
Memory Scanning
- Scans process memory for known signatures
- Triggers based on suspicious behavior
- Looks for shellcode, encryption, malicious strings
- Modern Context:
- Attackers also scan process memory for sensitive artifacts like authentication tokens. Co‑pilot/IDE integrations, chat assistants, and browser extensions frequently cache Bearer/JWT tokens in memory.
- Practical triage: search for
"Authorization: Bearer", "eyJ" (base64 JWT prefix), or provider‑specific headers; dump minimal pages to avoid tripping anti‑exfil rules.
OpSec Quickstart (lab)
- Pre‑run
- Network: block or sinkhole vendor EDR/XDR endpoints; disable cloud sample submission; tag lab hosts.
- Mitigations snapshot:
Get-ProcessMitigation -System; Get-CimInstance Win32_DeviceGuard (VBS/HVCI/KDP); Get-MpPreference (ASR/Cloud).
- Events baseline: enable and tail
Microsoft-Windows-CodeIntegrity/Operational, Security (4688/4689), Microsoft-Windows-Sense/Operational, Sysmon (if present).
- Injection hygiene
- Favor
MEM_IMAGE mappings (ghosting/herpaderping/overwriting) over MEM_PRIVATE RWX to avoid 24H2 hotpatch loader checks.
- Satisfy XFG/CET: jump via import thunks; ensure IBT
ENDBR64 at indirect targets; maintain plausible stacks for syscalls (replicate ntdll frames).
- Avoid noisy APIs: split
alloc/write/exec over time; prefer APC+NtContinue pivots; keep thread contexts consistent.
- Telemetry minimization
- Jitter long‑lived channels; prefer named‑pipe/HTTP3 over noisy HTTP1; throttle upload intervals.
- Use COM/runspace over PowerShell console to reduce script‑block logs; avoid AMSI‑flagged prologues.
- Cleanup
- Remove services, tasks, drivers; restore SDDL; revert registry policy flips (WDAC/CI/Defender) and re‑enable protections.
- Purge user caches (Recent Files, Jump Lists) and ETW providers enabled during tests.
Memory Regions
- Monitors suspicious memory allocation patterns
- Flags RWX (read-write-execute) regions
- Tracks regions that change from RW to RX
Callstack Analysis
- Examines the call stack of suspicious functions
- Verifies legitimate origin of critical operations
- Detects unusual function call chains
Hook Implementation
EDRs can't directly hook kernel memory due to PatchGuard, so they:
- Inject their DLL into newly spawned processes
- Position before malware can block/unmap it
- Adjust
_PEB, hook process's module IAT/Imports, and loaded libraries EAT/Exports
- Implement trampolines, hooks, and detours
ETW Monitoring
- EDR maintains ring-buffer with per-process activities produced by ETW Ti:
- Processes, command lines, parent-child relationships
- File/Registry/Process open/write operations
- Created threads, their call stacks, starting addresses
- Native functions called
- Created .NET AppDomains, loaded .NET assemblies, static class names, methods
Event Correlation
- High fidelity alert (such as LSASS open) triggers correlation of collected activities
- High memory/resources cost limits preservation of events to a time window
- ML/AI may compute risk scores and isolate TTP (Tactics, Techniques, and Procedures)
Shellcode Loaders
Shellcode loaders typically follow this pattern:
char *shellcode = "\xAA\xBB...";
char *dest = VirtualAlloc(NULL, 0x1234, 0x3000, PAGE_READWRITE);
memcpy(dest, shellcode, 0x1234)
VirtualProtect(dest, 0x1234, PAGE_EXECUTE_READ, &result)
(*(void(*)())(dest))(); // jump to dest: execute shellcode
Attacking EDR Infrastructure Directly
Driver Attack Surface Analysis
A systematic approach to analyzing EDR drivers from a low-privileged user perspective:
1. Driver Discovery
Static Analysis:
# List loaded drivers
driverquery /v
Get-WindowsDriver -Online -All
# Using WMI
Get-WmiObject Win32_PnPSignedDriver | Select-String "EDR_Vendor"
Dynamic Analysis:
# Using sc command
sc query type= driver state= all
# Process Monitor filtering
# Filter: Process and Thread Activity -> Show Image/DLL
2. Interface Enumeration
Device Driver Interfaces:
- Listed in WinObj under "GLOBAL??" as Symbolic Links
- Accessible via
\\.\DEVICE_NAME format
- Tools: WinObj (Sysinternals), DeviceTree (OSR - discontinued)
Mini-Filter Driver Interfaces:
- Listed in WinObj as "FilterConnectionPort" objects
- Communication via
FltCreateCommunicationPort API
- Example paths:
\CyvrFsfd, \SophosPortName
3. Access Permission Analysis
Device Driver ACL Checking:
// Using DeviceTree (preferred) or kernel debugger
// WinDbg example:
!object \Device\DeviceName
!sd <SecurityDescriptor_Address> 1
FilterConnectionPort ACL Checking:
# Using NtObjectManager (James Forshaw)
Get-FilterConnectionPort -Path "\FilterPortName"
# Error indicates access denied
# In WinDbg:
!object \FilterPortName
dx (((nt!_OBJECT_HEADER*)0xAddress)->SecurityDescriptor & ~0xa)
!sd <SecurityDescriptor_Address> 1
4. Interface Functionality Analysis
Device Driver Communication:
- Primary method: DeviceIoControl() → IRP_MJ_DEVICE_CONTROL
- IOCTL codes differentiate between functions
- May include process ID verification for authorization
FilterConnectionPort Communication:
- Uses callback functions: ConnectNotifyCallback, DisconnectNotifyCallback, MessageNotifyCallback
- Similar to IOCTL dispatch with different message types
5. Common EDR Driver Interfaces
Examples of accessible interfaces found in research:
Palo Alto Cortex XDR:
- Device Interfaces:
\\.\PaloEdrControlDevice (tedrdrv.sys) - ~20 IOCTL handlers with various functionality
\\.\CyvrMit (cyvrmtgn.sys) - Legacy Cyvera interface
\\.\PANWEdrPersistentDevice11343 (tedrpers-.sys) - Persistent device interface
- FilterConnectionPort: Various ports with different ACLs
- Research Findings:
- IOCTL 0x2260D8 returns 3088 bytes of statistics data (accessible to low-privileged users)
- IOCTL 0x2260D0 provides initialization status information
- Some interfaces accessible due to injected DLL architecture requiring broad permissions
Sophos Intercept X:
- FilterConnectionPort:
\SophosPortName
- Analysis Results: Accessible interfaces for legitimate process communication but limited attack surface
6. Why EDRs Have Open ACLs
EDRs often use an architecture where:
- Agent injects DLLs into processes (including low-privileged ones like
word.exe)
- Injected DLLs communicate directly with drivers via IOCTLs
- Drivers cannot restrict based solely on process privilege level
- Results in more permissive ACLs to accommodate legitimate injected processes
Evasion Techniques
Memory-Based Evasion
EDR-Freeze
A novel technique exploiting Windows Error Reporting (WER) to temporarily disable EDR/AV processes:
Mechanism
- Leverages
WerFault.exe and Windows Error Reporting infrastructure
- Suspends all threads in target EDR/AV processes indefinitely
- No kernel-mode access or driver exploitation required
- Operates entirely from user-mode context
Technical Implementation
- Trigger WER fault injection on target security process
- WER suspends all threads for crash dump generation
- Attacker maintains suspended state without completing crash handling
- Target process remains alive but non-functional
Advantages
- No elevation required in default WER configurations
- Avoids detection heuristics for process termination
- Temporary disabling without unloading kernel drivers
- Minimal forensic footprint compared to driver killing
Limitations
- Effectiveness varies by Windows version and WER configuration
- Some EDRs implement anti-suspension protections
- Temporary nature requires continuous re-application
- May generate WER event logs exposing the technique
[!TIP]
Blue team detection: Alert on PssSuspendProcess / PssSuspendThread API calls combined with OpenProcess targeting EDR process IDs, or monitor Event ID 1001 (Windows Error Reporting) with unusual source processes.
Memory Encryption
- Encrypts shellcode in memory when not in use
- Popular techniques:
- SWAPPALA / SLE(A)PING
- Thread Pool / Pool Party
- Gargoyle
- Ekko
- Cronos
- Foliage
Sleep Obfuscation
- ROP-Styles sleep obfuscations
- Ekko
- FOLIAGE
- these setup
_CONTEXT in advance so that EIP/RIP points to native API
- and then schedule APC with
NtContinue to jump to that requested API
Secure Enclaves (VBS)
- Virtualization-Based Security (VBS) enclaves provide an isolated user-mode TEE that even kernel-mode sensors cannot inspect under normal conditions.
- Deprecation/support scope (Microsoft):
- Windows 11 ≤ 23H2: VBS enclaves are deprecated; existing enclaves signed with the legacy EKU (OID
1.3.6.1.4.1.311.76.57.1.15) continue to run until re-signed. New enclave signing requires updated EKUs and is not supported on these versions.
- Windows 11 24H2+ and Windows Server 2025: VBS enclaves are supported with new EKUs.
- Security fix: CVE-2024-49076 (VBS Enclave EoP) — ensure December 2024+ updates are applied.
- Signing constraints: Only Microsoft-signed enclave DLLs or DLLs signed via Azure Trusted Signing load; test- or self-signed DLLs are rejected.
- Architecture summary:
- Enclave host app (VTL0) invokes enclave APIs; enclave DLL executes in isolated user mode (VTL1) with restricted API surface; Secure Kernel validates integrity.
- Offensive considerations (lab): viable for secure storage of secrets/implants during sleep and for hiding sensitive code paths; limited by restricted API surface and signing requirements.
- Practical notes:
- On unsupported SKUs/versions, enclave APIs may appear and return
STATUS_FEATURE_DEPRECATED.
- Prefer testing on Windows 11 24H2+/Server 2025 with proper signing.
Malware Virtualization
Malware virtualization provides advanced evasion against modern EDR:
- Embeds a custom virtual machine to execute bytecode instead of native code
- Makes static and dynamic analysis difficult through instruction obfuscation
- Prevents detection of instruction patterns and behavior prediction
Implementation advantages:
- Conceals malicious instructions from EDR monitoring
- Protects against code patching attempts
- Hinders behavioral analysis through custom execution model
Multi-VM approach further evades detection:
- Multiple VMs running concurrently disrupts heuristic pattern detection
- Each VM creates distinct event patterns, confusing EDR correlation
- "ETW noise" technique to blend with legitimate activity
Deployment strategies:
- Bytecode polling - periodically fetching new instructions from C2
- Using transpilers to convert compiled binaries to custom bytecode
- Applying polymorphic engine to mutate VM code itself
Successfully evaded detection for:
- Initial shellcode/bytecode execution (subsequent actions still monitored)
- Specific AV/EDR patching routines (may require updates per product)
- Initial C2 communication (ongoing traffic patterns may be detected)
- Specific AD queries (patterns of queries can still be flagged)
QEMU-Based Virtualization Evasion
Concept: Deploy portable QEMU VMs to execute malicious code within guest OS, avoiding host-based EDR detection
Technical Implementation:
- Portable QEMU deployment via ZIP archives containing VM binaries and configurations
- Tiny Core Linux as lightweight guest OS (minimal footprint ~50MB)
- VBS scripts for automated VM deployment and execution
- Custom hostname generation for VM identification and tracking
Configuration Examples:
# VBS deployment script
Set shell = CreateObject("WScript.Shell")
shell.Run "tc.exe -m 512 -hda tc.qcow2 -netdev user,id=net0 -device e1000,netdev=net0"
# QEMU configuration file (upd.conf)
-m 512
-hda tc.qcow2
-netdev user,id=net0
-device e1000,netdev=net0
Persistence Mechanisms:
bootlocal.sh modifications for startup execution
filetool.lst configuration for file persistence across reboots
- SSH service installation and configuration within guest VM
- Reverse SSH tunnels over port 443 for C2 communication
Advanced Techniques:
- Anti-forensic SSH configuration (
StrictHostKeyChecking=no, known hosts to /dev/null)
- SSL/NoSSL tool deployment for encrypted communications
- Randomized hostname generation to mask VM tracking
- Port 443 tunneling to blend with HTTPS traffic
Detection Evasion Benefits:
- Guest VM operations invisible to host-based EDR sensors
- VM network traffic appears as legitimate application activity
- File operations contained within guest filesystem
- Process execution isolated from host monitoring
Limitations & Considerations:
- Requires administrative privileges for some QEMU operations
- VM resource consumption may be detectable
- Network traffic patterns might still trigger detection
- Initial VM deployment artifacts remain on host filesystem
Hook Evasion
Unhooking
- malware overwrites EDR hooks before executing payload
- you can obtain original
ntdll.dll from disk and overwrite it inside your own process
- or you can start the malware process in suspended state and copy the clean
ntdll.dll from you own memory before executing
- Modern Context: While historically effective, relying solely on replacing
ntdll.dll or its hooked sections is less reliable. Modern EDRs often use kernel callbacks, ETW, and other telemetry sources that are not bypassed by user-mode unhooking alone. This technique is often used in conjunction with others.
[!CAUTION]
accessing ntdll.dll file can be flagged, API call to overwrite it also might be hooked by EDR
API Unhooking for AV Bypass
Most EDR/AVs like BitDefender hook Windows APIs by replacing first bytes with JMP instructions (opcode 0xE9)
Modern Context: Similar to general unhooking, patching specific API prologues can bypass simple user-mode hooks, but comprehensive EDR solutions have additional detection layers (kernel events, behavioral analysis) that may still detect the malicious activity following the unhook.
How to identify hooked APIs:
- Create a test program that calls potentially hooked APIs
- Examine first byte of API function using a debugger (like x64dbg)
- If first byte is
0xE9, the function is hooked
Common hooked APIs:
CreateRemoteThread/CreateRemoteThreadEx
VirtualAllocEx
WriteProcessMemory
OpenProcess
RtlCreateUserThread
Unhooking approach:
- Store original bytes of target APIs from clean system
- Identify hooked functions in memory
- Restore original bytes using
WriteProcessMemory on the current process
- Execute malicious code using now-unhooked APIs
Sample implementation:
// Find address of target API function
HANDLE kernelbase_handle = GetModuleHandle("kernel32");
LPVOID CreateRemoteThread_address = GetProcAddress(kernelbase_handle, "CreateRemoteThread");
// Check if function is hooked (first byte is 0xE9)
byte first_byte = (byte)*(char*)CreateRemoteThread_address;
if (first_byte == 0xe9) {
// Replace with original bytes
char original_bytes[] = "\x4C\x8B\xDC\x48\x83"; // Original prologue bytes
WriteProcessMemory(GetCurrentProcess(), CreateRemoteThread_address, original_bytes, 5, NULL);
}
This technique is effective but may require separate execution for the final payload since some AVs block executing immediately after unhooking. Modern EDRs might still correlate the unhooking activity with subsequent suspicious actions.
Unhooking Tools
- unhook BOF - module refreshing (less reliable now due to alternative EDR telemetry sources)
- Unhookme - dynamic unhooking
Direct System Calls
- malware circumvents hook in system DLL by directly system calling into kernel
- you can implement own syscall in assembly and bypass
ntdll.dll hooks
- or obtain
SSN(System Service Number) dynamically and call them(can be done via SysWhispers2)
- Direct syscalls bypass user-mode hooks in
ntdll.dll but do not inherently bypass kernel-level monitoring (e.g., via kernel callbacks or ETW). EDRs are increasingly monitoring for patterns indicative of direct syscall usage itself (e.g., unusual call stack origins for syscalls).
[!CAUTION]
having syscall assembly instructions can be flagged, also this only helps the loader to evade the EDR not the malware itself
- Major EDR vendorsnow flag non‑ntdll syscall sites; consider return‑address replication gadgets to re‑insert a plausible
ntdll frame before the transition.
[!CAUTION]
Some EDRs flag syscalls originating outside ntdll.dll. Maintaining plausible stacks/return frames may be required to avoid heuristics.
Direct Syscall Tools
Bypasses user-mode hooks but not kernel monitoring. Requires System Service Dispatch Table (SSDT) index:
Indirect System Calls
- malware uses code fragments in kernel DLL without calling the hooked functions in those DLL
- prepare the system call in assembly then find a syscall instruction in
ntdll.dll and jump to that location
- Modern Context: Similar to direct syscalls, this bypasses user-mode hooks but not necessarily kernel-level monitoring. Finding and jumping to existing
syscall instructions can be less suspicious than embedding raw syscall stubs, but the subsequent kernel activity is still visible.
[!TIP]
this is preferred,you can also boost evasion techniques by hiding inside a .dll
Kernel‑Mode EDR Killers (BYOVD)
- Bring‑Your‑Own‑Vulnerable‑Driver (BYOVD) attacks load legitimately signed but exploitable drivers—examples include rtcore64.sys, iqvw64e.sys, and terminator.sys—to execute privileged code inside the kernel.
- Typical payload actions
- Patch or unregister kernel‑mode notify callbacks (
PsSetCreateProcessNotifyRoutine, ObRegisterCallbacks) to blind user‑mode EDR components.
- Overwrite or unload WdFilter.sys and other sensor drivers, fully disabling Defender or third‑party agents.
- Public toolchains such as Terminator, kdmapper, and EDRSensorDisabler automate these steps.
- Case study: Lenovo
LnvMSRIO.sys (CVE‑2025‑8061). Exposes physical memory/MSR read‑write primitives to low‑privileged users; can overwrite MSR_LSTAR and pivot to Ring‑0 payload, then patch/unregister callbacks to blind EDR.
[!TIP]
The vulnerable‑driver blocklist (DriverSiPolicy.p7b) is enabled by default on Windows 11 22H2+ and refreshed every Patch Tuesday. Keep HVCI/KDP enabled so attacker drivers cannot patch protected code pages, and enable Hardware‑Enforced Stack Protection (CET/Shadow Stack) on Windows 11 24H2 to break call‑stack spoofing.
[!NOTE]
Because the blocklist is on by default and updated frequently, a BYOVD chain now often needs two vulnerable drivers: one to disable Secure Boot or flip CiOptions, and a second to perform the EDR‑killer actions before the next blocklist refresh.
User-Mode Application Whitelisting Bypass
Exploiting Vulnerable Trusted Applications
Windows Defender Application Control (WDAC) and similar application whitelisting solutions can be bypassed by leveraging vulnerabilities in trusted, signed applications. A notable technique involves exploiting N-day vulnerabilities in the V8 JavaScript engine within Electron-based applications.
- Concept (Bring Your Own Vulnerable Application - BYOVA):
- A trusted, signed Electron application (e.g., an older version of VSCode) with a known V8 vulnerability is used as a carrier.
- The application's
main.js (or equivalent) is replaced with a V8 exploit that executes a native shellcode payload.
- If the application is whitelisted, WDAC allows it to run, inadvertently executing the malicious shellcode.
- Advantages:
- Achieves native shellcode execution, overcoming limitations of pure JavaScript execution in some backdoored Electron app scenarios.
- Shellcode runs in a browser-like process context, where behaviors like Read-Write-Execute (RWX) memory regions (due to JIT compilers) are common and may appear less suspicious to EDRs.
- Exploit Development & Operationalization Challenges:
- V8 Version Targeting: Electron's V8 often lags behind Chrome's and includes backported security patches. Vulnerabilities must be chosen that were patched after the target application's Electron version was frozen. Electron's cherry-picked patches should be reviewed.
- Debugging: Building the specific V8 version (e.g., using
d8 debug shell with --allow-natives-syntax for %DebugPrint()) is crucial for understanding memory layouts and adapting exploits.
- Offset Inconsistencies: Hardcoded offsets in public exploits (often Linux-based) need adjustment for the target V8 version and OS (Windows). Function pointer offsets for overwriting can even vary between Windows versions.
- Solution for offset variation: Launch the exploit multiple times in child processes, each trying a different potential offset. The parent process monitors for success (e.g., mutex creation by payload).
- Sandbox Escape: Public V8 exploits might use sandbox escape techniques already patched (cherry-picked) in the target Electron V8 version, requiring new or modified escapes.
- JIT Compiler Interference (e.g., V8 TurboFan):
- Optimizations can consolidate repeated instruction sequences (e.g., multiple floating-point values), affecting shellcode smuggling. Workarounds include compact shellcode or varying instruction positions.
- Copying large shellcode payloads can be problematic. Workaround: multiple smaller copy loops or using a stager payload that fetches the main payload.
- Payload Obfuscation: Obfuscate the JavaScript exploit (e.g., in
main.js) to hinder analysis. Re-obfuscating per deployment can help avoid signature-based detection.
- Defense & Future Considerations:
- Electron's experimental integrity fuse feature, if enabled by developers, can verify the integrity of application files (including
main.js) at runtime, potentially thwarting this technique by exiting if tampering is detected.
- Older application versions without this fuse remain vulnerable.
Process Manipulation
Early Cascade Injection
- Novel process injection technique targeting user-mode process creation
- Combines elements of Early Bird APC with EDR-Preloading
- Avoids queuing cross-process APCs while maintaining minimal remote process interaction
- Works by:
- Targeting processes during the transition from kernel-mode to user-mode (
LdrInitializeThunk)
- Leveraging callback pointers (like
g_pfnSE_DllLoaded) during Windows process creation
- Executing malicious code before EDR detection measures can initialize
- Advantages:
- Operates before EDRs can initialize their hooks and detection measures
- Particularly effective against EDRs that hook
NtContinue or use delayed initialization
- Avoids ETW telemetry that traditional injection techniques trigger
- Minimal remote process interaction reduces detection footprint
- More stealthy than traditional techniques like DLL hijacking or direct syscalls
- Key insight: EDRs typically load their detection measures after the
LdrInitializeThunk function executes, providing a window of opportunity for code execution before security measures initialize
- watch for early
NtCreateThreadEx inside LdrInitializeThunk
Early Startup Bypass
Concept: Execute malware before the EDR's user-mode component fully initializes, creating a window of opportunity for undetected execution.
Implementation:
- Target the gap between kernel driver loading and user-mode agent initialization
- Execute payload during system startup before EDR hooks are established
- Leverage services that start before EDR components
Research Findings (Cortex XDR):
- Successfully executed Mimikatz with
lsadump::sam without detection during early startup
- EDR kernel drivers may be loaded but user-mode hooks not yet established
- Timing window varies depending on system performance and EDR implementation
Detection Evasion:
- Creates process activity before EDR monitoring is fully operational
- Avoids user-mode hooks that haven't been established yet
- Kernel-level monitoring may still detect activity depending on driver initialization order
Limitations:
- Requires precise timing and understanding of EDR startup sequence
- May not work against EDRs with early kernel-level monitoring
- Window of opportunity may be brief on fast systems
Waiting Thread Hijacking (WTH)
- A stealthier version of classic Thread Execution Hijacking
- Intercepts the flow of a waiting thread and misuses it for executing malicious code
- Avoids suspicious APIs like
SuspendThread/ResumeThread and SetThreadContext that trigger most alerts
- Required handle access:
- For target process:
PROCESS_VM_OPERATION, PROCESS_VM_READ, PROCESS_VM_WRITE
- For target thread:
THREAD_GET_CONTEXT
- Uses less monitored APIs:
NtQuerySystemInformation (with SystemProcessInformation)
GetThreadContext
ReadProcessMemory
VirtualAllocEx
WriteProcessMemory
VirtualProtectEx
- Implementation can be further obfuscated by splitting steps across multiple functions to evade behavioral signatures
- Primarily bypasses EDRs that focus on detecting specific API calls rather than behavioral patterns
- Effective against EDRs that are restrictive about remote execution methods but more lenient with allocations and writes
- Suitable for hiding the point at which implanted code was executed
PPID Spoofing
- Creates process with fake parent process ID
- Hides true process creation chain
- Makes process tree analysis misleading
Process Hiding
A technique to hide processes from EDR monitoring by manipulating the Interrupt Request Level (IRQL):
- Raise the IRQL of current CPU core
- Create and queue Deferred Procedure Calls (DPCs) to raise the IRQL of other cores
- Perform sensitive task (for example, hiding process)
- Signal DPCs in other cores to stop spinning and exit
- Lower IRQL of current core back to original
irql = RaiseIRQL();
dpcPtr = AcquireLock();
do_stuff();
ReleaseLock(dpcPtr);
LowerIRQL(irql);
This approach temporarily prevents EDR from monitoring the process during the critical operations by operating at an elevated privilege level.
[!NOTE]
HVCI-enabled 23H2 kernels may crash when raising IRQL this way. Safer alternative: kernel-driver patching of PsLookupProcessByProcessId.
UAC Bypass via Intel ShaderCache Directory
- Concept: Exploits weak permissions (
Authenticated Users: Full Control) on the Intel\ShaderCache directory (%LOCALAPPDATA%\LocalLow\Intel\ShaderCache) combined with the behavior of auto-elevated processes (like taskmgr.exe) writing to this location.
- Mechanism:
- Clear Directory: Requires aggressively terminating processes holding handles (
explorer.exe, sihost.exe, etc.) and deleting files within the ShaderCache directory. Permissions might need adjustment (icacls) to allow deletion. Launching taskmgr.exe briefly (with a timeout) helps identify recently written filenames and can trigger writes needed for the exploit.
- Junction Creation: Create a directory junction from
ShaderCache to \??\GLOBALROOT\RPC CONTROL.
- Symbolic Link: Determine a recently used filename within
ShaderCache (before clearing). Create an object directory symbolic link (CreateDosDevice) from Global\GLOBALROOT\RPC CONTROL\<recent_filename> to a target DLL path (e.g., \??\C:\Windows\System32\oci.dll).
- Trigger Write: Launch an auto-elevated process (e.g.,
taskmgr.exe) that writes to ShaderCache. The write operation follows the junction and then the symbolic link, resulting in the creation of a (dummy) target file (e.g., oci.dll) in a privileged location (System32).
- Overwrite & Execute: Overwrite the created dummy file with the actual malicious DLL. Launch a process (like
comexp.msc) that attempts to load the target DLL, thereby executing the malicious code with elevated privileges.
- EDR Relevance:
- Bypasses User Account Control (UAC), a primary defense layer.
- Relies on manipulating file system objects (junctions, symlinks) and process interactions that EDRs monitor.
- Involves potentially noisy actions like mass process termination and permission changes.
- The final payload execution often relies on DLL hijacking techniques.
[!TIP]
Symlink/junction UAC races are build‑dependent and brittle. Validate on the specific target build; many have partial or complete mitigations.
PPL (Protected Process Light) Bypass
Concept: Bypass Protected Process Light security by creating alternative service configurations that avoid PPL protections.
Palo Alto Cortex XDR PPL Bypass Technique:
# Create alternative service that launches cyserver.exe without PPL protection
sc create "fake_cyserver" binPath="C:\Program Files\Palo Alto Networks\Traps\cyserver.exe" start=auto
How it works:
- Creates a second service that launches the EDR's main process (cyserver.exe)
- Original PPL-protected service fails to start due to startup dependencies
- New service configuration is not protected by EDR drivers
- EDR process runs without PPL protection, expanding attack surface
Limitations:
- Service names beginning with "cyserver*" are blocked by some EDR implementations
- EDR functionality may remain intact despite PPL bypass
- Self-protection mechanisms may still be active at process level
- Vendor response varies - may not be considered a security vulnerability
Detection & Response:
- EDR thinks original service is stopped but agent continues running
- Attack surface increases as process no longer has PPL protections
- Reported to Palo Alto on 12.09.2023 with limited vendor response
Broader Implications:
- Demonstrates service configuration vulnerabilities in EDR implementations
- Shows potential for bypassing Windows security features through alternative execution paths
- Relevant for other EDRs that rely on PPL for self-protection
Using NtCreateUserProcess for Stealthy Process Creation
The native API NtCreateUserProcess(), located in ntdll.dll, is the lowest-level user-mode function for creating processes. Calling it directly can bypass EDR hooks placed on higher-level functions like CreateProcessW in kernel32.dll. This makes it a valuable technique for stealthier process creation.
Key Concepts:
- Bypass Mechanism: Avoids user-land hooks on more commonly monitored APIs like
CreateProcessW.
- Process Parameters: Requires careful setup of structures like
RTL_USER_PROCESS_PARAMETERS (often via RtlCreateProcessParametersEx), PS_CREATE_INFO, and PS_ATTRIBUTE_LIST.
RTL_USER_PROCESS_PARAMETERS: Defines process startup information, including image path, command line, environment variables, etc. The ImagePathName must be in NT path format (e.g., \??\C:\Windows\System32\executable.exe).
PS_ATTRIBUTE_LIST: Can specify attributes like the image name.
- Flags:
ProcessFlags and ThreadFlags allow fine-grained control over process and thread creation (e.g., creating suspended). Sources like Process Hacker's headers (ntpsapi.h) can provide valid flag definitions. For minimal use, these can sometimes be NULL.
- Implementation Details: Involves initializing several structures and using functions from
ntdll.dll such as RtlInitUnicodeString, RtlCreateProcessParametersEx, and RtlAllocateHeap. The article also mentions that the ProcessParameters argument for NtCreateUserProcess was found to be mandatory, and RtlCreateProcessParametersEx is used with the RTL_USER_PROCESS_PARAMETERS_NORMALIZED flag. The PS_CREATE_INFO structure needs its Size and State (e.g., PsCreateInitialState) members initialized. The PS_ATTRIBUTE_LIST is populated to include the image name.
Example High-Level Steps:
- Define the path to the executable using
UNICODE_STRING and initialize it with RtlInitUnicodeString (e.g., L"\??\C:\Windows\System32\calc.exe").
- Create and populate
RTL_USER_PROCESS_PARAMETERS using RtlCreateProcessParametersEx, providing the image path and normalizing parameters.
- Initialize a
PS_CREATE_INFO structure.
- Allocate and initialize a
PS_ATTRIBUTE_LIST, setting the PS_ATTRIBUTE_IMAGE_NAME attribute with the image path.
- Call
NtCreateUserProcess with the prepared handles, access masks, and structures.
- Perform cleanup, for instance, by calling
RtlFreeHeap and RtlDestroyProcessParameters.
This technique allows for creating a new process with more direct control, potentially evading EDRs that primarily hook kernel32.dll API calls. However, EDRs with kernel telemetry or hooks deeper within ntdll.dll (or monitoring syscalls directly) might still detect the NtCreateUserProcess call or the subsequent behavior of the spawned process.
Advanced Process Execution Alternatives
- TangledWinExec - alternative process execution techniques
- rad9800 - indirectly loading DLL through a work item
Acquiring Process Handles
- Without using suspicious
OpenProcess:
- Find
explorer.exe window handle using EnumWindows
- Convert to process handle with
GetProcessHandleFromHwnd
- Leverage
PROCESS_DUP_HANDLE to duplicate into a pseudo handle for Full Access
Callstack Manipulation
Return Address Overwrite
- overwrite function's return address with 0
- that terminates call stack's unwinding algorithm
- examination based on
DbgHelp!StackWalk64 fails
- implement custom API resolver similar to
GetProcAddress
- before calling out to suspicious functions, overwrite
RetAddr :=0
- when system API returns, restore own
RetAddr
Callstack Spoofing
- Manipulates the call stack to appear legitimate
- Makes it harder to detect malicious code execution
- Tools and techniques:
- ThreadStackSpoofer
- CallStackSpoofer
- AceL
…(truncated)
1---2name: offensive-edr-evasion3description: "EDR evasion offensive checklist: hook unhooking (user/kernel), direct syscalls, PPID spoofing, process injection variants, AMSI bypass, ETW patching, memory encryption, and behavior-based evasion. Use when planning EDR bypass during red team engagements or researching AV/EDR evasion techniques. Use only for authorized security research, training, or assessment."4category: infrastructure5source: SnailSploit/Claude-Red6license: MIT7upstream_commit: a8de813edc9f66f60d44cfe42d47750e89d9930b8metadata:9 source: https://skillmd.com/skills/26zl/offensive-edr-evasion10---1112# SKILL: Endpoint Detection and Response1314## Metadata15- **Skill Name**: edr-evasion16- **Folder**: offensive-edr-evasion17- **Source**: https://github.com/SnailSploit/offensive-checklist/blob/main/edr.md1819## Description20EDR evasion offensive checklist: hook unhooking (user/kernel), direct syscalls, PPID spoofing, process injection variants, AMSI bypass, ETW patching, memory encryption, and behavior-based evasion. Use when planning EDR bypass during red team engagements or researching AV/EDR evasion techniques.2122## Trigger Phrases23Use this skill when the conversation involves any of:24`EDR evasion, EDR bypass, hook unhooking, direct syscalls, PPID spoofing, process injection, AMSI bypass, ETW patch, memory encryption, AV evasion, behavioral evasion, red team evasion`2526## Instructions for Claude2728When this skill is active:291. Load and apply the full methodology below as your operational checklist302. Follow steps in order unless the user specifies otherwise313. For each technique, consider applicability to the current target/context324. Track which checklist items have been completed335. Suggest next steps based on findings3435---3637## Full Methodology3839# Endpoint Detection and Response4041## Fundamentals4243### AV vs EDR4445**Antivirus (preventive approach)**:4647- Static Analysis: Matching known signatures in files48- Dynamic Analysis: Limited behavioral monitoring/sandboxing49- Effective against known threats, weaker against advanced attacks5051**EDR (proactive & investigative approach)**:5253- Continuous endpoint monitoring54- Behavioral analysis at kernel level55- Anomaly detection and post-compromise visibility56- Prioritizes incident response and investigation5758### Windows Execution Flow5960Windows program execution follows a hierarchical flow:61621. **Applications** - User programs like firefox.exe632. **DLLs** - Libraries providing Windows functionality without direct low-level access643. **Kernel32.dll** - Core DLL for memory management, process/thread creation654. **Ntdll.dll** - Lowest user-mode DLL that exposes the NT API interface to the kernel665. **Kernel** - Core OS component with unrestricted hardware access6768Example operation flow (creating a file):69701. Application invokes `CreateFile` function712. CreateFile forwards to `NtCreateFile`723. Ntdll.dll triggers `NtCreateFile` syscall734. Kernel creates the file and returns a handle7475## EDR Visibility7677### EDR Architecture & Components7879EDR solutions consist of multiple components creating a complex attack surface:8081**Client-Side Components:**8283- **User-space Applications** - Main agent processes and UI components84- **Kernel-space Drivers** - Filter drivers, network drivers, software drivers85- **Communication Interfaces** - IOCTLs, FilterConnectionPorts, ALPC, Named Pipes8687**Component Communication Methods:**8889- **Kernel-to-Kernel**: Exported functions, IOCTLs90- **User-to-Kernel**: IOCTLs, FilterConnectionPorts (minifilter-specific), ALPC91- **User-to-User**: ALPC, Named Pipes, Files, Registry9293**Server-Side Components:**9495- Cloud services and management consoles96- On-premise servers (some vendors)97- Custom protocols for agent-to-cloud communication9899### EDR Visibility Methods100101EDR solutions require extended visibility into system activities:102103- Filesystem monitoring via mini-filter drivers104- Process/module loading via image load kernel callbacks105- Process/.NET modules/Registry/kernel object events via ETW Ti106- Network monitoring via NDIS and network filtering drivers107108### Static Analysis109110- Extract information from binary111 - Known malicious strings112 - Threat actor IP or domains113 - Malware binary hashes114115### Dynamic Analysis116117- Execute binary in a sandbox environment and observe it118 - Network connections119 - Registry changes120 - Memory access121 - File creation/deletion122- AntiMalware Scan Interface123124### Behavioral Analysis125126- Observe the binary as its executing, Hook into functions/syscalls127 - User actions128 - System calls129 - Kernel callbacks130 - Commands executed in the command line131 - Which process is executing the code132 - Event Tracing for Windows133134## Detection Methods135136### AV Signature Scanning137138- Scans files using known signatures (YARA rules)139- Typically targets loaders and droppers140- Primarily static analysis of files on disk141142### AV Emulation143144- Runs suspicious programs in a simulated environment145- Triggers on behaviors without executing real code146- Used to detect obfuscated malware147148### Usermode Hooks149150- EDR hooks critical API calls in userspace (ntdll.dll)151- Monitors process creation, memory allocations, and network operations152- Allows for inspection before execution continues153154### Kernel Telemetry155156- Monitors events directly from the kernel157- Captures file, registry, process, and network operations158- Difficult to bypass as it operates at a lower level159160### Memory Scanning161162- Scans process memory for known signatures163- Triggers based on suspicious behavior164- Looks for shellcode, encryption, malicious strings165- **Modern Context:**166 - Attackers also scan process memory for sensitive artifacts like authentication tokens. Co‑pilot/IDE integrations, chat assistants, and browser extensions frequently cache Bearer/JWT tokens in memory.167 - Practical triage: search for `"Authorization: Bearer"`, `"eyJ"` (base64 JWT prefix), or provider‑specific headers; dump minimal pages to avoid tripping anti‑exfil rules.168169## OpSec Quickstart (lab)170171- Pre‑run172 - Network: block or sinkhole vendor EDR/XDR endpoints; disable cloud sample submission; tag lab hosts.173 - Mitigations snapshot: `Get-ProcessMitigation -System`; `Get-CimInstance Win32_DeviceGuard` (VBS/HVCI/KDP); `Get-MpPreference` (ASR/Cloud).174 - Events baseline: enable and tail `Microsoft-Windows-CodeIntegrity/Operational`, `Security (4688/4689)`, `Microsoft-Windows-Sense/Operational`, Sysmon (if present).175- Injection hygiene176 - Favor `MEM_IMAGE` mappings (ghosting/herpaderping/overwriting) over `MEM_PRIVATE` RWX to avoid 24H2 hotpatch loader checks.177 - Satisfy XFG/CET: jump via import thunks; ensure IBT `ENDBR64` at indirect targets; maintain plausible stacks for syscalls (replicate `ntdll` frames).178 - Avoid noisy APIs: split `alloc/write/exec` over time; prefer APC+`NtContinue` pivots; keep thread contexts consistent.179- Telemetry minimization180 - Jitter long‑lived channels; prefer named‑pipe/HTTP3 over noisy HTTP1; throttle upload intervals.181 - Use COM/runspace over PowerShell console to reduce script‑block logs; avoid AMSI‑flagged prologues.182- Cleanup183 - Remove services, tasks, drivers; restore SDDL; revert registry policy flips (WDAC/CI/Defender) and re‑enable protections.184 - Purge user caches (Recent Files, Jump Lists) and ETW providers enabled during tests.185186### Memory Regions187188- Monitors suspicious memory allocation patterns189- Flags RWX (read-write-execute) regions190- Tracks regions that change from RW to RX191192### Callstack Analysis193194- Examines the call stack of suspicious functions195- Verifies legitimate origin of critical operations196- Detects unusual function call chains197198### Hook Implementation199200EDRs can't directly hook kernel memory due to PatchGuard, so they:2012021. Inject their DLL into newly spawned processes2032. Position before malware can block/unmap it2043. Adjust `_PEB`, hook process's module `IAT`/Imports, and loaded libraries `EAT`/Exports2054. Implement trampolines, hooks, and detours206207### ETW Monitoring208209- EDR maintains ring-buffer with per-process activities produced by ETW Ti:210 - Processes, command lines, parent-child relationships211 - File/Registry/Process open/write operations212 - Created threads, their call stacks, starting addresses213 - Native functions called214 - Created .NET AppDomains, loaded .NET assemblies, static class names, methods215216#### Event Correlation217218- High fidelity alert (such as LSASS open) triggers correlation of collected activities219- High memory/resources cost limits preservation of events to a time window220- ML/AI may compute risk scores and isolate TTP (Tactics, Techniques, and Procedures)221222#### Shellcode Loaders223224Shellcode loaders typically follow this pattern:225226```c227char *shellcode = "\xAA\xBB...";228char *dest = VirtualAlloc(NULL, 0x1234, 0x3000, PAGE_READWRITE);229memcpy(dest, shellcode, 0x1234)230VirtualProtect(dest, 0x1234, PAGE_EXECUTE_READ, &result)231(*(void(*)())(dest))(); // jump to dest: execute shellcode232```233234## Attacking EDR Infrastructure Directly235236### Driver Attack Surface Analysis237238A systematic approach to analyzing EDR drivers from a low-privileged user perspective:239240#### 1. Driver Discovery241242**Static Analysis:**243244```powershell245# List loaded drivers246driverquery /v247Get-WindowsDriver -Online -All248249# Using WMI250Get-WmiObject Win32_PnPSignedDriver | Select-String "EDR_Vendor"251```252253**Dynamic Analysis:**254255```powershell256# Using sc command257sc query type= driver state= all258259# Process Monitor filtering260# Filter: Process and Thread Activity -> Show Image/DLL261```262263#### 2. Interface Enumeration264265**Device Driver Interfaces:**266267- Listed in WinObj under "GLOBAL??" as Symbolic Links268- Accessible via `\\.\DEVICE_NAME` format269- Tools: WinObj (Sysinternals), DeviceTree (OSR - discontinued)270271**Mini-Filter Driver Interfaces:**272273- Listed in WinObj as "FilterConnectionPort" objects274- Communication via `FltCreateCommunicationPort` API275- Example paths: `\CyvrFsfd`, `\SophosPortName`276277#### 3. Access Permission Analysis278279**Device Driver ACL Checking:**280281```cpp282// Using DeviceTree (preferred) or kernel debugger283// WinDbg example:284!object \Device\DeviceName285!sd <SecurityDescriptor_Address> 1286```287288**FilterConnectionPort ACL Checking:**289290```powershell291# Using NtObjectManager (James Forshaw)292Get-FilterConnectionPort -Path "\FilterPortName"293# Error indicates access denied294295# In WinDbg:296!object \FilterPortName297dx (((nt!_OBJECT_HEADER*)0xAddress)->SecurityDescriptor & ~0xa)298!sd <SecurityDescriptor_Address> 1299```300301#### 4. Interface Functionality Analysis302303**Device Driver Communication:**304305- Primary method: DeviceIoControl() → IRP_MJ_DEVICE_CONTROL306- IOCTL codes differentiate between functions307- May include process ID verification for authorization308309**FilterConnectionPort Communication:**310311- Uses callback functions: ConnectNotifyCallback, DisconnectNotifyCallback, MessageNotifyCallback312- Similar to IOCTL dispatch with different message types313314#### 5. Common EDR Driver Interfaces315316**Examples of accessible interfaces found in research:**317318**Palo Alto Cortex XDR:**319320- **Device Interfaces**:321 - `\\.\PaloEdrControlDevice` (tedrdrv.sys) - ~20 IOCTL handlers with various functionality322 - `\\.\CyvrMit` (cyvrmtgn.sys) - Legacy Cyvera interface323 - `\\.\PANWEdrPersistentDevice11343` (tedrpers-<version>.sys) - Persistent device interface324- **FilterConnectionPort**: Various ports with different ACLs325- **Research Findings**:326 - IOCTL 0x2260D8 returns 3088 bytes of statistics data (accessible to low-privileged users)327 - IOCTL 0x2260D0 provides initialization status information328 - Some interfaces accessible due to injected DLL architecture requiring broad permissions329330**Sophos Intercept X:**331332- **FilterConnectionPort**: `\SophosPortName`333- **Analysis Results**: Accessible interfaces for legitimate process communication but limited attack surface334335#### 6. Why EDRs Have Open ACLs336337EDRs often use an architecture where:338339- Agent injects DLLs into processes (including low-privileged ones like `word.exe`)340- Injected DLLs communicate directly with drivers via IOCTLs341- Drivers cannot restrict based solely on process privilege level342- Results in more permissive ACLs to accommodate legitimate injected processes343344## Evasion Techniques345346### Memory-Based Evasion347348#### EDR-Freeze349350A novel technique exploiting Windows Error Reporting (WER) to temporarily disable EDR/AV processes:351352##### Mechanism353354- Leverages `WerFault.exe` and Windows Error Reporting infrastructure355- Suspends all threads in target EDR/AV processes indefinitely356- No kernel-mode access or driver exploitation required357- Operates entirely from user-mode context358359##### Technical Implementation360361- Trigger WER fault injection on target security process362- WER suspends all threads for crash dump generation363- Attacker maintains suspended state without completing crash handling364- Target process remains alive but non-functional365366##### Advantages367368- No elevation required in default WER configurations369- Avoids detection heuristics for process termination370- Temporary disabling without unloading kernel drivers371- Minimal forensic footprint compared to driver killing372373##### Limitations374375- Effectiveness varies by Windows version and WER configuration376- Some EDRs implement anti-suspension protections377- Temporary nature requires continuous re-application378- May generate WER event logs exposing the technique379380> [!TIP]381> Blue team detection: Alert on `PssSuspendProcess` / `PssSuspendThread` API calls combined with `OpenProcess` targeting EDR process IDs, or monitor Event ID 1001 (Windows Error Reporting) with unusual source processes.382383#### Memory Encryption384385- Encrypts shellcode in memory when not in use386- Popular techniques:387 - SWAPPALA / SLE(A)PING388 - Thread Pool / Pool Party389 - Gargoyle390 - Ekko391 - Cronos392 - Foliage393394#### Sleep Obfuscation395396- ROP-Styles sleep obfuscations397 - [Ekko](https://github.com/Cracked5pider/Ekko)398 - [FOLIAGE](https://github.com/y11en/FOLIAGE)399 - these setup `_CONTEXT` in advance so that `EIP/RIP` points to native API400 - and then schedule APC with `NtContinue` to jump to that requested API401402#### Secure Enclaves (VBS)403404- Virtualization-Based Security (VBS) enclaves provide an isolated user-mode TEE that even kernel-mode sensors cannot inspect under normal conditions.405- Deprecation/support scope (Microsoft):406 - Windows 11 ≤ 23H2: VBS enclaves are deprecated; existing enclaves signed with the legacy EKU (OID `1.3.6.1.4.1.311.76.57.1.15`) continue to run until re-signed. New enclave signing requires updated EKUs and is not supported on these versions.407 - Windows 11 24H2+ and Windows Server 2025: VBS enclaves are supported with new EKUs.408- Security fix: CVE-2024-49076 (VBS Enclave EoP) — ensure December 2024+ updates are applied.409- Signing constraints: Only Microsoft-signed enclave DLLs or DLLs signed via Azure Trusted Signing load; test- or self-signed DLLs are rejected.410- Architecture summary:411 - Enclave host app (VTL0) invokes enclave APIs; enclave DLL executes in isolated user mode (VTL1) with restricted API surface; Secure Kernel validates integrity.412- Offensive considerations (lab): viable for secure storage of secrets/implants during sleep and for hiding sensitive code paths; limited by restricted API surface and signing requirements.413- Practical notes:414 - On unsupported SKUs/versions, enclave APIs may appear and return `STATUS_FEATURE_DEPRECATED`.415 - Prefer testing on Windows 11 24H2+/Server 2025 with proper signing.416417#### Malware Virtualization418419- Malware virtualization provides advanced evasion against modern EDR:420 - Embeds a custom virtual machine to execute bytecode instead of native code421 - Makes static and dynamic analysis difficult through instruction obfuscation422 - Prevents detection of instruction patterns and behavior prediction423424- Implementation advantages:425 - Conceals malicious instructions from EDR monitoring426 - Protects against code patching attempts427 - Hinders behavioral analysis through custom execution model428429- Multi-VM approach further evades detection:430 - Multiple VMs running concurrently disrupts heuristic pattern detection431 - Each VM creates distinct event patterns, confusing EDR correlation432 - "ETW noise" technique to blend with legitimate activity433434- Deployment strategies:435 - Bytecode polling - periodically fetching new instructions from C2436 - Using transpilers to convert compiled binaries to custom bytecode437 - Applying polymorphic engine to mutate VM code itself438439- Successfully evaded detection for:440 - Initial shellcode/bytecode execution (subsequent actions still monitored)441 - Specific AV/EDR patching routines (may require updates per product)442 - Initial C2 communication (ongoing traffic patterns may be detected)443 - Specific AD queries (patterns of queries can still be flagged)444445### QEMU-Based Virtualization Evasion446447- **Concept**: Deploy portable QEMU VMs to execute malicious code within guest OS, avoiding host-based EDR detection448- **Technical Implementation**:449 - Portable QEMU deployment via ZIP archives containing VM binaries and configurations450 - Tiny Core Linux as lightweight guest OS (minimal footprint ~50MB)451 - VBS scripts for automated VM deployment and execution452 - Custom hostname generation for VM identification and tracking453454- **Configuration Examples**:455456 ```vbs457 # VBS deployment script458 Set shell = CreateObject("WScript.Shell")459 shell.Run "tc.exe -m 512 -hda tc.qcow2 -netdev user,id=net0 -device e1000,netdev=net0"460 ```461462 ```conf463 # QEMU configuration file (upd.conf)464 -m 512465 -hda tc.qcow2466 -netdev user,id=net0467 -device e1000,netdev=net0468 ```469470- **Persistence Mechanisms**:471 - `bootlocal.sh` modifications for startup execution472 - `filetool.lst` configuration for file persistence across reboots473 - SSH service installation and configuration within guest VM474 - Reverse SSH tunnels over port 443 for C2 communication475476- **Advanced Techniques**:477 - Anti-forensic SSH configuration (`StrictHostKeyChecking=no`, known hosts to `/dev/null`)478 - SSL/NoSSL tool deployment for encrypted communications479 - Randomized hostname generation to mask VM tracking480 - Port 443 tunneling to blend with HTTPS traffic481482- **Detection Evasion Benefits**:483 - Guest VM operations invisible to host-based EDR sensors484 - VM network traffic appears as legitimate application activity485 - File operations contained within guest filesystem486 - Process execution isolated from host monitoring487488- **Limitations & Considerations**:489 - Requires administrative privileges for some QEMU operations490 - VM resource consumption may be detectable491 - Network traffic patterns might still trigger detection492 - Initial VM deployment artifacts remain on host filesystem493494### Hook Evasion495496#### Unhooking497498- malware overwrites EDR hooks before executing payload499- you can obtain original `ntdll.dll` from disk and overwrite it inside your own process500- or you can start the malware process in suspended state and copy the clean `ntdll.dll` from you own memory before executing501 - **Modern Context:** While historically effective, relying solely on replacing `ntdll.dll` or its hooked sections is less reliable. Modern EDRs often use kernel callbacks, ETW, and other telemetry sources that are not bypassed by user-mode unhooking alone. This technique is often used in conjunction with others.502 > [!CAUTION]503 > accessing `ntdll.dll` file can be flagged, API call to overwrite it also might be hooked by EDR504505##### API Unhooking for AV Bypass506507- Most EDR/AVs like BitDefender hook Windows APIs by replacing first bytes with `JMP` instructions (opcode `0xE9`)508- **Modern Context:** Similar to general unhooking, patching specific API prologues can bypass simple user-mode hooks, but comprehensive EDR solutions have additional detection layers (kernel events, behavioral analysis) that may still detect the malicious activity following the unhook.509- How to identify hooked APIs:510 - Create a test program that calls potentially hooked APIs511 - Examine first byte of API function using a debugger (like x64dbg)512 - If first byte is `0xE9`, the function is hooked513- Common hooked APIs:514 - `CreateRemoteThread`/`CreateRemoteThreadEx`515 - `VirtualAllocEx`516 - `WriteProcessMemory`517 - `OpenProcess`518 - `RtlCreateUserThread`519- Unhooking approach:520 1. Store original bytes of target APIs from clean system521 2. Identify hooked functions in memory522 3. Restore original bytes using `WriteProcessMemory` on the current process523 4. Execute malicious code using now-unhooked APIs524- Sample implementation:525526 ```c527 // Find address of target API function528 HANDLE kernelbase_handle = GetModuleHandle("kernel32");529 LPVOID CreateRemoteThread_address = GetProcAddress(kernelbase_handle, "CreateRemoteThread");530531 // Check if function is hooked (first byte is 0xE9)532 byte first_byte = (byte)*(char*)CreateRemoteThread_address;533 if (first_byte == 0xe9) {534 // Replace with original bytes535 char original_bytes[] = "\x4C\x8B\xDC\x48\x83"; // Original prologue bytes536 WriteProcessMemory(GetCurrentProcess(), CreateRemoteThread_address, original_bytes, 5, NULL);537 }538 ```539540- This technique is effective but may require separate execution for the final payload since some AVs block executing immediately after unhooking. **Modern EDRs might still correlate the unhooking activity with subsequent suspicious actions.**541542#### Unhooking Tools543544- [unhook BOF](https://github.com/rsmudge/unhook-bof) - module refreshing (less reliable now **due to alternative EDR telemetry sources**)545- [Unhookme](https://github.com/mgeeky/UnhookMe) - dynamic unhooking546547#### Direct System Calls548549- malware circumvents hook in system DLL by directly system calling into kernel550- you can implement own syscall in assembly and bypass `ntdll.dll` hooks551- or obtain `SSN`(System Service Number) dynamically and call them(can be done via [SysWhispers2](https://github.com/jthuraisamy/SysWhispers2))552 - Direct syscalls bypass user-mode hooks in `ntdll.dll` but do not inherently bypass kernel-level monitoring (e.g., via kernel callbacks or ETW). EDRs are increasingly monitoring for patterns indicative of direct syscall usage itself (e.g., unusual call stack origins for syscalls).553 > [!CAUTION]554 > having syscall assembly instructions can be flagged, also this only helps the loader to evade the EDR not the malware itself555 - Major EDR vendorsnow flag **non‑ntdll syscall sites**; consider **return‑address replication gadgets** to re‑insert a plausible `ntdll` frame before the transition.556557> [!CAUTION]558> Some EDRs flag syscalls originating outside `ntdll.dll`. Maintaining plausible stacks/return frames may be required to avoid heuristics.559560##### Direct Syscall Tools561562Bypasses user-mode hooks but not kernel monitoring. Requires System Service Dispatch Table (SSDT) index:563564- [FreshyCalls](https://github.com/crummie5/FreshyCalls) - sorting system call addresses565- [SysWhispers2](https://github.com/jthuraisamy/SysWhispers2) - modernized syscall resolution566- [SysWhispers3](https://github.com/klezVirus/SysWhispers3) - adds x86/Wow64 support567- [Runtime Function Table](https://www.mdsec.co.uk/2022/04/resolving-system-service-numbers-using-the-exception-directory/) - reliable SSN computation568569#### Indirect System Calls570571- malware uses code fragments in kernel DLL without calling the hooked functions in those DLL572- prepare the system call in assembly then find a syscall instruction in `ntdll.dll` and jump to that location573 - **Modern Context:** Similar to direct syscalls, this bypasses user-mode hooks but not necessarily kernel-level monitoring. Finding and jumping to existing `syscall` instructions can be less suspicious than embedding raw syscall stubs, but the subsequent kernel activity is still visible.574 > [!TIP]575 > this is preferred,you can also boost evasion techniques by hiding inside a `.dll`576577#### Kernel‑Mode EDR Killers (BYOVD)578579- **Bring‑Your‑Own‑Vulnerable‑Driver (BYOVD)** attacks load legitimately signed but exploitable drivers—examples include **rtcore64.sys**, **iqvw64e.sys**, and **terminator.sys**—to execute privileged code inside the kernel.580- Typical payload actions581 - Patch or unregister kernel‑mode notify callbacks (`PsSetCreateProcessNotifyRoutine`, `ObRegisterCallbacks`) to blind user‑mode EDR components.582 - Overwrite or unload _WdFilter.sys_ and other sensor drivers, fully disabling Defender or third‑party agents.583- Public toolchains such as **Terminator**, **kdmapper**, and **EDRSensorDisabler** automate these steps.584- Case study: Lenovo `LnvMSRIO.sys` (CVE‑2025‑8061). Exposes physical memory/MSR read‑write primitives to low‑privileged users; can overwrite MSR_LSTAR and pivot to Ring‑0 payload, then patch/unregister callbacks to blind EDR.585586> [!TIP]587> The vulnerable‑driver blocklist (`DriverSiPolicy.p7b`) is **enabled by default** on Windows 11 22H2+ and refreshed every Patch Tuesday. Keep HVCI/KDP enabled so attacker drivers cannot patch protected code pages, and enable Hardware‑Enforced Stack Protection (CET/Shadow Stack) on Windows 11 24H2 to break call‑stack spoofing.588589> [!NOTE]590> Because the blocklist is on by default and updated frequently, a BYOVD chain now often needs **two** vulnerable drivers: one to disable Secure Boot or flip `CiOptions`, and a second to perform the EDR‑killer actions before the next blocklist refresh.591592### User-Mode Application Whitelisting Bypass593594#### Exploiting Vulnerable Trusted Applications595596Windows Defender Application Control (WDAC) and similar application whitelisting solutions can be bypassed by leveraging vulnerabilities in trusted, signed applications. A notable technique involves exploiting N-day vulnerabilities in the V8 JavaScript engine within Electron-based applications.597598- **Concept (Bring Your Own Vulnerable Application - BYOVA)**:599 - A trusted, signed Electron application (e.g., an older version of VSCode) with a known V8 vulnerability is used as a carrier.600 - The application's `main.js` (or equivalent) is replaced with a V8 exploit that executes a native shellcode payload.601 - If the application is whitelisted, WDAC allows it to run, inadvertently executing the malicious shellcode.602- **Advantages**:603 - Achieves native shellcode execution, overcoming limitations of pure JavaScript execution in some backdoored Electron app scenarios.604 - Shellcode runs in a browser-like process context, where behaviors like Read-Write-Execute (RWX) memory regions (due to JIT compilers) are common and may appear less suspicious to EDRs.605- **Exploit Development & Operationalization Challenges**:606 - **V8 Version Targeting**: Electron's V8 often lags behind Chrome's and includes backported security patches. Vulnerabilities must be chosen that were patched _after_ the target application's Electron version was frozen. Electron's cherry-picked patches should be reviewed.607 - **Debugging**: Building the specific V8 version (e.g., using `d8` debug shell with `--allow-natives-syntax` for `%DebugPrint()`) is crucial for understanding memory layouts and adapting exploits.608 - **Offset Inconsistencies**: Hardcoded offsets in public exploits (often Linux-based) need adjustment for the target V8 version and OS (Windows). Function pointer offsets for overwriting can even vary between Windows versions.609 - _Solution for offset variation_: Launch the exploit multiple times in child processes, each trying a different potential offset. The parent process monitors for success (e.g., mutex creation by payload).610 - **Sandbox Escape**: Public V8 exploits might use sandbox escape techniques already patched (cherry-picked) in the target Electron V8 version, requiring new or modified escapes.611 - **JIT Compiler Interference (e.g., V8 TurboFan)**:612 - Optimizations can consolidate repeated instruction sequences (e.g., multiple floating-point values), affecting shellcode smuggling. Workarounds include compact shellcode or varying instruction positions.613 - Copying large shellcode payloads can be problematic. Workaround: multiple smaller copy loops or using a stager payload that fetches the main payload.614 - **Payload Obfuscation**: Obfuscate the JavaScript exploit (e.g., in `main.js`) to hinder analysis. Re-obfuscating per deployment can help avoid signature-based detection.615- **Defense & Future Considerations**:616 - Electron's experimental integrity fuse feature, if enabled by developers, can verify the integrity of application files (including `main.js`) at runtime, potentially thwarting this technique by exiting if tampering is detected.617 - Older application versions without this fuse remain vulnerable.618619### Process Manipulation620621#### Early Cascade Injection622623- Novel process injection technique targeting user-mode process creation624- Combines elements of Early Bird APC with EDR-Preloading625- Avoids queuing cross-process APCs while maintaining minimal remote process interaction626- Works by:627 - Targeting processes during the transition from kernel-mode to user-mode (`LdrInitializeThunk`)628 - Leveraging callback pointers (like `g_pfnSE_DllLoaded`) during Windows process creation629 - Executing malicious code before EDR detection measures can initialize630- Advantages:631 - Operates before EDRs can initialize their hooks and detection measures632 - Particularly effective against EDRs that hook `NtContinue` or use delayed initialization633 - Avoids ETW telemetry that traditional injection techniques trigger634 - Minimal remote process interaction reduces detection footprint635 - More stealthy than traditional techniques like DLL hijacking or direct syscalls636- Key insight: EDRs typically load their detection measures after the `LdrInitializeThunk` function executes, providing a window of opportunity for code execution before security measures initialize637- watch for early `NtCreateThreadEx` inside `LdrInitializeThunk`638639#### Early Startup Bypass640641**Concept**: Execute malware before the EDR's user-mode component fully initializes, creating a window of opportunity for undetected execution.642643**Implementation**:644645- Target the gap between kernel driver loading and user-mode agent initialization646- Execute payload during system startup before EDR hooks are established647- Leverage services that start before EDR components648649**Research Findings (Cortex XDR)**:650651- Successfully executed Mimikatz with `lsadump::sam` without detection during early startup652- EDR kernel drivers may be loaded but user-mode hooks not yet established653- Timing window varies depending on system performance and EDR implementation654655**Detection Evasion**:656657- Creates process activity before EDR monitoring is fully operational658- Avoids user-mode hooks that haven't been established yet659- Kernel-level monitoring may still detect activity depending on driver initialization order660661**Limitations**:662663- Requires precise timing and understanding of EDR startup sequence664- May not work against EDRs with early kernel-level monitoring665- Window of opportunity may be brief on fast systems666667#### Waiting Thread Hijacking (WTH)668669- A stealthier version of classic Thread Execution Hijacking670- Intercepts the flow of a waiting thread and misuses it for executing malicious code671- Avoids suspicious APIs like `SuspendThread`/`ResumeThread` and `SetThreadContext` that trigger most alerts672- Required handle access:673 - For target process: `PROCESS_VM_OPERATION`, `PROCESS_VM_READ`, `PROCESS_VM_WRITE`674 - For target thread: `THREAD_GET_CONTEXT`675- Uses less monitored APIs:676 - `NtQuerySystemInformation` (with `SystemProcessInformation`)677 - `GetThreadContext`678 - `ReadProcessMemory`679 - `VirtualAllocEx`680 - `WriteProcessMemory`681 - `VirtualProtectEx`682- Implementation can be further obfuscated by splitting steps across multiple functions to evade behavioral signatures683- Primarily bypasses EDRs that focus on detecting specific API calls rather than behavioral patterns684- Effective against EDRs that are restrictive about remote execution methods but more lenient with allocations and writes685- Suitable for hiding the point at which implanted code was executed686687#### PPID Spoofing688689- Creates process with fake parent process ID690- Hides true process creation chain691- Makes process tree analysis misleading692693#### Process Hiding694695A technique to hide processes from EDR monitoring by manipulating the Interrupt Request Level (IRQL):696697- Raise the IRQL of current CPU core698- Create and queue Deferred Procedure Calls (DPCs) to raise the IRQL of other cores699- Perform sensitive task (for example, hiding process)700- Signal DPCs in other cores to stop spinning and exit701- Lower IRQL of current core back to original702703```c704irql = RaiseIRQL();705dpcPtr = AcquireLock();706do_stuff();707ReleaseLock(dpcPtr);708LowerIRQL(irql);709```710711This approach temporarily prevents EDR from monitoring the process during the critical operations by operating at an elevated privilege level.712713> [!NOTE]714> HVCI-enabled 23H2 kernels may crash when raising IRQL this way. Safer alternative: kernel-driver patching of `PsLookupProcessByProcessId`.715716#### UAC Bypass via Intel ShaderCache Directory717718- Concept: Exploits weak permissions (`Authenticated Users: Full Control`) on the `Intel\ShaderCache` directory (`%LOCALAPPDATA%\LocalLow\Intel\ShaderCache`) combined with the behavior of auto-elevated processes (like `taskmgr.exe`) writing to this location.719- Mechanism:720 1. Clear Directory: Requires aggressively terminating processes holding handles (`explorer.exe`, `sihost.exe`, etc.) and deleting files within the `ShaderCache` directory. Permissions might need adjustment (`icacls`) to allow deletion. Launching `taskmgr.exe` briefly (with a timeout) helps identify recently written filenames and can trigger writes needed for the exploit.721 2. Junction Creation: Create a directory junction from `ShaderCache` to `\??\GLOBALROOT\RPC CONTROL`.722 3. Symbolic Link: Determine a recently used filename within `ShaderCache` (before clearing). Create an object directory symbolic link (`CreateDosDevice`) from `Global\GLOBALROOT\RPC CONTROL\<recent_filename>` to a target DLL path (e.g., `\??\C:\Windows\System32\oci.dll`).723 4. Trigger Write: Launch an auto-elevated process (e.g., `taskmgr.exe`) that writes to `ShaderCache`. The write operation follows the junction and then the symbolic link, resulting in the creation of a (dummy) target file (e.g., `oci.dll`) in a privileged location (`System32`).724 5. Overwrite & Execute: Overwrite the created dummy file with the actual malicious DLL. Launch a process (like `comexp.msc`) that attempts to load the target DLL, thereby executing the malicious code with elevated privileges.725- EDR Relevance:726 - Bypasses User Account Control (UAC), a primary defense layer.727 - Relies on manipulating file system objects (junctions, symlinks) and process interactions that EDRs monitor.728 - Involves potentially noisy actions like mass process termination and permission changes.729 - The final payload execution often relies on DLL hijacking techniques.730731> [!TIP]732> Symlink/junction UAC races are build‑dependent and brittle. Validate on the specific target build; many have partial or complete mitigations.733734#### PPL (Protected Process Light) Bypass735736**Concept**: Bypass Protected Process Light security by creating alternative service configurations that avoid PPL protections.737738**Palo Alto Cortex XDR PPL Bypass Technique**:739740```powershell741# Create alternative service that launches cyserver.exe without PPL protection742sc create "fake_cyserver" binPath="C:\Program Files\Palo Alto Networks\Traps\cyserver.exe" start=auto743```744745**How it works**:746747- Creates a second service that launches the EDR's main process (cyserver.exe)748- Original PPL-protected service fails to start due to startup dependencies749- New service configuration is not protected by EDR drivers750- EDR process runs without PPL protection, expanding attack surface751752**Limitations**:753754- Service names beginning with "cyserver\*" are blocked by some EDR implementations755- EDR functionality may remain intact despite PPL bypass756- Self-protection mechanisms may still be active at process level757- Vendor response varies - may not be considered a security vulnerability758759**Detection & Response**:760761- EDR thinks original service is stopped but agent continues running762- Attack surface increases as process no longer has PPL protections763- Reported to Palo Alto on 12.09.2023 with limited vendor response764765**Broader Implications**:766767- Demonstrates service configuration vulnerabilities in EDR implementations768- Shows potential for bypassing Windows security features through alternative execution paths769- Relevant for other EDRs that rely on PPL for self-protection770771#### Using `NtCreateUserProcess` for Stealthy Process Creation772773The native API `NtCreateUserProcess()`, located in `ntdll.dll`, is the lowest-level user-mode function for creating processes. Calling it directly can bypass EDR hooks placed on higher-level functions like `CreateProcessW` in `kernel32.dll`. This makes it a valuable technique for stealthier process creation.774775**Key Concepts:**776777- **Bypass Mechanism**: Avoids user-land hooks on more commonly monitored APIs like `CreateProcessW`.778- **Process Parameters**: Requires careful setup of structures like `RTL_USER_PROCESS_PARAMETERS` (often via `RtlCreateProcessParametersEx`), `PS_CREATE_INFO`, and `PS_ATTRIBUTE_LIST`.779 - `RTL_USER_PROCESS_PARAMETERS`: Defines process startup information, including image path, command line, environment variables, etc. The `ImagePathName` must be in NT path format (e.g., `\??\C:\Windows\System32\executable.exe`).780 - `PS_ATTRIBUTE_LIST`: Can specify attributes like the image name.781- **Flags**: `ProcessFlags` and `ThreadFlags` allow fine-grained control over process and thread creation (e.g., creating suspended). Sources like Process Hacker's headers (`ntpsapi.h`) can provide valid flag definitions. For minimal use, these can sometimes be `NULL`.782- **Implementation Details**: Involves initializing several structures and using functions from `ntdll.dll` such as `RtlInitUnicodeString`, `RtlCreateProcessParametersEx`, and `RtlAllocateHeap`. The article also mentions that the `ProcessParameters` argument for `NtCreateUserProcess` was found to be mandatory, and `RtlCreateProcessParametersEx` is used with the `RTL_USER_PROCESS_PARAMETERS_NORMALIZED` flag. The `PS_CREATE_INFO` structure needs its `Size` and `State` (e.g., `PsCreateInitialState`) members initialized. The `PS_ATTRIBUTE_LIST` is populated to include the image name.783784**Example High-Level Steps:**7857861. Define the path to the executable using `UNICODE_STRING` and initialize it with `RtlInitUnicodeString` (e.g., `L"\??\C:\Windows\System32\calc.exe"`).7872. Create and populate `RTL_USER_PROCESS_PARAMETERS` using `RtlCreateProcessParametersEx`, providing the image path and normalizing parameters.7883. Initialize a `PS_CREATE_INFO` structure.7894. Allocate and initialize a `PS_ATTRIBUTE_LIST`, setting the `PS_ATTRIBUTE_IMAGE_NAME` attribute with the image path.7905. Call `NtCreateUserProcess` with the prepared handles, access masks, and structures.7916. Perform cleanup, for instance, by calling `RtlFreeHeap` and `RtlDestroyProcessParameters`.792793This technique allows for creating a new process with more direct control, potentially evading EDRs that primarily hook `kernel32.dll` API calls. However, EDRs with kernel telemetry or hooks deeper within `ntdll.dll` (or monitoring syscalls directly) might still detect the `NtCreateUserProcess` call or the subsequent behavior of the spawned process.794795#### Advanced Process Execution Alternatives796797- [TangledWinExec](https://github.com/daem0nc0re/TangledWinExec) - alternative process execution techniques798- [rad9800](https://github.com/rad9800/misc/blob/main/bypasses/WorkItemLoadLibrary.c) - indirectly loading DLL through a work item799800#### Acquiring Process Handles801802- Without using suspicious `OpenProcess`:803 - Find `explorer.exe` window handle using `EnumWindows`804 - Convert to process handle with `GetProcessHandleFromHwnd`805 - Leverage `PROCESS_DUP_HANDLE` to duplicate into a pseudo handle for [Full Access](https://jsecurity101.medium.com/bypassing-access-mask-auditing-strategies-480fb641c158)806807### Callstack Manipulation808809#### Return Address Overwrite810811- overwrite function's return address with 0812 - that terminates call stack's unwinding algorithm813 - examination based on `DbgHelp!StackWalk64` fails814- implement custom API resolver similar to `GetProcAddress`815 - before calling out to suspicious functions, overwrite `RetAddr :=0`816 - when system API returns, restore own `RetAddr`817818#### Callstack Spoofing819820- Manipulates the call stack to appear legitimate821- Makes it harder to detect malicious code execution822- Tools and techniques:823 - ThreadStackSpoofer824 - CallStackSpoofer825 - AceL826827…(truncated)