Importierte API Funktionen erweitern...

[Boombuler]

Hi Leute,

da ich gerne mal auf Assembler-Basis Code in andere Anwendungen injecte... Sei es zum Cheat schreiben oder sonstigen Spass haben.
In Asm auf die bereits Importierten API-Funktionen zugreifen ist kein sonderliches Problem... nur jetzt mal meine Frage: gibt es eine Möglichkeit auf eine nicht Importierte Funktion einer bereits geladenen DLL zu refferenzieren?

Also sozusagen die Funktion "nachladen"?

Greetz
Boombuler

[Olli]

Natürlich, wieso nicht?! Du mußt dir nur die Exporttabelle des geladenen Moduls (der DLL also) angucken und dann den gewünschten Export raussuchen. GetProcAddress macht ja nunmal nix anderes. Das Prinzip kriegst du aber auch ohne GetProcAddress mit ein paar billigen Zeilen Code gebacken.

[Boombuler]

Ah, Ok...

Läuft super!

Merke:

Delphi bastelt sich so ne art referenz tabelle die ca so aus sieht in ASM:

Code:

004085BC   $-FF25 68779F00  JMP DWORD PTR DS:[<&user32.ReleaseDC>]   ;  user32.ReleaseDC
004085C2     8BC0           MOV EAX,EAX
004085C4   $-FF25 64779F00  JMP DWORD PTR DS:[<&user32.RemoveMenu>]  ;  user32.RemoveMenu
004085CA     8BC0           MOV EAX,EAX
004085CC   $-FF25 60779F00  JMP DWORD PTR DS:[<&user32.RemovePropA>] ;  user32.RemovePropA
004085D2     8BC0           MOV EAX,EAX
004085D4   $-FF25 5C779F00  JMP DWORD PTR DS:[<&user32.ScreenToClien>;  user32.ScreenToClient
004085DA     8BC0           MOV EAX,EAX
004085DC   $-FF25 58779F00  JMP DWORD PTR DS:[<&user32.ScrollWindow>>;  user32.ScrollWindow

Und an den entsprechenden Speicherstellen auf die die Pointer zeigen steht der gleiche wert drin den mir GetProcAddress liefert...

also sollte ich mit folgendem Code hinkommen um mir die Adresse zu suchen:

Delphi-Quellcode:

function GetAddy(ModuleName, ProcName:String):Integer;
var MH:Cardinal;
begin
  MH := LoadLibrary(PChar(ModuleName));
  result := Integer(GetProcAddress(MH,PChar(ProcName)));
  FreeLibrary(MH);
end;

Greetz
Boombuler

[Robert Marquardt]

Besser GetModuleHandle statt LoadLibrary.
Der angegebene Code funktioniert nur wenn die DLL schon gelagen ist, da sonst FreeLibrary die DLL entlaedt und ein spaeterer Aufruf der Funktion ins Leere geht.

[Olli]

Zitat:

Zitat von Boombuler

Delphi bastelt sich so ne art referenz tabelle die ca so aus sieht in ASM:

Ist nichts delphispezifisches. Müßtest du doch aber eigentlich wissen, wenn du mit Assembler rumspielst ;)

[Boombuler]

Zitat:

Zitat von Olli

Zitat:

Zitat von Boombuler

Delphi bastelt sich so ne art referenz tabelle die ca so aus sieht in ASM:

Ist nichts delphispezifisches. Müßtest du doch aber eigentlich wissen, wenn du mit Assembler rumspielst ;)

Kommt deswegen weil ich mir das heute erst angesehn hab selber mal API aufrufe zu erstellen die vorher nicht da waren sonst hab ich mir immer einen gesucht der schon da war ^^

Aber noch mal dazu ne kleine Frage am Rande:
Sind die Sprungadressen immer gleich oder unterscheiden die sich je nach Windowsstart und oder Windowsversion ?

Greetz
Boombuler

[Olli]

Zitat:

Zitat von Boombuler

Sind die Sprungadressen immer gleich oder unterscheiden die sich je nach Windowsstart und oder Windowsversion ?

Du meinst die der Funktionen einer DLL? Die sind fast immer verschieden. Mit hardcoden ist da nix ;)

[Boombuler]

Auch das noch :| habs mir ja schon fast gedacht...
Das verlängert den Asm code ungemein... wo soll ich denn so ne große CodeCave finden ^^

Greetz
Boombuler

Edit:
Hmpf bei meinem Prog ist nicht mal GetProcAddress vorhanden... das wird komisch :(

[Olli]

Zitat:

Zitat von Boombuler

Das verlängert den Asm code ungemein... wo soll ich denn so ne große CodeCave finden ^^

Hängst du halt eine Section an :lol:

Zitat:

Zitat von Boombuler

Hmpf bei meinem Prog ist nicht mal GetProcAddress vorhanden... das wird komisch :(

Weshalb? Ist in 100 Byte erledigt, denke ich mal.
Frag mal Brechi per PN. Ich denke der kann dir das noch besser erklären als ich ;)

[brechi]

1) GetProcAddress nachbauen (das ist wirklich nicht viel code)
2) GetProcAddress mit kleinem crc-namecheck nachbauen um original GetProcAddress zu bekommen
3) einfach ( :) ) die nötigen funktionen zu der ImportTabelle hinzufügen
4) sollte GetProcAddress geladen sein dieses benutzen mit CALL[ImportPointer], optional (für dll sollte es gemacht werden) adresse zur reloaction section hinzufügen

[Olli]

Zitat:

Zitat von brechi

1) GetProcAddress nachbauen (das ist wirklich nicht viel code)
[...]

LOL, na so abstrakt kann ich es auch jederzeit erklären. Genaugenommen kann ich das auch praktisch an Beispielen (zB 2.), leider nur in C/asm und mit viel Zeitinvestition ...

[brechi]

http://www.arschvoll.net/gpa.txt

für variante 2.
ich weiß net ob GetModuleHanlde für 9x ganz richtig ist, ist net von mir
und beim exception handler solltest besser über den param $C (excpeption record) und dann -> ESP wieder ESP zurücksetzen und nicht so wie in dem bsp über EBP +4 weils vorher gespeichert wurde

für die anderen vairnten muss ich noch source suchen

(@oli das war auch nur damit er vill in der zeit wo ich was suche selbst mal nach schaun kann)

[Olli]

Zitat:

Zitat von brechi

(@oli das war auch nur damit er vill in der zeit wo ich was suche selbst mal nach schaun kann)

Clever :thumb:. Soweit habe ich nur wieder nicht gedacht :stupid:

[brechi]

1. variante

Delphi-Quellcode:

function GetProcAddressX(module: integer; procname: pchar): pointer; stdcall;
var
  DataDirectory: TImageDataDirectory;
  P1: ^integer;
  P2: ^Word;
  Base, NumberOfNames, AddressOfFunctions, AddressOfNames,
  AddressOfNameOrdinals, i, Ordinal: integer;
  TempStr1, TempStr2: string;
begin
  Result := nil;
  DataDirectory := PImageNtHeaders(Cardinal(module) +
    Cardinal(PImageDosHeader(module)^._lfanew))^.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
  P1 := Pointer(module + integer(DataDirectory.VirtualAddress) + 16);
  Base := P1^;
  P1 := Pointer(module + integer(DataDirectory.VirtualAddress) + 24);
  NumberOfNames := P1^;
  P1 := Pointer(module + integer(DataDirectory.VirtualAddress) + 28);
  AddressOfFunctions := P1^;
  P1 := Pointer(module + integer(DataDirectory.VirtualAddress) + 32);
  AddressOfNames := P1^;
  P1 := Pointer(module + integer(DataDirectory.VirtualAddress) + 36);
  AddressOfNameOrdinals := P1^;
  Ordinal := 0;
  if Cardinal(procname) > $0000FFFF then
  begin
    TempStr1 := PChar(procname);
    for i := 1 to NumberOfNames do
    begin
      P1 := Pointer(module + AddressOfNames + (i - 1) * 4);
      TempStr2 := PChar(module + P1^);
      if TempStr1 = TempStr2 then
      begin
        P2 := Pointer(module + AddressOfNameOrdinals + (i - 1) * 2);
        Ordinal := P2^;
        Break;
      end;
    end;
  end else
    Ordinal := integer(procname) - Base;
  if Ordinal <> 0 then
  begin
    P1 := Pointer(module + AddressOfFunctions + Ordinal * 4);
    if (P1^ >= integer(DataDirectory.VirtualAddress)) and
       (P1^ <= integer(DataDirectory.VirtualAddress + DataDirectory.Size)) then
    begin
      TempStr1 := PChar(module + P1^);
      TempStr2 := TempStr1;
      while Pos('.', TempStr2) > 0 do
        TempStr2 := Copy(TempStr2, Pos('.', TempStr2) + 1, Length(TempStr2) - Pos('.', TempStr2));
      TempStr1 := Copy(TempStr1, 1, Length(TempStr1) - Length(TempStr2) - 1);
      Base := GetModuleHandleA(PChar(TempStr1));
      if Base = 0 then
        Base := LoadLibrary(PChar(TempStr1));
      if Base > 0 then
        Result := GetProcAddressX(Base, PChar(TempStr2));
    end else Result := Pointer(module + P1^);
  end;
end;

es wird GetModuleHandleA und Loadlibrary, falls es eine API ist die weitergeleitet wird (forwarded) das kannst du getrost bei normalen APIs wie CreateFileA etc. rausnehmen dann ist der teil auch ohne andere delphi funktionen (copy etc) ausführbar

[brechi]

vielleicht dazu noch erklären wie die import tabelle erstellt wird (meine version, das GetProcAddressX ist von jemand anderem, wo ich aber paar sache geändert habe)

Delphi-Quellcode:

  procedure CreateImportTable(dllbasep, importp: pointer); stdcall;
  type timportblock = record
                        Characteristics: cardinal;
                        TimeDateStamp: cardinal;
                        ForwarderChain: cardinal;
                        Name: pchar;
                        FirstThunk: pointer;
                      end;
       pimportblock = ^timportblock;
  var myimport: pimportblock;
      thunksread, thunkswrite: ^pointer;
      dllname: pchar;
      dllh: thandle;
      old: cardinal;
  begin
    myimport := importp;
    while (myimport^.FirstThunk <> nil) and (myimport^.Name <> nil) do
    begin
      dllname := pointer(integer(dllbasep)+integer(myimport^.name));
      dllh := LoadLibrary(dllname);
      thunksread := pointer(integer(myimport^.FirstThunk)+integer(dllbasep));
      thunkswrite := thunksread;
      if integer(myimport^.TimeDateStamp) = -1 then
        thunksread := pointer(integer(myimport^.Characteristics)+integer(dllbasep));
      while (thunksread^ <> nil) do
      begin
        if VirtualProtect(thunkswrite,4,PAGE_EXECUTE_READWRITE,old) then
        begin
          if (cardinal(thunksread^) and  $80000000 <> 0) then
            thunkswrite^ := GetProcAddress(dllh,pchar(cardinal(thunksread^) and $FFFF)) else
            thunkswrite^ := GetProcAddress(dllh,pchar(integer(dllbasep)+integer(thunksread^)+2));
          VirtualProtect(thunkswrite,4,old,old);
        end;
        inc(thunksread,1);
        inc(thunkswrite,1);
      end;
      myimport := pointer(integer(myimport)+sizeof(timportblock));
    end;
  end;

das ist von mir -> importp ist der pointer zur importtabelle, dazu kannste den ersten teil von GetProcAddressX benutzen

variante 4. muss ich woh nicht erklären
zu variante 3. (dem hinzufügen von funktionen zur importtabelle) müsste ich gleich eben selbst noch ein beispiel machen

[Boombuler]

Hi,

der ganze Delphi Code is nett gemeint und ich bin mir auch sicher das es laufen würde... bringt mir aber nur relativ wenig bis gar nix (weil geht nur asm)...
Wie füllt das Programm eingentlich zur laufzeit die Speicheradressen wo die entsprechenden Pointer drin stehen? (ziehmlich wage umschrieben aber ich hoffe ihr wisst was ich meine)
das muss doch irgendwie rekonstruierbar sein.


Danke trotzdem...
evtl kann ich das noch in ner andern Problemstellung verwenden was du da gepostet hast @@brechi

Greetz
Boombuler

[brechi]

ganz simple erklärt, das macht die kernel32.dll mit hilfe der import tabelle einer exe/dll

(etwa so wie in meinem letzten post)

du kannst die sources einfach kompilieren und dann den bytecode rauskopieren und überall einsetzen (dafür ist das gedacht gewesen)
jedenfalls methode 1 und 2 (1 mussu halt noch den teil von den weitergeleitenden imports löschen


EDIT: für dich vielleicht ganz erfreulich

WICHTIG!

schau dir einfach mal LordPE (Royal TS) von yoda an
der kann funktionen und dlls zu der importtabelle hinzufügen

WICHTIG!