Hallo Liebe Community,
ich habe da mal eine Frage zu den Arrays und deren Verarbeitung...
Folgendes - mit Hilfe der
API WriteProcessMemory schreibe ich Daten in einen fremden Prozess.
Und zwar sieht das beispielsweise folgendermaßen aus:
WriteCheat(CaveAddy, DatenCave, SizeOf(DatenCave));
DatenCave = Ein statisches Array of Byte welches geschrieben wird.
Die Funktion WriteCheat habe ich folgendermaßen aufgebaut:
Delphi-Quellcode:
Function WriteCheat (Adresse: Int64; ZuSchreiben: Array of Byte; WievielSchreiben: Integer): String;
Begin
WriteProcessMemory(ProcOpen, Pointer(Adresse), @ZuSchreiben[0], WievielSchreiben, Wert);
end;
Mit den statischen Arrays komme ich so auch sehr gut zurecht. Aber nun folgendes...
Damit der fremde Prozess diese Daten bzw. diesen neu geschriebenen Code auch nutzt schreibe ich natürlich einen Sprung zu du dieser DatenCave. Damit ich meinen Sourcode nicht immmer neu und umständlich anpassen muss wird dieser Sprung folgendermaßen berechnet:
WriteJMP(OriginalCodeAddy, CaveAddy, SizeOf(OriginalCode)-5);
Ich schreibe also den Sprung (in Assembler 0xE9h) gefolgt von den Bytes für die Sprungweite. Dieser absolute Jump ist dann quasi 5 Bytes groß.
Die Funktion WriteJMP habe ich folgendermaßen aufgebaut:
Delphi-Quellcode:
procedure WriteJMP (SprungVON, SprungZU : Int64; NOPsAnzahl: Byte);
var
CalcValue: Int64;
begin
CalcValue:= SprungZU - SprungVON - 5;
JMP(SprungVON, CompleteJMPCalc(CalcValue), NOPsAnzahl);
end;
Procedure JMP (Adresse: Int64; ZuSchreiben: Int64; NOPs: Byte);
var
I: Integer;
Begin
WriteProcessMemory(ProcOpen, Pointer(Adresse), @ZuSchreiben, 5, Wert);
Adresse:= Adresse+$5;
// Hier werden noch die NOP's am Ende des Jumps geschrieben
for I := 1
to NOPs
do begin
WriteProcessMemory(ProcOpen, Pointer(Adresse), @NopsCC[0], SizeOf(NopsCC), Wert);
Adresse:= Adresse+$1;
end;
end;
function CompleteJMPCalc(
const Wert: Int64): Int64;
asm
mov qword [result], 0
mov dword [result+1],eax
mov byte [result],$E9
end;
Das Ganze funktioniert soweit auch sehr gut. Aber wie man sieht wird der Jump komplett geschrieben und die Nops im Anschluss aber byteweise. Jetzt nehmen wir mal rein theoretisch an ich habe einen Originalcode von 100 Byte Größe, dann wird der Sprung zwar komplett geschrieben aber die 95 Nops (0x90h) byteweise eines nach dem anderen. Ich hoffe ihr was ich damit sagen will. In diesem Beispiel würde ich gerne das die 95 Nops ebenfalls mit einem mal komplett geschrieben würden.
Da hatte ich mir zuerst zu testzwecken den Jump in einen String zu konvertieren mit IntToHex. Diesem String dann die entsprechende Anzahl an Nops hinzuzufügen und das Ganze dann wiederum in ein Array of Byte zu konvertieren.
Nun habe ich aber etwas von dynamischen Arrays gelesen und probiere da gerade meine ersten Gehversuche.
Und sicherlich gibt es da doch bestimmt eine elegantere Methode? Ich hoffe ich konnte mein Anliegen einigermaßen verdeutlichen.
Aber natürlich stehe ich für weitere Fragen zur Verfügung...
In diesem Sinne gute Nacht und bleibt gesund
sILeNt