Procedure umbiegen

[mr_emre_d]

Hiho liebes Community,

Ich versuche gerade seit ein paar Stunden eine Procedure (MessageBox)
so umzubiegen, dass zuerst eine von mir definierte Procedure aufgerufen
(hingejumpt) wird und anschließend wieder nach Beendigung der Procedure
zurück zu der eigentlichen Procedure gejumpt wird.

Das Problem liegt nun darin, dass die Adresse, wohin gejumpt werden soll,
nicht richtig übergeben wird :S

Delphi-Quellcode:

// umbiegen
var
  pMSG: Pointer;
  dw: DWord;
  dwOldProtect: DWord;
  Buffer: Pointer;
begin
  Buffer := Nil;
  GetMem(Buffer, 5);  // jmp = 1byte, adr = 4 byte .. 
  Byte(Buffer^) := Jmp;  //Jmp = $E9
  dw := Integer(@DOIT);  // DoIt = eigene Procedure ..
  Cardinal(Pointer(Integer(Buffer)+1)^) := dw; // $0045218c -> wird verkehrt rum reingeschrieben ..
  pMsg := GetProcAddress( GetMOduleHandle('user32.dll'), 'MessageBoxA' );
  VirtualProtect( pMsg, 5, PAGE_EXECUTE_READWRITE, dwOldProtect );
  WriteProcessMemory( OpenProcess(PROCESS_ALL_ACCESS, False, GetCurrentProcessID),
    pMsg, Buffer, 5, dw );
  VirtualProtect( pMsg, 5, dwOldProtect, dwOldProtect );
  FreeMem(Buffer, 5);

Wenn ich nach dem Aufruf von WriteProcessMemory in die CPU - Ansicht (strg+alt+c) wechsle,
sehe ich folgendes in der MessageBox Procedure:
E98C214500 jmp $776d7870

Anscheinend wurde es richtig "umgebogen" aber warum heißts bitte nun
$776d7870 und nicht $0045218C

MfG

[sirius]

Umgekehrt ist völlig richtig. Das nennt man Little Endian. Und passt schon.

Dein Fehler liegt im OpCode E9. Das ist ein relativer Sprung. Das heißt du gibst nicht die absolute Adresse sondern die relative Adresse an (also die Differenz). Rechne einfach die Differenz aus oder such den absoluten Sprung. Das waren irgendwie 2 Bytes (FF20 oder so)

Edit:
FAR JMP: "FF25"

[mr_emre_d]

hmm thx

Nun scheint die Adresse richtig eingetragen zu werden

Aber das Problem besteht immernoch

Delphi-Quellcode:

USER32.MessageBoxA:
772856DF FF258C214500     jmp dword ptr [$0045218c]  //hier müsste er doch "sauber" hinspringen oder ?
772856E5 90               nop

:S

[himitsu]

Delphi-Quellcode:

Var OldMSG: Function(hWnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; StdCall;

Function NewMSG(hWnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; StdCall;
  Var S: AnsiString;

  Begin
    S := 'Test: ' + lpCaption;
    Result := OldMSG(hWnd, lpText, PAnsiChar(S), uType);
  End;

Procedure TForm1.FormCreate(Sender: TObject);
  Var pMSG: PAnsiChar;
    dwOldProtect, dw: DWORD;
    JumpRec: packed Record
      mov:  Byte;
      addr: Pointer;
      jmp:  Word;
    End;

  Begin
    pMsg    := @MessageBoxA;
    OldMSG  := PPointer(PPointer(pMsg + 2)^)^;

    JumpRec.mov  := $B8;
    JumpRec.addr := @NewMSG;
    JumpRec.jmp  := $E0FF;

    VirtualProtect(pMsg, SizeOf(JumpRec), PAGE_EXECUTE_READWRITE, dwOldProtect);
    WriteProcessMemory(OpenProcess(PROCESS_ALL_ACCESS, False, GetCurrentProcessID),
      pMsg, @JumpRec, SizeOf(JumpRec), dw);
    VirtualProtect(pMsg, SizeOf(JumpRec), dwOldProtect, dw);

    MessageBoxA(0, 'der Text', 'Die Caption', MB_OK);
  End;

die genaue Definition für FarJump fiel mir grad nicht ein, aber so geht's auch
jupp, $E9 = NearJump ... man könnte da natürlich auch (in gewissen Grenzen) die Differenz berechnen und doch per $E9 springen

[add]
PS:

Delphi-Quellcode:

dw := Integer(@DOIT);
Cardinal(Pointer(Integer(Buffer)+1)^) := dw;

// entspricht:

PPointer(Integer(Buffer)+1)^ := @DOIT;

warum einfach, wenn's auch kompliziert geht
außerdem lag die (erste) Adresse bei +2 und nicht +1

[mr_emre_d]

zu deinem PS:

ich habe dw nur deshalb deklariert, weil ich mir die Werte anschauen wollte

Ansonsten - Dein Code funzt ... mysteriöserweise :S

PS:
ok irgendwie ists wirklich mysteriös ... Du mov'st die Adresse einfach in EAX und
springst anschließend dann zu eax - ohne Far Jmp :S

MfG

[himitsu]

Zitat von mr_emre_d:

ich habe dw nur deshalb deklariert, weil ich mir die Werte anschauen wollte

aso, na dann

[quote="mr_emre_d"]Ansonsten - Dein Code funzt ... mysteriöserweise :S
joar ... hast was anderes erwartet?

Zitat von mr_emre_d:

PS:
ok irgendwie ists wirklich mysteriös ... Du mov'st die Adresse einfach in EAX und
springst anschließend dann zu eax - ohne Far Jmp :S

mir war halt der die Definition nich eingefallen, aber Hauptsache es läuft

ich mach aber dennoch einen FarJump, nur halt über die Adresse in EAX
(zum Glück ist hier alles StdCall und EAX nicht belegt )


ja und der FAR JMP ($FF $25) hat als Parameter einen dereferenzieren Zeiger > JMP [addr]
$FF stimmt zwar, aber das $25 ist "falsch"

nja, aber zumindestens erklärt das, warum ich den Pointer zweimal dereferenziere, da ich ja den Zeiger von der Adresse ausles, welche in dem Original-Jump-Code angesprochen wird.

[mr_emre_d]

Vielen Dank euch beiden

MfG

[mr_emre_d]

[alte adresse einer function sichern]
[im importdirectory nach dieser function suchen] // per eigene Library
[anschließend entry pointer überschreiben mit der eigenen func]

[himitsu]

Zitat von mr_emre_d:

[alte adresse einer function sichern]
[im importdirectory nach dieser function suchen] // per eigene Library
[anschließend entry pointer überschreiben mit der eigenen func]

siehe #4

[mr_emre_d]

ja das ist die einfache version

warum einfach, wenn auch umständlich möglich ?



EDIT:
OK ... ich gebs zu ... ich habe deinen doppelten PPointer nicht
ganz verstanden gehabt

MfG