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?