Im Hook Rückgabewert selbiger, gehookter Funktion ausgeben

[gruena]

Hallo Leute,

bislang reichte es mir immer Funktionen "normal" mit einem JMP zu hooken, um die Parameter auszulesen und dann die Funktion neu zu implementieren, weil man eine gehookte Funktion ja schlecht nochmal aufrufen kann.

Aber wie geht man vor, wenn man den Rückgabewert der echten, gehookten Funktion braucht?

Viele Grüße,
gruena

[Shakademus]

Sich die Adresse der echten Funktion notieren bevor man sie überschreibt? In was für einer Umgebung bewegst Du Dich denn? Wie hookst Du?

[gruena]

So, mal alles zusammengesucht:

hook.c

#include <stdio.h>
#include <string.h>

#include <sys/mman.h> /* mprotect */

void hookFunction(int from, int to)
{
	int relative = to - (from+5); // +5 is the position of next opcode
	memset((void *)from, 0xE9, 1); // JMP-OPCODE
	memcpy((void *)(from+1), &relative, 4); // set relative address with endian
}

int hook()
{
	printf("hook\n");
	return 666;
}

int original()
{
	printf("original\n");
	return 123;
}

int main()
{
	// allow to write in executable memory
	mprotect((void *)0x08048000, 0x135000, PROT_READ | PROT_WRITE | PROT_EXEC);

	original();
	hookFunction((int)original, (int)hook);
	printf("%.8x %.8x\n", original, hook);
	original();
	
	/*
		example-output of /proc/$pid/maps:
			08048000-08049000 rwxp 00000000 92:1d 84377624                           /home/gruena/hook/a.out
			08049000-0804a000 rwxp 00000000 92:1d 84377624                           /home/gruena/hook/a.out
	*/
	printf("change mprotect() if needed: /proc/%d/maps", getpid());
	getchar(); // dont kill process till we got what we need from /proc/$pid/maps
}

Kompilieren 32-bit:

gcc -m32 hook.c

Ausgabe:

original
0804856b 08048552
hook
change mprotect() if needed: /proc/17565/maps

Also ich patche direkt die Funktion und nicht die CALL's darauf.

[Shakademus]

Reservier am Anfang von hookFunction zehn Byte, kopiere die ersten fünf aus from, bevor Du sie überschreibst, füge ein JMP an und anschließend die Adresse from+5.

Am Ende der Funktion gibst Du die Adresse dieses neuen Speicherbereichs zurück. Dort findet sich dann die bisherige Funktionalität.

[gruena]

Danke Shakademus.

Das tut jetzt auch schon, nur habe ich noch ein Problem mit unterschiedlichen Funktionen. Ich kann nicht einfach 5 Bytes an Opcodes aus der Funktion kopieren und dann ausführen, da es dann die Opcodes zerreißt.

Meine Erfahrung bis jetzt (z.B. gewinnbar durch gdb: disassemble original):
- Funktion ohne Parameter: 9 Bytes kopieren
- Funktion mit einem Parameter: 6 Bytes kopieren

Bräuchte eine Funktion, die die originale Funktion analysiert und mir dann sagt, wieviele Bytes ich kopieren muss, damit ich nur ganze Opcodes kopiere. Also konkret eine Funktion, welche jeden Opcode kennt und sagen kann, wie lang der ist, damit sie solange durchiteriert, bis mindestens 5 Bytes für den JMP+Adresse zusammengesucht sind.

[Shakademus]

Hm, stimmt, das muss variieren. Da fällt mir keine Universallösung ein.

Wenn Du weißt, wo die Funktionen enden, sie z. B. zu einem Block von Funktionen gehören (sprich: Du weißt, was direkt danach kommt), kannst Du sie auch komplett kopieren.

[Atho]

Normalerweise benutzt man dafür einen Length-disassembler um die Länge der ersten Instruktionen jeder Funktion rauszukriegen vor dem kopieren. Beliebt ist beispielsweise LDE32/64 oder HDE32/64. Ich bevorzuge HDE (Hacker Disassembler Engine).

[nait]

Um den Rückgabewert zu bekommen könntest du deinen "Detour"-Hook-Code wie folgt aussehen lassen:

:Echte_Funktion
   JMP Detour ;hier wurden wie schon beschrieben ein paar Byte geklaut
   hier folgt ggf ein paar Byte Muell
 :Einsprung_echte_Funktion
   Erster vollständiger Befehl der alten Funktion
   ...
   Aufräum-Code
   RET

:Detour
   MOV Orig_ret, [ESP] ; Speichere die original Rücksprungadresse
   MOV [ESP], Detour_Fortsetzung
   Stolen Bytes der original Funktion ausführen
   JMP Einsprung_echte_Funktion

:Detour_Fortsetzung
   Mach dein Ding, der Rückgabewert der Funktion liegt in EAX
   JMP Orig_ret

Auf diese Weise kehrt die Original-Funktion zu deinem Detour zurück und nicht zum Aurfufer. Du kannst mit dem Ergebnis arbeiten und zum Abschluss nur noch zurück zum Aufrufer Springen. Je nach calling convetion (vgl. http://de.wikipedia.org/wiki/Aufrufkonvention) ist der Stack dann auch schon wieder aufgeräumt, als wäre nichts gewesen.
Wenn man es ganz genau nimmt, liegen die alten Werte immer noch auf dem Stack aber halt auf der falschen Seite vom ESP.