WriteProcessMemory/dealloc fragen

[k4ni]

Hey leute,

also ich arbeite seit vorgestern an einem trainer.
Hier erstmal der code worum es sich handelt damit ihr es besser versteht

Delphi-Quellcode:

if GMZoritaVAC.Checked = true
then
begin
// Allocating for CSEAX X
  lulz := VirtualAllocEx(HandleWindow, nil, 128, MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE);
// Writing on allocated memory CSEAX X
buf := integer(lulz);
ShowMessage(IntToStr(buf));
  WriteProcessMemory(HandleWindow, lulz, @ZoritaAllc1, 5, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+5), @ZoritaAllc2, 1, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+6), @ZoritaAllc3, 6, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+12), @ZoritaAllc4, 1, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+13), @ZoritaAllc5, 6, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+19), @ZoritaAllc6, 2, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+21), @ZoritaAllc7, 3, Write);
  WriteProcessMemory(HandleWindow, ptr(integer(lulz)+24), @ZoritaAllc8, 1, Write);
// Writing the call
  WriteProcessMemory(HandleWindow, ptr($006DF140), [free], 2, Write);
  CloseHandle(HandleWindow);
end
else
  begin
    VirtualFreeEx(HandleWindow, lulz, 0, MEM_RELEASE);
    CloseHandle(HandleWindow);
  end;

Jetzt hab ich folgende probleme:
1. Das allocaten mit VirtualAllocEx allocated zu viel, ich will nur 128 bytes aber der macht mir 4kb oder so
2. Das deallocate (VirtualFreeEx) funktionier nicht. Aber ich kann keinen fehler sehen
3. Am ende bei "Writing the call" da muss ich auf die addresse $006DF140 schreiben "call "+Die eben allocated memory. Doch wie?

danke im vorraus..

[Apollonius]

Der erste Punkt lässt sich nicht ändern. Die Virtual-Funktion arbeiten immer mit ganzen Pages, die bei Windows üblicherweise 4 Kilobytes groß sind.
Für den zweiten Punkt solltest du dir noch mal dein Programm anschauen: Du rufst nämlich VirtualFreeEx genau dann auf, wenn du VirtualAllocEx nicht aufgerufen hast. Was soll das?
Und für das dritte solltest du dir nochmal überlegen, was du eigentlich willst. Das kann ich deinem Text nämlich nicht entnehmen. Und du musst dir anschauen, wie Call codiert wird und wie dabei die Adresse, an die gesprungen werden soll, geschrieben wird.

[k4ni]

Danke für die schnelle antwort.

Also zum 2. punkt: Also das ist ne checkbox der die das macht, man mus ja die checkbox ersteinmal anticken bevor man sie wieder wegticken kann. Also beim ersten mal anticken = allocate und des ganze zeug. dann kann man ja erst den hacken wegmachen. d.H wenn man den hacken wegmacht hat dar ja schon allocated. Also tut es dann deallocaten.

zum 3. punkt
Der allocated die memory ja immer wo anderst, also kann ich ja keinen festen array bestimmen oder?

[Apollonius]

Keinen festen was? Du hast doch die Adresse, das ist doch gerade lulz. Sorry, aber ein bisschen solltest du dir auch anschauen, was die Funktionen zurückgeben.

Ist lulz eigentlich global oder lokal?

[k4ni]

Jap, nur ich weis nicht wie ich das machen soll

Code:

buf := 'call 'ptr(lulz);
  WriteProcessMemory(HandleWindow, ptr($006DF140), buf, 2, Write);

Geht natürlich nicht. Ich müsste den code fuer "call" holen. aber auch dann wüsste ich nicht wie.
Hilfe bitte.

PS: irgend ne idee wegen dem dealloc dings?

lulz = lokal

[Apollonius]

Wenn lulz lokal ist, wie soll das dann funktionieren? Wenn der Haken in der Checkbox entfernt wird, wird das Ereignis aufgerufen, und in lokalen Variablen steht nunmal am Anfang Müll! Also global machen, damit der Pointer erhalten wird.

Die Frage mit den Opcodes wird hier gerade geklärt.

[DP-Maintenance]

Dieses Thema wurde von "Matze" von "Programmieren allgemein" nach "Windows API / MS.NET Framework API" verschoben.
Delphi-Frage

[k4ni]

Also das mit den opcodes versteh ich schon, ich mach das immer mit arrays.
also z.B:
Globaler wert:

Delphi-Quellcode:

 ZoritaAllc1:  Array [0..15] of Byte =($A1, $98, $C8, $80, $00, $50, $8B, $80, $40, $06, $00, $00, $58, $8B, $80, $48);

Und reinschreiben:

Delphi-Quellcode:

  WriteProcessMemory(HandleWindow, lulz, @ZoritaAllc1, 5, Write);

Aber der allocated die memory ja nicht immer auf der gleichen addresse also kann ich ja nicht das hier machen:

globaler wert (der array):

Delphi-Quellcode:

 ZoritaOn1:  Array [0..15] of Byte =($E8, $22, $34, $00, $00, $59, $85, $C0, $75, $08, $6A, $1C, $E8, $C3, $00, $00);

das wäre dann z.B "call 007493c6" (die addresse im call ist zufalls-auswahl) aber ich möchte einen array erstellen in dem "call lulz" also damit der den call auf lulz also auf die eben ge allocatedte memory macht.
Wie soll ich das machen?

[Apollonius]

Ich verstehe dein Problem nicht. Du schreibst den Opcode für Call, dann schreibst du die Adresse. Fertig. Und du solltest dich nicht auf Arrays festlegen. Du brauchst irgendeinen Puffer. Du kannst auch den Inhalt einer Integer-Variablen in den fremden Prozess schreiben.

[k4ni]

Also ich zeig dir mal den AA script des codes:

Code:

[Enable]
alloc(CSX,128)
alloc(CSY,128)
alloc(VACRange,4)
registerSymbol(VACRange)

VACRange:
dd 1E

CSX:
mov eax, [80c898]
push eax
mov eax, [eax+640]
pop eax
mov eax, [eax+648]
mov [ebx],eax
mov edi,[ebp+10]
ret

CSY:
mov eax, [80c898]
push eax
mov eax, [eax+644]
add eax,[VACRange]
pop eax
mov eax, [eax+64C]
mov [edi],eax
mov ebx,[ebp+14]
ret

006DF140:
call CSX

006DF1A5:
call CSY

[Disable]
006DF140:
mov [ebx],eax
mov edi,[ebp+10]

006DF1A5:
mov [edi],eax
mov ebx,[ebp+14]

dealloc(CSX)
dealloc(CSY)
dealloc(VACRange)
unregisterSymbol(VACRange)

Wie du siehst allocated er erst die memory (name=CSX) dann schreibt er darauf und dann bei der addresse $006DF140 macht er das

Code:

006DF140:
call CSX

Ich hoffe jetzt hast du es verstanden :)
doch wie kann ich genau das in delphi machen?

[Apollonius]

Ich verstehe weniger als vorher. Du versuchst, in ein Programm eine Call...-Anweisung einzufügen, richtig? Dann suchst du dir erstmal den Opcode von Call raus und schaust, ob die Adresse relativ oder absolut erwartet wird.

[k4ni]

also "e8" wäre call. Doch da ist wieder mein problem, wie kann ich den pointer (also lulz) in einen array (of byte) umwandeln und ablegen?

[Apollonius]

WOZU BRAUCHST DU DAS? Du kannst den Pointer auch direkt schreiben! Mal im Ernst, schau dir einfach mal die Parameter von WriteProcessMemory an.

[k4ni]

Delphi-Quellcode:

  WriteProcessMemory(HandleWindow, ptr($006DF140), ptr($e8+buf), 2, Write);

Sollte also funktionieren?
tut es aber nicht. Jetzt schreibt er irgendwie nix...hmm. Wie soll ich das machen? bsp bitte.

Edit:
buf := integer(lulz);

[Apollonius]

Du willst nicht die Summe von $E8 und der Adresse schreiben, sondern erst $E8 und dann die Adresse. Das kannst du entweder mit einem Array machen, was meiner Meinung nach allerdings unnötig kompliziert ist. Ich würde einfach zweimal WriteProcessMemory aufrufen. Und vergiss bitte nicht, dass der dritte Parameter ein Zeiger auf die Daten ist.
Irgendwie kommt es mir so vor, als hätte ich dir schon mehrfach gesagt, dass du dir mal WriteProcessMemory genauer anschauen sollst...
Auch meine wohlmeinenden Ratschläge zum Thema Call scheinst du zu ignorieren.

Zitat:

Und du musst dir anschauen, wie Call codiert wird und wie dabei die Adresse, an die gesprungen werden soll, geschrieben wird.

Zitat:

und schaust, ob die Adresse relativ oder absolut erwartet wird.

Ich gedenke nicht, diesen Hinweis nochmal zu wiederholen. Entschuldige, wenn das jetzt hart rüberkommt, aber habe keine Lust, ständig das gleiche zu schreiben.