Cod 4 Hack mit Cheat Engine und Autoit

Page 2 of 2 1 2
04/25/2010 18:42 P-a-i-n#16
ok desert naja hatte noch nie was mit autoit am hut
weil das ja c++ etwas nahkommt dachte ich funzt da auch

@fx168
und zu detour gibt es z.B ein tut hier im forum bei gamehacking tut's mußte mal schauen ;)
aber wie gesagt das wird aber nicht gehen weil es für c++ ist
und nicht für autoit
lern einfach c++ damit kannst du mehr machen ;)
04/25/2010 18:49 fx168#17
OK werds mir mal ansehen. Autoit und C++ sind sich ja teiweiße ähnlich. C++ kann ihc leider kaum. Aber Danke für den Tipp xD. Werd mal schauen ob sich das teilweiße übernehmen lässt :-)

----> Noch ne wichtige Frage warum stürtzt das Spiel fast bei jedem Memory ändern ab?
Mach ich da was falsch?

Hier zum Beispiel stürtzt es immer ab :
#include <NOmadmemory.au3>

$Priv=SetPrivilege("SeDebugPrivilege",1)
$Priv=0x38

$memory1 = _Memoryopen (ProcessExists("iw3mp.exe"))
$fog = 0x63DB0D


_Memorywrite ($fog, $memory1, "0x75, 0x20",'byte[4]')
Sleep (1000)


_memoryclose ($memory1)
04/25/2010 20:02 Akorn#18
Quote:
Originally Posted by P-a-i-n View Post
@fx168
und zu detour gibt es z.B ein tut hier im forum bei gamehacking tut's mußte mal schauen ;)
aber wie gesagt das wird aber nicht gehen weil es für c++ ist
und nicht für autoit
lern einfach c++ damit kannst du mehr machen ;)
Und das ist der grund warum das in Autoit nicht möglich ist weil man für Esp hacks hooks benutzt, man allerdings mit AutoIt nicht hooken kann.
04/28/2010 22:10 Lawliet#19
Hooken heißt eine Funktion des "Opfers" in sein eigenes Programm umleiten und diese dann nach belieben manipulieren.
05/11/2010 10:10 s4hamster#20
...
08/04/2010 18:46 lolkop#21
Quote:
Originally Posted by HardCore.1337 View Post
Bei Inline Assembler kannst du Assembler Code direkt in deine Programmiersprache (z.B. C++, Delphi...) einfügen. So zu sagen Assemblercode und der allgemeine Code vermischt. Bei AutoIt geht das aber nicht.
Quote:
Originally Posted by Akorn View Post
Und das ist der grund warum das in Autoit nicht möglich ist weil man für Esp hacks hooks benutzt, man allerdings mit AutoIt nicht hooken kann.
woher habt ihr denn diese weisheiten?
wenn man sich mit sprachen nicht auskennt, sollte man nicht so schnell mit abwertenden sprüchen daherkommen.

asm ist eine einfache sprache. man kann in jeder sprache jede andere sprache einbauen.
und da autoit in der lage ist winapis zu nutzen, ist der funktionsumfang ähnlich dem von c++.

selbstverständlich müsste man sich zunächst die benötigten asm funktionen definieren, kann jedoch mithilfe der in der kernel32.dll gegebenen funktionen leicht auch kompliziertere hacks realisieren.

dazu braucht man sich nur per VirtualAllocEx im targetprocess platz für seine eigenen funktionen schaffen.
auf diese art und weise kann man leicht funktionen in den neu geschaffenen raum umleiten und dort durch eigene erweitern/ersetzn.

auch sofortiges assemblieren vom eigenem code im targetprocess ist in sprachen die in der lage sind winapis zu nutzen kein problem. als grundlage hierfür kann man die CreateRemoteThread funktion nutzen.

ich kann also in autoit wie auch in jeder anderen sprache die in der lage ist winapis zu nutzen sowohl inline assmabling als auch codecaves in anderen processen nutzen.

habe leider cod noch nie gespielt und kann nicht darüber sagen aber hier mal ein kleines beispiel wie ich zb eine funktion aus dem perfect world client nutzen kann:
Code:
Func SelectMob($id)
	Local $pRemoteThread, $vBuffer, $loop, $result, $OPcode
	; --- save the position of the allocated memory ---
	$pRemoteMem = DllCall($kernel32, 'int', 'VirtualAllocEx', 'int', $mid, 'ptr', 0, 'int', 0x46, 'int', 0x1000, 'int', 0x40)
	; --- build up the asm code ---
	; 0046061D  A1 6C3E9F00       MOV EAX,DWORD PTR DS:[9F3E6C]
	; 00460622  57                PUSH EDI                        <---- EDI Contains Mob-ID
	; 00460623  8B48 20           MOV ECX,DWORD PTR DS:[EAX+20]
	; 00460626  81C1 EC000000     ADD ECX,0EC
	; 0046062C  E8 8F961800       CALL elementc.005E9CC0
	$OPcode &= '60'                                                           ; pushad
	$OPcode &= 'A1'&_hex($base)                                               ; mov eax, [base]
	$OPcode &= '68'&_hex($id)                                                 ; push mob-id
	$OPcode &= '8B4820'                                                       ; mov ecx, [eax+0x20]
	$OPcode &= '81C1'&_hex(0xEC)                                              ; add ecx, 0xEC
	$OPcode &= 'E8'&_hex($select_call-$pRemoteMem[0]-5-StringLen($OPcode)/2)  ; call select_call
	$OPcode &= '61'                                                           ; popad
	$OPcode &= 'C3'                                                           ; retn
	; --- enter the asm code to to a dllstruct, which can be used with WriteProcessMemory ---
	$vBuffer = DllStructCreate('byte[' & StringLen($OPcode) / 2 & ']')
	For $loop = 1 To DllStructGetSize($vBuffer)
		DllStructSetData($vBuffer, 1, Dec(StringMid($OPcode, ($loop - 1) * 2 + 1, 2)), $loop)
	Next
	; --- now letz write the code from our dllstruct ---
	DllCall($kernel32, 'int', 'WriteProcessMemory', 'int', $mid, 'int', $pRemoteMem[0], 'int', DllStructGetPtr($vBuffer), 'int', DllStructGetSize($vBuffer), 'int', 0)
	; --- now we run the asm code we've just written ---
	$hRemoteThread = DllCall($kernel32, 'int', 'CreateRemoteThread', 'int', $mid, 'int', 0, 'int', 0, 'int', $pRemoteMem[0], 'ptr', 0, 'int', 0, 'int', 0)
	; --- wait till the thread did his job ---
	Do
		$result = DllCall('kernel32.dll', 'int', 'WaitForSingleObject', 'int', $hRemoteThread[0], 'int', 50)
	Until $result[0] <> 258
	; --- close everything we've opened ---
	DllCall($kernel32, 'int', 'CloseHandle', 'int', $hRemoteThread[0])
	DllCall($kernel32, 'ptr', 'VirtualFreeEx', 'hwnd', $mid, 'int', $pRemoteMem[0], 'int', 0, 'int', 0x8000)
	Return True
EndFunc
wie man sieht ist es teilweise nicht leicht funktionen wie beispielweise calls in autoit umzusetzen, da dort der hex code nicht ohne weiteres erstellt werden kann, jedoch lässt sich mit einem gewissen hintergrundwissen über asm auch dies bewerkstelligen.

habe hier jetzt mal auf das definieren der asm funktionen verzichtet und direkt die hexcodes genutzt, was das ganze etwas unübersichtlicher macht, aber auch den code deutlich kleiner hält =)
08/04/2010 19:52 Akorn#22
Schon klar das man in jeder Sprache die die WinApi unterstützt hooken kann in den man eine funktion(die aus Maschienencode) als Opcodes in den speicher des fremden prozesses schreibt und eine funktion dan darauf umleitet.

Aber man kann keine funktion auf eine funktion umleiten die man in Autoit geschrieben hat.Die Also in Skriptcode vorliegt.

Es soll ja auch möglich sein in Autoit Inline Assembler zu benutzen.
Dadurch kann man sich schon eine eigene funkton schreiben die da in maschienencode vorliegt, und wo man dan eine andere funktion drauf umleiten kann. Aber dann ist die Eigene Funktion ja wieder in Assembler geschrieben und nicht in Autoit.
08/04/2010 20:36 lolkop#23
dir is schon klar das es inline asm genannt wird weil es asm ist?

der einzige unterschied zwischen autoit und c++ ist in diesem falle, das du dich bei c++ in den process setzen kannst, und bei autoit immer nur von aussen den process beeinflussen kannst.

das heist aber nicht das du nicht genau wie in c++ jede funktion umleiten, oder sogar den eigentlichen prozessfluss stoppen und deinen eigenen dafür einspringen lassen kannst.
der indirekte zugriff auf den prozess kann sogar in manchen situatuationen deutlich besser arbeiten als wenn man direkt im prozess sitzt.

wie auch immer... das gerücht das man in autoit kein inline asm nutzen kann ist schlichtweg falsch.
es ist vielleicht mit viel aufwand verbunden asm funktionen zu implementieren, jedoch ist es genau wie in den meisten anderen sprachen möglich.
08/04/2010 21:19 Bot_interesierter#24
Inline Assembler in einer Interpreter Sprache gibt es nicht.
Natürlich kann man sich mit jeder Sprache die Zugriff auf die Windows API hat eine schöne Code Cave oder Stub Funktionen bauen, um damit ähnliche Funktionalität zu implementieren, aber man hat immer noch den Nachteil auf IPC angewiesen zu sein.

Und damit auch klar ist was ich meine, Inline Assembler ist Assembler Code der in einer Funktion vorliegt, beim compilieren wird der Compiler diesen Code an den assembler übergeben und die daraus resultierenden Opcodes in die Funktion einbauen.

Darüber hinaus ist Autoit furchtbar langsam, es gibt genügend Skriptsprachen die schneller sind, deren Code lesbarer ist und die man trotzdem leicht erlernen kann, der einzige Grund für die Verbreitung von Autoit ist die Funktionssammlung die mit geliefert wird.
08/05/2010 03:24 MrSm!th#25
Quote:
Originally Posted by lolkop View Post
woher habt ihr denn diese weisheiten?
wenn man sich mit sprachen nicht auskennt, sollte man nicht so schnell mit abwertenden sprüchen daherkommen.

asm ist eine einfache sprache. man kann in jeder sprache jede andere sprache einbauen.
und da autoit in der lage ist winapis zu nutzen, ist der funktionsumfang ähnlich dem von c++.

selbstverständlich müsste man sich zunächst die benötigten asm funktionen definieren, kann jedoch mithilfe der in der kernel32.dll gegebenen funktionen leicht auch kompliziertere hacks realisieren.

dazu braucht man sich nur per VirtualAllocEx im targetprocess platz für seine eigenen funktionen schaffen.
auf diese art und weise kann man leicht funktionen in den neu geschaffenen raum umleiten und dort durch eigene erweitern/ersetzn.

auch sofortiges assemblieren vom eigenem code im targetprocess ist in sprachen die in der lage sind winapis zu nutzen kein problem. als grundlage hierfür kann man die CreateRemoteThread funktion nutzen.

ich kann also in autoit wie auch in jeder anderen sprache die in der lage ist winapis zu nutzen sowohl inline assmabling als auch codecaves in anderen processen nutzen.

habe leider cod noch nie gespielt und kann nicht darüber sagen aber hier mal ein kleines beispiel wie ich zb eine funktion aus dem perfect world client nutzen kann:
Code:
Func SelectMob($id)
	Local $pRemoteThread, $vBuffer, $loop, $result, $OPcode
	; --- save the position of the allocated memory ---
	$pRemoteMem = DllCall($kernel32, 'int', 'VirtualAllocEx', 'int', $mid, 'ptr', 0, 'int', 0x46, 'int', 0x1000, 'int', 0x40)
	; --- build up the asm code ---
	; 0046061D  A1 6C3E9F00       MOV EAX,DWORD PTR DS:[9F3E6C]
	; 00460622  57                PUSH EDI                        <---- EDI Contains Mob-ID
	; 00460623  8B48 20           MOV ECX,DWORD PTR DS:[EAX+20]
	; 00460626  81C1 EC000000     ADD ECX,0EC
	; 0046062C  E8 8F961800       CALL elementc.005E9CC0
	$OPcode &= '60'                                                           ; pushad
	$OPcode &= 'A1'&_hex($base)                                               ; mov eax, [base]
	$OPcode &= '68'&_hex($id)                                                 ; push mob-id
	$OPcode &= '8B4820'                                                       ; mov ecx, [eax+0x20]
	$OPcode &= '81C1'&_hex(0xEC)                                              ; add ecx, 0xEC
	$OPcode &= 'E8'&_hex($select_call-$pRemoteMem[0]-5-StringLen($OPcode)/2)  ; call select_call
	$OPcode &= '61'                                                           ; popad
	$OPcode &= 'C3'                                                           ; retn
	; --- enter the asm code to to a dllstruct, which can be used with WriteProcessMemory ---
	$vBuffer = DllStructCreate('byte[' & StringLen($OPcode) / 2 & ']')
	For $loop = 1 To DllStructGetSize($vBuffer)
		DllStructSetData($vBuffer, 1, Dec(StringMid($OPcode, ($loop - 1) * 2 + 1, 2)), $loop)
	Next
	; --- now letz write the code from our dllstruct ---
	DllCall($kernel32, 'int', 'WriteProcessMemory', 'int', $mid, 'int', $pRemoteMem[0], 'int', DllStructGetPtr($vBuffer), 'int', DllStructGetSize($vBuffer), 'int', 0)
	; --- now we run the asm code we've just written ---
	$hRemoteThread = DllCall($kernel32, 'int', 'CreateRemoteThread', 'int', $mid, 'int', 0, 'int', 0, 'int', $pRemoteMem[0], 'ptr', 0, 'int', 0, 'int', 0)
	; --- wait till the thread did his job ---
	Do
		$result = DllCall('kernel32.dll', 'int', 'WaitForSingleObject', 'int', $hRemoteThread[0], 'int', 50)
	Until $result[0] <> 258
	; --- close everything we've opened ---
	DllCall($kernel32, 'int', 'CloseHandle', 'int', $hRemoteThread[0])
	DllCall($kernel32, 'ptr', 'VirtualFreeEx', 'hwnd', $mid, 'int', $pRemoteMem[0], 'int', 0, 'int', 0x8000)
	Return True
EndFunc
wie man sieht ist es teilweise nicht leicht funktionen wie beispielweise calls in autoit umzusetzen, da dort der hex code nicht ohne weiteres erstellt werden kann, jedoch lässt sich mit einem gewissen hintergrundwissen über asm auch dies bewerkstelligen.

habe hier jetzt mal auf das definieren der asm funktionen verzichtet und direkt die hexcodes genutzt, was das ganze etwas unübersichtlicher macht, aber auch den code deutlich kleiner hält =)
Achso....leicht....
Du müsstest deine Funktion dann ja komplett da rein kopieren.
Wenn es wenigstens eine Dll von Detours gäbe, damit man per DllCall detouren kan, aber nein alles schön selbst in den Memory schreiben ;<
Klar ist es möglich, aber nicht komfortabel.
Das sieht man auch an deinem Source.
Außerdem definiere ich inline ASM als Möglichkeit, im Code direkt assembler nutzen zu können und sich nicht kompliziert die Opcodes dareinschreiben zu müssen.

Quote:
der einzige unterschied zwischen autoit und c++ ist in diesem falle, das du dich bei c++ in den process setzen kannst, und bei autoit immer nur von aussen den process beeinflussen kannst.

das heist aber nicht das du nicht genau wie in c++ jede funktion umleiten, oder sogar den eigentlichen prozessfluss stoppen und deinen eigenen dafür einspringen lassen kannst.
der indirekte zugriff auf den prozess kann sogar in manchen situatuationen deutlich besser arbeiten als wenn man direkt im prozess sitzt.
Naja, und evtl. dass die Sprache interpretiert wird und deswegen lahmer ist und man nicht alles per DllCall lösen kann.

Quote:
der indirekte zugriff auf den prozess kann sogar in manchen situatuationen deutlich besser arbeiten als wenn man direkt im prozess sitzt.
Weil man ja mit C++ nur im Prozess hocken kann ;)


Aber mal so als andere Frage in den Raum:

Warum liegt bitte eine Funktion direkt in Maschinencode vor, wenn man sie in inline asm schreibe?

ob ich
Code:
mov eax, my_variable
add eax, 5;
mov my_variable,eax
oder
Code:
my_variable += 5;
schreibe, erstmal liegt mir nur der text vor.
Wie kann ich dann einfach so die Funktion in einen anderen Speicherbereich kopieren?
Wenn ihr nun mit Funktionspointern kommen wollt (auch wenn mir nicht bekannt ist, wie man das Ende der Funktion einfach so finden will), das geht doch auch mit Highlevelfunktionen.
Warum muss sie in inline ASM vorliegen?
08/05/2010 12:34 lolkop#26
Quote:
Originally Posted by MrSm!th View Post
Weil man ja mit C++ nur im Prozess hocken kann ;)

Warum liegt bitte eine Funktion direkt in Maschinencode vor, wenn man sie in inline asm schreibe?

ob ich
Code:
mov eax, my_variable
add eax, 5;
mov my_variable,eax
oder
Code:
my_variable += 5;
schreibe, erstmal liegt mir nur der text vor.
Wie kann ich dann einfach so die Funktion in einen anderen Speicherbereich kopieren?
Wenn ihr nun mit Funktionspointern kommen wollt (auch wenn mir nicht bekannt ist, wie man das Ende der Funktion einfach so finden will), das geht doch auch mit Highlevelfunktionen.
Warum muss sie in inline ASM vorliegen?
also erstmal habe ich nie gesagt das c++ das nicht beherscht.

und zum rest kann ich nur sagen das ich bereits geschrieben habe, das man in autoit die befehle erst vordefinieren muss.

das der c++ compiler
Code:
my_variable += 5;
erst in
Code:
mov eax, my_variable
add eax, 5;
mov my_variable,eax
umwandelt sollte dir wohl klar sein. da der autoit compiler für solche aufgaben nie vorgesehen war, ist er nicht in der lage das von haus aus zu tun. jedoch ist es natürlich ohne weiteres möglich diese funktion selbst zu definieren.

ich sagte nie das es einfacher ist als in sprachen wo solche sachen bereits vordefiniert sind, ich sagte nur das es möglich ist. und das sagte ich nicht um euch hier zu wiedersprechen oder sonstwas sondern einfach nur weil ich leute die sagen das ist unmöglich einfach nicht ausstehen kann.

das schreiben von eigenen compilern ist in jeder sprache möglich. und wenn man den compiler selbst über maschienenbefehle aufbaut, so ist es selbst in autoit möglich deutlich effizientere funktionen aufzustellen als die die c++ nutzt.
08/05/2010 15:35 MrSm!th#27
Du hast da was zusammengewürfelt.
Die Codebeispiele waren für meine Frage.

Weil ich von euch hier irgendwo gelesen habe, dass es leicht sein soll, eine Funktion zu kopieren, wenn man sie in inline ASM formuliert und deshalb direkt in Maschinencode vorliegen hat und das habe ich nicht verstanden.
Eine komplette Funktion zu kopieren, die ich nicht in ein BYTE Array geschrieben habe (wäre recht aufwendig), scheint mir in C++ und inline asm gleich schwer o.ô


Und zu der Sache mit dem selbst definieren:
Das meine ich doch. Ich bewerte nur Möglichkeiten, die die Sprache von sich aus unterstützt. Man kann auch in C mit viel Gefummel Objektorientierung ermöglichen, aber das ist doch nicht das wahre und deshalb kann man C nicht objektorientiert nennen!

Kritisiert habe ich nur an deinem Post das "einfach". Denn wie man an deinem Source sieht, im Vergleich zu anderen Sprachen ist es alles andere als einfach.
Page 2 of 2 1 2