Tastatur Hook

Kromat

Liebe Community,
ich hab vor einigen Wochen mit der DirectX11 Programmierung begonnen und weil der erstellen Würfel so prima aussah dachte ich mir, stelle ich ihn als Popup über den ganzen Bildschirm da. Und als der Würfel dann meinen ganzen Desktop bedeckte wollte ich ein paar Faxen machen und habe versucht das Popup unantastbar zu machen. Dazu habe ich das Fenster in jeder MessageLoop wieder in den Vordergrund gebracht und den Taskmanager über system("taskkill") beendet sobald er gestartet wurde. Das ganze war ein ganz schönes Durcheinander, Bildschirmflackern und ständig DOS Konsolen die über den Bildschirm rasten. Und dann hab ich mich im Internet umgeschaut und bin auf den Tastaturhook gestoßen.

#include <Windows.h>

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam); // Keyboard Proc
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); // MessageHandler der Anwendung

HHOOK hhk; // Globale Variable -> Speichert Rückgabewert von SetWindowsHookEx

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
	// Folgende 3 Zeilen -> Setzen des Hooks
	hhk = NULL;
	hhk = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, hInstance, 0);
	// hhk = NULL wenn WH_KEYBOARD anstatt WH_KEYBOARD_LL verwendet wird
	if(!hhk) MessageBox(NULL, "Hook konnte nicht gesetzt werden!", "Error", MB_OK);

	// Erstellen eines schwarzen Popups, dass den ganzen Schirm bedeckt
	WNDCLASSEX wc;
	HWND       hWnd;
	MSG        msg;

	wc.cbSize        = sizeof(WNDCLASSEX);
	wc.style         = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc   = WndProc;
	wc.cbClsExtra    = 0;
	wc.cbWndExtra    = 0;
	wc.hInstance     = hInstance;
	wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	wc.lpszMenuName  = NULL;
	wc.lpszClassName = "DirectX Grafik";
	wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

	RegisterClassEx(&wc);

	int Width  = 1920;
	int Height = 1080;
	int xPos   = (GetSystemMetrics(SM_CXSCREEN) - Width ) / 2;
	int yPos   = (GetSystemMetrics(SM_CYSCREEN) - Height) / 2;

	hWnd = CreateWindowEx(NULL, "DirectX Grafik", "DirectX Grafik", WS_POPUP | CW_USEDEFAULT,
						   xPos, yPos, Width, Height, NULL, NULL, hInstance, NULL);

	ShowWindow(hWnd, SW_SHOW);
	ShowCursor(false);

	while(true)
	{
		if(PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		if(msg.message == WM_QUIT) break;

	}

	// Folgende Zeile -> Entfernen des Hooks
	UnhookWindowsHookEx(hhk);

	return 1;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
	return CallNextHookEx(hhk, nCode, wParam, lParam);
}

Ich habe im Internet viele Anhaltspunkte gefunden, wie man einen Tastaturhook implementiert, allerdings hat keiner funktioniert. In einigen Foren und bei msdn selber habe ich dann gelesen, dass es einer DLL Datei bedarf. Da ich jedoch noch nie eine DLL erstellt habe geschweige denn wüsste wie das geht war ich an dieser Stelle am Ende und hoffe auf konkrete Hilfe.

- Ziel meines Vorhabens: Ein leeres Fenster, dass einfach jeden Tastendruck global unterdrückt (Ich glaub, dass das für das Verständnis vorerst das leichteste ist anstatt noch spezifische Keys heraus zu filtern).

- Jetziger Stand: Windows setzt meine Tastenanschläge wie gewohnt um. Nach Programmstart wird nichts abgefangen. SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, hInstance, 0) funktioniert nicht mit WH_KEYBOARD.

-Frage: Brauche ich wirklich eine DLL Datei und wenn ja, was genau muss da hinein?

Ich hoffe Ihr könnt mir helfen und ich bedanke mich wie immer im Vorraus

gamer8o4

ich jedoch noch nie eine DLL erstellt habe geschweige denn wüsste wie das geht war ich an dieser Stelle am Ende und hoffe auf konkrete Hilfe.

zuersteinmal, ich habe keine ahnung von tastatur-hooks und wüsste auch nicht warum man dabei eine dll brauchen sollte, aber hier mal ein schnelllehrgang zum thema dll erstellen:

http://www.youtube.com/watch?v=j2uUEcwz12k
(kein besonders gutes tutorial, aber es erfüllt seinen zweck)

Eine dll ist im eigeltlichen zusammengefassten sinne eine sammlung von funktionen, die nicht in der exe, sondern halt in dll-dateinen gespeichert sind.
dein programm läd dann diese dll und führt funktionen die in ihr vorhanden sind aus.
vorteil:
-deine exe ist nicht so groß
-wenn du zum beispiel dein projekt in kleinere teile aufteilst, und nach der vertigstellung etwas an nur einem dieser teile ändern willst musst du nur die dll ersetzten und kannst den rest so lassen wie es ist.
- .. es gibt GENUG vorteile, aber das waren die beiden die helfen, das grundprinzip zu verstehen.. google ist dein freund.

PS: hoffe das konnte dir helfen, auch wenn meine antwort nichts mit tastatur hooks zu tun hatte

Swordfish

Ich bin mir ziemlich sicher, daß ein Keyboardhook Ctrl - Alt - Del nicht zu Gesicht bekommt.

-lowbyte- 0

Swordfish schrieb:

Ich bin mir ziemlich sicher, das ein Keyboardhook Ctrl - Alt - Del nicht zu Gesicht bekommt.

Es ist auch so...

gamer804 schrieb:

zuersteinmal, ich habe keine Ahnung von tastatur-hooks und wüsste auch nicht warum man dabei eine DLL brauchen sollte

Kannst Du hier entnehmen.
http://msdn.microsoft.com/en-us/library/windows/desktop/ms644959(v=vs.85).aspx

Ein WH_KEYBOARD braucht eine DLL wenn er Global gebraucht wird, da der Code in den Adressraum von jedem/(ausnahme Consolen Subsystem) Programm geladen wird.

Bei WH_KEYBOARD_LL brauchst du keine DLL da er kurzgesagt weiter unten ansetzt.

Aber Ctrl - Alt - Del kannst du mit sowas nicht abfangen.

Kromat

Vielen Dank für eure Antworten.
Das Youtubevideo und auch die Anleitung bei msdn
haben mir sehr geholfen die DLLs nachzuvollziehen. Anhang eines Beispiels was ich noch gefunden habe konnte ich das dann nachvollziehen und in meinen Stil umschreiben.

Der Hook arbeitet aufjedenfall Global. Ich bekomme alle Nachrichten, nur leider nicht immer als erstes.

- Im Browser (Firefox) werden Eingaben abgefangen bevor sie auf dem Bildschirm erscheinen. Dort kann ich die Tastatur komplett blocken und alle Ausgaben verhindern.

- Bei Eingaben im Startmenü oder im Editor bekommt mein Programm die Nachrichten erst, wenn die gedrückte Taste losgelassen wird. Das bedeutet, dass die Buchstaben beispielsweise im Editor erscheinen und erst dann weitergeleitet werden. Wenn ich dann einmal die Tasten losgelassen habe mussten jedoch die anderen Programme alle warte, bis mein Programm die Nachricht verarbeitet hatte bis es weiter gehen konnte.

- Der Taskmanager blieb wie Ihr schon angedeutet hattet komplett unberührt. Ich hab dann eine Funktion geschrieben, die jedes Fenster, dass den Fokus hat (außer meins) versteckt und deaktiviert wird. Das hat auch bei allen funktioniert ... nur beim Taskmanager mal wieder nicht

Ich merk schon, dass der Startbutton und der Taskmanager eine etwas größere Herausforderung sind und die Hooks übersteigen. Aber könntet ihr mir eventuell ein Stichwort nennen, in welcher Richtung ich suchen müsste um die Tastenkombis lahm zu legen?

ps: den taskmanager unter regedit abschalten funktioniert nur, wenn das Programm mit Admin Rechten ausgeführt wird, was daher auch keine Lösung ist.

-lowbyte- 0

Um den Taskmanager zu unterbinden kannst Du ja in einer Schleife das Window oder den Prozessnamen suchen und den Process killen.

-> Von hier an braucht es mehr...

Oder wenn dies Dir zu spät ist, kannst Du ein inline oder IAT Hook in der nicht dokumentierten Funktion NTCreateProcess von MS setzten, und so kontrollieren was gestartet werden darf und was nicht.

Um Ctrl-alt-Del abzufangen brauchst Du ein bisschen Kung-Fu Und ich glaube das übersteigt so ziemlich Dein Vorstellungsvermögen und gehört auch nicht hier hin.

Kromat

Viel weiter als das, was du beschrieben hast, würde ich vermutlich auch nicht kommen. Das mit dem Prozess killen hab ich schon gemacht, empfine ich jedoch als unschöne Variante. NTCreateProcess werde ich mir jedoch jetzt auch mal anschauen.
Danke

DarkShadow44

Also den Taskmanager deaktivieren kannst du indem du in der Registry unter

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\System

einen "DWORD 32" namens "DisableTaskMgr" mit Wert 1 erstellst.

Der Sinn dahinter erschließt sich mir aber nicht...

Zu dem Hook von "NTCreateProcess", diesen Hook müsstest du bei einem Systemprozess anbringen, damit würde ich dir raten nicht rumzuspielen. AFAIK wäre das "winlogon.exe", wenn du den Prozess crasht macht das dein ganzes System auch...

Und wenn du Str-Alt-Entf abfangen willst brauchst du schon nen Treiber

Aber was soll das werden, ein Trojaner.. ?

floorball

Die Registry ist wohl die beste Methode um den TaskMgr zu sperren. Allerdings würde ich ihn nicht wie DarkShadow44 es vorgeschlagen hat sperren weil dann eine Message Box erscheint sondern eher umlenken auf einen leeren Prozess Stichwort Hijacks. Mit dem hooken von funktionen würde ich gar nicht erst anfangen, da kann man sich viel kaputtmachen.
BTW: fürs inline Hooking brauchtt man doch die größe des ersten Opcodes und wie will man den bei einer undokumentierten funktion herausfinden

DarkShadow44

sondern eher umlenken auf einen leeren Prozess

Wie soll das gehen ? Was meinst du mit "leerer Prozess" ?

Die einzige mir bekannte Möglichkeit ist abzufangen welche Programme gestartet werden und den Taskmanager zu verbieten - nach einem Neustart ist auch nichts mehr kaputt wenn man den Hook verpfuscht hat

fürs inline Hooking brauchtt man doch die größe des ersten Opcodes

Du hast ja die Adresse der Funktion, bzw. kannst sie einfach rausfinden. Dann einfach das erste Byte einlesen und schauen welchem Opcode das enspricht, daran siehst du dann die Länger der Anweisung.

floorball

Der Process Explorer von Sysinternals hat unter Options die möglickeit "Replace Task Manager" indem er in der Registry einen Schlüssel unter
HKLM\SOFTWARE\Microsoft\WindowsNT\CurrentVersion\Image File Execution\taskmgr.exe setzt. Den Wert des Keys weiß ich nicht da ich ihn gelöscht habe. (Hat bei mir irgendwie nicht funktioniert).

DarkShadow44 schrieb:

Du hast ja die Adresse der Funktion, bzw. kannst sie einfach rausfinden. Dann einfach das erste Byte einlesen und schauen welchem Opcode das enspricht, daran siehst du dann die Länger der Anweisung.

Wenn es doch so einfach wäre

-lowbyte- 0

floorball schrieb:

BTW: fürs inline Hooking brauchtt man doch die größe des ersten Opcodes und wie will man den bei einer undokumentierten funktion herausfinden

Dies ist ganz einfach... Und übersteigt wohl eher deine Kompetenz.

floorball

Ist ja sehr freundlich und auch noch extrem hilfreich
(Ich hoffe mal sarkasmus übersteigt nicht deine Kompetenz).

-lowbyte- 0

quasimodule schrieb:

DarkShadow44 schrieb:

Du hast ja die Adresse der Funktion, bzw. kannst sie einfach rausfinden. Dann einfach das erste Byte einlesen und schauen welchem Opcode das enspricht, daran siehst du dann die Länger der Anweisung.

Wenn es doch so einfach wäre

Dokumentiert hier:
http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Process/NtCreateProcess.html

EDIT:

Ein Bsp. für CreateProcessW() (für NtCreateProcess musst Du halt den Code ein bisschen anpassen) dass Dir zeigt wie man in etwa auf Win x86 inline api hooking betreibt (aus diesem Code muss eine Dll erstellt werden + eine Prozess der die exportierten Funktionen in dieser DLL aufruft -> installhook()). Geht natürlich auch noch anders zbsp. IAT hooking, aber das ist hier nicht Thema. Und für mich ist das hier auch der letzte Post, da ich schon zu viel gelabert habe.
Du musst Dich halt einfach mit dem Thema befassen. Bücher lesen oder Tutorials die etwas taugen. Auf X64 funktioniert der Code nicht da ein 0xE9 == jmp (unconditional jump) nur 32Bit Sprungweiten unterstützt. Auf X64 arbeitet man zusätzlich mit Trampolin Techniken.

Aber wenn man mit der Materie nicht vertraut ist wird man bei einem X64 inline Api hook graue Haare bekommen...

Es gibt aber auch diverse Libs die alles einfacher machen. Zu empfehlen wäre da Mhook 2.3 -> http://codefromthe70s.org/mhook23.aspx läuf unter x86 und x64 !

#include <windows.h>
#include <psapi.h>
#include <stdio.h>
#include "hooking_dll.h"

#pragma data_seg("shared")
HINSTANCE hinstanc = 0;
HHOOK hkb = 0;
#pragma data_seg()

#pragma comment(linker, "/Section:shared,rws")

#define SIZE 5

typedef BOOL (WINAPI *pCreateProcessW) (LPCTSTR lpApplicationName ,LPTSTR lpCommandLine ,LPSECURITY_ATTRIBUTES lpProcessAttributes ,LPSECURITY_ATTRIBUTES lpThreadAttributes ,BOOL bInheritHandles ,DWORD dwCreationFlags ,LPVOID lpEnvironment ,LPCTSTR lpCurrentDirectory ,LPSTARTUPINFO lpStartupInfo ,LPPROCESS_INFORMATION lpProcessInformation);

BOOL WINAPI MyCreateProcessW(LPCTSTR lpApplicationName ,LPTSTR lpCommandLine ,LPSECURITY_ATTRIBUTES lpProcessAttributes ,LPSECURITY_ATTRIBUTES lpThreadAttributes ,BOOL bInheritHandles ,DWORD dwCreationFlags ,LPVOID lpEnvironment ,LPCTSTR lpCurrentDirectory ,LPSTARTUPINFO lpStartupInfo ,LPPROCESS_INFORMATION lpProcessInformation);

void BeginRedirect(LPVOID newFunction);

pCreateProcessW pOrigMBAddress = NULL;
BYTE oldBytes[SIZE] = {0};
BYTE JMP[SIZE] = {0};
DWORD oldProtect, myProtect = PAGE_EXECUTE_READWRITE;

int WINAPI DllMain(HMODULE hDLL ,DWORD Reason ,LPVOID Reserved)
{

    switch(Reason) {

			case DLL_PROCESS_ATTACH:

				hinstanc = hDLL;

				pOrigMBAddress = (pCreateProcessW) GetProcAddress( GetModuleHandleA("Kernel32.dll") ,"CreateProcessW");
				if(pOrigMBAddress != NULL) {	
					BeginRedirect(MyCreateProcessW);
					OutputDebugStringA("redirect");
				} else {
					OutputDebugStringA("no redirect");
				}

			break;

			case DLL_PROCESS_DETACH:

			if(pOrigMBAddress != NULL) {
				VirtualProtect((LPVOID)pOrigMBAddress ,SIZE ,myProtect ,&oldProtect);
				memcpy(pOrigMBAddress ,oldBytes ,SIZE);
				VirtualProtect((LPVOID) pOrigMBAddress ,SIZE ,oldProtect ,NULL);
			}

			break;

    }

    return TRUE;
}

LRESULT CALLBACK CBTProc(int nCode ,WPARAM wParam ,LPARAM lParam )
{

    return CallNextHookEx(hkb, nCode, wParam, lParam );
}

EXPORT BOOL CALLBACK installhook()
{
    hkb = SetWindowsHookEx(WH_CBT ,CBTProc ,hinstanc ,0);

    return 0;
}

EXPORT BOOL CALLBACK uninstallhook()
{

	return UnhookWindowsHookEx(hkb);
}

void BeginRedirect(LPVOID newFunction)
{
	BYTE tempJMP[SIZE] = {0xE9 ,0x90 ,0x90 ,0x90 ,0x90 };
	DWORD JMPSize;

	memcpy(JMP, tempJMP, SIZE);
	JMPSize = ((DWORD)newFunction - (DWORD)pOrigMBAddress - SIZE);
	VirtualProtect((LPVOID)pOrigMBAddress ,SIZE ,PAGE_EXECUTE_READWRITE ,&oldProtect);

	memcpy(oldBytes ,pOrigMBAddress ,SIZE);
	memcpy(&JMP[1] ,&JMPSize ,4);
	memcpy(pOrigMBAddress ,JMP ,SIZE);
	VirtualProtect((LPVOID) pOrigMBAddress ,SIZE ,oldProtect ,NULL);
}

BOOL WINAPI MyCreateProcessW(LPCTSTR lpApplicationName ,LPTSTR lpCommandLine ,LPSECURITY_ATTRIBUTES lpProcessAttributes ,LPSECURITY_ATTRIBUTES lpThreadAttributes ,BOOL bInheritHandles ,DWORD dwCreationFlags ,LPVOID lpEnvironment ,LPCTSTR lpCurrentDirectory ,LPSTARTUPINFO lpStartupInfo ,LPPROCESS_INFORMATION lpProcessInformation)
{
    BOOL retValue;
	wchar_t msg[1000] = {0};
	int ret = 0;

    VirtualProtect((LPVOID)pOrigMBAddress ,SIZE ,myProtect ,NULL);
    memcpy(pOrigMBAddress ,oldBytes ,SIZE);

   --> Hier kannst Du den Prozess übernehmen. bzw. die Ausführung verhindern!

    retValue = (pOrigMBAddress) (lpApplicationName ,lpCommandLine ,lpProcessAttributes ,lpThreadAttributes ,bInheritHandles ,dwCreationFlags ,lpEnvironment ,lpCurrentDirectory ,lpStartupInfo ,lpProcessInformation);

    memcpy(pOrigMBAddress ,JMP ,SIZE);
    VirtualProtect((LPVOID) pOrigMBAddress ,SIZE ,oldProtect ,NULL);

    return retValue;
}

-lowbyte- 0

Der Windows Explorer zum Bsp. braucht aber intern NtCreateProcessEx das aber praktisch nirgendwo Dokumentiert ist. Die Funktion müsstest Du hooken um denn Prozessstart vom Explorer.exe zu überwachen um den Processstart ganz früh zu erkennen!

Api Monitor v2.0 ist eine Hervorragendes Stück Code das sich in alle laufende Prozesse einklinkt und die Api Call's der Prozesse überwacht. Das tool kennt alle Funktionen der libs von MS, auch die meisten undokumentierten!

Ablauf:

1. Api Monitor v2.0 starten.
2. Auswählen welcher Prozess überwacht werden soll.
3. Filter anwenden. NtCreateprocessEx in unserem Fall. -> ntdll.dll
4. Jetzt kannst Du ein Programm Deiner Wahl starten via Desktop/Explorer.

Und jetzt solltest Du den function call sehen den Explorer.exe absetzt sowie vieles mehr. Danach denn Hook zu schreiben ist ein Kinderspiel!

voila

-lowbyte- schrieb:

quasimodule schrieb:

DarkShadow44 schrieb:

Du hast ja die Adresse der Funktion, bzw. kannst sie einfach rausfinden. Dann einfach das erste Byte einlesen und schauen welchem Opcode das enspricht, daran siehst du dann die Länger der Anweisung.

Wenn es doch so einfach wäre

Dokumentiert hier:
http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Process/NtCreateProcess.html

Passt irgendwie nicht ganz zusammen

-lowbyte- schrieb:

Ein Bsp. für CreateProcessW() (für NtCreateProcess musst Du halt den Code ein bisschen anpassen) dass Dir zeigt wie man in etwa auf Win x86 inline api hooking betreibt (aus diesem Code muss eine Dll erstellt werden + eine Prozess der die exportierten Funktionen in dieser DLL aufruft -> installhook()). Geht natürlich auch noch anders zbsp. IAT hooking, aber das ist hier nicht Thema. Und für mich ist das hier auch der letzte Post, da ich schon zu viel gelabert habe.
Du musst Dich halt einfach mit dem Thema befassen. Bücher lesen oder Tutorials die etwas taugen. Auf X64 funktioniert der Code nicht da ein 0xE9 == jmp (unconditional jump) nur 32Bit Sprungweiten unterstützt. Auf X64 arbeitet man zusätzlich mit Trampolin Techniken.

Aber wenn man mit der Materie nicht vertraut ist wird man bei einem X64 inline Api hook graue Haare bekommen...

Es gibt aber auch diverse Libs die alles einfacher machen. Zu empfehlen wäre da Mhook 2.3 -> http://codefromthe70s.org/mhook23.aspx läuf unter x86 und x64 !

Eindeutig, du hast zu viel gelabert ... wiederlegt aber nicht die Tatsache, dass nur bei den wenigsten Befehle in der x86 Architekturen, die Größe aus den Opcode-Bytes ermitteln werden kann. (Mal davon abgesehen, das das erste Byte auch eins der 4 möglichen Präfixes sein kann).

Trotzdem danke dass mich über eine Methode belehrt hast, die nur dann funktioniert, wenn das Zielprogramm die IAT auch während der Laufzeit benutzt

-lowbyte- 0

edit

DarkShadow44

quasimodule schrieb:

wiederlegt aber nicht die Tatsache, dass nur bei den wenigsten Befehle in der x86 Architekturen, die Größe aus den Opcode-Bytes ermitteln werden kann. (Mal davon abgesehen, das das erste Byte auch eins der 4 möglichen Präfixes sein kann).

Doch das geht verdammt gut. Wie sollte man sonst Anwendungen disassemblieren können ? Schau dir mal Debugger wie OllyDbg an, der kann das ziemlich gut

Die Prefixe sind AFAIK eindeutig, d.h. kein Opcode ist gleich einem Prefix, insofern stellen die kein Problem da.

-lowbyte- 0

quasimodule schrieb:

Trotzdem danke dass mich über eine Methode belehrt hast, die nur dann funktioniert, wenn das Zielprogramm die IAT auch während der Laufzeit benutzt

Wie bitte? Irgendwie scheinst Du da was durcheinander zu bringen!

Die meisten Funktionen auf x86 windows systemen haben ein Prolog der 5byte ist und so aussehen:

8bff     mov edi, edi
55       push ebp
8bec     mov ebp, esp

Die überschreibst Du dann mit dem jmp (E9 ,? ,? ,? ,?)zu deiner funktion.

Bei explizit gebundenen Funktionen, mittels LoadLibrary und GetProcAddress, wird kein IAT-Eintrag erstellt.
Inline Hooking bietet nicht nur die Möglichkeit, API-Funktionen zu hooken, sondern es lässt sich mit dieser Methode jede beliebige Funktion hooken. Im Gegensatz zur Modifikation der IAT ist es beim Inline Hooking irrelevant, ob die Bibliothek, welche die zu hookende Funktion exportiert, implizit oder explizit geladen wurde. Und im Gegensatz zur Modifikation der EAT hat diese Art, Hooks zu installieren, auch Einfluss auf Prozesse, welche bereits komplett geladen wurden, da direkt der Code der Funktion im Speicher verändert wird, anstatt nur eine modifizierte Kopie der zu hookenden Funktion zu erstellen. Außerdem besteht beim Inline Hooking nicht das Problem des kleinen Zeitfensters. All das macht das Inline Hooking wohl zu einer der effektivsten und effizientesten Methoden, einen Hook zu installieren.