Dynamisches Array erweitern

[sILeNt heLLsCrEAm]

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:

Delphi-Quellcode:

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:

Delphi-Quellcode:

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

[KodeZwerg]

Delphi-Quellcode:

type
  TDynByte: array of Byte;

function MakeArr(const ALength: Int64): TDynByte;
begin
  SetLength(Result, ALength);
  FillChar(Result, #0);
end;

Nurmal hier so getippst, meinst du so etwas?

[Uwe Raabe]

Das FillChar kannst du dir sparen: System.SetLength

Zitat:

Existing elements in the array are preserved and newly allocated space is set to 0 or nil.

[himitsu]

Zitat:

Delphi-Quellcode:

FillChar(Result, #0);

Abgesehn, dass hier die Angabe der Größe fehlt,
würde so die Variable, aber nicht der Array-Inhalt überschrieben.


Da in den Beispielen da oben irgendwie überall was fehlt.

* was / wo ist "Wert" im Ersten?

* und "NopsCC" ist das dynamische Array?
Wenn ja, dann ist SizeOf falsch, da das die Größe des internen Array-Zeigers ist und nicht die Größe eines Feldes.

[sILeNt heLLsCrEAm]

Schonmal Danke für eure Antworten...

In meinem Beispiel/Source ist derzeit NopsCC ein statisches Array of Byte und sieht folgendermaßen aus:

Delphi-Quellcode:

NopsCC: array [0..0] of byte = ($90);

Ich hab mir die Ganze Sache über Nacht nochmal durch den Kopf gehen gehen lassen. Und die logischste oder beste Methode ist wohl die das ich den berechneten Jump in ein dynamisches Array konvertieren und an dieses Array wiederum die entsprechende Anzahl an Nops Anhänge... Quasi nach folgendem Schema...

Delphi-Quellcode:

CalculatedJMP = $E95F3C4412
ConvertedJMP: array [0...4] of byte ($E9, $5F, $3C, $44, $12)

Und da wiederum halt die Anzahl an Nops (No Operations) anfügen. Und dann wird das komplette Array, welches ja prinzipiell immer eine Mindestlänge von 5 Bytes hat, der API WriteProcess übergeben und so komplett geschrieben...
Vielleicht kann mir da einer einen Tipp geben wie man das bewerkstelligt Integer in ein dynamisches Array zu wandeln und eben weitere Zeichen/Ziffern/Zahlen anzufügen...

Gruß
sILeNt

[Blup]

Ich würde so vorgehen:

Delphi-Quellcode:

procedure WriteJump(var APos; ACommand: Byte; AAdress: Cardinal);
begin
  PByte(@APos)[0] := ACommand;
  PByte(@APos)[1] := Byte(AAdress shr 24);
  PByte(@APos)[2] := Byte(AAdress shr 16);
  PByte(@APos)[3] := Byte(AAdress shr  8);
  PByte(@APos)[4] := Byte(AAdress       );
end;

var
  Buffer: TBytes;
const
  NOP: Byte = $90;
  JMP: Byte = $E9;
begin
  {Speicherbereich im lokalen Adressraum anlegen}
  SetLength(Buffer, 100);
  {komplett mit NOP füllen}
  FillChar(Buffer[0], Length(Buffer), NOP);
  {Jump eintragen}
  WriteJump(Buffer[0], JMP, $5F3C4412);
  {in den Zielbereich des anderen Prozess kopieren}
  WriteProcessMemory(ProcOpen, Pointer(Adresse), @Buffer[0], Length(Buffer), Wert);
end;