Byte in Speicher schreiben

[bundy]

Hi Leute

Ich bin gerade dabei einen Trainer für das Spiel Harry Potter und der Feuerkelch zu schreiben.

Das funktioniert soweit auch wunderbar.
Ich suche via TSearch die Speicheradressen und schreibe dann die Werte.

Ich setzte den Wert der Leben auf 200

Adresse | Value
$241BC08 | 200

das mach ich so

Delphi-Quellcode:

const
Address1='$241BC08';
 
procedure TForm1.setLives;
var
x:integer;
begin
  x:=cxSpinEdit1.Value;
    GetMem(buf, 1);
  buf^ := chr(x);
  WriteProcessMemory(HandleWindow, ptr(Address1), buf, NumberOfBytes, write);

end;

Bis daher funktioniert das wunderbar

Doch jetzt will ich die "Zauberbohnen" editieren.

Adresse: $24194F0

Ich will über einen SpinEdit den Wert ändern z.B 99999999 Bohnen.

Jetzt die Frage :
Wie rechne ich das den um, weil die Ganze Zahl bekomme ich ja nicht in die Adresse.
Er müsste den Rest in die nächste Adresse schreiben.

Hat jemand ne ahnung wie ich das uf die Reihe bekomme, das wenn die Zahl für das einen Byte zu gross ist er ins nächste schreibt ?



lg
Bundy



Jetzt zu meinem Problem

[jim_raynor]

Warum so kompliziert:

sollte wunderbar klappen.

Delphi-Quellcode:

var 
  x:integer; 
begin 
  x:=cxSpinEdit1.Value; 
  WriteProcessMemory(HandleWindow, ptr(Address1), x, sizeof(x), write);

[ichbins]

Ich glaube du machst einen grundlegenden Fehler.

Mit welchem Programm hast du denn die Adressen gesucht?

Bei TSearch musst du ja auswählen welcher Datentyp vorliegt. Ein Integer bei Delphi belegt z.B. immer 4 Bytes (zumindest bei 32-Bit-EXEn). Dabei enthält das letzte Byte den niedrigsten Zweierpotenwert,

Code:

00000000 00000000 00000000 00001000

heisst also z.B. 8.

Du schreibst allerdings deine 200 (Binär: 01100100) einfach ins erste Byte, so dass es dann so aussieht:

Code:

 * NEU * * ALT *   * ALT *  * ALT *
01100100 00000000 00000000 00001000

und das ergibt jetzt eine unvorstellbar grosse Zahl, nämlich:

Delphi-Quellcode:

0*2^0          ALTER WERT
0*2^1          ALTER WERT
0*2^2          ALTER WERT
1*2^3 = 8      ALTER WERT
0*2^4          ALTER WERT
...
0*2^24   //das Element dass im linken Byte als erstes kommt, also am rechtesten (*g*) steht
0*2^25
1*2^26 = 67108864 (:shock:)
0*2^27
0*2^28
1*2^29 = 536870912
1*2^30 = 1073741824
0*2^31  //das linkseste also letzte Byte

somit hat der neue Leben-Integer den Wert 1677721600 (der neue, hinzugefügte) + 8 (die Ursprüngliche Anzahl, welche nicht überschrieben wurde), also insgesammt 1677721608 und nicht 200, wie du es beabsichtigt hast. Du musst den kompletten Inhalt deiner Integer-Variable auf die nächsten 4 Bytes kopieren. Du musst aber darauf achten, dass das Leben auch evtl. ein Real-Wert sein könnte, dann musst du eben den kompletten Inhalt einer Real-Variable über die nächsten Bytes kopieren.

[Frickeldrecktuxer_TM]

Zitat:

Zitat von ichbins

Dabei enthält das letzte Byte den niedrigsten Zweierpotenwert,

Nicht auf PCs.
Die Byte-Order bei LE ist das least significant Byte links nicht rechts. Die Zahl 0x12345678 wird also zur Byte-Folge 0x78 0x56 0x34 0x12. Entsprechend sind die Bytes auch left-aligned, ein 0x1234 wird nicht zu 0x00 0x00 0x34 0x 12, sondern zu 0x34 0x12 0x00 0x00.

[bundy]

Hi danke für eure schnelle antwort

Zitat:

Zitat von jim_raynor

Warum so kompliziert:

sollte wunderbar klappen.

Delphi-Quellcode:

var 
  x:integer; 
begin 
  x:=cxSpinEdit1.Value; 
  WriteProcessMemory(HandleWindow, ptr(Address1), x, sizeof(x), write);

so gehts nicht


[Pascal Fehler] Unit1.pas(153): E2010 Inkompatible Typen: 'Pointer' und 'Integer'

auch nicht wenn ich statt x wieder buf einsetzte

jetzt steht Leben = 1

$588BEC 01 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00

jetzt leben = 200
$588BEC C8 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00

jetzt leben = 999999
$588BEC 3F 42 0F 00 02 00 00 00 00 00 00 00 00 00 00 00


oh mann , das check ich jetzt irgendwie net.

[Frickeldrecktuxer_TM]

Zitat:

Zitat von bundy

auch nicht wenn ich statt x wieder buf einsetzte

jetzt steht Leben = 1

$588BEC 01 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00

jetzt leben = 200
$588BEC C8 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00

jetzt leben = 999999
$588BEC FF 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00


oh mann , das check ich jetzt irgendwie net.

Wieso? Passt doch alles. Das Problem ist nur, daß dein buf nur 1 Byte groß ist, und Zahlen größer als 255 kriegst du da auch mit Mühe nicht rein ;-)
jim_raynors Idee ist richtig, bis auf ein kleines Detail funktioniert sie auch:

Delphi-Quellcode:

WriteProcessMemory(HandleWindow, ptr(Address1), @x, sizeof(x), write);

WPM will einen Zeiger auf die Daten haben, nicht die Daten selbst.

[bundy]

:thumb: :thumb: :thumb: :thumb: :thumb: :thumb:
Leute Ihr seit einfach GENIAL !!!!!!
:thumb: :thumb: :thumb: :thumb: :thumb: :thumb:

funktioniert :)

lg
Bundy

[jim_raynor]

Zitat:

Zitat von Frickeldrecktuxer_TM

jim_raynors Idee ist richtig, bis auf ein kleines Detail funktioniert sie auch:

Delphi-Quellcode:

WriteProcessMemory(HandleWindow, ptr(Address1), @x, sizeof(x), write);

WPM will einen Zeiger auf die Daten haben, nicht die Daten selbst.

harhar. Wusste doch, irgendwas hab ich vergessen :zwinker:.

Für den, den @ nicht gefällt kann auch Addr(x) verwenden ;)

[bundy]

Ist das auch richtig ?

Delphi-Quellcode:

 x:=cxSpinEdit2.Value;
    GetMem(buf, sizeof(x));
  buf^ := chr(x);
  WriteProcessMemory(HandleWindow, ptr(Address4), buf, sizeof(x), write);

[Dax]

Nö.

Delphi-Quellcode:

var x: Integer;
begin
  x := csSpinEdit2.Value;
  WriteProcessMemory(HandleWindow, ptr(Address4), @x, sizeof(x), write);
end;

So wärs richtig ;)

[Luckie]

Jetzt erklär mir mal bitte jemand eins: Bisher dsachte ich unter Windows NT ff kjönnte man nicht mehr so einbfach in dem Speicher anderer Anwendungen runfuschen. Warum geht das doch so einfach? Oder war mit der Aussage, dass man nicht mehr so einfach im fremden Adressraum schreiben kann ein anderer Sachverhalt gemeint? Wenn ja, welcher?

[Daniel G]

Zitat:

Zitat von Luckie

Bisher dsachte ich unter Windows NT ff kjönnte man nicht mehr so einbfach in dem Speicher anderer Anwendungen runfuschen. Warum geht das doch so einfach?

Hey Luckie,
vor ein paar Stunden hier angeschnitten:

http://www.delphipraxis.net/internal...=539290#539290

Es dreht sich alles um den virtuellen Adressraum...

[Luckie]

Ja, das ist mir klar, nur gehört der auch der virtuelle Adressraum ja auch einem fremden Prozess.

[Daniel G]

Jupp, und mit den beiden Funktionen "WriteProcessMemory" und "ReadProcessMemory" kann man darauf zugreifen, sofern man ein Handle mit PROCESS_VM_WRITE und PROCESS_VM_OPERATION zu dem Prozess bekommt. Geht von Win95 bis XP. So steht es zumindestens im PSDK.

Ich hab's allerdings noch nicht ausprobiert. Im Prinzip muss es ja auch irgendwie gehen, sonst würde ja kein Debugger funktionieren.

[Luckie]

Das muss ich mir noch mal durch den Kopf gehen lassen. Aber nicht mehr heute.

[brechi]

Wenn man ein gültiges Handle mit OpenProcess erhalten hat (und mit ensprechenden Rechten) dann kann man die Zielapplikation ohne Probleme mit Write/ReadProcessmemory ändern.
Was sich im Gegensatz zu 9x geändert hat, ist dass man nicht mehr so leicht auf den Speicher > 0x80000000 zugreifen kann. Unter 9x konnte man diesen noch ohne Probleme auslesen aber nicht modifizieren. Unter XP braucht man dazu schon speziellere Rechte :)

[Frickeldrecktuxer_TM]

Zitat:

Zitat von Luckie

Jetzt erklär mir mal bitte jemand eins: Bisher dsachte ich unter Windows NT ff kjönnte man nicht mehr so einbfach in dem Speicher anderer Anwendungen runfuschen. Warum geht das doch so einfach?

Definiere "so einfach". Der Prozess, der debuggt, benötigt immer noch das SeDebugPrivilege Privileg, und das ist ein Privileg, daß man Prozessen entziehen kann ;-) Falsch ausgedrückt: Wenn der Prozess die entsprechenden Zugriffsarten nicht erlaubt, benötigt man immer noch das SeDebugPrivilege Privileg, um die ACL zu umgehen, und das ist ein Privileg, das man Prozessen (und Usern) entziehen kann.

Anscheinend kennst du deinen eigenen Code nicht :mrgreen: Schau dir mal dein LuckieDIPS an, dort schreibst du auch ungefragt in den Explorer-Prozess ;-)

[Luckie]

Nein tue ich nicht. Ich reserviere mir Speicher im Explorer Prozess, kopiere etwas hinein und lese es aus. Ich ändere nichts im Speicher des fremden Prozesses! Das ist ein großer Unterschied.

[Frickeldrecktuxer_TM]

Zitat:

Zitat von Luckie

Das ist ein großer Unterschied.

Nicht wirklich. Du schreibst in den fremden Adressraum. Auf Page-Ebene gibt es keine weiteren Einschränkungen. Würde mich sehr wundern, wenn Windows hier eine Tabelle enlegen würden "Adresse $a bis $b ist vom geladenen Modul, hier nicht schreiben, Adresse $c bis $d ist von diesem Prozess allokiert worden, der darf hier schreiben, Adresse $e bis $f ist von jenem Prozess allokiert worden, der darf hier schreiben, usw". Unter Strich veränderst du vielleicht nicht die .data-Section des Explorer-Prozesses, aber du bearbeitest seinen Adressbereich. Und dann könntest du auch direkt die .data-Section bearbeiten. Sämtliche In-Memory-Patches und -Hacks funktionieren nicht anders.