Mensajes

[pointers]

Hermanito, una pregunta, la dirección de memoria cambia en cada ejecución cierto? como se podría identificar automáticamente la dirección después de haber cambiado?

Muy buena pregunta. Hay dos formas para hacer eso:

- Utilizar pointers (no lo he explicado)
- Utilizar Auto-Assemble Scripts (Explicado en el paso 2 y 3)

Volviendo al ejemplo del paso 3 MoneyBag



Se puede encontrar de forma fácil el pointer que almacena la dirección dinámica del Dinero. De igual forma se puede hacer un AA script para incrementar el dinero. Éstas 2 formas de trabajar con CE funcionarán siempre, incluso después de cerrar y volver a ejecutar el proceso:



Puedes ver en la imagen que los pointers se identifican por P->000000. Te dejo mi tabla de CE para el ejemplo de MoneyBag, podrás abrirla sin problema y verás como el Pointer y el AA script funciona siempre:

http://www.mediafire.com/?d51sd1qc3l0jiic

______________________________________________

Si lo necesitáis, puedo escribir un tutorial para buscar pointers

[FTLGame.exe"+B133F:]

Disculpa si no formule bien mi pregunta, pero quiero saber si al crear el script se agregan los pointers automaticamente y hablo de direcciones estaticas.

La otra pregunta era que si FTLGame.exe"+B133F: lo reemplazo por el addy que deberia de ser que es "00123456" CE leeria igual el script.

Cuando generas un script usando los pasos descritos en la parte 3, se agrega todo automáticamente, no tienes que escribir nada. Te lo explico usando el ejemplo del tutorial 3:

Como puedes ver, el debugger de CE me muestra la instrucción que modifica mi dirección donde almaceno el dinero, dicha instrucción es moneybag_tutorial.exe"+2C19 (mira la imagen). Al añadir las plantillas, CE escribe automáticamente el siguiente código:

[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)

newmem: //this is allocated memory, you have read,write,execute access
//place your code here

originalcode:
mov [esi+34],ax
jg moneybag_tutorial.exe+2C23

exit:
jmp returnhere

"moneybag_tutorial.exe"+2C19:
jmp newmem
nop
returnhere:




[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
"moneybag_tutorial.exe"+2C19:
mov [esi+34],ax
jg moneybag_tutorial.exe+2C23
//Alt: db 66 89 46 34 7F 04

Lo que está en negrita es la primera línea que se ejecutará, justamente es la dirección donde tengo mi instrucción mágica mov [esi+34],ax. Si quieres remplazar la dirección del salto puedes usar direcciones no relativas, para ello suma la BASE con la dirección: 40400+2C19 = moneybag_tutorial.exe+2C19, así que supongo que CE lo leerá igual, pero no estoy seguro, deberías probarlo.

Exactamente no entiendo tu pregunta Que es lo que quieres hacer?

El tema de pointers o multi-level pointers no he hablado en el tutorial. No me gusta trabajar con ellos ya que son algo confusos, puedes realizar cualquier hack sin recurrir a los pointers, incluso en direcciones dinámicas

a medio me perdi en la 2 parte y en el 3 ya bff. imposible para mi 

Exactamente en que parte te perdiste? Quizás pueda ayudarte

Como ya te han dicho, vbs es un lenguaje interpretado (script) que no necesita compilarse. Lo mismo ocurre con javascript o con HTML (HTML no es un lenguaje de programación, pero es un claro ejemplo para entender el concepto de un "código" interpretado).

Si lo que quieres es un "entorno de programación" para vbs, yo te recomiendo Notepad++ http://notepad-plus-plus.org/



Puedes ver un ejemplo de un source mío, Notepad++ interpreta el script y le da un formato al código para poder trabajar mejor.

[CE]

Te felicito y agradezco por tomarte el tiempo por enseñar partes de un debugger como es el CE, tengo muy claro todo lo unico que aun no aprendia era la parte de crear scripts en AA, ahora que lo se me gustaria saber ya que hablastes del alloc y label, podrias decirme en que casos o para que sirve el registersymbol y un ejemplo para que asi los demas tambien puedan entenderlo.

Gracias.

alloc es para indicar a CE cuanto espacio en memoria necesitas para tu script, normalmente con 2kbytes tienes espacio suficiente paa inyectar tu código.
label sirve para utilizar una palabra como si fuera una dirección de memoria, te dejo un ejemplo:

[ENABLE]
alloc(InfiniteHull,2048)
label(SkipDmg)
label(return)

"FTLGame.exe"+B133F:
jmp InfiniteHull
nop
return:

InfiniteHull:
cmp [eax+04],0
je SkipDmg
fistp dword ptr [eax+38]
db D9 6D FE
jmp return
SkipDmg:
mov [eax+38],1E
db D9 6D FE
jmp return

[DISABLE]
dealloc(newmem)
"FTLGame.exe"+B133F:
fistp dword ptr [eax+38]
db D9 6D FE

Si lees el código desde arriba verás que empiezo con un jmp InfiniteHull (mi primer label). Comparo la estructura [eax+4] con un je SkipDmg (mi segundo label). Es un claro ejemplo de uso de labels, éste script AA comprueba el registro [eax+4] para determinar si es un enemigo o un amigo, si es un amigo el valor será 0 y lanzo el código de evitar daño, si es un enemigo ejecuto el código original para aplicar daño. Así de sencillo.

RegisterSymbol es algo más avanzado, sirve para registrar una palabra como variable interna. A efectos prácticos será tratada como una dirección de memoria más y podrás trabajarla con CE, te dejo un ejemplo inventado:

En algunos casos, los videojuegos utilizan direcciones estáticas donde almacenan sus variables, dichas direcciones nunca varían y las puedes utilizar para hacer "hacks". Imagínate que tenemos un juego llamado "game.exe" y que en la dirección de memoria BCA64 el registro EAX contiene las videas de tu personaje, podrías hacer lo siguiente:

[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(exit)
alloc(y_addr,4)
registersymbol(y_addr)

"game.exe"+BCA64:
jmp newmem
jmp exit
nop

newmem:
mov [y_addr],eax

exit:

[DISABLE]
...
dealloc(y_addr)
unregistersymbol(y_addr)

Aquí lo que hemos hecho es saltar a la dirección de memoria BCA64 y guardar en nuestro símbolo y_addr el valor de EAX que contiene las vidas. A partir de aquí el símbolo y_addr podrá ser utilizado en cualquier ventana del CE, incluso en otros script's. Es otra forma de trabajar, pero yo lo veo algo complicado. Si te interesa el tema de las funciones en AA te dejo las que hay (en inglés)

There are 3 special commands you can give it, ALLOC , LABEL and FULLACCESS. With LABEL you can give a address a name by declaring it before you use it. ALLOC is basicaly the same as LABEL but allocates some memory for you.
Usage:
LABEL(labelname) //Enables the word labelname to be used as a address
ALLOC(allocname,sizeinbytes, preferedregion OPTIONAL) //same as label, but allocates the memory it points to itself
DEALLOC(allocname) //Deallocates a block of memory allocated with alloc. It always gets executed last, no matter where it is positioned in the code, and only actually frees the memory when all allocations have been freed.  only usable in a script designed as cheattable. (e.g used for the disable cheat)
FULLACCESS(address,size)  //makes a memory region at the specified address and at least "size" bytes readable, writable and executable

REGISTERSYMBOL(symboname) //adds the symbol to the userdefined symbol list so cheattables and the memory browser can use that name instead of a address (The symbol has to be declared in the script when using it)
UNREGISTERSYMBOL(symbolname) //removes the symbol from the userdefined symbol list. It won't give a error if it isn't found


DEFINE(name,whatever) :Will replace all tokens with the specified name with the text of whatever
INCLUDE(filename) :includes another auto assembler file at that spot
LOADBINARY(address,filename) :Will load a binary file at the specified address
CREATETHREAD(address) :Will spawn a thread in the process at the specified address
LOADLIBRARY(filename) :Will inject the specified dll into the target process
READMEM(address,size) :Will write the addresses at address at the location this instruction is placed


GLOBALALLOC(name,size) : Will allocate a certain amount of memory and registers the specified name. Using GlobalAlloc in other scripts will then not allocate the memory again, but reuse the already existing memory. (Or allocate it anyhow if found it was not allocated yet)


ASSERT(address, array of byte) : Will check the memory address for the given address. If the memory is not what is defined by the array of byte given, the auto assemble script will not execute.
AOBSCAN(name, array of byte) : Will scan the memory for the given array of byte (Wildcards are supported) and replaces all tokens with the specified name with the address the array of byte was found. If it's not found, the auto assemble script will not execute


Value notation:
Normally everything is written as hexadecimal in auto assembler, but there are ways to override this so you can input decimal values, and even floating point values.
for example, a integer value of 100 can be written in hex as 64, but you can also write it as #100, or as (int)100
for floating point value like 100.1 you can use (float)100.1


Y por si te interesa, te dejo un AA script de un juego real, el script es bastante extenso, por suerte está bien escrito y comentado, quizás aprendas algo de él

//=========================================
// Majesty 2 - The Fantasy Kingdom Sim
// Game Version  : 1.0.0.0
// Script Version: 1.0
// CE Version    : 5.5
// Gold, GodMode
// 08-Oct-2009
//=========================================

[ENABLE]
alloc(MyCode,1024)

//=========================================
// Declaration section
label(_MonGold)
label(_BackMG)
label(_ExitMG)
label(_GodMode)
label(_BackGM)
label(_ExitGM)
label(_GodM0)
label(pGold)
label(fMinGold)
label(iEnableMG)
label(iEnableGM)

registersymbol(MyCode)
registersymbol(pGold)
registersymbol(fMinGold)
registersymbol(iEnableMG)
registersymbol(iEnableGM)

//=========================================
// Hacking Points
Game.dll+1d7d07:
jmp _MonGold
nop
_BackMG:

Game.dll+20ff5e:
jmp _GodMode
_BackGM:

MyCode:
//=========================================
_MonGold:
push eax
 
mov [pGold],ecx              // Save ptr for further use
 
cmp dword ptr [iEnableMG],0
je _ExitMG                   // Jump if feature is disabled
 
mov eax,[fMinGold]           // Get minimum gold value
cmp eax,[ecx+00040474]       // Current value >= minimum?
jle _ExitMG                  // Jump if true
 
mov [ecx+00040474],eax       // Make current value = minimum
mov [ecx+04],eax             // Make current value = minimum (display)

_ExitMG:
pop eax
fld dword ptr [ecx+00040474] // Original code
jmp _BackMG                  // Back to main code

//=========================================
_GodMode:
push ebx
mov ebx,ecx
 
cmp dword ptr [iEnableGM],0
je _GodM0                    // Jump if feature is disabled

mov ecx,[ecx+14]             // Get ptr Level 1
or ecx,ecx                   // Valid pointer?
jz _GodM0                    // Jump if false

mov ecx,[ecx+000000a0]       // Get ptr Level 2
or ecx,ecx                   // Valid pointer?
jz _GodM0                    // Jump if false

mov ecx,[ecx+00000014]       // Get ptr Level 3
or ecx,ecx                   // Valid pointer?
jz _GodM0                    // Jump if false
 
mov ecx,[ecx+000000A4]       // Get ptr Level 4
cmp ecx,07000000             // Valid pointer?
jle _GodM0                   // Jump if false

mov ecx,[ecx+00000024]       // Get ptr to owner
cmp ecx,[pGold]              // Player´s unit?
jne _GodM0                   // Jump if false

fld dword ptr [ebx+24]       // Get Maximum HP
jmp _ExitGM  

_GodM0:
fld dword ptr [eax]          // Original code

_ExitGM:
mov ecx,ebx
pop ebx
 
fstp dword ptr [ecx+1c]      // Original code
jmp _BackGM                  // Back to main code

//=========================================
// Variables
iEnableMG:
dd 1
iEnableGM:
dd 1
pGold:
dd 0
fMinGold:
dd 461c4000                  // 10000

//=========================================
// Original Codes
[DISABLE]
Game.dll+1d7d07:
fld dword ptr [ecx+00040474]

Game.dll+20ff5e:
fld dword ptr [eax]
fstp dword ptr [ecx+1c]

dealloc(MyCode)
unregistersymbol(MyCode)
unregistersymbol(pGold)
unregistersymbol(fMinGold)
unregistersymbol(iEnableMG)
unregistersymbol(iEnableGM)

Ya he terminado la parte 3 del tutorial, creo que no me he dejado nada. Inyección de código y creación de script's en Auto-Assemble. Si hay algo mal o que no se entienda avisad!!

Está posteado en el reply #3 de la primera página

Mad mira hace tiempo jugaba a un juego llamado BoomBang y se me ocurrio entrar y probar para ponerme mucho dinero, y lo consegui lo que pasa esque siempre que me pongo dinero en un juego tan solo es visual, en realidad es como si no tuviera nada. Igual me ocurre en el juego Plants Vs Zombies.
Espero que me resuelvas la duda

Bueno, eso que te ocurre puede ser por varios motivos. Te explico:

Imaginate que soy programador de un juego, en el juego tienes monedas (o dinero), de forma interna el juego almacena el valor de tu dinero así

VariableDinero = 50 * 10 = 500

Tú en el juego verás de forma gráfica que tienes 500 monedas, pero en realidad el juego almacena el valor 50 y lo multiplica por 10 para mostrarlo. Cuando uses CE para buscar 500 jamás te saldrá bien, ya que de forma interna, la variable de 500 monedas se almacena de una forma distinta. Eso sería un método de protección para evitar éste tipo de trampas. Lo mejor es usar búsquedas en Increased o Decreased para no fallar.

Por cierto, el Plant vs Zombi lo conseguí hackear con CE, no es complicado, que versión estás jugando tú? Yo lo tengo para Steam, si quieres te puedo ayudar.

Umm bueno ai alguna otra forma se sacar el andress  o pointer
estatico  q no se por debuger aver si me pordrian orientar
en algo toy provando con dos juegos el mu heroes mu sanluis
y gunbound     

Esas juegos usan tecnologia Game Shield, además son juegos online (server side) así que no lograrás nada

Holas  soy pollito  tengo un problema q pasa
cuando le doy  "Find out what writes to this address"
se cierra el juego no es el juego q pusistes es otro
como podria en caso como sacar las andress pointer offzet....

Buenas, lo que te ocurre es que el juego que estás tratando de debuggear tiene protecciones anti-debugg, al lanzar el debugger interno de CE se cierra por protección.

Que juego estás tratando de hackear?