A buffer overrun has occurred in WinApiVictim.exe which has corrupted the program's internal state. Press Break to debug the program or Continue to terminate the program.

Ich habe mir das ganze mal im OllyDebugger angeschaut, hier mal ein bild das den vergleich zeigt:
http://www.pictureupload.de/originals/pictures/090308183900_Weg.JPG

Und wenn er von meiner Funktion wieder zurück springt dann hängt sich das Programm beim nächsten Call auf. Hmm.... Muss ich da die überschriebenen Bytes sichern? und wenn ja, wie gehts dann weiter?

Ich hoffe ihr könnt mir da helfen?!

Gruß Tobi.

Muss ich da die überschriebenen Bytes sichern? und wenn ja, wie gehts dann weiter?

Es sieht so aus, als ob Du hooking gar nicht verstanden hast...

Schau Dir Detours an.

Dann wundert es mich nicht...

@Jochen: Ich habe mir das Detours ja mal runter geladen gehabt aber ne richtige Doku habe ich nicht dazu gefunden, halt nur Funktionen und so, halt ohne Beschreibung.

Ist es Dir eigentlich klar, daß Du mit den manipulierten Bytes in andere Prozesse hineinpfuschst?
Bist Du Dir überhaupt im klaren, daß Du von Deinem Prozess aus NIEMALS in den Adressraum eines anderen Prozesses einsehen kannst?
Das ist der Sicherheitsmechanismus von WinNT um die Prozesse untereinander z.B. bei einem Absturz zu schützen.
(Ich gehe davon aus, Du redest hier von ganz normalen Prozessen, und nicht von Kernel- oder gar Ring 0-Funktionen)
Das sind Grundlagen, die man wissen müßte bevor man überhaupt irgendwas mit Hooks anfangen soll, die prozessübergreifend wirken.

Sowohl Martin Richter als auch Jochen Kalmbach SIND über jeden Zweifel erhaben absolut professionelle Programmierer.
Und sie haben Dir hier erklärt das das so nicht geht wie Du das beschrieben hast. Wie sollen wir Dir da noch helfen?

Speziell Du, mein Freund TObi, scheinst ein sehr hartnäckiger Typ zu sein.
Jochen hatte Dir schon mal Detours empfohlen, lese mal Deinen eigenen Beitrag von anno dazumal: http://www.c-plusplus.net/forum/viewtopic-var-t-is-206993-and-highlight-is-.html

Martin

Bist Du Dir überhaupt im klaren, daß Du von Deinem Prozess aus NIEMALS in den Adressraum eines anderen Prozesses einsehen kannst?

ReadProcessMemory

(Alles Process intern!)

*(1) Ich suche mir die Funktion die ich hooken will (MessageBoxA) aus der user32.dll und besorge mir deren Addresse

(2) Ich suche die Adresse meiner Funktion

(3) Da es meistens long jumps sind um auf Funktionen um zuleiten, werden 5Bytes benötigt, also schau ich im OllyDbg ob ich evtl. Bytes auseinander reiße oder nicht ( War nicht der Fall )

(4) Ich allociere in meiner Anwendung genug Speicher um: 1. den Sprung zu meiner Funktion im speicher / 2. die x zu sichernden Bytes / 3. den Sprung zurück zur original funktion zu machen bzw dahinter, zu speichern. Das macht am Ende 15Bytes die zu allocieren sind: 5 Sprung zur Funktion + 5 zu sichern + 5 Sprung zurück.

(5) Ich rechne alle Sprung weiten aus hin und zurück und schreibe dann alles so der reihe nach in den Speicher

(6) Nun schreibe ich von der zu hookenden Funktion ein Sprung zu diesen Speicher der alles beinhalten (4)*

Ich habe mir das alles mal Stück für Stück im Debugger angeschaut und festgestellt, das er exakt die 15Bytes sichert aber nachdem er den Jump zu meiner Funktion macht und diese ausgeführt hat springt er gleich zur Orignalen Funktion zurück ohne das er die anderen gesicherten Bytes ausführt die ihn da ja nun fehlen.

Wieso ist das so?

Gruß Tobi.

Wie sieht den exakt, der Code im Assembler aus, den Du ersetzt?
Und wie exakt ersetzt du ihn?

http://www.pictureupload.de/originals/pictures/120308174835_Unbenannt.JPG

Doch mir ich gerade da fehlt noch ein Jmp zurück, doch das ist im moment nicht das Problem.

und dann evtl. noch mal hier
http://msdn2.microsoft.com/en-us/library/ms644959.aspx

Gruß Tobi.

Genau das hatte ich geahnt, was Du hier gebastelt hast.

Warum glaubst Du, dass nach dem umbiegen und dem einfügen eines JPs hinter dem JP weitere Code ausgeführt wird?

Du machst einen JP in Deinen HOOK! Von dort einen JP (EINEN JP!!!!!) in Deinen Code. Wie soll er denn zurückkommen.

Das wäre eine Lösung:
- JP in deinen neuen Code block
- CALL in Deinen Code.
- ausführen der geischerten Bytes (auf vollständigen op-codeist zu achten. Nicht alle 5 Byte Kombinationen sind plausibel
- JP zurück hinter Deinen 1. JP

PS: Ich werde Dir nicht mehr helfen...

Hier mal der Ausschnitt aus dem Debugger:

77D5050B U>- E9 F0FABC88             JMP     00920000
77D50510     833D 1C04D777 00        CMP     DWORD PTR DS:[77D7041C],0
77D50517     74 24                   JE      SHORT USER32.77D5053D
77D50519     64:A1 18000000          MOV     EAX,DWORD PTR FS:[18]
77D5051F     6A 00                   PUSH    0
77D50521     FF70 24                 PUSH    DWORD PTR DS:[EAX+24]
77D50524     68 F40AD777             PUSH    USER32.77D70AF4
77D50529     FF15 1812D177           CALL    DWORD PTR DS:[<&KERNEL32.InterlockedCompareExchange>]    ; kernel32.InterlockedCompareExchange
77D5052F     85C0                    TEST    EAX,EAX
77D50531     75 0A                   JNZ     SHORT USER32.77D5053D
77D50533     C705 F00AD777 01000000  MOV     DWORD PTR DS:[77D70AF0],1
77D5053D     6A 00                   PUSH    0
77D5053F     FF75 14                 PUSH    DWORD PTR SS:[EBP+14]
77D50542     FF75 10                 PUSH    DWORD PTR SS:[EBP+10]
77D50545     FF75 0C                 PUSH    DWORD PTR SS:[EBP+C]
77D50548     FF75 08                 PUSH    DWORD PTR SS:[EBP+8]
77D5054B     E8 2D000000             CALL    USER32.MessageBoxExA
77D50550     5D                      POP     EBP                                                      ; DivertIT.00401273
77D50551     C2 1000                 RETN    10
77D50554     90                      NOP
77D50555     90                      NOP
77D50556     90                      NOP
77D50557     90                      NOP
77D50558     90                      NOP
77D50559 U>  8BFF                    MOV     EDI,EDI
77D5055B     55                      PUSH    EBP
77D5055C     8BEC                    MOV     EBP,ESP
77D5055E     6A FF                   PUSH    -1
77D50560     FF75 18                 PUSH    DWORD PTR SS:[EBP+18]                                    ; DivertIT.00401130
77D50563     FF75 14                 PUSH    DWORD PTR SS:[EBP+14]
77D50566     FF75 10                 PUSH    DWORD PTR SS:[EBP+10]
77D50569     FF75 0C                 PUSH    DWORD PTR SS:[EBP+C]
77D5056C     FF75 08                 PUSH    DWORD PTR SS:[EBP+8]
77D5056F     E8 F1590100             CALL    USER32.MessageBoxTimeoutW
77D50574     5D                      POP     EBP                                                      ; DivertIT.00401273
77D50575     C2 1400                 RETN    14
77D50578     90                      NOP
77D50579     90                      NOP
77D5057A     90                      NOP
77D5057B     90                      NOP
77D5057C     90                      NOP
77D5057D U>  8BFF                    MOV     EDI,EDI
77D5057F     55                      PUSH    EBP
77D50580     8BEC                    MOV     EBP,ESP
77D50582     6A FF                   PUSH    -1
77D50584     FF75 18                 PUSH    DWORD PTR SS:[EBP+18]                                    ; DivertIT.00401130
77D50587     FF75 14                 PUSH    DWORD PTR SS:[EBP+14]
77D5058A     FF75 10                 PUSH    DWORD PTR SS:[EBP+10]
77D5058D     FF75 0C                 PUSH    DWORD PTR SS:[EBP+C]
77D50590     FF75 08                 PUSH    DWORD PTR SS:[EBP+8]
77D50593     E8 505A0100             CALL    USER32.MessageBoxTimeoutA
77D50598     5D                      POP     EBP                                                      ; DivertIT.00401273
77D50599     C2 1400                 RETN    14

Also Zeile 1 ist der Sprung zu meiner Codestelle. dann nach lande ich zurück in Zeile 2, und dann wird noch mal MessageBoxA aufgerufen? Die stelle ist dann aber nich gehookt, das verstehe ich nicht ganz?

EDIT:
Ich habe mir mal dein code angesehen und eigentlicch machst du das selbe wie ich nur das ich statt alles mit _asm zu schreiben mit WriteProcessMemory() gearbeitet habe, dass ist doch eigentlich nicht weiter schlimm oder?

Also Zeile 1 ist der Sprung zu meiner Codestelle. dann nach lande ich zurück in Zeile 2, und dann wird noch mal MessageBoxA aufgerufen?

Nicht "noch mal" sondern "immer noch".

Die Funktion MessageBoxA ist simpel gesagt eine Adresse, die in Zeile 1 anfängt !!! (und bis incl. Zeile 19 geht).

EDIT:
Müsste ich evtl. dann für jeden Funktion die ich evtl. hooken will im Debugger schaun wie groß die ist? und dann x Bytes dahinter springen? bzw zum return der funktion?