Hier habe ich eine Funktion, die soll an der Adresse XY einen Wert ändern.
Der User soll in Editfelder die Adresse, den Wert und die Länge angeben.

zusammenfalten · markieren

Delphi-Quellcode:

var
  Form1: TForm1;
  ProzessName : String = 'Projekt1.exe';

implementation

{$R *.dfm}

//Funcktion
function SchreibeInAdresse( Adresse : Integer; Value: PChar; LengthValu : Byte) : Boolean;
var
  ProcessId, Write : Cardinal;
  hProcSnap: THandle;
  PE32: TProcessEntry32;
  ProzessListe : TStringList;
  Snap: THandle;
  ProcessE: TProcessEntry32;
begin
  ProzessListe := TStringList.Create;
//* Prozess bereits am laufen?
  ProzessListe.Clear;
  Snap := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  try
    ProcessE.dwSize := SizeOf(ProcessE);
    if Process32First(Snap, ProcessE) then
      Repeat
        ProzessListe.Add(ProcessE.szExeFile);
      Until not Process32Next(Snap, ProcessE)
    else
      RaiseLastOSError;
  finally
    CloseHandle(Snap);
  end;
  if ProzessListe.IndexOf(ProzessName) < 0 then
  begin
    MessageDlg('Programm nicht gestartet.', mtWarning, [mbOK], 0);
    Exit;
  end;

//* ProzessID auslesen
  hProcSnap := CreateToolHelp32SnapShot(TH32CS_SNAPPROCESS, 0);
  if hProcSnap = INVALID_HANDLE_VALUE then
    Exit;
  PE32.dwSize := SizeOf(ProcessEntry32);
  if Process32First(hProcSnap, PE32) = true then
    while Process32Next(hProcSnap, PE32) = true do
    begin
      if pos(ProzessName, pe32.szExeFile) <> 0then
        ProcessId := PE32.th32ProcessID;
    end;
  CloseHandle(hProcSnap);

//* In Adresse schreiben
  ProcessId := OpenProcess(PROCESS_ALL_ACCESS,False,ProcessId);
  WriteProcessMemory(ProcessId,Ptr( Adresse ), Value , LengthValu ,Write);
  CloseHandle(ProcessId);
end;

Aufgerufen wird das bis jetzt so:

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
    SchreibeInAdresse( StrToInt('$'+ '243AEC3C'), '#2', StrToint('1'));
end;

Habe die Werte direkt eingetragen und nicht durch Edit1, dsa kommt später, aber wie geht das nun? Das Problem liegt beim Value, aber wie kann ich das denn nun zum laufen bringen?

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
    SchreibeInAdresse( StrToInt('$'+ '243AEC3C'), PChar('#2'), StrToint('1'));
end;

Der PChar Typecast ist nicht notwendig, den macht Delphi implizit.

Und durch deinen Typecast mit einem 1-Byte grossen Wert provozierst du sogar einen falschen Cast, da du nun als PChar einen Pointer 0x00000002 bekommst anstatt einen Pointer auf die 2. Kannst du gerne nachdebuggen.
Ach, ist ja ein String von #2

@napsterxx: Sicher dass du "#2" schreiben willst und nicht vllt. einfach nur ein Byte mit dem Wert von 2?

Ja der Wert soll 2 sein und da will ich ein Byte schreiben, dachte das mache ich auch :S
aber wie geht das dann?

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  val: Byte;
begin
  val := $02;
  SchreibeInAdresse( $243AEC3C, @val, 1);
end;

und was wenn ich ein Array schreiben will? Also nicht ein Byte sondern vll 6? das ging vorher so:
#90#90#90#90#90#90

und jetzt? $90$90$90$90$90$90

????????

Und müsste ich es nicht eig so machen:
procedure TForm1.Button1Click(Sender: TObject);
var
val: Byte;
begin
val := StrToInt('$' + '02');
SchreibeInAdresse( $243AEC3C, @val, 1);
end;

Ich habe ja schließlich einen String.
und geht sowas dann: $90$90$90$90$90$90 ?

WAS willst du denn jetz in den Prozess schreiben, einen String oder ein Byte?

Das: val := StrToInt('$' + '02');
Ist das gleiche wie:
val := 2;
oder
val := $2;
(in dem Fall ist Hex 0x02 genau das gleiche wie dezimal 2)

Warum machst du einen Umweg über den String?

So geht ein Array:

markieren

Delphi-Quellcode:

//global
NopArray: Array[0..4] Byte = ($90, $90, $90, $90, $90);

procedure TForm1.Button1Click(Sender: TObject);
begin
  SchreibeInAdresse( $243AEC3C, @NopArray, 5);
end;

oder

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  test: Array[0..4] of Char;
begin
  test := #90#90#90#90#90;
  SchreibeInAdresse( $243AEC3C, @test, 5);
end;

Kommt auf das gleiche raus.

Der wert, die Adresse und länge wie viel überschrieben werden soll wird in Edits eingetippt. Die Werte der Edits möchte ich halt dann schreiben

Das Problem ist halt das Umwandeln von nem String.
Ich will meine SchreibeInAdresse Fuktion so um moddeln, dass ich nur Strings übergebe aber es noch funktioniert

Bei der Adresse geht das ja noch. Dort kannst du wie gewohnt umwandeln.

Aber im anderen Edit mit dem Wert sieht es insofern schwieriger aus, weil man undruckbare Zeichen nicht tippen kann.
Du musst also einen kleinen Parser schreiben.
Wenn wir zum Beispiel im Edit für die zu schreibenden Bytes folgendes finden:

'$90$90$90$90$90'

Und im Edit für die Länge folglich '5'. Dann muss der Parser folgendes leisten: Er geht in dreier-Schritten vorwärts (5 mal (Länge) in einer Schleife) und wandelt jeweils die 3 Zeichen immer in ein Byte um, was er in ein dynamisches Array schreibt. Die Größe des Arrays setzt du mit SetLength vorher auf die Länge 5.

================

So jetzt aber aufgepasst. Wenn du jetzt zum Beispiel nur ein Wert der Länge eines Integers schreibe willst. Dann muss was anderes im Edit stehen, als gewohnt. Sagen wir du möchtest ein DWORD schreiben. 23000 zum Beispiel. Was musst du dann machen?
Erstmal umwandeln in Hex: 0x000059D8. Dann aber noch in little Endian schreibweise, da wir jedes einzelne Byte tippen:
Also am Ende müssten wir für 23000, das ins Edit schreiben: $D8$59$00$00.

Blöd oder? Ich würde vorschlagen du implementierst verschiedene Modi in dein programm. Bei Arrays unbestimmter Länge und undruckbaren Zeichen nimmst du meinen Eingabemodus. Bei normalen Integers einen anderen. Und bei Strings mit druckbaren Zeichen, einfach den String so rauskopieren.

ALso die schleife würde ich hinbekommen
Ich hätte dann $90 sowas, aber wie wandel ich das denn bitte (es ist ja ein string) in ein ?Byte? um?