ida pro funktion

Page 1 of 2 1 2
06/10/2015 23:05 Slade100#1
hey, hier gibts leider keine asm section daher poste ich das mal hierhin :)
unzwar wollte ich eine funktion hooken, welche mir in ida mit folgenden übergabeparametern angezigt wird __stdcall sub(float, int, int, char, int, int, int), der hook ist getan(ist nicht das erstemal das ich eine function hooke,also habe den schon richtig gemacht ^^ ), aber ich vermute das die parameter nicht ganz stimmen(sofern das möglich ist), sobald ich irgendwas in meinen hook reinschreibe, sogar bei einem einfach printf("hallo") crasht mein game... also ist es möglich das ida pro mir da ein funtktion zeigt, die nicht der wahrheit entspricht?^^
06/11/2015 14:52 Terrat#2
Das liegt daran das ihr euch glaube nicht alle sicher seit was ihr da tut. Ein midfunction hook heißt das ihr in der Runtime des Programms seit sprich ihr dürft nicht denken das es euer Programm ist. Du must hutsam mit dem Stack umgehen da er dir ansonsten wegcrasht.In den midfunction hook sollte man auch sonst asm x86 fortführen, womit sich auch eig. so gut wie alles machen läst und wenn du wirklich vc++/c++ weiter nutzen möchtest musste die flags und den stack speichern und am ende des hooks wieder restoren.
06/11/2015 14:59 Padmak#3
Ich glaube nicht dass er von einem Midfunction-Hook spricht, sondern eher von einem normalen, am Anfang der Funktion.

Er hat schon recht, es kann sein dass IDA die falsche Funktionssignatur anzeigt, allerdings ist das nur der Fall wenn der Hook auch crasht wenn du in der Funktion nichts machst, außer zu returnen.
Kannst du mal deinen Code zeigen? Dann lässt sich einfacher helfen

Padmak
06/11/2015 15:04 Terrat#4
Quote:
Originally Posted by Padmak View Post
Ich glaube nicht dass er von einem Midfunction-Hook spricht, sondern eher von einem normalen, am Anfang der Funktion.

Er hat schon recht, es kann sein dass IDA die falsche Funktionssignatur anzeigt, allerdings ist das nur der Fall wenn der Hook auch crasht wenn du in der Funktion nichts machst, außer zu returnen.
Kannst du mal deinen Code zeigen? Dann lässt sich einfacher helfen

Padmak
Kein Programm ist perfekt außer der Windows Movie Maker ° _° :rtfm:
06/11/2015 22:28 Slade100#5
Quote:
Originally Posted by Terrat View Post
Kein Programm ist perfekt außer der Windows Movie Maker ° _° :rtfm:
danke schonmal für die antworten. hier die meine funktion
Code:
DWORD func_add = 0x006439E0;
DWORD func_back = func_add + 0x06;
int(__stdcall *OnMapClick)(float, int, int, char, int, int, int);
int __declspec(naked) myfunction(float floatA, int intA, int intB, char charA, int intC,int intD, int intE){

	__asm
	{
		push    ebp // func_add, wenn der hook noch nicht gesetzt ist
		mov     ebp, esp
		sub     esp, 48h
	}
	printf("hey");//das hier alleine verursacht schon den crash :S
	


	__asm {jmp func_back}
}
also in der main schreibe ich an der func_add ein jmp zu meiner function, dann kommt der asm teil der aus der funktion rausgeschrieben ist und dann kommen meine funktionen und dann der jmp back.
die funktion hat aufjedenfall etwas mit dem clicken in einem game zutun, die wird immer aufgerufen wenn ich iwo hinclicke um hinzulaufen.

crashen tut es nur wenn ich nicht auf den boden clicke, also wenn ich auf ein anderen player/npc/monster klicke dann crasht es :S wenn ich auf normalen boden clicke um hinzulaufen, dann läufts perfekt, echt komig

hier der ida auszug
was ich hier komig fand, war das die funktion 7 args oben hat, aber unten im stack iwie nur 6 sind, aber ich bin gerade noch in der anfangsphase bei asm, daher versteh ich solche funktionen auch leider immer nur bis zu einem gewissen teil, :S
Code:
text:006439E0 ; int __stdcall sub_6439E0(float, int, int, char, int, int, int)
.text:006439E0 sub_6439E0      proc near               ; CODE XREF: sub_5DFCB0+4Bp
.text:006439E0                                         ; sub_5DFCB0+2D4p ...
.text:006439E0
.text:006439E0 var_48          = dword ptr -48h
.text:006439E0 var_41          = byte ptr -41h
.text:006439E0 var_40          = dword ptr -40h
.text:006439E0 var_3C          = dword ptr -3Ch
.text:006439E0 var_38          = byte ptr -38h
.text:006439E0 var_34          = dword ptr -34h
.text:006439E0 var_2D          = byte ptr -2Dh
.text:006439E0 var_2C          = dword ptr -2Ch
.text:006439E0 var_28          = dword ptr -28h
.text:006439E0 var_24          = dword ptr -24h
.text:006439E0 arg_0           = dword ptr  8
.text:006439E0 arg_4           = dword ptr  0Ch
.text:006439E0 arg_8           = dword ptr  10h
.text:006439E0 arg_C           = byte ptr  14h
.text:006439E0 arg_10          = dword ptr  18h
.text:006439E0 arg_14          = dword ptr  1Ch
.text:006439E0
.text:006439E0                 push    ebp
.text:006439E1                 mov     ebp, esp
.text:006439E3                 sub     esp, 48h
.text:006439E6                 mov     [ebp+var_24], ecx
.text:006439E9                 mov     eax, [ebp+arg_4]
.text:006439EC                 mov     [ebp+var_28], eax
.text:006439EF                 mov     ecx, [ebp+var_28]
.text:006439F2                 inc     ecx
.text:006439F3                 mov     [ebp+var_2C], ecx
.text:006439F6
.text:006439F6 loc_6439F6:                             ; CODE XREF: sub_6439E0+25j
.text:006439F6                 mov     edx, [ebp+var_28]
.text:006439F9                 mov     al, [edx]
.text:006439FB                 mov     [ebp+var_2D], al
.text:006439FE                 inc     [ebp+var_28]
.text:00643A01                 cmp     [ebp+var_2D], 0
.text:00643A05                 jnz     short loc_6439F6
.text:00643A07                 mov     ecx, [ebp+var_28]
.text:00643A0A                 sub     ecx, [ebp+var_2C]
.text:00643A0D                 mov     [ebp+var_34], ecx
.text:00643A10                 jnz     short loc_643A17
.text:00643A12                 jmp     loc_643C0C
.text:00643A17 ; ---------------------------------------------------------------------------
.text:00643A17
.text:00643A17 loc_643A17:                             ; CODE XREF: sub_6439E0+30j
.text:00643A17                 mov     edx, [ebp+var_24]
.text:00643A1A                 movzx   eax, byte ptr [edx+0C0h]
.text:00643A21                 cmp     eax, 0FFh
.text:00643A26                 jnz     short loc_643A51
.text:00643A28                 movzx   ecx, [ebp+arg_C]
.text:00643A2C                 cmp     ecx, 0FFh
.text:00643A32                 jnz     short loc_643A51
.text:00643A34                 mov     edx, [ebp+var_24]
.text:00643A37                 mov     eax, [ebp+arg_10]
.text:00643A3A                 mov     [edx+0BCh], eax
.text:00643A40                 mov     ecx, [ebp+var_24]
.text:00643A43                 mov     dl, [ebp+arg_C]
.text:00643A46                 mov     [ecx+0C0h], dl
.text:00643A4C                 jmp     loc_643C0C
.text:00643A51 ; ---------------------------------------------------------------------------
.text:00643A51
.text:00643A51 loc_643A51:                             ; CODE XREF: sub_6439E0+46j
.text:00643A51                                         ; sub_6439E0+52j
.text:00643A51                 mov     eax, [ebp+var_24]
.text:00643A54                 cmp     dword ptr [eax+0ECh], 0
.text:00643A5B                 jz      short loc_643A88
.text:00643A5D                 mov     ecx, [ebp+var_24]
.text:00643A60                 mov     edx, [ecx+0BCh]
.text:00643A66                 cmp     edx, [ebp+arg_10]
.text:00643A69                 jnz     short loc_643A88
.text:00643A6B                 mov     eax, [ebp+var_24]
.text:00643A6E                 mov     ecx, [eax+0E4h]
.text:00643A74                 fld     [ebp+arg_0]
.text:00643A77                 fld     dword ptr [ecx+5Ch]
.text:00643A7A                 fucompp
.text:00643A7C                 fnstsw  ax
.text:00643A7E                 test    ah, 44h
.text:00643A81                 jp      short loc_643A88
.text:00643A83                 jmp     loc_643C0C
.text:00643A88 ; ---------------------------------------------------------------------------
.text:00643A88
.text:00643A88 loc_643A88:                             ; CODE XREF: sub_6439E0+7Bj
.text:00643A88                                         ; sub_6439E0+89j ...
.text:00643A88                 mov     edx, [ebp+var_24]
.text:00643A8B                 mov     eax, [ebp+arg_10]
.text:00643A8E                 mov     [edx+0BCh], eax
.text:00643A94                 mov     ecx, [ebp+var_24]
.text:00643A97                 mov     dl, [ebp+arg_C]
.text:00643A9A                 mov     [ecx+0C0h], dl
.text:00643AA0                 mov     eax, [ebp+var_24]
.text:00643AA3                 mov     ecx, [ebp+arg_8]
.text:00643AA6                 mov     [eax+0B4h], ecx
.text:00643AAC                 call    ds:GetTickCount
.text:00643AB2                 mov     edx, [ebp+var_24]
.text:00643AB5                 mov     [edx+0C4h], eax
.text:00643ABB                 mov     eax, [ebp+var_24]
.text:00643ABE                 mov     cl, [eax+0C0h]
.text:00643AC4                 mov     [ebp+var_38], cl
.text:00643AC7                 cmp     [ebp+var_38], 0
.text:00643ACB                 jz      short loc_643ADB
.text:00643ACD                 cmp     [ebp+var_38], 1
.text:00643AD1                 jz      short loc_643AFA
.text:00643AD3                 cmp     [ebp+var_38], 2
.text:00643AD7                 jz      short loc_643B18
.text:00643AD9                 jmp     short loc_643B44
.text:00643ADB ; ---------------------------------------------------------------------------
.text:00643ADB
.text:00643ADB loc_643ADB:                             ; CODE XREF: sub_6439E0+EBj
.text:00643ADB                 mov     edx, [ebp+var_24]
.text:00643ADE                 mov     eax, [edx+0E4h]
.text:00643AE4                 mov     dword ptr [eax+40h], 1
.text:00643AEB                 mov     ecx, [ebp+var_24]
.text:00643AEE                 mov     dword ptr [ecx+0B8h], 0FFFFFFh
.text:00643AF8                 jmp     short loc_643B61
.text:00643AFA ; ---------------------------------------------------------------------------
.text:00643AFA
.text:00643AFA loc_643AFA:                             ; CODE XREF: sub_6439E0+F1j
.text:00643AFA                 mov     edx, [ebp+var_24]
.text:00643AFD                 mov     eax, [edx+0E4h]
.text:00643B03                 mov     dword ptr [eax+40h], 0
.text:00643B0A                 mov     ecx, [ebp+var_24]
.text:00643B0D                 mov     edx, [ebp+arg_14]
.text:00643B10                 mov     [ecx+0B8h], edx
.text:00643B16                 jmp     short loc_643B61
.text:00643B18 ; ---------------------------------------------------------------------------
.text:00643B18
.text:00643B18 loc_643B18:                             ; CODE XREF: sub_6439E0+F7j
.text:00643B18                 mov     eax, [ebp+var_24]
.text:00643B1B                 mov     dword ptr [eax+0B4h], 0FFFFFFFFh
.text:00643B25                 mov     ecx, [ebp+var_24]
.text:00643B28                 mov     edx, [ecx+0E4h]
.text:00643B2E                 mov     dword ptr [edx+40h], 1
.text:00643B35                 mov     eax, [ebp+var_24]
.text:00643B38                 mov     dword ptr [eax+0B8h], 0FFFFFFh
.text:00643B42                 jmp     short loc_643B61
.text:00643B44 ; ---------------------------------------------------------------------------
.text:00643B44
.text:00643B44 loc_643B44:                             ; CODE XREF: sub_6439E0+F9j
.text:00643B44                 mov     ecx, [ebp+var_24]
.text:00643B47                 mov     edx, [ecx+0E4h]
.text:00643B4D                 mov     dword ptr [edx+40h], 0
.text:00643B54                 mov     eax, [ebp+var_24]
.text:00643B57                 mov     dword ptr [eax+0B8h], 0FFFFFFh
.text:00643B61
.text:00643B61 loc_643B61:                             ; CODE XREF: sub_6439E0+118j
.text:00643B61                                         ; sub_6439E0+136j ...
.text:00643B61                 mov     ecx, [ebp+var_24]
.text:00643B64                 mov     edx, [ecx+0E4h]
.text:00643B6A                 mov     eax, [ebp+arg_0]
.text:00643B6D                 mov     [edx+5Ch], eax
.text:00643B70                 mov     ecx, [ebp+arg_4]
.text:00643B73                 mov     [ebp+var_3C], ecx
.text:00643B76                 mov     edx, [ebp+var_3C]
.text:00643B79                 inc     edx
.text:00643B7A                 mov     [ebp+var_40], edx
.text:00643B7D
.text:00643B7D loc_643B7D:                             ; CODE XREF: sub_6439E0+1ACj
.text:00643B7D                 mov     eax, [ebp+var_3C]
.text:00643B80                 mov     cl, [eax]
.text:00643B82                 mov     [ebp+var_41], cl
.text:00643B85                 inc     [ebp+var_3C]
.text:00643B88                 cmp     [ebp+var_41], 0
.text:00643B8C                 jnz     short loc_643B7D
.text:00643B8E                 mov     edx, [ebp+var_3C]
.text:00643B91                 sub     edx, [ebp+var_40]
.text:00643B94                 mov     [ebp+var_48], edx
.text:00643B97                 mov     eax, [ebp+var_48]
.text:00643B9A                 push    eax
.text:00643B9B                 mov     ecx, [ebp+arg_4]
.text:00643B9E                 push    ecx
.text:00643B9F                 mov     ecx, [ebp+var_24]
.text:00643BA2                 add     ecx, 0C8h
.text:00643BA8                 call    sub_40B5E0
.text:00643BAD                 push    0
.text:00643BAF                 mov     edx, [ebp+arg_10]
.text:00643BB2                 push    edx
.text:00643BB3                 call    sub_40CDC0
.text:00643BB8                 add     esp, 8
.text:00643BBB                 mov     ecx, [ebp+var_24]
.text:00643BBE                 mov     [ecx+0ECh], eax
.text:00643BC4                 mov     edx, [ebp+var_24]
.text:00643BC7                 cmp     dword ptr [edx+0ECh], 0
.text:00643BCE                 jz      short loc_643BF2
.text:00643BD0                 mov     eax, [ebp+var_24]
.text:00643BD3                 mov     ecx, [eax+0ECh]
.text:00643BD9                 mov     edx, [ebp+var_24]
.text:00643BDC                 mov     eax, [edx+0ECh]
.text:00643BE2                 mov     edx, [ecx]
.text:00643BE4                 mov     ecx, eax
.text:00643BE6                 call    dword ptr [edx+5Ch]
.text:00643BE9                 movzx   eax, al
.text:00643BEC                 test    eax, eax
.text:00643BEE                 jnz     short loc_643BF2
.text:00643BF0                 jmp     short loc_643C0C
.text:00643BF2 ; ---------------------------------------------------------------------------
.text:00643BF2
.text:00643BF2 loc_643BF2:                             ; CODE XREF: sub_6439E0+1EEj
.text:00643BF2                                         ; sub_6439E0+20Ej
.text:00643BF2                 cmp     dword_891C08, 0
.text:00643BF9                 jz      short loc_643BFD
.text:00643BFB                 jmp     short loc_643C0C
.text:00643BFD ; ---------------------------------------------------------------------------
.text:00643BFD
.text:00643BFD loc_643BFD:                             ; CODE XREF: sub_6439E0+219j
.text:00643BFD                 mov     ecx, [ebp+var_24]
.text:00643C00                 add     ecx, 14h
.text:00643C03                 push    ecx             ; lprc
.text:00643C04                 mov     ecx, [ebp+var_24]
.text:00643C07                 call    sub_410940
.text:00643C0C
.text:00643C0C loc_643C0C:                             ; CODE XREF: sub_6439E0+32j
.text:00643C0C                                         ; sub_6439E0+6Cj ...
.text:00643C0C                 mov     esp, ebp
.text:00643C0E                 pop     ebp
.text:00643C0F                 retn    1Ch
.text:00643C0F sub_6439E0      endp
06/12/2015 00:59 Padmak#6
Urgh.
Bevor du printf aufrufst, solltest du noch pushad und popad machen (vllt auch pushfd und popfd, ich mache immer beides und bin zu faul nachzusehen.)
Wieso machst du das aber von Hand? Nimm dir lieber Microsoft Detours, oder MologieDetours, damit sparst du dir das ganze naked Assembler zeugs.

Außerdem ist __declspec(naked) *nicht* das gleiche wie __stdcall, da ist vermutlich dein Crash zu finden

Padmak
06/12/2015 09:19 Jeoni#7
Das ganze ist KEIN stdcall, sondern ein thiscall. Dies kann man recht gut an 0x006439E6 sehen, wo ecx (this) gelesen wird, ohne dass es in der Funktion vorher gesetzt wird.
Dein Hook selbst ist korrekt, wenn auch, wie Padmak schon sagte, mit dem inline asm irgendwie unnötig. Aber wenn du am Ende unbedingt springen willst, meinetwegen.

Ob die Hookfunktion an der Stelle stdcall ist oder nicht, ist extrem egal, da die Funktion eh kein return (ret XX) beinhaltet, sondern lediglich einen unbedingten Sprung zurück.
Das fehlende Sichern der Register ist das, was hier vermutlich für den Crash sorgt. Insbesondere ecx wird während dem printf aller Wahrscheinlichkeit nach verändert (da Caller-Saved) ohne wiederhergestellt zu werden. Dadurch kann die Originalfunktion nach dem Rücksprung nicht richtig arbeiten, weil ihr this (ecx) irgendein Müll ist. Alle anderen Register werden entweder von printf wieder korrekt hergestellt (Callee-Saved Register) oder sind nicht zu sichern, weil der Hook eh am Anfang der Funktion ist und noch keine Caller-Saved Register von der Originalfunktion verwendet wurden. Ein Sichern des Flagregisters wird auch nicht nötig sein.
Mein Vorschlag also:
Code:
int __declspec(noreturn) __declspec(naked) __fastcall myfunction(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC,int intD, int intE){
	__asm
	{
		push    ebp // func_add, wenn der hook noch nicht gesetzt ist
		mov     ebp, esp
		sub     esp, 48h
                push   ecx
	}

	printf("hey");
	
        __asm pop ecx;
	__asm jmp func_back;
}
Durch das Deklarieren der Funktion als Fastcall, werden die ersten beiden Argumente in ecx und edx erwartet. Dadurch kriegst du das this (hier thisptr) der Funktion mit.
Trotzdem kein Fan von der inline asm Variante, wenn es nicht sein muss (und hier muss es nicht sein).
Abgesehen davon, speichere BITTE Pointer NICHT in DWORDs. Welcher Trottel ist bitte auf solchen Mist gekommen und warum kopiert das quasi jeder? Nicht einmal in der WinAPI werden irgendwo Pointer als DWORD übergeben. Ein DWORD ist eine 32 bit lange Ganzzahl ohne Vorzeichen. Sobald du solchen Code auf 64 bit ausführst, hast du 32 bit zu wenig. Sehe dauernd irgendwelche ... naja, Programmierer, die sich dann wundern, warum ihr toller Code auf 64 bit gar nicht funktioniert. Davon abgesehen impliziert ein DWORD auch irgendwie keinen Pointer. Wie man also auf derartigen Unfug kommen kann, ist mir irgendwie immernoch rätselhaft.
Mit freundlichen Grüßen
Jeoni
06/12/2015 12:44 Padmak#8
Streber ;)

Kurzer Einwurf für MSVC (wovon ich nach dem ASM-Syntax ausgehe:)
Man braucht diesen __fastcall-Hack nicht, man kann sich mit einem anderen Hack behelfen (ich hoffe der Syntax passt so, bin bisschen zu faul zum Testen gerade):
Code:
struct dummy{
static int __thiscall myfunction((float, int, int, char, int, int, int);
};
Ich finde, dass die Funktion dadurch wesentlich schöner ist, weil man keine "unnützen" Parameter hat und noch dazu keine Probleme mit this hat.
Funktioniert so aber nur unter MSVC, woanders habe ich das noch nicht zum Laufen bringen können.

POPAD/POPFD hab ich vorgeschlagen, weil er im Endeffekt in seiner Funktion wesentlich mehr machen möchte als nur ein einfaches printf, wenn er jetzt nach deiner Erklärung nur ECX sichert, schmiert es ihm dann später ab, wenn er irgendeine seiner eigenen Funktionen benutzt. (Oder Stack-Variablen einführt, was ihm ESP zerschießen dürfte, oder? Kann das jemand verifizieren/widerlegen?)

Padmak
06/12/2015 12:53 Terrat#9
Ihr seid beide streber ⊙ω⊙, aber meine Streber <3 #nohomo
06/12/2015 13:03 Slade100#10
Quote:
Dein Hook selbst ist korrekt, wenn auch, wie Padmak schon sagte, mit dem inline asm irgendwie unnötig. Aber wenn du am Ende unbedingt springen willst, meinetwegen.

Ob die Hookfunktion an der Stelle stdcall ist oder nicht, ist extrem egal, da die Funktion eh kein return (ret XX) beinhaltet, sondern lediglich einen unbedingten Sprung zurück.
Das fehlende Sichern der Register ist das, was hier vermutlich für den Crash sorgt. Insbesondere ecx wird während dem printf aller Wahrscheinlichkeit nach verändert (da Caller-Saved) ohne wiederhergestellt zu werden. Dadurch kann die Originalfunktion nach dem Rücksprung nicht richtig arbeiten, weil ihr this (ecx) irgendein Müll ist. Alle anderen Register werden entweder von printf wieder korrekt hergestellt (Callee-Saved Register) oder sind nicht zu sichern, weil der Hook eh am Anfang der Funktion ist und noch keine Caller-Saved Register von der Originalfunktion verwendet wurden. Ein Sichern des Flagregisters wird auch nicht nötig sein.
Mein Vorschlag also:
Code:
int __declspec(noreturn) __declspec(naked) __fastcall myfunction(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC,int intD, int intE){
	__asm
	{
		push    ebp // func_add, wenn der hook noch nicht gesetzt ist
		mov     ebp, esp
		sub     esp, 48h
                push   ecx
	}

	printf("hey");
	
        __asm pop ecx;
	__asm jmp func_back;
}
Durch das Deklarieren der Funktion als Fastcall, werden die ersten beiden Argumente in ecx und edx erwartet. Dadurch kriegst du das this (hier thisptr) der Funktion mit.
Trotzdem kein Fan von der inline asm Variante, wenn es nicht sein muss (und hier muss es nicht sein).
Abgesehen davon, speichere BITTE Pointer NICHT in DWORDs. Welcher Trottel ist bitte auf solchen Mist gekommen und warum kopiert das quasi jeder? Nicht einmal in der WinAPI werden irgendwo Pointer als DWORD übergeben. Ein DWORD ist eine 32 bit lange Ganzzahl ohne Vorzeichen. Sobald du solchen Code auf 64 bit ausführst, hast du 32 bit zu wenig. Sehe dauernd irgendwelche ... naja, Programmierer, die sich dann wundern, warum ihr toller Code auf 64 bit gar nicht funktioniert. Davon abgesehen impliziert ein DWORD auch irgendwie keinen Pointer. Wie man also auf derartigen Unfug kommen kann, ist mir irgendwie immernoch rätselhaft.
Mit freundlichen Grüßen
Jeoni
danke dir sehr für die Antwort , und schon hat man wieder was gelernt :)
eine frage hätte ich jedoch noch unzwar, wie sieht das aufrufen so einer funktion in der eigenen main aus? also ich habe gesehn das die adresse vom thisptr, das selbe ist wie die value vom intA, nun hatte ich versucht die funktion zu callen, erstmal so
Code:
MyOnMapClick( (void*)intA, NULL, floatA, intA, intB, charA, intC, intD, intE);
naja iwie hat mein (void*)intA 0 einfluss den thisptr in der function
Code:
	printf("ecx(this) = %p\n", thisptr);/* kommt immer was komplett anderes raus, als das wie ich es aufrufen will, auch wenn ich für intA 0 habe steht da was anderes*/
daher dachte ich mir ich ändere ecx halt in meinem asm code.
dann hab ichs so versucht
Code:
int __declspec(noreturn) __declspec(naked) __fastcall MyOnMapClick(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC, int intD, int intE){

	__asm
	{
		push    ebp
			mov     ebp, esp
			sub     esp, 48h
			push ecx
	}
	printf("ecx(this) = %p\n", thisptr);
	printf("floata = %d\n", floatA);
	printf("inta = %d\n", intA);
	printf("intb = %d\n", intB);
	printf("intc = %d\n", intC);
	printf("intd = %d\n", intD);
	printf("inte = %d\n", intE);
	printf("charA = %d\n", charA);

	__asm pop ecx
	__asm mov ecx, intC 
	__asm jmp mapclick_back
}
hab zwar nicht geprüft was für ein wert ecx nach meinem mov hatte, aber da die function nicht getan hat was sie sollte wusst ich schon das ich iwas falsch mache, sry das ich noch so schlecht drin bin und soviel frage :(
06/12/2015 14:10 Terrat#11
Quote:
Originally Posted by erfan100 View Post
danke dir sehr für die Antwort , und schon hat man wieder was gelernt :)
eine frage hätte ich jedoch noch unzwar, wie sieht das aufrufen so einer funktion in der eigenen main aus? also ich habe gesehn das die adresse vom thisptr, das selbe ist wie die value vom intA, nun hatte ich versucht die funktion zu callen, erstmal so
Code:
MyOnMapClick( (void*)intA, NULL, floatA, intA, intB, charA, intC, intD, intE);
naja iwie hat mein (void*)intA 0 einfluss den thisptr in der function
Code:
	printf("ecx(this) = %p\n", thisptr);/* kommt immer was komplett anderes raus, als das wie ich es aufrufen will, auch wenn ich für intA 0 habe steht da was anderes*/
daher dachte ich mir ich ändere ecx halt in meinem asm code.
dann hab ichs so versucht
Code:
int __declspec(noreturn) __declspec(naked) __fastcall MyOnMapClick(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC, int intD, int intE){

	__asm
	{
		push    ebp
			mov     ebp, esp
			sub     esp, 48h
			push ecx
	}
	printf("ecx(this) = %p\n", thisptr);
	printf("floata = %d\n", floatA);
	printf("inta = %d\n", intA);
	printf("intb = %d\n", intB);
	printf("intc = %d\n", intC);
	printf("intd = %d\n", intD);
	printf("inte = %d\n", intE);
	printf("charA = %d\n", charA);

	__asm pop ecx
	__asm mov ecx, intC 
	__asm jmp mapclick_back
}
hab zwar nicht geprüft was für ein wert ecx nach meinem mov hatte, aber da die function nicht getan hat was sie sollte wusst ich schon das ich iwas falsch mache, sry das ich noch so schlecht drin bin und soviel frage :(
Nutz als erstes mal eine andere printf formatierung.
Code:
	printf("floata \t| %f\n", floatA);
	printf("inta \t| %i\n", intA);
	printf("intb \t| %i\n", intB);
	printf("intc \t| %i\n", intC);
	printf("intd \t| %i\n", intD);
	printf("inte \t| %i\n", intE);
	printf("charA \t| %c\n", charA);
// %c = char , %i = int,  %, %f = float
// http://www.cplusplus.com/reference/cstdio/printf/
// \n ist eine escape sequenz
//https://msdn.microsoft.com/de-de/library/6aw8xdf2.aspx
Und um die funktion aufzurufen musst du erstmal gucken was mit dem Registern gemacht wird, falls vorher werte gesetzt wurden etc. Könntest du mir einmal sagen ob du beim ecx wirklich immer den Wert von Inta hattest und nicht die adresse ?
Hab dir das mal mit einem Code verdeutlicht:
Code:
#include <iostream>

void Output(void *thisptr)
{
	printf("ecx(this) = %p\n", thisptr);
}
int main()
{
	int Test = 11;
	// Hier wird der Wert der Adresse übergeben, 11
	Output((void*)Test);
	// Hier wird die Adresse übergeben ( bei jedem start anders )
	Output((void*)&Test);
	getchar();
	return 0;
}
Da ich eher auf klassischen C++ cast stehe:
Code:
	// Wird der Wert der Adresse übergeben, 11 (Durch den printf wird dadurch aber B, B = 11 in Hexadezimal)
	Output( reinterpret_cast<void*>(Test) );
	// Hier wird die Adresse übergeben
	Output( reinterpret_cast<void*>(&Test) );
06/12/2015 14:37 Jeoni#12
Quote:
Originally Posted by Padmak View Post
POPAD/POPFD hab ich vorgeschlagen, weil er im Endeffekt in seiner Funktion wesentlich mehr machen möchte als nur ein einfaches printf, wenn er jetzt nach deiner Erklärung nur ECX sichert, schmiert es ihm dann später ab, wenn er irgendeine seiner eigenen Funktionen benutzt. (Oder Stack-Variablen einführt, was ihm ESP zerschießen dürfte, oder? Kann das jemand verifizieren/widerlegen?)
Das Sichern der Flags ist nicht nötig. Die Zielfunktion wurde am Anfang gehookt. Nach dem Standard, an den sich die Compiler halten, sind die meisten Flags zu diesem Zeitpunkt eh unbestimmt. Und die, die einen vordefinierten Wert haben (Direction-Flag soweit ich weiß), haben diesen auch noch nach der Hookfunktion, da jeglicher Code, welche diese umsetzt am Ende auch gleich wieder zurücksetzt. Jedenfalls habe ich das bisher nicht anders gehen.
Alle Caller-Saved Register (abgesehen von ECX, welches hier ja die Sonderrolle von this einnimmt) müssen ebenfalls nicht gesichert werden (wie es der Name auch schon impliziert, in dem Fall ebenfalls korrekt). Die Funktion, welche die Zielfunktion aufruft, muss damit rechnen, dass diese Register nach dem Call der Zielfunktion zerstört sind (und muss die Register entsprechend selbst sichern, wenn sie diese noch braucht). Da die Register beim Aufruf keine besonderen Werte tragen und die Zielfunktion dank Hook am Funktionsbeginn die Register auch noch nicht mit Werten belegt hat, ist es egal, ob die Register ihren Wert in der Hookfunktion verlieren.
Callee-Saved Register müssen gesichert werden, sofern sie verwendet werden. Normalerweise muss man sich nicht kümmern, wenn man quasi-standardisierte Hooks benutzt. Mit diesem inline asm Zeug und den compilergenerierten Code dazwischen, wird es aber durchaus sinnvoll sein, diese zu sichern. Wobei simple Funktionsaufrufe (bspw. printf) eigentlich kein Callee-Saved Register ändern sollten, weil die Unterfunktion selbst das Callee-Saved Register natürlich selbst speichert und wiederherstellt und der Aufruf (also das Ablegen der Argumente auf dem Stack, das Call und das Säubern des Stacks) keine Callee-Saved Register benutzt, soweit ich weiß. Wobei diese Entscheidung eigentlich auch wieder Compilersache ist.

Nein, Stack-Variablen zerschießen ihn nicht den Stack, da der Compiler in einer declspec(naked) Funktion nicht für das Allokieren von Speicher auf dem Stack (in der Regel durch "sub esp, XX") zuständig ist. Ferner wird der Compiler sowieso keine lokalen Variablen zulassen, sofern er nicht sieht, dass entsprechend Platz auf dem Stack geschaffen wurde. Das sieht er meines Wissens nach, wenn man "sub esp, __LOCAL_SIZE" in den Prolog schreibt. Entsprechend muss man den Speicher aber am Ende auch wieder freigeben (bspw. mit add oder "mov esp, ebp" wenn man mit Framepointern arbeitet).

Quote:
Originally Posted by Terrat View Post
Und um die funktion aufzurufen musst du erstmal gucken was mit dem Registern gemacht wird, falls vorher werte gesetzt wurden etc. Könntest du mir einmal sagen ob du beim ecx wirklich immer den Wert von Inta hattest und nicht die adresse ?
this wird sicherlich nicht die Adresse eines Arguments auf dem Stack sein :D

Quote:
Originally Posted by Terrat View Post
Code:
void Output(void *thisptr)
{
	printf("ecx(this) = %p\n", thisptr);
}
Wenn du schon, wie du sagst, auf C++ stehst, kann man es auch gleich so machen und sich die Casts ganz sparen:
Code:
template<typename T>
void Output(T thisptr)
{
  printf("ecx(this) = %p\n", thisptr);
}
Da wäre es aber vermutlich eh besser einfach zweimal printf zu schreiben, statt die Funktion zu nutzen :D
Der Cast von "&Test" (einem int*) auf ein void* ist btw. unnötig, weil ein typisierter Zeiger (hier int*) auch ein (untypisierter) Zeiger (void*) ist. Der Cast dort geht implizit und das ist an der Stelle meiner Meinung nach auch vollkommen in Ordnung.

Quote:
Originally Posted by erfan100 View Post
naja iwie hat mein (void*)intA 0 einfluss den thisptr in der function
Code:
	printf("ecx(this) = %p\n", thisptr);/* kommt immer was komplett anderes raus, als das wie ich es aufrufen will, auch wenn ich für intA 0 habe steht da was anderes*/
Ich rate dazu entweder die Funktion aussschließlich in asm zu schreiben oder ausschließlich in C/C++, da du dank declspec(naked) auf Register achten musst, aber dennoch Code vom Compiler generieren lässt, auf welchen du quasi keinen Einfluss hast. Oft wird eine kleine Stub in asm geschrieben, die alles Nötige an eine abstraktere C/C++-Funktion weiterreicht und bei Bedarf Register und Flags sichert und wiederherstellt. Das sieht man häufiger bei Midfunction-Hooks. In dem Fall braucht man eigentlich gar kein asm, da reicht ein "Standard"-Hook für den Funktionsanfang doch komplett aus. Du machst es dir wirklich schwerer als es eigentlich ist :D

Mit freundlichen Grüßen
Jeoni
06/12/2015 14:47 Terrat#13
Ja gut, hab ich was von Tempelates erwähnt ja gut hab ich nicht aber ja gut
06/12/2015 17:07 Slade100#14
danke euch wirklich sehr für die hilfe habs jetzt normal mit ms detours gemacht und scheint auch gut zu klappen :),
hier wie es jetzt aus sieht,vllt ist etwas ja doch noch falsch :D
Code:
typedef int(__thiscall* tOnMapClick)(void*,float, int, int, char, int,int,int);
tOnMapClick oOnMapClick;
int  __fastcall MyOnMapClick(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC, int intD, int intE){


	printf("ecx(this) = %p      edx= %p\n", thisptr,_edx);
	printf("floata = %d\n", floatA);
	printf("inta = %d\n", intA);
	printf("intb = %d\n", intB);
	printf("intc = %d\n", intC);
	printf("intd = %d\n", intD);
	printf("inte = %d\n", intE);
	printf("charA = %d\n", charA);

	return oOnMapClick(thisptr, floatA, intA, intB, charA, intC, intD, intE);
}
06/12/2015 17:17 Jeoni#15
Quote:
Originally Posted by Terrat View Post
Ja gut, hab ich was von Tempelates erwähnt ja gut hab ich nicht aber ja gut
Oh, sorry, mein Fehler. Ich sollte weniger von mir auf Andere schließen. Ich bin ein Fan von solchen Dingen.

Quote:
Originally Posted by erfan100 View Post
danke euch wirklich sehr für die hilfe habs jetzt normal mit ms detours gemacht und scheint auch gut zu klappen :),
hier wie es jetzt aus sieht,vllt ist etwas ja doch noch falsch :D
Code:
typedef int(__thiscall* tOnMapClick)(void*,float, int, int, char, int,int,int);
tOnMapClick oOnMapClick;
int  __fastcall MyOnMapClick(void* thisptr, void* _edx, float floatA, int intA, int intB, char charA, int intC, int intD, int intE){


	printf("ecx(this) = %p      edx= %p\n", thisptr,_edx);
	printf("floata = %d\n", floatA);
	printf("inta = %d\n", intA);
	printf("intb = %d\n", intB);
	printf("intc = %d\n", intC);
	printf("intd = %d\n", intD);
	printf("inte = %d\n", intE);
	printf("charA = %d\n", charA);

	return oOnMapClick(thisptr, floatA, intA, intB, charA, intC, intD, intE);
}
Sieht schon viel besser aus. Floats kannste, wie Terrat schon vor ein paar Posts erwähnte, schlecht mit %d ausgeben. Für die anderen Argumente kannste %d eigentlich weiter verwenden. Ist meines Wissens nach Synonym zu %i, aber man möge mich korrigieren, wenn ich falsch liege. Habe da jetzt nicht nachgeschaut.
Den char kannste theoretisch mit %c ausgeben, wie Terrat ebenfalls erwähnte. Das macht aber nur Sinn, wenn das tatsächlich ein Asciicharakter ist, und halt keine beliebige 8 bit Zahl (für was man char ja ebenfalls verwenden kann). In letzterem Fall ist %d / %i vermutlich die sinnvollere Variante.
Mit freundlichen Grüßen
Jeoni
Page 1 of 2 1 2