C++/ASM Gewisse Stelle anspringen

C

ChiefWiggum

0
Hey HaBo =)

Habe ein kleines Problem und bekomme einfach keine (einfach) Lösung raus.
Ich will eine Adresse im Speicher anspringen(in dem Fall SetCursorPos)
Das Problem ist es jedoch, diese Adresse zur Laufzeit anzuspringen.
So hab ich eine Funktion
Code: 
BOOL callSetCursorPos(int x, int y){
int blubb = (int)GetProcAddress(LoadLibrary("user32.dll"), "SetCursorPos");
asm("call %%ebx":"+b" (blubb));
asm("leave"); //<- Zur Returnaddresse aufm Stack rücken
asm("ret");//Hier will ich den Rückgabewert direkt 'Weiterreturnen'
return 0; // <- Dummy dass der Compiler nicht meckert.
}
Olly sagt dazu
Code: 
004013EE  /$  55                          PUSH EBP
004013EF  |.  89E5                        MOV EBP,ESP
004013F1  |.  53                          PUSH EBX                                                     ;  USER32.SetCursorPos
004013F2  |.  83EC 14                     SUB ESP,14
004013F5  |.  C70424 5D204400             MOV DWORD PTR SS:[ESP],ggTest.0044205D                       ; |ASCII "user32.dll"
004013FC  |.  E8 4F3F0100                 CALL <JMP.&KERNEL32.LoadLibraryA>                            ; \LoadLibraryA
00401401  |.  83EC 04                     SUB ESP,4
00401404  |.  C74424 04 68204400          MOV DWORD PTR SS:[ESP+4],ggTest.00442068                     ; |ASCII "SetCursorPos"
0040140C  |.  890424                      MOV DWORD PTR SS:[ESP],EAX                                   ; |USER32.SetCursorPos
0040140F  |.  E8 443F0100                 CALL <JMP.&KERNEL32.GetProcAddress>                          ; \GetProcAddress
00401414  |.  83EC 08                     SUB ESP,8
00401417  |.  8945 F8                     MOV [LOCAL.2],EAX                                            ;  USER32.SetCursorPos
0040141A  |.  8B5D F8                     MOV EBX,[LOCAL.2]                                            ;  USER32.SetCursorPos
0040141D  |.  FFD3                        CALL EBX                                                     ;  USER32.SetCursorPos
0040141F  |.  895D F8                     MOV [LOCAL.2],EBX                                            ;  USER32.SetCursorPos
00401422  |.  C9                          LEAVE
00401423  \.  C3                          RETN
00401424   .  B8 00000000                 MOV EAX,0
00401429   .  8B5D FC                     MOV EBX,DWORD PTR SS:[EBP-4]
0040142C   .  C9                          LEAVE
0040142D   .  C3                          RETN
Code: 
0022FF20   77D10000  USER32.77D10000
0022FF24   77D55E4B  USER32.SetCursorPos
0022FF28   00000008
0022FF2C   77C04E2F  RETURN to msvcrt.77C04E2F from msvcrt.77C09D59
0022FF30   77D55E4B  USER32.SetCursorPos
0022FF34   7FFDE000
0022FF38  /0022FF78
0022FF3C  |0040150E  RETURN to ggTest.0040150E from ggTest.004013EE
0022FF40  |00000001  <---- [COLOR=Red][B]PARAM[/B][/COLOR]
0022FF44  |00000002  <---- [COLOR=Red][B]PARAM[/B][/COLOR]
0022FF48  |0040CD28  ggTest.0040CD28
0022FF4C  |004014F5  RETURN to ggTest.004014F5 from ggTest.0040D238
Soweit sogut, aber irgendwie hab ich noch ne menge Zeugs aufm Stack..
D.h. die Parameter sind weiter unten

Wie komme ich am leichtesten an die Parameter?
Generell scheint mir die Funktion irgendwie umständlich.. Geht es nicht viel einfacher?

Danke im voraus


P.s. Die Stackansicht ist gebreakt @ CALL EBX (0040141D)


EDIT:
Ich möchte es nicht mit typedef usw machen, da ich meine Funktion quasi noch etwas umleiten will
also die Funktion ist jetzt roh, da soll vorher noch was bearbeitet werden und dann mitten in die SetCursorPos reingesprungen werden.
 
Zuletzt bearbeitet:
Du hast die Addresse wo du hinspringen willst, also caste diesen n doch einfach auf einen Funktionszeiger (mit den Argumenten) und ruf die Funktion über den Zeiger auf.
Bzw. ich glaub man kann im inline-asm die Variablen benutzen, also mach doch einfach push x, push y vor dem call.
 
Ja das mach ich ja quasi schon mit
asm("call %%ebx":"+b" (blubb));Aber ich will z.b. auf blubb+0x3 (oder was auch immer) springen und die Befehle, die bis dahin ausgeführt wurden, durch eigene ersetzen.
EDIT:
Code: 
BOOL callSetCursorPos(int x, int y){
int blubb = (int)GetProcAddress(LoadLibrary("user32.dll"), "SetCursorPos");
blubb+=0;
asm("push %%ebx":"+b" (y));
asm("push %%ebx":"+b" (x));

asm("call %%ebx":"+b" (blubb));

asm("leave");
asm("ret");
return 0; // <- Dummy dass der Compiler nicht meckert.
}
Funktioniert soweit, aber wenn ich blubb jetzt z.b. um 7 erhöhe, müsste ich folgende Befehle ausführen:
MOV EDI,EDI
PUSH EBP
MOV ESP, EBP
PUSH 0x6F

Aber wenn ich die ja ausführe, hab ich wieder neue Daten aufm Stack..

Vorher hatte ich es so gemacht:
const unsigned char* setCursorPos = (const unsigned char*) "8B\xFF\x55\x8B\xEC.....";
typedef BOOL (WINAPI *setcursorpos_template)(int, int);
setcursorpos_template mySetCursorPos = (setcursorpos_template)setCursorPos;

Das Problem ist aber, dass der Jump ja Relativ angegebne wird, und je nachdem wo ich dann (mySetCursorPos)(bla,bla); aufrufe, springt er woanders hin.


Ist es überhaupt [einfacher] möglich, was ich habe vorhabe zu realisieren?

Theoretisch bräuchte ich auch nur einen Absoluten-Jump aber wie bekomme ich den hin?
 
Zuletzt bearbeitet:
Zugriff auf Parameter funktioniert üblicherweise über "EBP+X". Die Details hängen von der Callingconvention ab. So wie hier (stdcall zusammen mit Stackframeeinrichtung über PUSH EBP; MOV EBP,ESP):

Aufruf: stacall myFunc(param1,param2,param3);
Zugriff in der Funktion:
DWORD PTR SS:[EBP+8] <-- Param1
DWORD PTR SS:[EBP+C] <-- Param2
DWORD PTR SS:[EBP+10] <--- usw
 
Habs jetzt endlich hinbekommen =)

const char* blabla = "
Eigene Befehle...
0044305B 68 585ED577 PUSH <Addr von Funktion +X>
00443060 83C4 04 ADD ESP,4
00443063 - FF6424 FC JMP DWORD PTR SS:[ESP-4]
";

Dann wie oben beschrieben mit typedef usw.
Die "Funktion" aufgerufen, und voila es geht :] DANKE!

(Push weil dann der Jump Near Absolut ist und nicht relativ)


Danke nochmal
 
ma ne frage, warum

00443060 83C4 04 ADD ESP,4
00443063 - FF6424 FC JMP DWORD PTR SS:[ESP-4]

+ 4, und dann -4?

-- edit: ahh stack wiederherstellen weil du danach unnötig schwer pop machen kannst, ^_^'' habs gechekt, hoff ich xD
 
Zuletzt bearbeitet:
Also, aufm Stack steht ja die Rücksprungadresse(nenn ich einfach mal RSA)

Durch
Push <addr>
Schreib ich ja einen weiteren Wert auf den Stack => ESP wird um 4 vermindert (Der Stack füllt sich nach 'unten')
Dann wäre aufm Stack:
ESP--><addr>
ESP+4>RSA
Wenn ich jetzt ESP um 4 erhöhe, zeigt der ESP wieder auf die RSA (die addr bleibt aber bestehen, also steht dann dort:
ESP-4><addr>
ESP-->RSA

Nun springe ich noch an [ESP-4] => <addr>, und die RSA bleibt bestehen.


Wieso so umständlich:
Ein Jump mit absoluten Adressen funktioniert nur, wenn man an den Wert von dem Zeiger (in dem Fall ESP-4) springt.
also:
JMP [ESP-4] -> absolut zur Addresse springen, die an ESP-4 steht
Also muss ich die Adresse irgendwo speichern und dann einen Zeiger dazu finden, und ich glaub das wäre so die einfachste Methode..

Hoffentlich ist es nicht zu schwer erklärt/korrekt erklärt^^

EDIT:

Argh zu langsam xD
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben