Hook

[R4Yx]

Hey,

Ich versuche jetzt schon seid ein paar stunden einen hook zum laufen zu bekommen. Leider crasht das programm direkt wenn es dort ankommt.

hier der assembler code:

.code:0052CD87 loc_52CD87:                             ; CODE XREF: sub_52CD70+10j
.code:0052CD87                 mov     ecx, [ebp+var_10]
.code:0052CD8A                 mov     edx, [ecx+4]
.code:0052CD8D                 mov     [ebp+len], edx
.code:0052CD90                 mov     eax, [ebp+var_10]
.code:0052CD93                 mov     ecx, [eax+5F54h]
.code:0052CD99                 mov     [ebp+var_C], ecx
.code:0052CD9C                 push    0               ; flags
.code:0052CD9E                 mov     edx, [ebp+len]
.code:0052CDA1                 push    edx             ; len
.code:0052CDA2                 mov     eax, [ebp+var_10]
.code:0052CDA5                 add     eax, 8          ; Add
.code:0052CDA8                 push    eax             ; buf
.code:0052CDA9                 mov     ecx, [ebp+var_C]
.code:0052CDAC                 mov     edx, [ecx+4]
.code:0052CDAF                 push    edx             ; s
.code:0052CDB0                 mov     ecx, [ebp+var_C]
.code:0052CDB3                 call    sub_52F0C0      ; Call Procedure
.code:0052CDB8                 mov     [ebp+Size], eax
.code:0052CDBB                 cmp     [ebp+Size], 0FFFFFFFFh ; Compare Two Operands
.code:0052CDBF                 jnz     short loc_52CDDA ; Jump if Not Zero (ZF=0)
.code:0052CDC1                 call    dword ptr byte_6920D0+0C8h ; Indirect Call Near Procedure
.code:0052CDC7                 cmp     eax, 2733h      ; Compare Two Operands
.code:0052CDCC                 jnz     short loc_52CDD0 ; Jump if Not Zero (ZF=0)
.code:0052CDCE                 jmp     short loc_52CE0A ; Jump

Die andere function wo der stack ist den ich haben möchte

.code:0052F0C0 ; int __stdcall sub_52F0C0(SOCKET s, char *buf, int len, int flags)
.code:0052F0C0 sub_52F0C0      proc near               ; CODE XREF: sub_52CC80+6Dp
.code:0052F0C0                                         ; sub_52CD70+43p
.code:0052F0C0
.code:0052F0C0 var_8           = dword ptr -8
.code:0052F0C0 var_4           = dword ptr -4
.code:0052F0C0 s               = dword ptr  8
.code:0052F0C0 buf             = dword ptr  0Ch
.code:0052F0C0 len             = dword ptr  10h
.code:0052F0C0 flags           = dword ptr  14h
.code:0052F0C0
.code:0052F0C0                 push    ebp
.code:0052F0C1                 mov     ebp, esp
.code:0052F0C3                 sub     esp, 8          ; Integer Subtraction
.code:0052F0C6                 mov     [ebp+var_8], ecx
.code:0052F0C9                 mov     eax, [ebp+flags]
.code:0052F0CC                 push    eax             ; flags
.code:0052F0CD                 mov     ecx, [ebp+len]
.code:0052F0D0                 push    ecx             ; len
.code:0052F0D1                 mov     edx, [ebp+buf]
.code:0052F0D4                 push    edx             ; buf
.code:0052F0D5                 mov     eax, [ebp+s]
.code:0052F0D8                 push    eax             ; s
.code:0052F0D9                 call    send            ; Indirect Call Near Procedure
.code:0052F0DF                 mov     [ebp+var_4], eax
.code:0052F0E2                 cmp     [ebp+var_4], 0FFFFFFFFh ; Compare Two Operands
.code:0052F0E6                 jnz     short loc_52F100 ; Jump if Not Zero (ZF=0)
.code:0052F0E8                 mov     ecx, 1
.code:0052F0ED                 test    ecx, ecx        ; Logical Compare
.code:0052F0EF                 jz      short loc_52F0F3 ; Jump if Zero (ZF=1)
.code:0052F0F1                 jmp     short loc_52F100 ; Jump

Ich habe mir gedacht ich fange den call von der ersten function ab und versuche dann irgendwie an edx bzw eax zu kommen...

Dieser abschnitt sendet normalerweise die packet von einem Spiel. Ich will jetzt den buf auslesen. Was mich leich irritiert ist das der buf beim ersten mal EAX ist und beim 2. mal EDX.

Was ich bisher versucht habe:

DWORD backsend=0x0052F0C0;

DWORD WINAPI MySend()
{
	DWORD buf;
	DWORD abcd=0x0052F0C0;

	printf("Packet Sended: n");

	StartZw();

	__asm
	{
		mov buf,EAX
	}
	
	EndZw();

	printf("%xn",buf);

	__asm jmp backsend;
}

Intercept(INST_CALL,0x0052CDB3,(DWORD)MySend,5);

Ich hoffe ihr könnt mir da ein bissal weiterhelfen bzw mir sagen was falsch ist ...


//edit
sry hatte ich vergessen

void StartZw()
{
	__asm
	{
		push eax
		push ebx
		push ecx
		push edx
	}
}

void EndZw()
{
	__asm
	{
		pop edx
		pop ecx
		pop ebx
		pop eax
	}
}

Die braucht ihr auch noch

greetz
R4Y

[mr.rattlz]

Ich denke, es wäre ganz hilfreich, wenn du deinen eigenen code auch mal als assemblercode betrachtest, ich habe da so die Vermutung, dass du unbeabsichtigt Register verwendest. Printf hat doch einen Rückgabewert oder ? Ich nehme an, dass du allein schon damit eax veränderst.

[bloodx]

das erste printf gibt ja nur den text wieder
mit dem zweiten printf wollte R4Y glaube ich schon die daten wiedergeben lassen.

[R4Yx]

Originally Posted by mr.rattlz

Ich denke, es wäre ganz hilfreich, wenn du deinen eigenen code auch mal als assemblercode betrachtest, ich habe da so die Vermutung, dass du unbeabsichtigt Register verwendest. Printf hat doch einen Rückgabewert oder ? Ich nehme an, dass du allein schon damit eax veränderst.

das glaube ich eher nicht ... da ich vorher alle register gepusht habe und danach alle register wieder gepopt habe.

Ich werde mal printf weglassen und gucken was passiert

//edit
auch wenn ich das printf weglasse crasht es immernoch

Ich habe mal so einen noob debug programmiert.
Es crasht erst wenn es an mov buf,EAX kommt.

Die printf's hben damit nix zu tun

[mr.rattlz]

Originally Posted by R4Yx

das glaube ich eher nicht ... da ich vorher alle register gepusht habe und danach alle register wieder gepopt habe.

Ich werde mal printf weglassen und gucken was passiert

//edit
auch wenn ich das printf weglasse crasht es immernoch

Ich habe mal so einen noob debug programmiert.
Es crasht erst wenn es an mov buf,EAX kommt.

Die printf's hben damit nix zu tun

kannst du das ganze mal disassemblen und die entsprechenden Stellen hier posten ?
Ich weiß nicht, ob du dir der Tatsache bewusst bist, dass du da anscheinend calls zu StartZw und EndZw hast. Bei einem Call wird ja die Adresse des nächsten Befehls auf den Stack geschoben, der dann am Ende der Prozedur von ret wieder geholt wird um dahin zu springen.
Wenn du jetzt StartZw aufrufst ist am Ende der Prozedur EDX auf dem Stack und es wird zu der Adresse gesprungen die in EDX enthalten ist.
Das kann ich aber wie gesagt nur mutmaßen, letztendlich kann ich dir einfach nichts genaues sagen, da es davon abhängt wie intelligent dein Compiler ist. Ohne den Maschinencode ist es praktisch unmöglich zu sagen, was genau da jetzt wirklich passiert.

[R4Yx]

So hab dank Aylen die lösung

int WINAPI MySend(SOCKET s, const char* buf, int len, int flags) 
{ 
     DWORD sub_52F0C0 = 0x52F0C0; 
     DWORD storeECX; 
      
     _asm 
     { 
          mov     storeECX, ecx 
     } 
 
 
     _asm 
     { 
          mov     edx, flags 
          push    edx           ; flags 
          mov     edx, len 
          push    edx             ; len 
          mov     edx, buf 
          push    edx             ; buf 
          mov     edx, s 
          push    edx             ; s 
          mov     ecx, storeECX 
          call    sub_52F0C0      ; Call Procedure 
     } 
}

Nochmals vielen danke an Aylen Ich werde mich dankbar zeigen wenn ich kann

[BakaBug]

Originally Posted by R4Yx

Hey,
Was ich bisher versucht habe:

DWORD backsend=0x0052F0C0;

DWORD WINAPI MySend()
{
	DWORD buf;
	DWORD abcd=0x0052F0C0;

	printf("Packet Sended: n");

	StartZw();

	__asm
	{
		mov buf,EAX
	}
	
	EndZw();

	printf("%xn",buf);

	__asm jmp backsend;
}

Intercept(INST_CALL,0x0052CDB3,(DWORD)MySend,5);

Ich hoffe ihr könnt mir da ein bissal weiterhelfen bzw mir sagen was falsch ist ...


//edit
sry hatte ich vergessen

void StartZw()
{
	__asm
	{
		push eax
		push ebx
		push ecx
		push edx
	}
}

void EndZw()
{
	__asm
	{
		pop edx
		pop ecx
		pop ebx
		pop eax
	}
}

Die braucht ihr auch noch

greetz
R4Y

Ich weiß net genau was du hooken möchtest oder wie..
aber ich kann dir sagen was du grundsetzlich falsch machst..

DWORD WINAPI MySend()
{
	DWORD buf;
	DWORD abcd=0x0052F0C0;

-> der compile wird dein EBP verschieben undzwar um 0x08 .. platz für 2 variablen..

printf("Packet Sended: n");

-> diese funktion wird das EAX überschrieben ..

StartZw();

-> Ein aufruf solch einer funktion .. hat nicht gerade viel sin..
-> EBP gespeichert
-> Alle register werden gepusht
-> Alltes EBP wird wiederhergestellt (heißt so viel wie deine gepushten werte sind weg)
-> möglicher weiße wird EAX überschrieben...

EndZw();

-> selbe wie "StartZw();" ... nur das halt irgendwas gepopt wird .. weil ja dein gepushtes nicht da ist...

printf("%xn",buf);

-> Hier wird er versucehn dir irgendwas anzuzeigen .. wenn der Stack noch net im arsch ist xD

__asm jmp backsend;

-> du jumpst dort hin mit falschen werten am stack ..

... ich kann dir kurz un schnell die richtige lösung geben.. aber ich post das mal..

Ich schrieb die lösung noch.. wart ein bissal xD

[BakaBug]

PHP Code:

//meine funktion die mit den gestohlene daten arbeiten soll
void MySendSteal(DWORD MyEAX)
{
    printf("%xn", MyEAX);
}


//Ein paar hilfsfunctionen ..die so nix am stack ändern
#define StartZw __asm{ push eax };__asm{ push ebx };__asm{ push ecx };__asm{ push edx };
#define EndZw __asm{ pop edx };__asm{ pop ecx };__asm{ pop ebx };__asm{ pop eax };

#define Naked __declspec( naked )
void Naked MySend() //wenn ein fehler kommt .. dann halt "int Naked"
{
    StartZw; //alle sichern .. 
    //es würd auch reichen einfach 2 mal push eax ... damit es im stack bleibt
    __asm
    {
        push EAX //ein mal pushen für die funktion
        call MySendSteal //hilfsfunktion aufrufen
    }
    EndZw;  //alles wiederherstellen
    __asm
    {
        mov EBX, 0x0052F0C0
        jmp EBX //original aufrufen
    }
} 


Das ist C++ ~.~ .. und ja so sollte es gehen

[BakaBug]

Originally Posted by R4Yx

So hab dank Aylen die lösung

int WINAPI MySend(SOCKET s, const char* buf, int len, int flags) 
{ 
     DWORD sub_52F0C0 = 0x52F0C0; 
     DWORD storeECX; 
      
     _asm 
     { 
          mov     storeECX, ecx 
     } 
 
 
     _asm 
     { 
          mov     edx, flags 
          push    edx           ; flags 
          mov     edx, len 
          push    edx             ; len 
          mov     edx, buf 
          push    edx             ; buf 
          mov     edx, s 
          push    edx             ; s 
          mov     ecx, storeECX 
          call    sub_52F0C0      ; Call Procedure 
     } 
}

Nochmals vielen danke an Aylen Ich werde mich dankbar zeigen wenn ich kann

So gehts auch .. ändert aber daran nix das du keien ahnung von ASM hast..

Weil was du jetzt hast ist eine Funktionsweiterleitung .. und keine Code-Cave (wie es in deine falschen beispiel war)...

Aber egal... es war ja auch net wircklich kal was du haben woltest.. man hat ja net gesehen was und wie du hookst..

Code-Cave geht meistens mit JMP
Funktionsweiter leitungen IMMER mit CALL !