[Help]recv midfunction hooking

[Lazeboy]

Hey,
ich versuche die Funktion recv zu hooken ohne das der hook entdeckt wird. Kurzsichtig wie ich bin hab ich bei send nen midfunction hook gemacht nur bei recv muss sich der buffer ja erstmal füllen also kann ich erst fast am ende der Funktion hooken. Das hab ich auch probiert nur irgendwie funktioniert das nicht.


recv ollydbg

CPU Disasm
Address   Hex dump          Command                                  Comments
76AA47DF  /$  8BFF          MOV EDI,EDI
76AA47E1  |.  55            PUSH EBP
76AA47E2  |.  8BEC          MOV EBP,ESP
76AA47E4  |.  83EC 10       SUB ESP,10
76AA47E7  |.  53            PUSH EBX
76AA47E8  |.  33DB          XOR EBX,EBX
76AA47EA  |.  813D 4870AC76 CMP DWORD PTR DS:[76AC7048],76AA3336
76AA47F4  |.  56            PUSH ESI
76AA47F5  |.- 0F85 F4EEFFFF JNE 76AA36EF
76AA47FB  |.  391D 7070AC76 CMP DWORD PTR DS:[76AC7070],EBX
76AA4801  |.- 0F84 E8EEFFFF JE 76AA36EF
76AA4807  |.  FF35 4470AC76 PUSH DWORD PTR DS:[76AC7044]             ; /Index = 4294967295.
76AA480D  |.  FF15 4812AA76 CALL DWORD PTR DS:[<&API-MS-Win-Core-Pro ; \KERNEL32.TlsGetValue
76AA4813  |.  8945 F8       MOV DWORD PTR SS:[EBP-8],EAX
76AA4816  |.  3BC3          CMP EAX,EBX
76AA4818  |.- 0F84 D1EEFFFF JE 76AA36EF
76AA481E  |.  895D FC       MOV DWORD PTR SS:[EBP-4],EBX
76AA4821  |>  FF75 08       PUSH DWORD PTR SS:[EBP+8]                ; /Arg1
76AA4824  |.  E8 47E8FFFF   CALL 76AA3070                            ; \WS2_32.76AA3070
76AA4829  |.  8BF0          MOV ESI,EAX
76AA482B  |.  3BF3          CMP ESI,EBX
76AA482D  |.- 0F84 E1EEFFFF JE 76AA3714
76AA4833  |.  8B4D F8       MOV ECX,DWORD PTR SS:[EBP-8]
76AA4836  |.  8B45 10       MOV EAX,DWORD PTR SS:[EBP+10]
76AA4839  |.  57            PUSH EDI
76AA483A  |.  83C1 08       ADD ECX,8
76AA483D  |.  8D55 FC       LEA EDX,[EBP-4]
76AA4840  |.  52            PUSH EDX
76AA4841  |.  51            PUSH ECX
76AA4842  |.  53            PUSH EBX
76AA4843  |.  53            PUSH EBX
76AA4844  |.  8D4D 14       LEA ECX,[EBP+14]
76AA4847  |.  51            PUSH ECX
76AA4848  |.  8D4D 08       LEA ECX,[EBP+8]
76AA484B  |.  51            PUSH ECX
76AA484C  |.  6A 01         PUSH 1
76AA484E  |.  8945 F0       MOV DWORD PTR SS:[EBP-10],EAX
76AA4851  |.  8B45 0C       MOV EAX,DWORD PTR SS:[EBP+0C]
76AA4854  |.  8D4D F0       LEA ECX,[EBP-10]
76AA4857  |.  51            PUSH ECX
76AA4858  |.  FF75 08       PUSH DWORD PTR SS:[EBP+8]
76AA485B  |.  8945 F4       MOV DWORD PTR SS:[EBP-0C],EAX
76AA485E  |.  8B46 0C       MOV EAX,DWORD PTR DS:[ESI+0C]
76AA4861  |.  FF50 54       CALL DWORD PTR DS:[EAX+54]
76AA4864  |.  8BCE          MOV ECX,ESI
76AA4866  |.  8BF8          MOV EDI,EAX
76AA4868  |.  E8 E3E7FFFF   CALL 76AA3050                            ; [WS2_32.76AA3050
76AA486D  |.  3BFB          CMP EDI,EBX
76AA486F  |.  5F            POP EDI
76AA4870  |.- 0F85 B27F0000 JNE 76AAC828
76AA4876  |.  F745 14 00800 TEST DWORD PTR SS:[EBP+14],00008000
76AA487D  |.- 0F85 85EEFFFF JNE 76AA3708
76AA4883  |.  8B45 08       MOV EAX,DWORD PTR SS:[EBP+8]
76AA4886  |>  5E            POP ESI
76AA4887  |.  5B            POP EBX
76AA4888  |.  C9            LEAVE
76AA4889  \.  C2 1000       RETN 10

my code:

unsigned long dwBufRecv = 0;
int lenRecv = 0;
char *lpBufRecv = 0;
unsigned long dwBackRecv = 0x76D9486D;
unsigned long callAddr = 0x76D93050;
__declspec(naked) void hkRecv()
{

	__asm
	{
		call [callAddr]
				
		//push edx
		//mov edx, dword ptr [ebp+0xc]
		//mov dwBufRecv, edx
		//mov edx, eax
		//mov lenRecv, edx
		//pop edx
		push edx
		mov edx, dword ptr [ebp+0xc]
		mov dwBufRecv, edx
		mov edx, dword ptr ss:[ebp+0x8]
		mov lenRecv,edx
		pop edx
	}
	
	lpBufRecv = (char*)malloc(lenRecv+1);
	printf("RecvPacket: Len: %d    AddrStr: %08X\n", lenRecv, dwBufRecv);
	memcpy(lpBufRecv, &dwBufRecv, lenRecv);

	for(int i=0; i < lenRecv; i++)
	{
		printf("%02X ", (unsigned char)lpBufRecv[i]);
	}
	//MessageBox(0,lpBufRecv,0,0);
	printf("\n\n\n");
	delete[] lpBufRecv;
	
	__asm
	{
		
		
		jmp [dwBackRecv]
	}




MakeJMP((unsigned char*)GetProcAddress(GetModuleHandle("Ws2_32.dll"), "recv")+0x89, (unsigned long)&hkRecv ,5);

mein erster Versuch war es hier anzusetzen

76AA4883  |.  8B45 08       MOV EAX,DWORD PTR SS:[EBP+8]
76AA4886  |>  5E            POP ESI
76AA4887  |.  5B            POP EBX

nur fürhte das zu problem und irgendwie krieg ich das mit dem ollydbg debuggen unter 64bit(was ich seit 3tagen habe) nicht auf die kette. Also hab ich aus verzweiflung hier versucht zu hooken

76AA4868  |.  E8 E3E7FFFF   CALL 76AA3050

jedoch mit dem Hintergedanken könnte mehrfach aufgerufen werden und somit zu problemen führen und das passierte dann auch.
Weiss vlt jemand von euch wie ich mein denken in die Tat umsetzen kann und recv undetected hooke.

mfg Lazeboy

[yihaaa]

Was meinst du denn mit unentdeckt bleiben? Mit welchem Schutz ist den dein Targetprogramm versehen? Schon mal HWBP in Erwägung gezogen?

MfG

[Lazeboy]

das spiel ist mit hackshield versehen, hwbp waren auf 32bit ohne einen hook auf kernelebene nicht möglich und auf 64bit hab ichs noch nicht probiert und mich auch noch nicht mit der Treiberprogrammierung beschäftigt. Man könnte bestimmt NtReadProcessMemory hooken um den buffer zu manipulieren nur wollte ich das ja eben vermeiden indem ich einfach in der mitte oder irgendwo in der funktion hooke. So wie ich bis jetzt hooke kommt es zu keiner detection oder so(vermute ich weil das game einfach abschmiert).

[MrSm!th]

Kurzsichtig wie ich bin hab ich bei send nen midfunction hook gemacht nur bei recv muss sich der buffer ja erstmal füllen also kann ich erst fast am ende der Funktion hooken.

Den Gedankengang kann ich nicht nachvollziehen, wo ist das Problem?

[Lazeboy]

ja ich weiss net wieso aber es kackt einfach ab xD nachdem nen paar packet gesnifft worden sind das heisst ja dann eig. das am hook was failed nur kann ich das ganze ne debuggen. Eig. wäre auch ne frage wie ich das mit dem debuggen auf 64bit windows 7 mache um dann das ganze mir anzugucken xD hab wohl zum teil bisschen die überschrift gestern nacht vefehlt.

[MrSm!th]

Ich meinte, wieso du glaubst, du müsstest am Ende von recv hooken.

[Dr. Coxxy]

in deiner midfunction:
-rücksprungadresse über stackpointer auslesen und speichern.
-rücksprungadresse auf eigene adresse manipulieren.
-Bufferptr/length abspeichern.
-normale funktion weiterlaufen lassen.

in der funktion die jetzt als rücksprung definiert ist:
-register/eax speichern.
-buffer ist nun gefüllt, tu was du nicht lassen kannst.
-zu gespeicherter originalrücksprungadresse springen.

[Lazeboy]

Originally Posted by MrSm!th

Ich meinte, wieso du glaubst, du müsstest am Ende von recv hooken.

weil bei recv der buffer doch erst gefüllt werden muss und eax die length returned und das auch erst gegen ende gesetzt wird.


@ Dr.: Super Idee probiere ich sofort aus ^^ thx

btw. das mit dem debuggen hab ich glaube auch hin bekommen macht die problemfindung leichter

[MrSm!th]

Du hast wohl grad nen kleinen Denkfehler.

Was machst du denn dann, wenn du direkt am Anfang mit nem konventionellen Detour hookst?
Du machst doch in deinem Hook etwa sowas, wenn du die Bytes nach dem Empfangen manipulieren willst

int hkRecv(SOCKET s, char *buf, int len, int flags)
{
    int result = recv_orig(s, buf, len, flags);
    *((short*)buf) = 0x1337:
    //whatever
    return result;
}

Wo ist dann nun dein Problem?
Wenn du kurz nach Anfang hookst, wie du es auch bei send tust, rufst du halt erst dein Trampolin auf, welches mit dem orginalen Funktionsfluss weitermacht und bearbeitest den Buffer danach.
Es ändert sich doch nicht wirklich was, du musst halt nur auf den Stack besonders aufpassen, da lokale Variablen etc. schon alloziert sein könnten.
Kommt halt drauf an, wo du genau hookst.

[Dr. Coxxy]

es ist um einiges schwieriger inmitten der funktion ein funktionierendes trampolin zu basteln.
am anfang zu hooken gibt einem den vorteil, dass man das trampolin CALLen kann und er nach ausführung der originalen funktion zurückkommt.
Mit dem trampolin mitten in der funktion, wo die hälfte der funktion schon abgelaufen ist, geht das idr. nicht mehr und wirst dir im zweifelsfall den stack kaputthauen.

wenn man nur jumpt, muss man ohnehin die rücksprungadresse aufm stack umbauen.

[MrSm!th]

Es ist schwerer, aber nicht unmöglich oO
Es ist außerdem nicht mitten drin, sondern um solche grundlegenden Checks zu umgehen reicht schon ein Offset größer 5, um halt nicht den Standard Detour zu haben.
Dann wird manchmal noch das Ende der Funktion kontrolliert und alles andere ist eh außerhalb jeglicher Checks, die man mit Offsets umgehen kann.
Wenn dazwischen der Hook noch detected wird, wird wohl ziemlich wahrscheinlich ein Hash der ganzen Funktion berechnet.

Man muss jedenfalls nicht mitten drin hooken, will ich damit sagen.

Was übrigens den Stack angeht:
Mitten drin kannst du zwar nicht callen, aber jumpen und dann halt die Return Adresse so manipulieren, dass der Flow danach wieder zu deiner Routine geht, bevor du dann returnst.
Aber im Grunde ist es doch genau das, was du geschrieben hast, seh ich gerade.

[Lazeboy]

hey,
also ich hab das ganze jetzt mal so versucht wie ihr das gesagt habt.
Hier erstmal meine Funktion die ein Detour schreiben soll und durch das Trampolin erst die orig_funktion aufruft(will da vlt noch was mit disasm librrary einbringen um den size parameter zu entfernen).

void DeourWithTampoline(unsigned char* pSrc, unsigned char* pDst, void** ppTrampolin, unsigned long size)
{
	unsigned char* pTmp = NULL;
	unsigned long old;
	
	pTmp = new unsigned char[(size+5) +1];
	if(pTmp == NULL)
		return;
		
	VirtualProtect(pTmp, size+5, PAGE_EXECUTE_READWRITE, &old);	
	memset(pTmp, 0x90, (size+5));
	
	
	VirtualProtect(pSrc, size, PAGE_READWRITE, &old);
	
	memcpy(pTmp, pSrc, size);
	pTmp += size;
	pTmp[0] = 0xE9;
	*(unsigned long*)(pTmp+1) = (unsigned long)(pSrc + size - pTmp)-5;
	
	
	pSrc[0] = 0xE9;
	*(unsigned long*)(pSrc+1) = (unsigned long)(pDst-pSrc)-5;
	
	for(int i = 5; i < size; i++)
		*(pSrc+i) = 0x90;
		
	*ppTrampolin = (pTmp - size);
		
	VirtualProtect(pSrc, size, old, &old);	
}

so das funktioniert soweit auch ganz gut wenn ich normal bei recv hooke. Versuche ich 5 opcodes später zu hooken funktioniert das auch noch bis die die orig_recv returned. Der return führt irgendwo ins nirgendwo lol.

int hkRecv(SOCKET s, char * buf, int len, int flags)
{
	//__asm sub esp,4
	
	int i = orecv(s,buf,len,flags); 
	return i;
}


DeourWithTampoline((unsigned char*)GetProcAddress(GetModuleHandle("Ws2_32.dll"), "recv")+5, (unsigned char*)&hkRecv, (void**)&orecv, 6);

Aber das kann doch so auch gar nicht gehen weil auf dem Stack ja schon einmal gepushed wurde und zwar "push ebp". Wenn ich vorher den stack um 4 verringer returned nach dem orig_recv zum orginalen rücksprungs punkt und nicht zurück zu meiner hkRecv. Den Stack einfach um 4 verringern ist glaube auch keine gute idee das haut ja alles kaputt .

[Dr. Coxxy]

machs doch einfach so wie ich gesagt habe, mit 2 funktionen, von der die erste die midfunctionhook ist, die nichts anderes macht als die rücksprungadresse auf die 2. funktion zu korrigieren und die parameter sichert, und die 2. die dann nachher die parameter auswertet.
dann brauchste dich bis auf um an die parameter und an die rücksprungadresse ranzukommen überhaupt nicht um den stackkram zu kümmern.

[MrSm!th]

Die disasm lib wird dir kaum helfen, da der stack bei jeder Funktion anders beschaffen sein kann, wo du deinen hook platzierst. Was genau du sichern und was du korrigieren musst, musst du dir also eh immer selbst ansehen.
btw. Das was du da in deiner Detour Function schreibst kannst du auch gleich mit Ms Detours machen, das ist wesentlich besser als so eine selbstgebaute Funktion und hat auch noch besagte disasm Lib direkt intern.

bis auf um an die

qtf

[Lazeboy]

hey,
@Dr.Coxxy du hasst dir das so gedacht ne ?

unsigned long dwBufRecv = 0;
int lenRecv = 0;
char *lpBufRecv = 0;
unsigned long dwBackRecv = 0x76AA47EA;
unsigned long dwRetnRecv = 0;
unsigned long callAddr = 0x76D93050;

__declspec(naked) void hkRecv()
{
	printf("Worked\n");
	__asm
	{
		jmp [dwRetnRecv]
	}
}

__declspec(naked) void tmpRecv()
{
	__asm
	{	
		push edx
		mov edx, dword ptr ss:[ebp+4]
		mov dwRetnRecv, edx
		mov edx, hkRecv
		mov dword ptr ss:[ebp+4], edx
		pop edx
		
		SUB ESP,10
		PUSH EBX
		XOR EBX,EBX
		jmp [dwBackRecv] 
	}
}

MakeJMP((unsigned char*)GetProcAddress(GetModuleHandle("Ws2_32.dll"), "recv")+0x5, (unsigned long)&tmpRecv ,6);

ales das funktioniert auch soweit returned zu meiner funktion ich führe meine funktion aus und springe zum orginalen punkt und dann ka wieso crashed es danach irgendwie. Hab zum testen die parameter einfach mal raus gelassen