CheatEngine Function Calling + in AutoIt übernehmen

04/27/2019 18:39 SwarN#1
Hallo,

ich bräuchte spezielle Hilfe, da ich mehr so der Hochsprachen-Typ bin und mit Assembler was hier gebraucht wird eher nur "rate" was hier vor sich geht.

Speziell geht es darum in einem Prozess via CheatEngine eine Function im Dissassembler zu finden sowie diese über CheatEngine zu "callen".

Dazu das ganze in AutoIt zu übernehmen (etwas vorarbeit habe ich hier schon).

Wer sich also gut damit auskennt und Discord/TS3 hat sowie mit mir via AnyDesk dies durchgehen möchte kann sich gerne bei mir direkt via PN melden.

Bin auch bereit für genug "Hilfe" ein Trinkgeld zu geben.

Viele Grüße,
Swarn
04/27/2019 19:24 warfley#2
Hier mal ne grobe zusammenfassung
Ein prozess hat seinen eigenen vrituellen Speicherbereich bestehend aus TEXT (dem programmcode) DATA (konstanten/globalen variablen) HEAP und STACK.
Cheatengine basically ließt das TEXT segment aus und disassembled das. Dafür benötigst du aber keine Runtime analyse, du kannst genauso gut die Executable disassembeln und am ende die basisaddresse an die die libc geladen wurde drauf rechnen.

Kleines beispiel unter Linux, mit dem gdb. Ich will die addresse von sprintf aus der LibC in meinem gdb finden (ignorieren wir mal das ich einfach print &sprintf eingeben könnte).
Zunächst disassemble ich die libc mit objdump.
Code:
$ objdump -T /usr/lib/libc.so.6

/usr/lib/libc.so.6:     file format elf64-x86-64

DYNAMIC SYMBOL TABLE:
[...]
0000000000059530 g    DF .text  00000000000000b6  GLIBC_2.2.5 sprintf
[...]
Die ausgabe sagt mir jetzt die Funktion sprintf ist in addresse 0x059530. Die ist, solange sich die libc version nicht ändert, immer gleich.
Jetzt gilt es die basisadresse des moduls herauszufinden. Dafür starte ich mein programm im gdb, breake und gebe mir das memory mapping aus:
Code:
(gdb) info proc mappings
process 112443
Mapped address spaces:

          Start Addr           End Addr       Size     Offset objfile
      0x555555554000     0x555555555000     0x1000        0x0 /home/frederic/a.out
      0x555555555000     0x555555556000     0x1000     0x1000 /home/frederic/a.out
      0x555555556000     0x555555557000     0x1000     0x2000 /home/frederic/a.out
      0x555555557000     0x555555558000     0x1000     0x2000 /home/frederic/a.out
      0x555555558000     0x555555559000     0x1000     0x3000 /home/frederic/a.out
      0x7ffff7dcf000     0x7ffff7df1000    0x22000        0x0 /usr/lib/libc-2.28.so
      0x7ffff7df1000     0x7ffff7f3c000   0x14b000    0x22000 /usr/lib/libc-2.28.so
      0x7ffff7f3c000     0x7ffff7f88000    0x4c000   0x16d000 /usr/lib/libc-2.28.so
      0x7ffff7f88000     0x7ffff7f89000     0x1000   0x1b9000 /usr/lib/libc-2.28.so
      0x7ffff7f89000     0x7ffff7f8d000     0x4000   0x1b9000 /usr/lib/libc-2.28.so
      0x7ffff7f8d000     0x7ffff7f8f000     0x2000   0x1bd000 /usr/lib/libc-2.28.so
      0x7ffff7f8f000     0x7ffff7f95000     0x6000        0x0 
      0x7ffff7fce000     0x7ffff7fd1000     0x3000        0x0 [vvar]
      0x7ffff7fd1000     0x7ffff7fd3000     0x2000        0x0 [vdso]
      0x7ffff7fd3000     0x7ffff7fd5000     0x2000        0x0 /usr/lib/ld-2.28.so
      0x7ffff7fd5000     0x7ffff7ff4000    0x1f000     0x2000 /usr/lib/ld-2.28.so
      0x7ffff7ff4000     0x7ffff7ffc000     0x8000    0x21000 /usr/lib/ld-2.28.so
      0x7ffff7ffc000     0x7ffff7ffd000     0x1000    0x28000 /usr/lib/ld-2.28.so
      0x7ffff7ffd000     0x7ffff7ffe000     0x1000    0x29000 /usr/lib/ld-2.28.so
      0x7ffff7ffe000     0x7ffff7fff000     0x1000        0x0 
      0x7ffffffde000     0x7ffffffff000    0x21000        0x0 [stack]
Hier kann ich sehen das die libC an addresse 0x7ffff7df1000 geladen wurde. Addiere ich also die addressen auf 0x7ffff7df1000 + 0x059530 = 0x7ffff7e28530 (Ein schnelles print &sprintf verifiziert die rechnung).

Mit diesem Funktionspointer kann ich jetzt was anfangen. Wenn ich jetzt z.B. im GDB p ((int (*) (const char *)) 0x7ffff7e28530) (ToAddr, "ABC") eintippen würde, würde die gdb die Funktion sprintf ausführen, und basically ABC an die addresse ToAddr schreiben.
GDB macht das ganze richtig, Pausiert die prozess bereitet das memory vor (stack frame, register, etc.) und macht dann den call. Beschrieben ist das hier: [Only registered and activated users can see links. Click Here To Register...]. Während du das so auch versuchen könntest zu basteln, gibt es glaube ich einen weitaus schmerzloseren weg.

Zurück zu Windows. Um funktionen in Assemblies (.exe, .dll) zu finden kannst du z.B. IDA pro oder Binary Ninja verwenden, zwei state of the Art disassembler die noch viel mehr funktionalität haben, aber auch super einfach dir alle funktionen anzeigen können. Du disassemblest damit einfach die binary, suchst die funktion die du willst, und schreibst dir die Addresse auf

Um nun die Basisadresse zu bekommen ohne einen debugger zu verwenden, bietet dir die WinAPI folgende Möglichkeit: [Only registered and activated users can see links. Click Here To Register...].
Zu guter letzt kannst du den Funktionspointer den du dir einfach aus Basisadresse + Funktionsaddresse ausgerechnet hast mithilfe von [Only registered and activated users can see links. Click Here To Register...] erzeugen.

Aber achtung, die Funktion wird wie der name schon sagt in einem Separaten Thread ausgeführt, es kann also zu Raceconditions führen. Wenn du das programm während dessen anhalten willst musst du es so machen wie es der GDB macht
04/28/2019 14:21 SwarN#3
So, erstmal ein herzliches Dankeschön an warfley, die Funktion ist gefunden und nun stehe ich nur noch vor dem letzten Problem, den ASM-Code von AutoIt aus in den Speicher der Zielanwendung zu bekommen, damit ich diese Funktion von dort aus via CreateRemoteThread aufrufen kann.

Folgender ASM-Code soll letzendlich in der Ziel-Exe dann stecken:
Code:
movss xmm2,[B7D478]
movss xmm1,[B7D470]
push ecx
mov ecx,[9E994C]
call 6F2D20
ret
Wenn ich das ganze über CheatEngine via "Allocate Memory" + genau den obigen ASM-Code via Auto-Assemble in den Speicher der Exe schreibe, funktioniert schon alles 1a und kann die Funktion via AutoIt und CreateRemoteThread verwenden.

Hat das schon jemand gemacht und kann mir hier helfen?
04/28/2019 17:54 th0rex#4
Solltest eigentlich einfach mit VirtualAllocEx speicher mit execute Rechten (flAllocationType sollte MEM_COMMIT | MEM_RESERVE sein und flProtect sollte PAGE_EXECUTE_READWRITE sein) aus AutoIT in dem Prozess allokieren können, mit irgendeinem assembler dein assembler code assemblen so dass du die entsprechenden bytes hast (kannst die ja einfach von dem was bei Auto Assemble in cheat engine rauskommt sehen), und diese bytes dann mit WriteProcessMemory in deinen Speicher schreiben. Dann mit CreateRemoteThread da nen thread erstellen und das sollte gehen. Wie man das in AutoIT genau macht weiß ich leider nicht.
04/28/2019 18:27 SwarN#5
Quote:
Originally Posted by th0rex View Post
mit irgendeinem assembler dein assembler code assemblen so dass du die entsprechenden bytes hast (kannst die ja einfach von dem was bei Auto Assemble in cheat engine rauskommt sehen), und diese bytes dann mit WriteProcessMemory in deinen Speicher schreiben.
Genau und daran scheitert es aktuell, speicher frei machen ist nicht das Problem, aber wie ich meinen gewünschen ASM Code hier in den Speichern schreibe und diesen erstmal umwandle.

Da wäre ein Beispiel ganz nett
04/28/2019 18:50 th0rex#6
Naja, wirklich am einfachsten wäre einfach das einmal in dem cheat engine auto assembler zu machen und dir dann den speicher anzuschauen, den du vorher in cheat engine allokiert hast. Da stehen dann ja die bytes neben den instructions, die würdest du dann einfach in ein array in autoit kopieren. Hab leider kein windows und cheat engine mehr, von daher wird das etwas schwer das dir mit cheat engine zu zeigen. Ich würde auf Linux halt einfach
Code:
global _start
section .text

_start:
movss xmm2, [0xB7D478]
movss xmm1, [0xB7D470]
push ecx
mov ecx, [0x9E994C]
call 0x6F2D20
ret
in eine assembly.S datei oder so schreiben, dann mit
Code:
nasm -felf32 assembly.S && objdump -d assembly.o
folgendes kriegen:
Code:
00000000 <_start>:
   0:   f3 0f 10 15 78 d4 b7    movss  0xb7d478,%xmm2
   7:   00
   8:   f3 0f 10 0d 70 d4 b7    movss  0xb7d470,%xmm1
   f:   00
  10:   51                      push   %ecx
  11:   8b 0d 4c 99 9e 00       mov    0x9e994c,%ecx
  17:   e8 1c 2d 6f 00          call   6f2d38 <_start+0x6f2d38>
  1c:   c3                      ret
(Das würdest du halt mit cheat engine machen, oder dir irgendeinen anderen assembler suchen, oder einfach jetzt von mir die bytes kopieren).

Die bytes die links stehen schreibst du jetzt einfach mit WriteProcessMemory aus autoit in deinen speicher, dh. du würdest so ein Array hier erstellen:
Code:
[0xf3, 0x0f, 0x10, 0x15, 0x78, 0xd4, 0xb7, 0x00, 0xf3, 0x0f, 0x10, 0x0d, 0x70, 0xd4, 0xb7, 0x00, 0x51, 0x8b, 0x0d, 0x4c, 0x99, 0x9e, 0x00, 0xe8, 0x1c, 0x2d, 0x6f, 0x00, 0xc3]
und das dann in den Speicher schreiben.
04/28/2019 18:54 SwarN#7
Werd ich mal versuchen klingt logisch für mich mal schauen ob ichs hinkrieg :)

Okay ich hab's nun hinbekommen, ging fast wie gewollt.

Lediglich die Call Funktion musste ich etwas abändern, da sich dieser OP-Code immer ändert, hab ich aber dennoch hinbekommen und es funktioniert :).

Für alle die vll mal drüberstolpern hier der AutoIt Code:

Code:
Func _Inject_Function()

	Local $push_dword = 0x68
	Local $call = 0xE8
	Local $return=0xC2
	Local $Push_ebp = 0x55
	Local $MovEbpEsp = 0xEC8B
	Local $MovEspEbp = 0xE58B;MOV ESP,EBP
	Local $Pop_ebp = 0x5D
	Local $AddESP = 0xC483
	Local $MovEcx = 0x0D8B
	Local $Aktuell = 0

	$FunctionCTM=0x6F2D20
	$Object=0x9E994C



	;ASM Funktion die abgebildet werden soll
	;movss xmm2,[B7D478]
	;movss xmm1,[B7D470]
	;push ecx
	;mov ecx,[9E994C]
	;Call 6F2D20
	;ret

	;OP-Code für movss-Float Parameter + mov ecx:
	Local $CTM_OPCode[23] = [0xf3, 0x0f, 0x10, 0x15, 0x78, 0xd4, 0xb7, 0x00, 0xf3, 0x0f, 0x10, 0x0d, 0x70, 0xd4, 0xb7, 0x00, 0x51, 0x8B, 0x0D, 0x4C, 0x99, 0x9E, 0x00]

	;Speicher frei machen
	$AllocAdresse = _MemVirtualAllocEx ($HPID[1],0,29,$MEM_COMMIT ,$PAGE_EXECUTE_READWRITE)
	$Aktuell=$AllocAdresse

        ;Float Parameter "movss" hinzufügen via OPCode aus CE kopiert.
	For $i = 0 To UBound($CTM_OPCode)-1
		_MemoryWrite($Aktuell,$HPID,$CTM_OPCode[$i],"byte")
		$Aktuell+=1
	 Next

        ;Function Call
	_MemoryWrite($Aktuell,$HPID,$call,"byte")
	$Aktuell+=1
	$offsetToCall=0x6F2D20-(Number ($Aktuell)+4)
	_MemoryWrite($Aktuell,$HPID,$offsetToCall,"dword")
	$Aktuell+=4

	;Return
	_MemoryWrite($Aktuell,$HPID,$return,"byte") ;RETN
	$Aktuell+=1
EndFunc