Vorgänge in einem Programm automatisieren

[Ineluki]

genau mit dem selben Krempel habe ich mich auch schon fuer den rm2k rumgeschlagen fuer meine Patches .. und bei allen habe ich dann aus Zeitmangel aufgegeben.

Ich hatte sigar mal eine Loesung fuer F12+runter+enter, aber dort war das Problem dann, dass das timing exakt stimmen musste. Also hab ich die funktion irgendwann ausgebaut, weil es einfach zu kompliziert war, die tastendruecke in exakt dem richtigen moment zu senden.

Fuer das Load Problem waere es wohl eine loesung, wenn man im Spiel die Addresse der Load Subroutine mit einem Debugger oder einem Disassembler rausbekommen wuerde, und dann in einer dll (z.B. dem Tastenpatch), die vom rm2k geladen wird (-> gleicher addressraum) als funktionspointer aufruft. Allerdings hab ich das noch nicht probiert, da ich mich mit debuggern nicht so sonderlich auskenne und keine Zeit hab zum einarbeiten ...

Beim rm2k3 sieht es noch schlechter aus, da dort die moeglichkeit wegfaellt, ueber eine DLL freien Zugriff auf die Programmbibliotheken zu bekommen ...

Das Problem mit dem Aendern der Variablen ist aehnlich vertrackt. Zwar kannst du mit Read/WriteProcessMemory daten lesen und schreiben, das Problem ist allerdings, zu wissen, wo die Daten stehen. Da der maker seinen Speicher dynamisch alloziiert, stehen die bei jedem Start idR wo anders im speicher. Zwar sollte es eine konstante Addresse geben (die pointervariable zum Speicherbereich) die die addresse enthaellt, und ich konnte auch schon die Routine ermitteln (rm2k), in der die Variablen geaendert werden, doch fehlte mir dann zeit und ausdauer, den schritt zu komplementieren.

Alles in allem ein kompliziertes Problem, selbst fuer mich.

Ich kann ja mal posten, was ich damals so rausbekommen habe ...
Vielleicht nuetzt es ja einem. Alle Angaben natuerlich ohne Gewähr.

Code:

Speicherauszug aus RPG_RT.EXE

0046a047    8BD6                            mov edx,esi
0046a049    C1E202                          shl edx,0x2
0046a04c    8D4328                          lea eax,[ebx+0x28]
0046a04f    E8DC86F9FF                      call 0x00402730
0046a054    8B5324                          mov edx,[ebx+0x24]
0046a057    8BC6                            mov eax,esi
0046a059    48                              dec eax
0046a05a    2BC2                            sub eax,edx
0046a05c    7C0D                            jl short 0x0046A06B
0046a05e    40                              inc eax
0046a05f    8B4B28                          mov ecx,[ebx+0x28]
0046a062    33FF                            xor edi,edi
0046a064    893C91                          mov [ecx+edx*4],edi
0046a067    42                              inc edx
0046a068    48                              dec eax
0046a069    75F4                            jnz short 0x0046A05F
0046a06b    897324                          mov [ebx+0x24],esi
0046a06e    5F                              pop edi
0046a06f    5E                              pop esi
0046a070    5B                              pop ebx
0046a071    C3                              retn
0046a072    8BC0                            mov eax,eax
0046a074    83FA01                          cmp edx,0x1
0046a077    7C05                            jl short 0x0046A07E
0046a079    3B5024                          cmp edx,[eax+0x24]
0046a07c    7E03                            jle short 0x0046A081
0046a07e    33C0                            xor eax,eax
0046a080    C3                              retn
0046a081    8B4028                          mov eax,[eax+0x28]
0046a084    8B4490FC                        mov eax,[eax+edx*4-0x4]
0046a088    C3                              retn
0046a089    8D4000                          lea eax,[eax]		eax=eax^	<---- Begin Subrotine ?
0046a08c    53                              push ebx			speichern ebx
0046a08d    56                              push esi			speichern esi
0046a08e    57                              push edi			speichern edi
0046a08f    8BF9                            mov edi,ecx			edi=ecx
0046a091    8BF2                            mov esi,edx			esi=edx
0046a093    8BD8                            mov ebx,eax			ebx=eax
0046a095    83FE01                          cmp esi,0x1			esi-1
0046a098    7C15                            jl short 0x0046A0AF		? < 0 goto pops
0046a09a    3B7324                          cmp esi,[ebx+0x24]		esi - (ebx+0x24)^	<---- Begin Patch
0046a09d    7E09                            jle short 0x0046A0A8	? <=0 ueberspringe call
0046a09f    8BD6                            mov edx,esi			edx=esi
0046a0a1    8BC3                            mov eax,ebx			eax=ebx
0046a0a3    E898FFFFFF                      call 0x0046A040		Unterprogramm 0046A040
0046a0a8    8B4328                          mov eax,[ebx+0x28]		eax=(ebx+0x28)^	<---- Ende Patch
0046a0ab    897CB0FC                        mov [eax+esi*4-0x4],edi     (eax+esi*4-0x4)^=edi --> v[esi]=wert
0046a0af    5F                              pop edi			reload edi
0046a0b0    5E                              pop esi			reload esi
0046a0b1    5B                              pop ebx			reload ebx
0046a0b2    C3                              retn			fertsch	<---- Ende Subrotine ??
0046a0b3    90                              nop
0046a0b4    53                              push ebx
0046a0b5    56                              push esi
0046a0b6    8BF1                            mov esi,ecx
0046a0b8    8BDA                            mov ebx,edx
0046a0ba    6A01                            push 0x1
0046a0bc    56                              push esi
0046a0bd    8B0DE4AE4900                    mov ecx,[0x49AEE4]
0046a0c3    BADCA04600                      mov edx,0x46A0DC
0046a0c8    8BC3                            mov eax,ebx
0046a0ca    E899F8FEFF                      call 0x00459968
0046a0cf    5E                              pop esi
0046a0d0    5B                              pop ebx
0046a0d1    C3                              retn
0046a0d2    0000                            add [eax],al
0046a0d4    FFFF                            ???
0046a0d6    FFFF                            ???
0046a0d8    050000004D                      add eax,0x4D000000
0046a0dd    7573                            jnz short 0x0046A152
0046a0df    6963000000558B                  imul esp,[ebx],0x8B550000
0046a0e6    EC                              in al,dx
0046a0e7    83C4F8                          add esp,-0x8
0046a0ea    53                              push ebx
0046a0eb    56                              push esi
0046a0ec    33DB                            xor ebx,ebx
0046a0ee    895DF8                          mov [ebp-0x8],ebx
0046a0f1    884DFF                          mov [ebp-0x1],cl

Patch Ansatz ....

Original:
0x46A09A:
3B 73 24 7E 09 8B D6 8B C3 E8 98 FF FF FF 8B 43 28  

Modifiziert:
0x46A09A:
90 90 90 90 90 8B D6 8B C3 8B 43 28 A3 9A A0 46 00  

danach steht pointer auf v[1] in 0x46A09A

0x46A09A
asm original                asm modifiziert

3B                          90  nop         <--- Hier kommt die Addr rein
73                          90  nop
24  cmp esi,[ebx+0x24]      90  nop
7E                          90  nop         <--- 32 Bit = Ende Addresse
09  jle short 0x0046A0A8    90  nop
8B                          8B
D6  mov edx,esi             D6  mov edx,esi
8B                          8B	
C3  mov eax,ebx             C3  mov eax,ebx
E8                          8B
98                          43
FF                     +--> 28  mov eax,[ebx+0x28]  <--- Addresse steht nun in eax
FF                     |    A3
FF  call 0x0046A040    |    9A
8B                     |    A0
43                     |    46
28  mov eax,[ebx+0x28] +--+ 00	mov [0x46A09A],eax  <--- Addresse speichern in 0x46A09A
*************************************************************************
89	
7C
B0
FC	mov [eax+esi*4-0x4],edi
5F	pop edi
5E	pop esi
5B	pop ebx
C3	retn

Bitte nicht schlagen .. ich hab den Code vor Jahren geschrieben, und war damals noch dumm und unwissend ^^

Ziel war es also, beim ersten Aufruf von ChangeVariable im Spiel nach injektion des neuen codes den wert des Pointers zu bekommen. Den habe ich kurzerhand im Programmsegment nops ueberschreiben lassen, weil ich dann genau wusste, wo er steht. nach dem change Variable, wenn ich den pointer hatte, ersetzte ich den veraenderten code wieder durch das original. Das Problem watr aber immer, man brauchte Change Variable dazu, wobei die ausfuehrung exakt einmal kommen musste. wuerde in der zeit vor der wiederherstellung nochmal change variable durchgefuehrt, haette man das Programm ins Nirvana geschickt.

Das Verfahren hat wirklich funktioniert, allerdings war es mir fuer den allgemeinen Markt zu unsicher.