Offset bei AllocMem?

[Plastewolf]

Hallöchen miteinander,

Ich beschäftige mich seit kurzem mit der Programmierung von DLL's. Der Sinn dahinter ist diese in ein externes Programm zu Injecten und dort ein ein Offset zu patchen. Der Grund hierfür ist relativ simpel: Es wurde bei der Entwicklung ein fixer Wert innerhalb der EXE für den verfügbaren Speicher gegeben, kommt man in die Situation mehr zu benötigen, so schwappt der Speicher über und überschreibt damit teile Nachbarspeicher, was natürlich zum Absturz führt. Bisher habe ich über einen Hex Editor einfach ein paar KB hinten an der EXE angehängt und über einen Debugger dann das Offset geändert. Jetzt kam mir die Idee man könnte das ganze doch viel eleganter über eine eigene DLL lösen könnte.

Die Theorie: Prozess starten, DLL laden, DLL reserviert Speicher, DLL patcht Offset zur Laufzeit, EXE schreibt nun in den von der DLL reservierten Speicher statt des eigenen.

Zu diesem Zweck habe ich mir die Dokumentation durchgelesen und bin über den Befehl AllocMem gestoßen. Wenn ich das ganze also richtig interpretiert habe, müsste ich mit der Funktion Addr := AllocMem(1024) genau 1 KB im Arbeitsspeicher reservieren und das dazu passende Offset an den Pointer ADDR übergeben.

Wenn ich jetzt aber über Showmessage(PChar(Addr)); das Offset von dem frisch Reservierten Speicher ausgeben will, bekomme ich einfach garnichts angezeigt.


Habe ich dabei etwas vergessen? Laut Doku müsste AllocMem einen Wert zurück liefern.


Vielen Dank schonmal im vorraus.

[Bummi]

AllocMem gibt Dir einen Pointer auf den Speicherbereich zurück. Mit Showmessage(PChar(Addr)); würdest Du Dir den Inhalt des Speicherbereiches as "String" anzeigen lassen.

Delphi-Quellcode:

Const
  s: String = 'Hallo'#0;
var
  Addr: Pointer;
begin
  Addr := AllocMem(1024);
  try
    Move(s[1], Addr^, Length(s) * SizeOf(char)); // ein Stück Text in den Speicherbereich schieben
    Showmessage(PChar(Addr)); // und den Text anzeigen
    Showmessage(IntToHex(DWord(Addr), 8)); // den Wert der Adressse in HEX anzeigen
  finally
    FreeMem(Addr);
  end;
end;

[Plastewolf]

Hallo Bummi,

Vielen Dank für dein Beispiel
Also habe ich das richtig verstanden: der Pointer übergibt einen Integer, welcher erst in einen HEX Wert umgewandelt werden muss (logisch). Das DWord verwende ich um es später als String zur Weiterverarbeitung zu nutzen und die 8 gibt an das alles über der üblichen Offset größe abgeschnitten wird.

Auf diese weise könnte man den Speicher theoretisch ja dynamisch berechnen lassen, jedoch weiß ich leider nicht wieviel Speicher das Programm exakt benötigt (da die Sperre damit raus ist, ändert sich der Speicher natürlich je nach Anwendung). Aber vermutlich ist es in der heutigen Zeit kein Problem mehr wenn ich einfach permanent für die Funktion einen Bereich von 16 MB deklariere statt der üblichen ~4 MB welche im Originalzustand verwendet werden um auf Nummer sicher zu gehen.

Danke nochmals!

[Plastewolf]

Entschuldige für den Doppelpost aber darf ich nochmals eine kleine Frage einwerfen?

Ich habe mir über den Debugger die von mir benötigten Offsets herausgesucht.

Code:

Offset    | Code
0042053B    MOV EDX,OFFSET 0055E170
00420704   MOV EAX,DWORD PTR DS:[EDX*4+EAX+55E170]
0042075D    MOV DWORD PTR DS:[EAX*4+55E170],EDI
004207C9   MOV DWORD PTR DS:[EAX*4+55E170],0

Im Klartext würde das bedeuten das ich nur eine Funktion brauche, welche das originale Offset "0055E170" mit dem neuen Offset der DLL ändert (BZW die gesamte Zeile neu schreibt).
Ich hatte hierfür zuerst den Befehl "WriteProcessMemory" vorgesehen, aber nachdem ich eine Weile herum probiert habe musste ich feststellen das dieser nicht so ganz so funktioniert wie ich es gerne möchte. Das liegt wohl auch daran das er für Integer Werte gedacht ist. Über Google fand ich einen Tipp der besagte das ich einfach über die integrierte ASM Funktion von Delphi arbeiten könnte, aber auch das führt eigentlich nur zu Speicherproblemen und fehlern.

Die naheliegenste Lösung liegt in diesem Fall also in dem von dir erwähnten "MOVE" Befehl. Leider konnte ich bisher noch nicht herausfinden wie ich diesen so verwenden kann das er eine Zeile im Arbeitsspeicher eines externen Programmes ändern kann. Erschwerend kommt dazu das ich derzeit nicht weiß wie ich das Handle abfragen soll, da die DLL bereits im Prozess integriert ist.

Ich müsste Theoretisch ja nur von Delphi den String "MOV EDX,OFFSET" kopieren, dann das neue Offset anhängen und letztendlich den ganzen Wert in Hex umwandeln lassen. Dann hätte ich eine Grundlage die ich in den Speicher schreiben könnte. Oder Irre ich mich dabei?

[Zacherl]

WriteProcessMemory würde schon funktionieren, macht aber im eigenen Prozess keinen Sinn. Du kannst einfach mit Zeigern arbeiten z.b.
PByte($00401234)^ := $90; um ein NOP zu setzen. Dementsprechend kannst du auch mit PDWord($00401337)^ := $008457A4; die Adresse patchen.

Dein erster Versuch ist fehlgeschlagen, da du vermutlich die Memory Protection nicht geändert hast. Du musst bevor du irgendwas patchst mit VirtualProtect das PAGE_EXECUTE_READWRITE Flag setzen, damit du in diesem Bereich schreiben kannst.

[Plastewolf]

Wenn ich das mit dem VirtualProtect jetzt richtig gesehen habe, müsste ich den Befehl also insgesamt 4x ausführen und dabei als ersten Parameter den Offset, dann die Größe des Bereiches gefolgt von der gewünschten Operation und schlussendlich einen willkürlichen Parameter der einfach nur dafür da ist die Voreinstellung zu sichern.


Der erste Code läuft also von 42053B bis 42053F was einer größe von 4 entspricht.

Delphi-Quellcode:

Code := StrToHex('MOV EDX,OFFSET '+NewOffset);

VirtualProtect('$42053B', 4, PAGE_EXECUTE_READWRITE, OldProtect);
PByte($0042053B)^ := Code;

Edit:

Ach entschuldige bitte mein Kopf ist heute scheinbar nichtmehr so ganz auf der Höhe... PByte kann ja logisch auch nur das Byte schreiben, das dann natürlich vorraussetzt das ich die Hex werte Pärchenweise übergeben müsste...