ReadProcessmemory-Schleife funktioniert nicht

[Karlson]

Hallo.

Ich habe hier eine Readprocessmemoryfunction, und eine dazu gehörige Schleife.

Ich hab die Schleife jetzt mal relativ weit vereinfacht, eigentlich wird des Readprocessmemory in einen Farbwert umgerechnet.
Hab jetzt hier einfach mal soweit umgeschrieben, dass die Schleife überprüft ob der Speicher einen bestimmten Wert hat. Hier der Code:

Delphi-Quellcode:

{Zunächst mal die Read-Function, diese funktioniert zu 100%, ich poste sie trotzdem mal:}

function ReadMemory(Adresse:String; Fenstername : string):string;
var fensterhandle, processhandle : THandle;
    ProcessID : Cardinal;
    wert : integer;
    b : cardinal;
    i : integer;
begin
 fensterhandle := FindWindow(nil, PChar(FensterName));
 if fensterhandle = 0 then
  begin
   showmessage('Fenster kann nicht gefunden werden');
   exit;
  end;
 GetWindowThreadProcessId(Fensterhandle, @ProcessId);
 processhandle := OpenProcess(PROCESS_ALL_ACCESS, false, ProcessId);
 readprocessmemory(processhandle, ptr(strtoint(adresse)), @wert, sizeof(wert), b);
 if b = sizeof(wert) then
  begin
   result := inttostr(puffer);
  end;
end;

{Hier meine Prozedure:}

procedure TForm1.DOLIST(Grenze1, Grenze2, Fenstertitel, Wert : String);
var i : integer;
    gA, gB : Integer;
    ZW : Integer;
    TeilerCount : Integer;
begin
 gA := strToInt(Grenze1);
 gB := strToInt(Grenze2);
 ZW := gB - gA;
 TeilerCount := round(ZW div 100);
 for i := gA to gB do
  begin
   if ReadMemory('$' +inttoHex(i,2), FensterTitel)=Wert then
    begin
     listbox1.Items.add(ColorToString(clblue);
    end;
   if (i mod 500) = 0 then
    begin
     Application.ProcessMessages;
     gauge1.Position := round(i div TeilerCount);
    end;
   end;
end;

Grenze1 beschreibt die Adresse, ab der angefangen werden soll zu suchen.
Grenze2 bis wohin gelesen werden soll.
Wobei ich für Grenze 1 immer $4000 und $7FFFFFFF einsetze. Soweit ich weiss, müsste das ungefähr den Speicherbereich eines Prozesses abdecken.
ZW ist einfach die Grösse des Zwischenraums, daraus berechne ich Teilercount, welches dann für die Gauge(Progressbar) als Modifikator dient. Aber auch das funktioniert nicht. Ich glaube ich mache da beim rechnen mit den Hexzahlen was falsch :(

Und zwar: Es werden einfach keine Werte gefunden. Wenn ich für Wert also 0 einsetze und als Grenzen $40000 bis $FFFFF angebe, so findet er garnichts...was ja nicht sein kann.

Hier ist übrigens der Link zum Crosspost im Delphi-Forum. Dort antwortet leider niemand.
http://www.delphi-forum.de/topic_Rea...cht_36184.html

[c113plpbr]

Ich hab mir den code bisher nur kurz angeschaut, und habe keinen direkten verdacht, aber ein paar wichtige Verbesserungsvorlschläge:

Wenn du schon in einem derartig großen "Stil" Speicher lesen willst, dann solltest du nicht bei jedem Aufruf von ReadMemory nochmals nach dem Fenster zu suchen, und den Prozess zu öffnen. Das kostet viel zuviel Zeit. Desweiteren sollte das Prozesshandle auf jedenfall per CloseHandle freigegeben werden.

Eine weitere Frage die sich mir stellt: Warum wandelst du den Wert zuerst in Hexadezimal (IntToHex) um, um ihn dann wieder ins Dezimalsystem (StrToInt) zu konvertieren?

Schönheitsfehler: mit {}-Klammern werden meist nur Compileranweisungen angegeben. Man sollte (* und *) bzw. // verwenden. (ist natürlich nicht unbedingt nötig)

Und wie sicher bist du dir mit deinen "Grenzen"? Mit denen wäre ich mir nämlich garnicht so sicher ...

ciao, Philipp

[The-Fox]

Jo, da bin ich wieder (habe vorhin von Karlson's PC aus gepostet).

Also zunächst mal haste recht, aber ich hab mich eigentlich noch nicht ans optimieren gemacht. Trotzdem danke für den Tip, werds mir merken!

Ich wandle zunächst mal in STring um, weil ich dieses $ brauche. Wenn ich einfach so einen Integer übergebe, dann bringt er ja einen Fehler bei z.B. FF.

[c113plpbr]

Zitat:

Zitat von The-Fox

Ich wandle zunächst mal in STring um, weil ich dieses $ brauche.

Nein, brauchst du nicht!

Zitat:

Zitat von The-Fox

Wenn ich einfach so einen Integer übergebe, dann bringt er ja einen Fehler bei z.B. FF.

Dann machst du was falsch ...

So, ich hab nen bissl gecoded:

Delphi-Quellcode:

function ReadMem(c_addr : Cardinal; h_phandle : THandle) : integer;
var
  c_bytesread : Cardinal;
begin
  if not(ReadProcessMemory(h_phandle, Pointer(c_addr), @Result, SizeOf(Result), c_bytesread) and (c_bytesread = SizeOf(Result)))then
    ShowMessage('ReadProcessMemory Fehler bei $' + IntToHex(c_addr, 8));
end;

procedure ka(c_start, c_end : Cardinal; str_wname : string);
var
  h_whandle : THandle;
  c_PID     : Cardinal;
  h_phandle : THandle;
  c_raddr  : Cardinal;
begin
  h_whandle := FindWindow(nil, PChar(str_wname));
  if(h_whandle = 0)then
  begin
    ShowMessage('FindWindow Fehler, Fenstername: ' + str_wname);
    Exit;
  end;

  GetWindowThreadProcessId(h_whandle, @c_PID);

  h_phandle := OpenProcess(PROCESS_ALL_ACCESS, false, c_PID);
  if(h_phandle = 0)then
  begin
    ShowMessage('OpenProcess Fehler, PID: ' + IntToStr(c_PID));
    Exit;
  end;

  c_raddr := c_start;
  while(c_raddr <= c_end)do
  begin
    ShowMessage('$' + IntToHex(ReadMem(c_raddr, h_phandle), 8));
    Inc(c_raddr, SizeOf(integer));
  end;

  CloseHandle(h_phandle);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  ka($00010000, $07FFFFFF, 'MineSweeper');
end;

Das sollte funktionieren, allerdings ist zu beachten, dass die wenigsten Prozesse den gesamten adressraum von $00010000 - $07FFFFFF haben, genau gesagt, weis ich nicht besonders viel darüber.
(Informier dich dazu mal über VirtualQueryEx)

Die Frage die sich mir stellt, ist, warum machst du das? Hinterher kommt ja eh nur Blau raus ... außerdem ist das relativ sinnlos, wenn du nicht weist, nach was du wo suchst ... naja ... aber das is ja deine sache ...

Vielleicht hilft dir ja ein Spieletrainer weiter ... such mal nach "Generic Game Trainer" hier im Forum, ich hab dessen Quellcode schon mind. 1x gepostet ...

ciao, Philipp

[Christian Seehase]

Moin Fox,

auf diesem Wege kannst Du Dir alle zu einem Prozess gehörenden Speicherbereiche auslesen (entsprechende Berechtigung vorausgesetzt).
Eine zusammenhängende Region umfasst immer einen Speicherbereich, bei dem der Wert für State und AllocationProtect (siehe MEMORY_BASIC_INFORMATION gleich ist.

(Das ganze ist nicht Copy&Paste fähig, nur fast ;-))

Delphi-Quellcode:

procedure GetMemoryList(const AhProcID : DWORD);

var
  hProc       : DWORD;
  pMemStart   : Pointer;
  dwRead      : DWORD;
  mbi         : MEMORY_BASIC_INFORMATION;
  pBufLocal   : Pointer;
  dwReadToBuf : DWORD;

begin
  // Prozess öffnen
  hProc := OpenProcess(PROCESS_ALL_ACCESS,true,AhProcID);
  // Lies sich nicht öffen ==> Fertig (kann bei ALL_ACCESS schon mal passieren ;-)
  if hProc = 0 then exit;
  try
    // wir beginnen bei Adresse 0
    pMemStart := nil;
    // auslesen des MBI für die Adresse in pMemStart
    dwRead    := VirtualQueryEx(hProc,pMemStart,mbi,SizeOf(mbi));
    // Solange Daten ausgelesen werden können weitermachen
    while dwRead = SizeOf(mbi) do begin
      // Speicherbereich vom Prozess belegt?
      if (mbi.State = MEM_COMMIT) then begin
         // Puffer reservieren
         pBufLocal := AllocMem(mbi.RegionSize);
         try
           // Versuchen den Speicher auszulesen
           if ReadProcessMemory(hProc,mbi.BaseAddress,pBufLocal,mbi.RegionSize,dwReadToBuf) then begin
             // Hier kann dann etwas mit dem gelesenen Speicher geschehen
           end;
         finally
           // Buffer wieder freigeben
           FreeMem(pBufLocal,mbi.RegionSize);
         end;
      end;
      // Auf nächste mögliche Speicheradresse setzen
      pMemStart := Pointer(DWORD(mbi.BaseAddress)+mbi.RegionSize);
      // und den nächsten MBI auslesen
      dwRead    := VirtualQueryEx(hProc,pMemStart,mbi,SizeOf(mbi));
    end;
  finally
    CloseHandle(hProc);
  end;
end;