Foro de elhacker.net

Bueno, lo prometido es deuda, he terminado mi último tutorial sobre Cheat Engine. He querido subir un escalón en cuanto a conceptos y dificultad. El tutorial trabajará sobre un mismo objetivo; un juego llamado Hack, Slash, Loot. Intentaré explicar al detalle todos mis conocimientos. El glosario tratado es el siguiente:

# Introducción
# Buscar Address
# Conceptos Básicos
# VEH Debugger
# Pointers
# Creando el cheat GODMODE (intento fallido)
# Shared Codes
# Diseccionar Shared Code
# Creando el cheat GODMODE (auto-assemble)
# Diseccionar Estructuras
# Localizar estructuras dinámicas
# AoB to Memory Data
# Script VBS - AoB Pattern generator
# Bonus: Comparar estructuras con WinMerge
# TeleportHack
# Despedida

El tutorial lo he escrito en PDF, explicando paso a paso cada concepto. Más de 50 paginas y 100 capturas de pantalla. Espero que lo disfruten.

BUSCAR ADDRESS
CONCEPTOS BÁSICOS
Primero de todo voy a presentar lo que será nuestro objeto de estudio, nada más y nada menos que Hack, Slash, Loot. Un juego tipo roguerlike basado en un sistema de combates por turnos que nos ayudará a entender cada una de las partes del tutorial. El juego es un sencillo ejecutable de apenas 10MB que no necesita instalación. No puedo postear el link directo de descarga ya que el juego es de pago (aprox 5€), pero creo que no os costará demasiado hacer una búsqueda en “la baía del barco pirata” para encontrarlo. En el tutorial trabajaremos con la versión 8.0 de Hack, Slash, Loot.

(http://ns2.elhacker.net/img_cheat_engine/image001.png)
 
Para empezar, yo he seleccionado el arquero, pulsamos el último botón de la derecha para iniciar el juego. Puedes seleccionar otro personaje si lo deseas. El juego se maneja con el ratón; es un roguerlike así que al tratarse de un juego “por turnos” no nos tendremos que preocupar en pausar el juego mientras lo reversamos, Hack, Slash, Loot (a partir de ahora HSL) es el juego ideal para explicar en un tutorial como éste:


(http://ns2.elhacker.net/img_cheat_engine/image002.png)

Abajo del todo aparecen los stats de mi jugador, primero de todo hay que marcarse un objetivo, en mi caso nuestro objetivo será crear un cheat de tipo godmode (invulnerable). Cada juego es diferente, y cada cheater trabaja de forma diferente. Hay varios caminos que conducen al mismo lugar, cualquier comino es válidos siempre y cuando consigamos cumplir nuestro objetivo. Cuando un juego muestra claramente los puntos de vida (HP) a mi me gusta localizar el address que almacena la vida y bloquearla, otro método válido sería buscar la instrucción que modifica la vida y nopear, otro método es localizar los puntos de vida que te van a restar al recibir un golpe y setearlos a 0. Hay muchos métodos/caminos, y todos son válidos. Yo os explicaré los 3 métodos.

TRABAJANDO CON VEH DEBUGGER

Empezaremos abriendo nuestro Cheat Engine 6.3 (a partir de ahora CE), os recomiendo que configuréis las opciones de CE, tiene 3 debuggers (2 por software y uno tipo ring0 kernel-mode), a mi me gusta el VEH, es practicamente indetectable para los sistemas de anti-cheat, así que nos vamos a “Setting” y modificamos las opciones tal que así:

(http://ns2.elhacker.net/img_cheat_engine/image003.png)
 
Una vez tenemos habilitado el VEH Debugger, procedemos a abrir el proceso del HSL
 
 (http://ns2.elhacker.net/img_cheat_engine/image004.png)

En los stats de nuestro jugador tenemos 30 puntos de vida, así que realizaremos una búsqueda. No conocemos el funcionamiento del juego, no sabemos de que forma almacena los datos (integer, float, double, …), mi recomendación y experiencia me dice que probablemente el juego almacene los valores en formato Integer (Long) es decir, 4-bytes. Procedemos a realizar la primera búsqueda:

(http://ns2.elhacker.net/img_cheat_engine/image005.png)
 
En mi caso han aparecido 990 direcciones con el valor 30. Lo que realizaremos ahora es buscar algún enemigo y dejaremos que nos haga daño para reducir nuestros puntos de vida, por suerte he aparecido al lado de un enemigo, así que haré click con el ratón encima de mi personaje para “pasar el turno” y conseguir que me hagan daño:

(http://ns2.elhacker.net/img_cheat_engine/image006.png)
 
Bien, el maldito kobold me ha pegado una zurra y ahora mi personaje tiene 14 puntos de vida, así que realizo la segunda búsqueda en CE:

(http://ns2.elhacker.net/img_cheat_engine/image007.png)
 
Bien! De las 990 direcciones encontradas al inicio, ahora solo tengo 2! No necesito hacer más búsquedas, solo tengo que probar cual de las 2 direcciones almacena la vida. Hacemos click derecho en la primera dirección y selleccionamos la opción “Change value of selected address”, en el cuadro emergente ponemos un número cualquiera, por ejemplo 40 y miramos si nuestra vida a aumentado.
 
(http://ns2.elhacker.net/img_cheat_engine/image008.png)
 
En mi caso he fallado, la dirección 0101FD98 no es la correcta, ya que si establezco su valor a 40, automáticamente se vuelve a poner con 14. Así que pruebo con la segunda:

 (http://ns2.elhacker.net/img_cheat_engine/image009.png)
 
Sí! Como podemos observar, la vida ha aumentado a 40, así que en mi ordenador, la dirección 03651910 almacena los puntos de vida. El único problema que tenemos ahora es que esa dirección no es estática. Si apagamos y encendemos el juego de nuevo, la dirección de los puntos de vida habrá cambiado por otra y tendría que volver a buscarla. ¿Cómo podemo evitar tener que buscar siempre una dirección no estática? Con los Pointers. Siguiente capítulo…

 
POINTERS

No voy a extenderme mucho hablando de los punteros (pointers), pero básicamente son una especie de “cajita” en la que el juego almacena la dirección de otro address. Nuestro objetivo es localizar el pointer (la cajita) que almacena la dirección de nuestra vida, así aunque la dirección cambie, el pointer siempre apuntará a la dirección correcta.

Para ello utilizaremos una función propia del CE llamada Pointer Scan. Necesitamos primero de todo localizar la dirección actual de nuestra vida, en mi ejemplo es la dirección 03651910. Hacemos doble-click encima de la direcció encontrada para mandarla en la parte inferior, pulsamos botón derecho encima y seleccionamos “Find out what accesses this address”:

(http://ns2.elhacker.net/img_cheat_engine/image010.png)
 
Nos preguntará si queremos iniciar el debugger, le decimos que sí, aparecerá una ventanita pequeña. Ahora volvemos al juego y jugamos un poco, movemos el personaje por la pantalla y luchamos con algún enemigo (intentando que nos hagan un poco de daño), tras recibir unos golpes volvemos a la ventanita del CE y encontraremos algo similar a esto:

 (http://ns2.elhacker.net/img_cheat_engine/image011.png)
 
En mi caso el debugger ha encontrado 4 instrucciones que han accedido a la dirección 03651910. Lo que tenemos que realizar ahora es buscar un patrón repetitivo. A simple vista me llama la atención el patrón [???+50]. En cada línea hay un [eax+50] o [ebx+50] ¿Qué significa? Hacemos click en una instrucción, yo he escogido  la instrucción SUB, abajo aparece una porción de las instrucciones así como el estado de los registros:
 
(http://ns2.elhacker.net/img_cheat_engine/image012.png)

[ebx+50] se traduce como 036518C0 + 50 (Hexadecimal), así que abrimos nuestra calculadora de Windows (modo Programador) y realizamos la suma:

(http://ns2.elhacker.net/img_cheat_engine/image013.png)
 
El resultado de dicha suma es 3651910 que se corresponde a nuestra dirección con los puntos de vida. Todo esto lo hemos realizado para conocer que tipo de pointer tendremos que buscar, os recomiendo que abráis un documento de texto para ir anotando los valores. En ésta instrucción, EBX apunta a la estructura base de nuestro jugador. El offset +50 de dicha estructura almacena los puntos de vida, tal que así:
EBX = 036518C0 (PLAYER STRUCTURE)
EBX+50 = 3651910 (PLAYER HP VIDA)
El pointer que tenemos que buscar ha de terminar con el offset +50 ya que es el patrón que hemos visto con el debugger, anotad en vuestro fichero algo así como:

(http://ns2.elhacker.net/img_cheat_engine/image014.png)
 
Cerramos el debugger y volvemos a la ventana principal del CE, con nuestro address mostrando la vida del jugador. Hacemos click derecho encima del address y seleccionamos Pointer Scan:

(http://ns2.elhacker.net/img_cheat_engine/image015.png)
 
Se nos abrirá una ventana con muchas opciones. En la parte superior nos pregunta que dirección queremos buscar. Automáticamente CE ha rellenado el address de nuestra vida (3651910) ya que lo que queremos es buscar cualquier pointer que apunte a nuestra vida. Más abajo tendremos que cambiar las opciones que he señalado en rojo. Primero le indicaremos al pointer-scan que nuestro pointer debe terminar con el offset +50 (es lo que descubrimos con el debugger!) Luego parametrizamos la complejidad del pointer, para juegos de éste tipo, con un nivel entre 1-5 es suficiente, el tamaño puede ir desde 1024 a 2048. Para nuestro ejemplo yo he puesto nivel = 3 y tamaño = 1024.

(http://ns2.elhacker.net/img_cheat_engine/image016.png)
 
Pulsamos OK y nos preguntará donde guardar el fichero de pointers, mi recomendación es que hagáis una sub-carpeta para almacenar el pointer, yo le he puesto el nombre de vida. Tras unos segundos se iniciará el scaneo de pointers y nos dará un resultado:

 (http://ns2.elhacker.net/img_cheat_engine/image017.png)

Wow 85 punteros. En algunos juegos, la primera búsqueda de pointers puede devolver más de 5 millónes de resultados (es normal), para lograr encontrar el pointer correcto se necesitan realizar varios escaneos consecutivos.
Bien, ya hemos realizado la primera búsqueda y nos ha devuelto 85 punteros. Lo que realizaremos ahora es cerrar el juego por completo y lo volveremos a abrir. Volveremos  abrir el proceso de HSL y realizaremos de nuevo la búsqueda manual del address con los puntos de vida:

(http://ns2.elhacker.net/img_cheat_engine/image018.png)
 
Como podéis observar, la antigua dirección 03651910 ya no muestra la vida real del jugador, ahora la vida se almacena en la nueva dirección 038388B0 (que abremos buscado manualmente tal y como hemos visto en el inicio de éste tutorial). Ya hemos encontrado la nueva dirección con los puntos de vida, así que pulsamos click derecho encima de la dirección y seleccionamos Pointer Scan de nuevo:

 (http://ns2.elhacker.net/img_cheat_engine/image019.png)
 
ATENCIÓN! Ahora se ha vuelto a abrir la misma ventana de antes, con las opciones del pointer. Lo que hay que hacer es CERRAR ésta ventana ya que no queremos iniciar una nueva búsqueda, si no continuar la búsqueda con los resultados anteriores:
 
 (http://ns2.elhacker.net/img_cheat_engine/image020.png)

(http://ns2.elhacker.net/img_cheat_engine/image021.png)

Se nos habrán cargado los pointers anteriores (en mi caso 85), así que realizaremos una búsqueda utilizando estos 85 punteros de referencia:

(http://ns2.elhacker.net/img_cheat_engine/image022.png)
 
Se nos abrirá una ventana más pequeña, aquí indicaremos el valor de la nueva dirección que debería tener el pointer, introduciremos la nueva address que hace referencia a los puntos de vida, en mi caso 038388B0:

(http://ns2.elhacker.net/img_cheat_engine/image023.png)
 
Pulsamos OK (nos preguntará donde guardar los resultados, podéis guardar con el mismo nombre o con un nombre nuevo) tras unos segundos nos reducirá los resultados según el valor buscado:
 
(http://ns2.elhacker.net/img_cheat_engine/image024.png)

Bieeeen, 1 solo resuntado. Seguro que ese es nuestro pointer! Además el offset termina en +50 tal y como hemos configurado. Hacemos doble-click en el resultado y el pointer se mandará a nuestra tabla de CE:
 
(http://ns2.elhacker.net/img_cheat_engine/image025.png)

Podemos ver como CE muestra los pointers con el carácter P->, si ahora reiniciamos el juego, el pointer nos mostrará la dirección de nuestra vida, podremos editar, congelar o trabajar con la dirección.
Hasta aquí el tutorial sobre pointers, practicad y veréis que no es tan complicado como parece.
 
CREANDO EL CHEAT GODMODE
(PRIMER INTENTO FALLIDO)

Bueno, ya que hemos encontrado el address de nuestra vida y que, además, tenemos el pointer estático de dicho address, podemos establecer un valor y marcar la casilla para “congelarlo”, así obtendríamos lo que sería una especia de godmode:

(http://ns2.elhacker.net/img_cheat_engine/image026.png)
 
Lo único que no me gusta de éste método es que si luchamos contra un enemigo muy poderoso y de un solo golpe nos quita -700 puntos de vida… terminaremos muriendo ya que la velocidad de refresco del CE nunca será superior a la del juego. Para evitar eso y conseguir un godmode más real podemos hacer muchas cosas, pero yo recomiendo las siguientes:
•   Detectar el valor de daño que nos aplicarán y establecerlo siempre a 0
•   Detectar la instrucción que modifica o resta los puntos de vida y cambiarla por un NOP
Ambos métodos son correctos y yo los aconsejo ya que son “mejores” que setear un pointer a un valor fijo. Para ello pulsaremos click derecho en nuestro pointer (que apunta a la address de los puntos de vida) y miraremos que instrucciones escriben en dicha dirección:

(http://ns2.elhacker.net/img_cheat_engine/image027.png)
 
 
Al tratarse de un pointer, CE nos preguntará si queremos mirar la instrucción que modifica el pointer o la instrucción que modifica la dirección a la que apunta nuestro pointer. Siempre, siempre, siempre escogeremos la segunda opción:


(http://ns2.elhacker.net/img_cheat_engine/image028.png)
 
Nos volverá a salir la pequeña ventanita del debugger, que estará vigilando a ver que instrucción escribirá sobre el address del pointer (los puntos de vida). Volvemos al juego y jugamos unos cuantos turnos hasta recibir un poco de daño, cuando hayamos recibido daño, volvemos a la ventanita del debugger y encontraremos lo siguiente:

(http://ns2.elhacker.net/img_cheat_engine/image029.png)
 
La ventana nos muestra que la instrucción 00550474 ha modificado nuestra vida, ademas nos enseña el código ASM que realiza la acción de modificar sub [ebx+50],eax y el estado de todos los registros, vámos a interpretar:
POINTER VIDA = 37490B0
INSTRUCCIÓN = SUB [EBX+50],EAX
EBX = 03749060
EAX = 7
Lo que está ocurriendo aquí es la llamada a la instrucción SUB (substract / restar) el valor de EAX a la dirección [EBX+50]
EBX+50 = 03749060 + 50 = 37490B0 (Pointer Address Vida)
En resumen, resta el valor de EAX=7 a nuestra dirección de memoria que almacena los puntos de vida, por lo que dicha instrucción me quita 7 puntos de vida.
Perfecto, ahora ya entra la genialidad de cada uno para reversar dicha instrucción. Hay varias formas y todas son válidas:
•   Cambiar el SUB por un ADD (así en cada golpe, la vida aumentará)
•   Cambiar EAX por 0, quedaría así: sub [ebx+50],0 (así en cada golpe, la vida disminuye en 0)
•   Nopear la instrucción cambiando el sub [ebx+50],eax por varios NOP
De las 3 opciones que os he propuesto, la primera de todas parece la más sencilla. Además a parte de conseguir un godmode, nuestra vida aumentaría en cada golpe. Vámos a probar. Pulsamos el botón “Show disassembler” para abrir la ventana de Memory View:

(http://ns2.elhacker.net/img_cheat_engine/image030.png)
 
CE ya nos ha posicionado en la instrucción 00550474, así que hacemos click derecho en la instrucción y seleccionamos “Assemble” para editarla:

(http://ns2.elhacker.net/img_cheat_engine/image031.png)
 
Y cambiamos la palabra SUB por ADD:

(http://ns2.elhacker.net/img_cheat_engine/image032.png)
 
Os recomiendo que hagáis click derecho de nuevo sobre la instrucción y os guardéis la dirección en el fichero de texto:

(http://ns2.elhacker.net/img_cheat_engine/image033.png)

(http://ns2.elhacker.net/img_cheat_engine/image034.png)
 
 
Así tendréis guardada la dirección para más tarde y ahorraremos tiempo, en mi caso es HackSlashLoot.exe+150474. Cerramos el Memory View y la ventanita del debugger, dejando solo la ventana principal del CE y el juego. Iniciamos un nuevo combate para ver si funciona nuestro “hack”:

(http://ns2.elhacker.net/img_cheat_engine/image035.png)
 
670 puntos de vida! En lugar de disminuir ha aumentado! Bien somos unos hackers-cheaters-crackers de la elite profesional, pero… si intentas matar a tu enemigo haciendo click encima del kobold, verás que por una extraña circunstancia no puedes matarlo… ¿Qué raro, no? Si miramos bien, el juego nos muestra la vida de nuestro enemigo si lo seleccionamos con el ratón:

(http://ns2.elhacker.net/img_cheat_engine/image036.png)
 
Horror! La vida del enemigo también aumenta! ¿Cómo es eso posible? Bueno, esto por desgracia suele ocurrir. El programador del juego está utilizando la misma función para restar vida al jugador y a los enemigos, por eso al haber cambiado el SUB por el ADD, tanto la vida del jugador como la de los enemigos aumenta en cada golpe. Éste efecto se le conoce como Shared Code (código compartido) ya que la instrucción HackSlashLoot.exe+150474 es compartida por más de una dirección de memoria. ¿Hay alguna forma de solucionar éste problema? Sí, sigue leyendo…
 
SHARED CODES
Primero de todo vamos a dejar el juego como estaba, quitando el ADD que pusimos anteriormente por el SUB original, abrimos el Memory View:

(http://ns2.elhacker.net/img_cheat_engine/image037.png)
 
Si hemos cerrado el CE quizás ya no estemos encima de la instrucción original, copiamos la instrucción de nuestras notas (en mi caso HackSlashLoot.exe+150474) y hacemos:

(http://ns2.elhacker.net/img_cheat_engine/image038.png)
 
(http://ns2.elhacker.net/img_cheat_engine/image039.png)
 
Nos situaremos delante de la instrucción, hacemos doble-click encima (o click derecho / “Assemble”) y cambiamos el ADD por el SUB original, así todo estará en su sitio.
 
Ahora lo que os voy a enseñar es un método para comprobar si una misma instrucción modifica más de una dirección de memoria, para ello pulsamos botón derecho encima de la instrucción y seleccionamos “Find out what addresses this instruction accesses”

(http://ns2.elhacker.net/img_cheat_engine/image040.png)

(http://ns2.elhacker.net/img_cheat_engine/image041.png)
 
 
 
Si lo hemos hecho bien, la instrucción quedará marcada en verde y aparecerá una ventana. Sin cerrar la ventana, volvemos al juego e intentamos forzar que dicha instrucción trabaje. Para ello iniciaos un combate hasta recibir algo de daño y causar nosotros daño al enemigo:

(http://ns2.elhacker.net/img_cheat_engine/image042.png)
 
Y aquí tenemos el resultado, han aparecido 2 direcciones que han sido accedidas por la misma instrucción, la primera (104D3490) tiene valor 70 y se corresponde con la vida del enemigo (ver foto). La segunda dirección (037490B0) es la dirección de mi vida, además su valor coincide con la vida de mi personaje (ver foto). Está más que claro que ésta instrucción ha modificado ambas direcciones, por lo que si cambiamos el SUB por un ADD afectará tanto a mi vida como a la vida de los enemigos.

Bueno, pulsamos STOP para que CE deje de observar la instrucción (la instrucción ya no estará marcada en verde) y dejamos la ventanita con las 2 direcciones abierta). Ahora que ya conocemos el método para saber cuando estamos delante de un Shared Code os explicaré como diseccionar la estructura del jugador y la del enemigo para buscar diferencias y poder aplicar un ADD en el caso que sea el jugador y un SUB en el caso de un enemigo.

DISECCIONAR SHARED CODE
Seguimos! Hemos encontrado una instrucción del tipo Share Code”, os dejo el resumen:
DIRECCIÓN   =   HACKSLASHLOOT.EXE+150474
OPCODES   =   SUB [EBX+50],EAX
TIPO      =   SHARED CODE

Sabemos que el offset +50 de la estructura es donde el juego almacena la vida, dependiendo del valor de EBX la instrucció modificará la dirección del jugador o la del enemigo. Está clarisimo que tendremos que ver el estado de los registros para saber la dirección afectada, para ello hacemos click drecho en nuestra dirección del jugador y seleccionamos “Show register states”:

(http://ns2.elhacker.net/img_cheat_engine/image043.png)
 
Se nos abrirá una mini ventana con el estado de los registros, hacemos lo mismo con la dirección del enemigo y ponemos las 2 ventanas una al lado de la otra:

(http://ns2.elhacker.net/img_cheat_engine/image044.png)
 
Nos fijamos en los registros EBX, naturalmente EBX apunta al inicio de la estructura de cada jugador (nuestro player y el enemigo). Si miramos con más atención, el registro ESI tiene el mismo valor que EBX en el caso del Player pero en el caso del Enemigo ESI no vale lo mismo que EBX.

Pues de ésta forma tan sencilla acabamos de inventarnos un método para conocer cuando la instrucción está modificando el address del player o del enemigo, dicho método es una simple comparación:

CMP EBX,ESI
JNE ENEMIGO

O lo que es lo mismo, comparamos el valor de EBX con ESI y saltaremos a “ENEMIGO” si no son iguales. ¿Qué os parece? Habría otras formas para diferenciar ambas estructuras, pero la que a mi se me ha ocurrido es ésta. Ahora solo falta decirle a CE que sepa diferenciar el Shared Code y nos haga un ADD o un SUB cuando nosotros queramos.
 
CREANDO EL CHEAT GODMODE

(SEGUNDO INTENTO) : AUTO-ASSEMBLE
Cerramos la ventanita para quedarnos delante del Memory View con la instrucción seleccionada. Vamos al menú “Tools / Auto-Assemble”:

(http://ns2.elhacker.net/img_cheat_engine/image045.png)
 
Se nos abrirá un editor de Auto-Assemble (a partir de ahora AA), podemos escribir a mano todo el script pero CE tiene un par de plantillas que nos ahorrarán mucho trabajo, hay que usar los siguientes menús, hay que hacerlo en el mismo orden que os explicaré:

1.   “Template / Cheat Table framework code”
2.   “Template / Code Injection”
3.   Pulsar OK para aceptar la dirección de nuestra instrucción

Si lo hemos hecho bien obtendremos el siguiente código automático:


(http://ns2.elhacker.net/img_cheat_engine/image046.png)
 
Ahora vamos al menú “File / Assign to current cheat table” y luego “File / Exit”. Si lo hemos hecho bien, la ventana del Auto-Assemble se habrá cerrado y tendremos un script en la ventana principal del CE:


(http://ns2.elhacker.net/img_cheat_engine/image047.png)
 
 
Hacemos doble click encima del script y se volverá a abrir la ventana del Auto-Assemble, desde aquí ya podremos modificar el script para conseguir un godmode como dios manda (valga la redundancia), vámos a identificar cada parte del código:

El script está separado por 2 secciones grandes llamadas [ENABLE] y [DISABLE]. El código de la parte [ENABLE] se ejecutará cuando el script esté activo. Cuando desactivemos el script, se ejecutarán las instrucciones de la sección [DISABLE].
En la parte de [ENABLE] empieza con un alloc() que sirve para reservar una sección de memoria. Por defecto CE nos asignará 2kbytes para inyectar código ASM, dicha sección de código estará bajo la etiqueta NEWMEM. Luego encontramos 3 etiquetas que sirven para identificar partes del código:

•   Returnhere   =   Indica el final del código
•   Originalcode   =   Indica la parte original del código, en nuestro caso el SUB
•   Exit      =   No se utiliza, es lo mismo que Returnhere

Teniendo éstas 3 partes bien identificadas queda muy claro que escribiremos nuestro código bajo la etiqueta NEWMEM, el resto no lo queremos modificar. En el espacio que tenemos entre NEWMEM y ORIGINALCODE escribimos lo siguiente:

CMP EBX,ESI
JNE ORIGINALCODE
MOV EAX,0

¿Que significan éstas líneas? Básicamente lo que estamos realizando primero es comparar el registro EBX con ESI. Anteriormente dijimo que si EBX = ESI significa que es el jugado, en cambio si EBX != ESI entonces es el enemigo. Luego lanzamos un salto condicional JNE (Jump if Not Equal) es decir ”salta si no es igual”, si EBX no es igual a ESI entonces saltará a ORIGINALCODE y ejecutara el SUB, en cambio si EBX es igual a ESI (jugador) no saltará y se ejecutará la instrucción MOV EAX,0 es decir, EAX=0. Con esto lo que conseguimos es que cuando se ejecute el SUB, el registro EAX valdrá 0 y no nos restará la vida. El script te ha de quedar así:

(http://ns2.elhacker.net/img_cheat_engine/image048.png)
 
 
Ahora activamos el script haciendo click en el recuadro y luchamos con algún enemigo. Verás que si eres golpeado, tu vida no decrece. En cambio si golpeas a un enemigo, su vida decrecerá con normalidad. Desactiva el script y abre el Memory View, hacemos un GoTo Address "HackSlashLoot.exe"+150474, aparecerá el código original:

(http://ns2.elhacker.net/img_cheat_engine/image049.png)
 
Ahora pulsamos el script para activarlo y miramos que ocurre en dicha instrucción:

(http://ns2.elhacker.net/img_cheat_engine/image050.png)

 
El código original ha sido sustituido por un jmp 02C50000 (en tu caso podrá ser otro address), hagamos click derecho en el jmp y seleccionamos Follow para ver que hay ahí:

(http://ns2.elhacker.net/img_cheat_engine/image051.png)
 
Lo que encontramos tras ese jmp es el código ASM que hemos inyectado con el Auto-Assemble script, aquí se ve muy claro como trabaja CE, si desactivamos el script, dicha zona de memoria será borrada.
 
DISECCIONAR ESTRUCTURAS

RECORRER LOS OFFSETS “A MANO”
Ahora ya tenemos un script en Auto-Assemble que nos permite activar un cheat tipo godmode y que además es capaz de diferenciar si se trata de un jugador o de un enemigo. Lo que voy a explicar a continuación es como diseccionar una estructura para encontrar otros valores interesantes.

Una estructura en programación consiste en declarar una serie de variables comunes y asignarlas a un “nombre”, ejemplo:
STRUCT PLAYER
{
INT  ID;
CHAR NAME[10];
FLOAT MANA;
DOUBLE HEALTH;
};

En éste caso he creado una estructura llamada player que contiene 4 variables (id, nombre, mana, health). Así es como están programados la gran mayoría de video-juegos. Las estructuras están cargadas en memoria (tiempo de ejecución). Nuestro objetivo será conocer el address de la estructura de nuestro jugador para poder diseccionarla con una herramienta (base-address). Sigamos con el tutorial…
Primero de todo trabajaremos con el juego “original”, así que el script de godmode lo dejamos desactivado. Tenemos ya nuestro pointer que apunta a la dirección de los puntos de vida del jugador. Hacemos click derecho encima del pointer y seleccionamos “Find out what writes to this address”:

(http://ns2.elhacker.net/img_cheat_engine/image052.png)
 
Al tratarse de un pointer nos preguntará si queremos mirar la instrucción que escribe encima del pointer o la instrucción que escribe el address de nuestro pointer. Siempre escogeremos la segunda opción. Se abrirá la ventana del debugger así que volvemos al juego y dejamos que un enemigo nos golpee, acto seguido volvemos a la ventanita y nos aparecerá nuestra instrucción famosa:

(http://ns2.elhacker.net/img_cheat_engine/image053.png)
 
Si hacemos click en ella nos aparece abajo toda la información. Pulsamos el botón “More Information”

(http://ns2.elhacker.net/img_cheat_engine/image054.png)
 
Nos aparece un recuadro con información adicional, he subrallado una frase importante que nos indica CE… nos está calculando cual es la direcció probable de nuestra estructura, en mi caso nos indica 03918860, así que hacemos click derecho encima para copiar la dirección:

(http://ns2.elhacker.net/img_cheat_engine/image055.png)
 
Perfecto, ya tenemos la base-address de la estructura de nuestro jugador, ya podemos diseccionarla! Cerramos la ventana de “More Information” y la ventanita del debugger. Nos situamos en la ventana principal de CE, pulsamos en Memory View y luego en el menú: “Tools / Dissect data & structures”:

(http://ns2.elhacker.net/img_cheat_engine/image056.png)
 
Se abrirá una ventana grande de color blanco, en la parte superior podremos escribir una address. Lo que hay que hacer es escribir la base-address de nuestra estructura (en mi caso 03918860):

(http://ns2.elhacker.net/img_cheat_engine/image057.png)
 
Vámos al menú: “Structures / Define New structure”. Nos preguntará que nombre queremos asignar, puedes poner lo que quieras, yo puse PLAYER. A continuación nos preguntará si queremos que CE rellene automáticamente la estructura:

(http://ns2.elhacker.net/img_cheat_engine/image058.png)
 
Le diremos YES para ahorrarnos trabajo, jeje. Luego nos preguntará el tamaño. Por defecto CE asigna 4096 offsets. Bajo mi punto de vista son demasiados, así que yo lo bajo a 1024 o 2048:

(http://ns2.elhacker.net/img_cheat_engine/image059.png)
 
Finalmente, tras definir el tamaño, CE cogerá la base-address de la estructura y la diseccionará 1024 offsets, obtendremos lo siguiente:

(http://ns2.elhacker.net/img_cheat_engine/image060.png)
 
No nos asustemos, vámos a interpretar la información que nos proporciona CE… ¿recuerdas que offset corresponde a los puntos de vida? Puedes mirar las notas o el pointer que tenemos en la tabla:

(http://ns2.elhacker.net/img_cheat_engine/image061.png)
 
Pues sí, la vida está situata en el offset +50, si miramos la estructura diseccionada veremos que se corresponde al valor del pointer y a los puntos de vida:
 
 
(http://ns2.elhacker.net/img_cheat_engine/image062.png)

(http://ns2.elhacker.net/img_cheat_engine/image063.png)

Ahora a partir de aquí es cuestión de “tocar, explorar y probar”. Mi recomendación personal es que cerca de un offset válido se encuentran el resto de offsets de la estructura. Lo primero que ahoremos es poner un nombre a los offsets conocidos, por el momento solo conocemos el offset +50 así que damos doble-click encima y le pones un nombre:

(http://ns2.elhacker.net/img_cheat_engine/image064.png)
 
Ahora lo interesante sería poder detectar que offsets se corresponden al ataque, rango, magia, defensa, etc… estoy seguro que esos offsets estarán cerca de la vida (+50) así que miraré los offsets cercanos y los compararé con mi jugador:
 
(http://ns2.elhacker.net/img_cheat_engine/image065.png)


(http://ns2.elhacker.net/img_cheat_engine/image066.png)
 
Me llama la atención el offset +34… tiene un valor de 40 que coincide con los 40 puntos de daño en el juego:

(http://ns2.elhacker.net/img_cheat_engine/image067.png)
 
Así que hacemos click derecho encima del offset +34 y seleccionamos la opción “Change Value” e introducimo un nuevo valor, por ejemplo 77


(http://ns2.elhacker.net/img_cheat_engine/image068.png)

 
BINGO! El offset +34 es el encargado de almacenar el daño (Melee Attack) así que hacemos doble-click para editarlo y apuntamos el offset a nuestras notas:
 
(http://ns2.elhacker.net/img_cheat_engine/image069.png)

Está clarísimo que los offsets entre +34 y +50 serán los otros stats, así que iremos editando cada offset para conocer su valor en el juego y lo anotaremos en nuestra disección y en nuestras notas. Así me ha quedado a mi:


(http://ns2.elhacker.net/img_cheat_engine/image070.png)
 
Bueno, ya tengo la estructura diseccionada al completo, hay otros offsets, quizás alguno esté almacenando algo interesante, pero eso ya lo veremos más adelante. Ahora ya tenemos la estructura diseccionada con los offsets principales. Solo nos queda poder calcular automáticamente la base-address de nuestra estructura para luego sumar +50 +34 +etc… e ir sacando cada una de las direcciones importantes. ¿Cómo lo hacemos? Pues tendremos que encontrar un patrón que no sidentifique la base-address de la estructura de nuestro jugador. Empezemos…
 
LOCALIZAR ESTRUCTURAS DINÁMICAS

AOB TO MEMORY DATA
Necesitamos encontrar un patron en la memoria del programa/juego que nos identifique la base-address de forma automática. El método es muy sencillo, hay que buscar la base-address manualmente y copiar los bytes que contiene dicha base-address. Éstos pasos hay que repetirlos varias veces, dependiendo del juego y de su complejidad, necesitarás repetir ésta operación 5, 6, 7 o 10 veces. En el caso de Hack, Slash, Loot he realizado 5 búsquedas hasta encontrar un patrón válido.
Podemos empezar de varias formas, pero a mi me gusta partir siempre de la instrucción que modifica un offset de nuestra estructura. En las notas tenemos apuntado lo siguiente:

(http://ns2.elhacker.net/img_cheat_engine/image071.png)
 
Sabemos que la instrucción HackSlashLoot.exe+150474 modifica el offset +50 de nuestra estructura, así que abrimos el Memory View, hacemos click derecho y pulsamos “GoTo Address”:

(http://ns2.elhacker.net/img_cheat_engine/image072.png)
 
Estaremos delante de la instrucción famosa SUB que se encarga de restar la vida, así que pondremos un breakpoint en dicha instrucción (si pulsas F5 se pone el Breakpoint) o podemos hacer click derecho y seleccionar “Toggle Break Point”. Se nos quedará marcada la instrucción en verde indicando que hay un breakpoint:
 
 (http://ns2.elhacker.net/img_cheat_engine/image073.png)

Ahora volvemos al juego, iniciamos una pelea y dejamos que el enemigo nos golpee, verás que el juego se queda “congelado” ya que el breakpoint ha detenido la ejecución del juego así que volvemos a CE y nos encontraremos lo siguiente:

(http://ns2.elhacker.net/img_cheat_engine/image074.png)
 
A la derecha aparece el stack y los registros. Lo que nos interesa son los registros para poder conocer la base-address de nuestra estructura. La instrucción es sub [ebx+50],eax por lo que el valor de EBX nos mostrará la base-address, en mi caso 03918860. Pulsamos click-derecho sobre EBX y seleccionamos “Show in hex view”:
 
 (http://ns2.elhacker.net/img_cheat_engine/image075.png)

Automáticamente, en la parte inferior (Hex Dump) nos mostrará la dirección de EBX (03918860), en mi caso:

(http://ns2.elhacker.net/img_cheat_engine/image076.png)
 
Lo que tenemos que hacer ahora es coger esos bytes y copiarlos a nuestras notas. Yo siempre cojo 3 líneas. Para ello con el ratón seleccionamos desde el primer byte hasta el último (se quedarán marcados en rojo) y pulsamos Ctrl+C para copiar, a continuación los pegamos en nuestro fichero de texto:
 
(http://ns2.elhacker.net/img_cheat_engine/image077.png)

(http://ns2.elhacker.net/img_cheat_engine/image078.png)
 
Esos son los bytes que se corresponden a la base-address de la estructura de nuestro personaje. Ahora hay que repetir todos éstos pasos un mínimo de 3 veces. Para ello pulsaremos F9 en la ventana de Memory View para continuar la ejecución a partir del Breakpoint y luego cerraremos por completo el juego. Abriremos de nuevo el juego, iniciaremos una nueva partida y volveremos a seleccionar el proceso de Hack, Slash, Loot para trabajar con CE. A partir de aquí hay que repetir los pasos de éste tutorial, es decir:
•   Iniciar el Memory View
•   Ir a la instrucción que modifica la estructura, en nuestro caso HackSlashLoot.exe+150474
•   Poner un Breakpoint
•   Iniciar un combate en el juego hasta recibir daño
•   Mirar los registros (EBX) y hacer “Show in hex view”
•   Copiar los bytes al fichero de texto
•   Cerrar el juego y volverlo a iniciar para empezar de nuevo
Estos pasos los he realizado 5-6 veces y al final he conseguido las siguientes líneas:

(http://ns2.elhacker.net/img_cheat_engine/image079.png)
 
Ahora solo tenemos que calcular un patrón válido partiendo de éstas muestras. Se puede hacer a mano, pero para los más perezosos he programado un script en lenguaje VBS que realizará el cálculo automáticamente
 
SCRIPT VBS - AOB PATTERN GENERATOR
El código VBS está en pastebin, solo tienes que copiarlo en un notepad y guardarlo con extensión *.vbs
 http://pastebin.com/tQsvbSkh
Set oWSH = CreateObject("WScript.Shell")
Set oFSO = CreateObject("Scripting.FileSystemObject")

T = InputBox("Enter array of bytes nº 1:")
T = T & vbcrlf & InputBox("Enter array of bytes nº 2:")

X = 3
While MsgBox("Do you want to introduce another array of bytes?", vbYesNo, "AoB Pattern Generator") = vbYes
   T = T & vbcrlf & InputBox("Enter array of bytes nº " & X &":")
   X = X + 1
Wend

AoB = Split(T, vbcrlf)

F = ""
W = 0
X = 0
For i = 1 To Len(AoB(0))
   For u = 1 To UBound(AoB)
      If Mid(AoB(u), i, 1) <> Mid(AoB(0), i, 1) Then
         F = F & "?"
         W = W + 1
         X = 1
         Exit For
      End If
   Next
   If X <> 1 Then F = F & Mid(AoB(0), i, 1)
   X = 0
Next

Set File = oFSO.CreateTextFile("aob.txt")
   File.Write "Original array of bytes:" & vbcrlf & vbcrlf
   File.Write Replace(T, vbcrlf & vbcrlf, vbcrlf) & vbcrlf & vbcrlf
   File.Write "Total array of bytes: " & UBound(AoB) + 1 & vbcrlf
   File.Write "Total wildcards used: " & W & vbcrlf & vbcrlf
   File.Write "Your AoB Pattern:" & vbcrlf & vbcrlf & F
File.Close

'MsgBox F

If MsgBox("AoB Patter Generator finished" & vbcrlf & vbcrlf & "Do you want to open aob.txt file?", vbYesNo, "AoB Pattern Generator") = vbYes Then
   oWSH.Run "notepad.exe aob.txt"
End If
El script comparará todos los bytes y buscará un patrón. Si un byte no coincide será sustituido por el carácter ?. Al final, mi script me dice que el Array of Bytes (AoB) es:
18 12 BB 00 0? 00 00 00 ?? ?? ?? 0? ?? ?? ?? 0? 03 00 00 00 03 00 00 00 ?? 00 00 00 ?? 00 00 00 0? 00 00 00 ?? ?? ?? 0? 00 00 00 00 ?? ?? ?? ??
 
Como puedes observar, se puede calcular fácilmente a mano, solo hay que sustituir los bytes que no son iguales por un simbolo de interrogación. Ahora ya tenemos un array de bytes que identificará la base-address de la estructura. Volvemos al CE, abrimos el Memory View y nos vamos al editor de Auto-Assemble (Ctrl+A) en el menu “Tools”, en el editor pegamos el siguiente código:
[ENABLE]
aobscan(player, 18 12 BB 00 0? 00 00 00 ?? ?? ?? 0? ?? ?? ?? 0? 03 00 00 00 03 00 00 00 ?? 00 00 00 ?? 00 00 00 0? 00 00 00 ?? ?? ?? 0? 00 00 00 00 ?? ?? ?? ??)
label(_player)
registersymbol(_player)
player:
_player:
[DISABLE]
unregistersymbol(_player)
Solo tendrás que sustituir el array AoB por el valor que hayas encontrado. Una vez copiado el texto vamos al menu: “File / Asign to current cheat table” para añadir el script a la tabla, obtendremos lo siguiente:

(http://ns2.elhacker.net/img_cheat_engine/image085.png)
 
Mi recomendación es que edites los nombres para no confundirte:

(http://ns2.elhacker.net/img_cheat_engine/image086.png)
 
El script es muy sencillo, cuando lo activamos lanzamos un AoB Scan (buscar un array de bytes) y le indicamos que busque nuestro patrón de bytes, CE localizará la coincidencia y nos devolverá el resultado en la etiqueta _player. Eso significará que podremos utilizar la etiqueta _player para referirnos al inicio de la estructura (base-address).
Volvemos al CE y seleccionamos “Add Address Manually”
 
 
En el recuadro hay que poner la dirección que queremos añadir, como la dirección es dinámica, introduciremos la variable _player, añadimos tambien una descripción para no confundirnos:
 
(http://ns2.elhacker.net/img_cheat_engine/image087.png)
 
Pulsamos OK y se añadirá la dirección:

(http://ns2.elhacker.net/img_cheat_engine/image088.png)
 
Actualmente CE no reconoce la dirección _player, por eso no muestra nada. Ahora lo que haremos es activar el script con el AoB y sucederá la magia…
 
Tachan!! CE ha ejecutado el AoB, ha buscado el patrón de bytes y ha devuelto el resultado en la variable _player, ahora CE ya sabe el valor de dicha dirección y nos muestra 0FF3AAA0 que se corresponde al actual base-addres de la estructura de nuestro personaje. A partir de aquí ya tenemos el camino hecho, solo falta completarlo.
Desactivamos el script y volvemos a pulsar “Add Address Manually”, añadiremos ahora la siguiente dirección:

(http://ns2.elhacker.net/img_cheat_engine/image089.png)
 
 
La explicación es sencilla; estamos añadiendo una nueva dirección que será base-address+50 que según nuestras notas se corresponde al offset de la vida. Hacemos lo propio con los offsets encontrados:
•   +50   =   HP
•   +40   =   DEF
•   +34   =   Melee Atk
•   +38   =   Range Atk
•   +3c   =   Magic Atk
•   +44   =   Melee Dmg
•   +48   =   Range Dmg
•   +4c   =   Magic Dmg
Obtendremos lo siguiente:
 
Ahora que ya tenemos todos los offset introducidos solo falta activar el script AoB para recoger la estructura:

(http://ns2.elhacker.net/img_cheat_engine/image090.png)
 
BAMP! De un solo golpe ya tenemos todos los valores. Además como estamos usando un AoB Scan, en la próxima ejecución del juego CE buscará la base-address y la guardará en _player, por lo que podremos visualizar y editar las direcciones dinámicas de la estructura de nuestro jugador.
 
Os recomiendo que con vuestro ratón ordenéis la tabla y dejéis todos los offsets “dentro” del script:

(http://ns2.elhacker.net/img_cheat_engine/image091.png)
 
Para luego hacer click derecho en el script y seleccionar:

(http://ns2.elhacker.net/img_cheat_engine/image092.png)
 
Así los offsets permanecerán ocultos si el script está desactivado y se mostrarán cuando activemos el script.
Bueno, pues de ésta forma se consigue encontrar un patrón de bytes que apunte a una estructura dinámica para luego sacar los offsets estáticos de su interior. Practicad!
 
BONUS: COMPARAR ESTRUCTURAS CON WINMERGE
TELEPORT HACK
Ya que hemos llegado hasta aquí nos podemos esforzar un poco más para terminar de rizar el rizo. Os voy a explicar como utilizar el programa WinMerge para comparar 2 estructuras y buscar los offsets de forma casi automática. Primero de todo nos descargamos WinMerge de su web y lo instalamos: http://winmerge.org/
Nuestro objetivo es crear un Teleport Hack, la mayoría de juegos almacenan en la propia estructura del personaje su posición en el plano X / Y. Si se trata de un juego en 3D tendremos un tercer eje llamado Z. En el caso de Hack, Slash, Loot, solo habrá 2 coordenadas para posicionar al jugador, vámos a intentar sacarlas.
Abrimos CE, abrimos el proceso de HSL y cargamos nuestra tabla con el pointer, los scripts en Auto-Asemble y la estructura diseccionada.
 
 
Pulsamos el script “Search Player Structure”, la función AoB Scan hará su trabajo y nos devolverá la estructura rellenada:

(http://ns2.elhacker.net/img_cheat_engine/image093.png)
 
Hemos activado el script para cargar la base-address de la estructura de nuestro jugador en la variable _player. Ahora abrimos el Memory View y vamos al menú “Tools / Dissect data & structures”:

(http://ns2.elhacker.net/img_cheat_engine/image094.png)
 
En el recuadro para la base-address podemos poner _player, CE se encargará de interpretar la variable. Abrimos el menú “Structures” y seleccionamos la estructura que ya hicimos en el capitulo anterior:

(http://ns2.elhacker.net/img_cheat_engine/image095.png)
 
 
CE nos mostrará la estructura _player con sus offsets:

(http://ns2.elhacker.net/img_cheat_engine/image096.png)
 
Ahora, sin tocar nada más, abrimos el menú: “File / Save values (Ctrl+S)” y guardamos con un nombre, por ejemplo “struct_1.txt”
A continuación volvemos al juego y desplazamos nuestro personaje un par de casillas, asegurando que mueves tanto el eje X como el Y (por ejemplo, moviéndote una casilla arriba y otra a la derecha). Volvemos a la ventana de “Structure dissect” y pulsamos de nuevo menú: “File / Save values (Ctrl+S)” para guardar la estructura, pondremos otro nombre, por ejemplo “struct_2.txt”
Ahora ya tenemos 2 ficheros de texto con la misma estructura pero con el personaje en 2 posiciones diferentes. Toca hacer trabajar a WinMerge para conocer las diferencias de ambos ficheros:

(http://ns2.elhacker.net/img_cheat_engine/image097.png)
 
Cargamos los 2 ficheros para comparar y pulsamos Aceptar, WinMerge nos mostrará cualquier línea que esté diferente:

(http://ns2.elhacker.net/img_cheat_engine/image098.png)
 
Y aquí tenemos claramente las diferencias, offsets +18 +1C. En la primera estructura tenian el valor de 48/14 y luego han pasado a 47/15. Ahora solo queda identificar que offset es la X o la Y y crear la dirección manual como ya vimos anteriormente:

(http://ns2.elhacker.net/img_cheat_engine/image099.png)

(http://ns2.elhacker.net/img_cheat_engine/image100.png)
 
 
Finalmente guardamos los cambios en nuestra tabla, activamos el script y nos movemos por la pantalla para ver funciona. Los valores de X/Y se pueden editar a mano para desplazar al jugador por la pantalla. También se podría crear un Auto-Assemble script que almacene la posición actual de X/Y y luego con un hotkey volver a setear los offsets al valor guardado para hacer un teleport-hack. Pero eso ya es algo más avanzado y tengo demasiado sueño como para seguir expllicando cosas.

 
DESPEDIDA
Bueno, hasta aquí el tutorial, espero que os haya gustado, me ha tomado 2 días escribirlo, tomar las fotos y maquetarlo. Espero que lo disfruten y puedan probar todas y cada una de las cosas que he explicado. Nos vemos por el foro…

MadAntrax – 26/04/2014

[eof]


Descargar PDF:
http://ns2.elhacker.net/Tutorial_Cheat_Engine_Avanzado.pdf

** Intentaré hablar con el-brujo para ver si existe alguna forma automática de traducir el tutorial a BB-Code y postearlo en el foro, por el momento posteo el ZIP para que lo podáis descargar.

http://ns2.elhacker.net/Tutorial CheatEngine Avanzado - MadAntrax.zip (http://ns2.elhacker.net/Tutorial CheatEngine Avanzado - MadAntrax.zip)

Saludos! Espero respuestas y críticas (aunque sean negativas)

Ya me he bebido la mitad y está muy bien explicado ^^

Eso sí, he intentado sacar un puntero estático en otro juego (LoL) y (después de abrir 5 juegos diferentes y comparar y buscar valores) aún son más de 100.000, por lo que lo veo poco viable no? ¿Algún consejo?

Salud

En el tutorial creo que no lo he explicado, pero lo normal en un juego "grande" es obtener alrededor de 10000 punteros. Cualquiera de ellos sería válido. Haz una prueba: de tus resultados agrega 5 punteros aleatorios y verás que siempre son esos. No tienes que realizar búsquedas hasta encontrar un pointer.

El resto del tutorial como lo has visto? Has hechso las practicas con el ejemplo de Hack, Slash, Loot?

Saludos

He desperdiciado dos horas de mi vida :P


Sí. Es más, primero lo conseguí y luego leí tu recomendacion de 'a quién pedirselo' (a ese se lo había pedido xD).
El tutorial está muy bien explicado. Pero con estas cosas me gusta ir poquito a poco y asimilando lo que aprendo, que demasiados conceptos nublan. Me he quedado en los Shared Codes. Mañana seguiré tocando lo que he visto hoy (y estudiaré que el martes tengo examen) Y a partir del martes seguiré con el tuto ;)

Saludos y gracias ;)

Excelente, muy bien explicado...  ahora se que hacer cuando me encuentro frente a "shared codes"


Gracias!

¡Que pedazo de tutorial!
Bien maquetado, presentado, escrito y muy útil.

Excelente aporte!!!

Chic@s descargarlo que merece y mucho la pena!!!!

Gracias jeje.

A día de hoy tengo más temario para añadir (creación de patrones AoB estáticos o con wildcards para dumpear estructuras y offsets a punteros estáticos). Si veo que el tutorial agrada a los usuarios y piden más información o métodos, añadiré el anexo.

Saludos!

Buenas Mad... Y una vez que tenemos la dirección estática mediante AoB (por ejemplo) que en este caso era cómo hacemos para poder usar esa dirección estática en c++ o VBasic?

Saludos y gracias, es un muy gran aporte ;)

hola amigo mil gracias x tu aporte!!!!!!!!!!!!!!!!! mil años esperando que aparecieras de nuevo ;) lo prometido es deuda y lo cumpliste!!!!!!! ahora a absorver tu sabiduria y ponerla en practica!!!

No sabía lo del Structure Dissect, yo usaba el ReClass :P

Muy buen tutorial.

mil gracias amigo por dedicarnos tiempo!!!!!     :laugh:   he buscado durante bastante tiempo tutoriales sobre este tema y nunca hay, y de haber, no son ni la mitad de buenos en contenido y explicacion como este!!!!!!!!!!! gracias bro desde cuba!!!!! te daria un beso y un abrazo pero eso seria demasiado gay jajajjajaj  :huh:  como sea, aqui ando de vacaciones y solo he empleado mi tiempo en leer y practicar!!!! otra vez mil gracias     

Gran tutorial.
Ya he leído gran parte y seguiré en otro momento para terminarlo sin duda. Yo ya usaba el CE para sacar pointers y tal, pero el tema de la disección de estructuras y demás nunca lo había hecho, pero la verdad que está muy interesante.

Buen trabajo Mad!

Gracias a todos por los agradecimientos. Tengo intención de ampliarlo un poco más, ya que me quedaron un par de cosas en el tintero. Además me gustaría introduciros a la programación "manual" de trainers avanzados.

Para los que estén revisando el tutorial, recomiendo la versión en PDF, que está mejor maquetado y en el ZIP viene con las herramientas para seguir el tutorial

Veo que han surgido dudas, en cuanto tenga un poco de tiempo contestaré a NikNitro!

Saludos!

HOLA AMIGO SI TE SIRVE DE ALGO YO ENCONTRE UNA SOLUCION A ESO, SIEMPRE DEBES FIJARTE EN EL OFFSET 0 QUE CONCIDA CON TU OFFSET, Y LUEGO EL ADDRESS DEBE COINCIDIR CON EL DE CE, ESA COINCIDENCIA SOLO APARECERA EN EL POINTER QUE ESTAS BUSCANDO, Y SI POR EJEMPLO EL OFFSET ES DE 50, TE ACONSEJO EN LA PESTAÑA O BOTON OFFSET 0 DARLE CLICK PARA QUE TE LOS ORGANICE DE MENOR A MAYOR Y TE SEA MAS FACIL ENCONTRAR TU OFFSET. AHORA, HAY VECES QUE TE SALE MISMO POINTER QUE ESTAS BUSCANDO REPETIDO, ES DECIR EL MISMO OFFSET, MISMA ADDRESS DE CE, YO AGARRO EL PRIMERO Y PRUEBO EL HACK, SI FUNCA ME LO QUEDO, SI NO PRUEBO OTRO. ;) SUERTE

BRO TODO EXCELENTE!!!!!!!! DE HECHO TENGO UN JUEGO QUE LLEVABA CASI UN AÑO TRATANDO DE HACKEAR Y NO HABIA PODIDO MAS QUE ENCENDERLO JUGARLO Y APAGARLO Y CON ESTE TUTO YA PUDE HACER MI PRIMER TRAINER SUPER SENCILLO PERO TRAINER!!!!!!!!!!!!    :o   


AHORA ME TRABE EN LA PARTE DE ESTRUCTURAS DINAMICAS DONDE SE AGREGA LA ADDRESS MANUAL, de hecho estoy en el search player structure, NO LO PUEDO ACTIVAR, YA DE AHI NO PUEDO AVANZAR, ES DECIR SI AGREGO LAS DIRECCIONES MANUALES ME SALEN CON EL VALOR EN ???, PERO YA NO LOGRO ACTIVAR EL SCRIPT. AYUDA PORFAS

gracias, se agradece

queria haceros 2 preguntas:

se puede hacer portable el cheat engine? ya sea con thinapp o similares, no instala drivers ni nada?

es mejor el artmoney o el cheat engine?

excelente man , tengo una consulta el cheat engine es detectado por algunos protectores de juegos como por ejemplo

el xtra-p

sabes o conoces como hacer "un scanner de memoria" propio

Mucha gracias por tu aportaso man.
una consulta, no se si pondrias un tute como se configura el cheat engeni para cada tipo de juego y/o como hacerlo oculto o bypasearlo para que no lo detecte el juego. yo recuerdo que hace años hacian trainers para juegos, y siempre ,me ha gustado saber por que lo configuran asi Gracias.

bro una pregunta aparte de la primera  :rolleyes:

En este caso el juego es de la siguiente forma aqui tienes una foto

(http://i57.tinypic.com/30cn7gm.jpg)

Como hago para saber cuando me atacan me bajan la vida "ojala me entiendas"

las vidas son esas lineas verdes

Busca un valor desconocido y cuando te ataquen busca los que hayan disminuido. Así hasta que la encuentres.

Salud

los datos los almacena en float man alguna demo ?

muy pero muy completo tu guia increible.. solo queda agradecerte por el tiempo y dedicacacion que le has puesto. ya he logrado hacer algunas cosillas en juegos que no son oline y hasta ahí todo bien. la primera parte de tu tutorial me ha servido de mucho y en esta segunda parte esperaba intentar trucar un juego online (por ejemplo en el zoom o teleport o cosas así en los cuales las memorias se ubican en tu pc) y me ha surgido un problema.. y es que ni empezar pude ( jajajaja ) ya que al buscar direcciones me aparecen muchisimas y la verdad al darle a increased o decreased dependiendo del caso me baja como minimo a 200 o 250 mas o menos.. y como verán pues ni empezar puedo realmente es frustrante no saber con que dirección trabajar ( he cogido una al azar como dicen pero no funciona ).. lo que quiero es concretamente cómo buscar direcciones en jugos online ( por lo menos algún tip debe haber ) ya que como he dicho son demasiadas las adres que me aparecen.. espero respondan mi duda (pillos ya se que la mayoria intenta usar CE en juegos online y muchos lo logran, ¿ cómo buscan direcciones o masomenos los tips para encontrar la dirección exacta del proceso que quieres encontar? ) de antemano gracias por responder. y otra vez MUCHAS GRACIAS POR EL TUTORIAL AL CREADOR DEL TUTO MIS AGRADECIMIENTOS Y FELICITACIONES.

PD: el juego que quiero intentar trucar se llama Tantra..

Excelente manual Mad, a mi si me interesa profundizar mas en estos temas.
Yo tengo una pregunta, tengo 2 variables estaticas, y quiero copiar el valor de una a la otra, es posible hacerlo con los scripts?.

buen tuto men . se nota que sabes lo que ases ;-) . podrias hacer un tutorial de cuales son las funciones y como usar correctamente charlesproxy . porfavor te lo rruego se que hacer un totorial cmo este no es nada facil . pero quiro ser un hacker profesional . realmente me interesa muchisimo el tema . ;D .

Muy buen tutorial, muy completo y detallado.

Felicidades y gracias por el aporte


Enviado desde mi iPhone utilizando Tapatalk

Solo pasaba por aquí para agradecerte por este gran tutorial, después de tu otro tutorial de " Usar Cheat Engine para modificar juegos + inyección de código " , pues vine aquí, ya me habia descargado este tutorial en PDF, y pues recién hoy lo he leído como para hecharle un vistazo, y me he leído todo el tutorial :D, porque ha estado muy interesante. ¡Muchas Gracias!

Oye puede hacer un tutorial como usar memory view de cheat engine? porfa :silbar:

El memory View de CE es muy parecido a un debugger, arriba muestra los opcodes (bytes y asm) de la memoria del ejecutable (o de sus modulos). Abajo tienes el dump. Puede sponer breakpoints, saltar y modificar registros, etc... Evidentemente no le llega ni a la suela de los zapatos a ollydbg, pero para trucar un juego random tienes las herramientas suficientes para hacerlo.

No sabría como preparar un tutorial de esa utilidad... en el tutorial que hay posteado en 1 lo trabajo un poco (breakpoints, saltar al debugger, controlar los registros, etc...)

Un saludo!

exelente tuto, da gusto leer y aprender :D muchas gracias


una duda, este tuto sirve para games online? e intentado sacar el pointer de un game online. cuando pongo pointer scan y abro el scan anterior, encuentra 0 pointer. (el primero si encontro 3m)


saludos y gracias sigue subiendo este material tan bueno :D

Bueno como vais con el tutorial? Tenéis ganas de más? >:D Durante éstos días he seguido investigando y aprendiendo más técnicas de cheating. Estoy desarrollando la continuación del tutorial avanzado.

En el último capitulo os enseñé como sacar las coordenadas que posicionan a nuestro héroe en la pantalla (coordenadas X/Y), para juegos en 3D hay una tercera coordenada Z. Si os parece bien podemos enfocar el nuevo tutorial trabajando las coordenadas, ya que dan mucho juego:

- Teleporthack con saveslots
- Inmovilicar NPC's enemigos
- Flyhack
- Infinite Jump
- Y un largo etc...

Dominar las coordenadas de un juego con Cheat Engine te abre muchas puertas para modificar el juego, creo que puede salir un tutorial divertido. Aún lo estoy terminando de redactar, pero posteo éste mensaje para me hagáis propuestas sobre otros temas, si queréis repasar alguna lección, trabajar más el godmode, estructuras... vosotros diréis!!

Ésta semana un usuario del foro se puso en contacto conmigo para ayudarle con un cheat de un juego en concreto, al final con TeamViewer hicimos una clase "en vivo" y pude trabajar con él temas de estructuras, shared code y data-to-pointer utilizando globalalloc(). Si os interesa éste tema podría mirar de incluirlo también.

Ya os avanzo que tocaremos muchísima inyección de código, comparaciones y ASM en general, así que agarraos el culo!

 :rolleyes: :rolleyes:

Yo no he podido avanzar con la duda sobre crear en c una aplicación que se encargue de leer datos del juego (porque no se como hacerla buscar la dirección estática de forma automática) -.-

Saludos;)

Preguntaste tu duda en el foro de C/C++? Hay librerias y toolkits preparados para hacer ese tipo de procesos, yo tengo una para VB6 que funciona muy bien, incluso hay una función interpretada para realizar un AoBScan(). De todas formas para continuar con el tutorial on necesitas hacer eso.

Saludos

Hola! muy bueno el tutorial lo entendi a pesar de que no se mucho de informatica  :laugh:  quería preguntarte si me podes enseñar a hacer lo mismo pero en un juego online que usa Unity Web Player?

Como has podido leer en mi firma, no ayudo a modificar juegos online. El 90% de juegos online están programados de tal forma que las principales variables se almacenan en el servidor (server-sided). Programas de edición de memoria local (como Cheat Engine) no son capaces de conseguir resultado con juegos online. Para ello deberás adentrarte al mundo de la edición de paquetes TCP, pero ya te adelanto que es complejo.

Un saludo

Estaba probando lo de los paquetes TCP pero:
El juego cuando esta en single player se conecta con el servidor solo para cargar los datos del jugador e iniciar sesión, el juego prácticamente esta en la PC.
Se intercambian paquetes TCP solo en multijugador y todos son para poner a los otros jugadores en el juego.
Hay cosas del juego que no son hackeabes como la salud o el XP porque son guardados en el server pero hay hacks del juego que lo que hacen cambiar las variables del juego que afectan al jugador, como por ejemplo editar un valor para que el jugador sea invisible en vez  de hacerlo inmortal o detener el movimiento de todo el juego menos del jugador.
Y por últimos, con el Cheat Engine ya hackee el juego buscando los valores con la opción de array of byts y editarla.
No se si me explique bien no se casi nada de ingeniería inversa. Perdón por la insistencia. :-[
PD: No te estaba pidiendo ayuda para modificarlo si no que me digas como es que funciona.  :rolleyes: :rolleyes:

Correcto, la mayoría de juegos tienen sus variables importantes en el servidor (como la salud o XP que comentas). Pero los programadores a veces no pueden poner todas las variables en el server y algunas se controlan desde local. En esas casos podrás utilizar CE de forma habitual.

Lo más común es encontrar timers locales y coordenadas, por eso es viable crear un speedhack en muchos juegos online o teleporthack. En juegos donde sueles teener algñun tipo de cooldown (tiempo de espera entre ataque y ataque) se suele controlar desde local. ¿Como conseguirlo? Pues probando, la mayoría de coldowns son de tipo float y van desde XXX.XX hasta 0 para indicar al juego si puedes efectuar una acción o movimiento. En el caso de las coordenadas mira si es un juego en 2D o 3D y busca con increased o decreased cuando te muevas por el eje X, Y

Si queréis puedo ampliar la parte 2 del tutorial utilizando un ejemplo de juego online.

Saludos y suerte!!

Me gustaría que hagas un tutorial  ;D 
también me gustaría aprender a manejarme dentro de la memoria
Voy a ver si se pueden ver las coordenadas desde el CE, no me serviría mucho pero me ayudaría a comprender mejor como se maneja el juego internamente.

También seria interesante el como buscar en juegos programados con C# o mono, tipos de ofuscacion de datos como por ejemplo XOR u otros métodos para que las variables no estén tal cual en memoria, me he encontrado juegos que guardan en 2 bytes, uno suma cuando llega a 255 vuelve a 0 y suma uno en el segundo, etc...
También no estaría mal un tuto mas avanzado del autoassemble.
Muchas gracias.

Para .net y mono hay programado un datacollector que funciona MUY bien, lo mismo ocurre para juegos en JAVA. Por el momento no dispongo de ningún juego al que pueda aplicar dichos colectores, si conoces alguno dime el nombre y lo ojearé :)

El tema de ofuscación... es bastante complejo explicarlo. Cada juego ofuscado es un mundo y siempre terminarás tirando de ollydbg o similares para conocer a fondo lo que hace el juego. Podría programar algún juego ofuscado y enseñar como sacar el algoritmo, pero eso no significa que la lección explicada pueda aplicarse "tal cual" para el resto de juegos ofuscados... lo pensaré pero quizás para añadirlo en una tercera parte.

Sobre autoassemble nos meteremos de cabeza, intentaré enseñar un poco más a fondo el "poder" de autoassemble. También quiero tocar un poco de LUA, así como la inyección de código en juegos Direct3D (hookear el render y dibujar poligonos encima del juego, para un menú, crosshair, mostrar address y valores por pantalla... etc), aquí un humilde ejemplo:

(http://i.imgur.com/VSpIgOC.png)

Se puede ver el menú azul inyectado con un hook al directx (d3dhook). En resumidas cuentas, para el proximo tutorial hablaré:

- Coordenadas X, Y, Z
- Programar un teleporthack con autoassemble
- Diseccionar estructuras (avanzado)
- Inmovilizar objetos, enemigos o NPC's
- Metodo cheating: Data-to-pointer globalalloc()
- Introducción a la ofuscación (pondré un juego/reto)
- Autoassemble (lo tocaré en los distintos capitulos)
- Introducción al d3dhook()
- Alguna cosilla más.

Sobre el hack de juegos online... se me alarga demasiado el tutorial, ya veré si lo publico o lo dejo para más adelante

:P

Ya, a lo que me refiero es a ver como se pueden guardar las variables en memoria para aprender a buscar bien y no quedarse simplemente con lo básico, entrenar la mente :D.
Efectivamente hay un data colector pero solo vale para sacar las estructuras del juego y diseccionar las creo, cada vez que reinicias el juego a buscar de nuevo.
Juegos .net hay muchos, Terraria por ejemplo, los que estén con xna o unity también, Teslagard.

Bueno, sigo redactando el tutorial, todavía me falta un poco... Por el momento os dejo un juego que he programado para que probéis vuestros conocimientos con CheatEngine. Lo he posteado en el foro oficial de CE (en inglés) pero se entiende bastante bien.

http://forum.cheatengine.org/viewtopic.php?t=577886

(http://i.imgur.com/ltYIgRe.png)

(http://i.imgur.com/AxyDe3k.png)

Aviso que no es para principiantes. El juego tiene un anticheat engine casero bastante jodido, además todas las variables están ofuscadas y con comprobaciones de memoria. No creo que vaya a utilizar éste "juego" como ejemplo para el próximo tutorial, pues es demasiado avanzado y no quiero dejarme las otras cosas sin explicar.

Probarlo y ya me diréis!! :)

Esto es nu desafío??!!! me encantan los desafíos voy a tratar de ver lo que hago con mi poco conocimiento.  :xD

Voy a tener que instalar una VM de windows para probar :)

Hola, una pregunta, estoy intentando utilizar el CE con el resident evil 5, de momento estoy usando lo basico, resulta que estoy cambiando personajes en el momento de jugar con ce, mi duda es la siguiente, en coperativo si lo hago la otra persona no ve el cambio, es decir, si yo cambio x enemigo por "otro" solo lo veo yo, la otra persona no, me gustaria saber que hacer para que podamos ver los cambios los dos, lo que hago es lo siguiente:

Me meto por ejemplo en la primera pantalla, y busco como string "uEm10" es el codigo de los zombis hombres de la primera y de algunas pantallas mas, luego por ejemplo lo substituyo por "uEm11" o "uEm80" el 11 seria mujer, y el 80 seria wesker, al reiniciar la pantalla se cambia perfectamente, pero como digo estos cambios no los puede ver la otra persona en coperativo, como lo hago? thanks.

Depende del tipo de multijugador. El servidor es externo a ti, verdad? Pues de ser así poco puedes hacer... :S

Saludos;)

Hombre, digo yo que alguna forma habra, porque el trainer que rula por internet que se llama wilsonso, puedes cambiar cosas al jugador 2 cop, ya sea del inventario y tal o la pantalla o lo que sea.

sigo los pasos como indica el tutorial, pero cuando le doy next scan solo me da la opcion de first scan otra vez y me vuelven a aparecer el monton de  direcciones

Por favor ayudame, no puedo Localizar las Estructuras Dinamicas, a cada rato me da esto 80 3C BA 00 04 00 00 00 B0 AC BA 00 C8 AC BA 00 03 00 00 00 03 00 00 00, esto 80 3C BA 00 03 00 00 00 B0 AC BA 00 C8 AC BA 00 03 00 00 00 03 00 00 00, o esto 80 3C BA 00 05 00 00 00 B0 AC BA 00 C8 AC BA 00 03 00 00 00 03 00 00 00, pero despues de eso ya no cambia en nada, amenos que yo ataque

Emm tengo una duda, en un juego online busco un valor que quiero cambiar lo busco pero cuando intento modificarlo vuelve a su estado actual y si estoy seguro de que ese es el valor sé que no ayudarías a esto en un juego online, pero es pero y me ayudes con ello y si no quieres por elgún motivo o razón no te preocupes. y otra duda los juegos de fb cuentan como online?? 

Hola. Enhorabuena por los tutoriales.
Estoy disfrutando bastante con esto de los trainers.
Como todos aqui tengo mis preguntas, pero intentare limitarme a preguntas tecnicas.

Para empezar solo quiero preguntar un par de cosas que me estan martirizando.

¿Hay algun modo en el visor de pasar de la ventana de ensamblador a la misma direccion de la ventana de HEX y al contrario sin escribirlo a mano?
A veces tampoco aparece la direccion de memoria en el ensamblador, sino programa.exe+D0F23... y tienes que andar buscando.
Hay un copy que copia de todo menos la direccion real :P

Igualmente, cuando tengo en la lista del CE una direccion, solo puedo ver quien escribe o el HEX, no puedo ver el ensamblador de esa direccion, que a veces es codigo y que tambien a veces es resultado de una busqueda y no aparece la direccion para copiarla y te toca escribir.
Eso se arreglaria si pudieras ir del HEX a la misma direccion en el visor de ASM (pregunta anterior).

Saludos

EDIT:
Jo, no hay como preguntar algo para dar con ello de golpe.

Ya se al menos copiar la direccion del HEX para llevarla al visor de ensamblador.
Pinchas el byte de inicio y eliges goto address para copiar de ahi la direccion.

A ver si alguien sabe como hacerlo en el visor de ASM cuando ni siquiera es una direccion completa.

EDIT2:
:D
Voy a tener que dejar de preguntar :P
O quizas a alguien le vengan bien mis deliberaciones.

Para copiar la direccion real desde el visor ASM para llevarla al de HEX es igual que lo otro :D
Pinchas la instruccion, eliges goto address y te muestra esa misma direccion y en modo real.
La copias y la pegas en el visor de HEX.

Siento las molestias si las hubiere.

Saludos

EDIT3:

Ya puestos a informar sobre encontrar codigo, para los novatos como yo, algo que acabo de notar:
Cuando encuentras un codigo y sabes que es el bueno, o quieres guardar la direccion por si acaso, lo mas comodo es pinchar con el boton derecho y en "replace whit code that does nothing". Eso cambia el codigo por "no operacion".
Luego lo restauras con "restore with original code".
Automaticamente te guarda la direccion de modo que puedes ir cuando quieras cada vez que cargues el proyecto, con solo pinchar abajo del todo en "Advanced Options" y elegir ahi la direccion que encontraste, que puedes hasta renombrar para reconocerla.
Claro, solo funciona con direcciones fijas (Programa.exe+XXXXXX)

Son detalles que a veces cuesta notar y que suavizan la experiencia... que me lo digan a mi :P

Mas saludos

Oye como hago para modificar una aplicacion trainer creada con CE

Bueno, iba a responderte, aunque ya veo que tú solo lo has encontrado todo. jajaja. Saludos! :D

Hola Mad Antrax. Gracias por contestar.
La verdad es que de momento he aparcado un poco lo del CE.
Despues de sacar unos trainers de Flash con busquedas aob, (por cierto, vi tu script, pero tengo desactivados los scripts vb y preferia algo mas comodo, y creo que me quedo bastante bien), y viendo que es facil que no funcionen por haber algun valor que no has filtrado, empece con los cambios de codigo.
Al no ser capaz de descifrar todo el ASM lo deje y empece a experimentar buscando las variables Flash con SWF Decompiler y modificandolas con el reproductor que hice en VB, añadiendo a este listas de variables que puedes fijar o leer continuamente (inspirado por CE).
Despues vi que muchas veces no encuentro variables o las que encuentro no devuelven valores ni afecta que las cambies, (algunos juegos si :D).
Entonces empece con el curso de Olly de Ricardo Narvaja, y despues de 4 o 5 capitulos pense mejorar mi lector de textos para que admitiera textos con imagenes, y asi segun lo escuchas, ves lo que esta leyendo y la imagen a que se esta refiriendo el tema.
Asi que me he tirado una semanita entre que deducia como son los rtf por dentro y como capturarlos, pegarlos, juntar las lineas para que no haga pausas raras y guardarlos (desde varias paginas separadas) a un fichero .rtf. Algo bastante complicado, por cierto, ya que un solo capitulo del curso, en formato rtf, ocupa de 40MB en adelante, y cada vez que manipulas el textbox se congela el programa hasta que procesa los 40MB.
Anoche buscando una cosa por curiosidad encontre por fin un manual de rtf, je, espero no necesitarlo ya, porque esta en ingles y mi lector no traduce :P  (de momento).
Por fin creo que ha quedado mas o menos bien, asi que ahora solo tengo que ir pasando a rtf los doc del tuto y ¡a aprender! (aunque creo que me falta memoria).
En fin, como ves, intento no aburrirme.
Cuando vuelva al CE (si no me lio con otra burrada) ya me pasare con las dudas, aunque ya ves que no se me da mal experimentar :D Lo peor que llevo es que olvido enseguida casi todo lo que aprendo y tengo que aprenderlo de nuevo cada vez :( Sera por eso que he aprendido a buscarme la vidilla :D

Un saludo a todos y que lo lleveis "bonito" (como decia uno que conoci).

EDIT;
Nuevo record. 1,30 horas y ya traduce al español con auto-deteccion de idioma de origen.
Te lo juro, no me beso porque no me llego. :D
Ves el texto en ingles y lo escuchas en español. Se sale.
Igual hasta le pongo que elijas el idioma de destino, pero de momento solo lo uso yo, asi que se qieda en spanish :D

Muy buenas, 1º decirte que es un gran tutorial, buscaba uno de estos hace tiempo y 2º felicitarte por ello, gracias. ;-)

Pero yo tengo un problema solamente con empezar el tutorial, es el usar el VEH Debugger, al intentar buscar los pointers me da dos errores:

1º Error in line 1 ("vehdebug-i386.ConfigName":): This address specifier is not valid

2º I couldn't attach the debugger to this process! You could try to open the process using the processpicker and try that! If that also doesn't work check if you have debugging rights.

No se si tiene algo que ver de que tenga windows 7 de 64 bits.

Gracias de nuevo y espero saber manejarme con el cheat engine.

EDIT: Nada, he actualizado a la version 6.4 y ya no me da estos fallos, gracias por este gran tutorial!!!

muy buen tutorial, muchas gracias !!!!   ;-) ;-)

Excelente tutorial me a ayudado mucho con casi todos los juegos, pero uno si que me a sacado canas después de unos días intentando no se como "hackearlo" se trata de Terraria, todo lo hice normalmente desde una escritura normal hasta inyección de código pero esta ultima no funciona debido a que las direcciones de instrucciones parecen ser dinámicas mi pregunta es si hay alguna forma o herramienta que me permita saber donde se encuentra una instrucción después de que se reinicie el juego? (espero poder hacerme entender)

Agradezco de antemano en verdad lo expuesto aquí es muy buen material.

Pd: envié un mensaje privado con imágenes no se si hice bien en hacerlo espero sea de ayuda.

Hola!!

Primero de todo, me gustaría que el contenido del mensaje que me has enviado lo postees aquí, así servirá de ejemplo para el resto de usuarios. Terraria es un juego programado en .Net, y como tal sus direcciones son "allocadas" de forma dinámica. Deberás cambiar el template utilizado en tu AA script, te recomiendo que pruebes el AOB Injection, con eso debería bastar.

Saludos y felicidades, me alegra muchisimo ver como la gente que no "sabe nada" es capaz de inyectar código de la forma que lo has hecho :)

Saludos

Amigo, eres un genio,
Yo tengo una duda, no puedo subir la velocidad de ce a mayor de 100
si la pongo a 200 o 500 se trava, por que sera????
favor contestame gxxxss

A que te refieres con subir la velocidad? Al speedhack?

Primero que nada, agradecer por este material, realmente hay poco sobre esto en la red, no he avanzado mucho aun en el tuto pues quiero entenderlo todo al detalle.....

Me gustaria hacerles una consulta y de ante mano agradezco sus respuestas.

Estoy trabajando sobre el emulador SNES 9x v1.53 para win 64 bits en un juego de RPG llamado Lufia, con el Cheat Engine 6.4 con la opcion MEM_MAPPED activa y que estoy trabajando con un emulador y VEH Debugger.

Soy capaz de encontrar los valores de vida(HP), experiencia en batalla (EXP) y hasta los valores de base de caracteristicas de cada personaje como ATP, DFP, STR, etc, etc Obviamente al reiniciar el emulador las direcciones de memoria donde se alojaban estos valores cambian y sinceramente no he podido rastrear el puntero, de hecho al dar click derecho sobre alguna de las posiciones de memoria y darle a la opcion "Pointer scan for this address", me abre una ventana solo modifico ahi el "Nr of threads scanning" y lo pongo a 4 y "Max Level" en 3 click en OK, me pide guardar un archivo, me abre una pantalla en blanco donde por unos segundos se ve que busco algo y luego queda en blanco y ahi ya no se que hacer, si asi debe ser, si lo estoy haciendo mal, agradecia mucho si me explican como puedo hacer lo que quiero, si voy en la direccion correcta....reintero que agradezco cualquiera de sus valiosos aportes.

gracias y saludos.

Hola, veamos. Para usar CE con emuladores hay que marcar MEM_MAPPED, eso es correcto. Desconozco si es posible encontrar pointers en un emulador (nunca lo he probado), pero puedes intentar lo siguiente;

http://i.imgur.com/atfXFm7.png

Maximun offset Value: 2048 o 4096
Max Level: 5

De ésta forma, incrementarás el rango de búsqueda, algunos juegos/programas usan pointers de tamaños muy grandes y de muchos niveles. Si no encuentras resultados prueba de subir el max level a 6, 7 u 8. La búsqueda de pointers es lenta y un poco aburrida. Que tengas suerte!!
Por otra parte, DarkByte nos deja éste consejo a la hora de buscar pointers en emuladores:


Saludos

Muy buen toturial, como mencionaban antes, no se encuentran estas cosas muy seguido por la red, claro al menos que entres al foro del CE.
Muy bien explicado y detallado, espero los proximos tutos con ansias. Este me ayudo bastante,  :Por cierto una duda, he estado probando con un rpg que me descargue, cuando entro en el modo batalla encuentro la direccion de la vida en color verde, lo que me dice que es una estatica, lo que no entiendo es que cuando cierro el juego, mantengo la direccion en el cheat, vuelvo abrir el juego junto con el CE, me cambia automaticamente la direccion pero el valor de la vida sigue siendo el mismo, a qui a que procedo?

hola me gustaria saber si con este metodo se
podria hackear un juego oline como wow lol o aion.

muy bueno el tuto esperare tu respuesta  :)

Vas a tener que leer el thread para saberlo. Normalmente es útil leer los posts que los demás usuarios han hecho. Hay algunos que ya han hecho esta pregunta. Lee el thread.

Saludos!

limitado tutorial lo eh probado pero la verdad que no me sirvio.........claro tu juego llega hasta 4 bytes pero cuando lo pongo en practica en mis juegos no sirve porque son de 2 o 1 byte de scan en CE por ende cuando realizo pointer scan no me aparece ningun resultado!!! IGUAL GRACIAS seguire buscando

Pero que dices? xDDDDD

Ni te molestes Mad. Revisa sus mensajes (incluso el que está en la papelera) y verás que no vale la pena...  :P

Saludos!

Esta vez voy a intentar poner mi granito de arena después de la jartada de preguntas del otro post (tengo que editarlo porque haciendo este tutorial estoy comprendiendo muchas cosas) para resolver alguna posible duda, en la parte que se explica lo del AoBScan me di cuenta de un pequeño detalle y es que el Hex Dump (lo de abajo en la ventana del Memory viewer) no se veía igual que en el mio, se veían más bytes además de unas lineas amarillas y al copiarlos copiaba menos y no sabía muy bien por que era pero lo he encontrado, es solo el "tamaño que le das" al Hex Dumper en la ventana:

(http://i.imgur.com/x4FBVhs.png)

Por lo tanto en realidad cuando dices que coges 3 líneas estás cogiendo 6, (no se si esta afirmación es del todo correcta pero la cuestión es que coges más bytes de los que cogería yo si cogiera 3 líneas como me las mostraba por defecto) no se si esto hace que cambie mucho o que pero bueno aquí lo dejo por si acaso.

---

Pff estoy teniendo problemas con lo del AoB, la primera vez hice el patrón con 6 AoB y al hacer el Script y añadir la addr (_player) no me dejaba activarlo y no sabía por que era, se quedaba como parado el CE un segundo y no me dejaba activarlo, sigo cogiendo AoB hasta que tengo unos 10, hago otra pattern y la subtituyo en el script, esta vez si que me deja activarlo pero la addr no es la que tendía que ser de ebx-50 (es decir la que señala el pointer de arriba -50). Vuelvo a leer el tutorial detenidamente, borro todo (lo del AoBScan, el pointer y el script de godmode los dejo) y lo vuelvo a hacer de nuevo hago una pattern a partir de 10 AoB y hago el script, añado la addr de (_player) y antes de activar el script ya me sale una addr que no tiene nada que ver con EBX, no se si me estoy equivocando en algo o es que fallo algún paso sin querer pero me voy a volver loco, a ver si sabéis que puede ser porque creo que lo estoy haciendo bien...  :-( La versión del juego es la v1.0 FB6 no es la v8 porque no me aclaro con los torrents y no la encontraba en descarga directa que es como yo me solía bajar los juegos, de hecho estuve a punto de comprarmelo porque no había manera y el torrent no sabía cuanto iba a tardar en bajarse (de hecho a lo mejor me lo pillo si lo ponen en algún bundle o en oferta de steam cuando tenga pasta), bueno que al final me bajé la v1.0 FB6 para ir haciendo marcha y hasta ahora no había tenido ningún problema y sinceramente no creo que este sea el problema, tengo la versión del CE 6.4 también en vez de la 6.3 no se si es que hay que configurar algo o lo tengo mal configurado o me estoy dejando algo pero no lo veo, en fin que me va a explotar la cabeza jajajaja

No se si tendrá algo que ver pero cuando hice el primer script y luego decidí obtener más AoB para ver si lo solucionaba al hacer la pattern la hice manual para ahorrar tiempo pero me equivoque y puse un ? de más, cuando hice el script seguía sin funcionar (no hacia nada igual que antes), revisé la pattern con el pattern_generator y puse el dígito que tenía que ir donde el ? que había puesto por error, ahí es cuando volví modificar el script y me paso lo que comento arriba que me dejo activarlo pero me dio una addr errónea. No se... voy a probar repitiendo muchas veces más lo de abrir el Memory view por la instrucción que modifica la vida, poner el breakpoint, recibir daño, mostrar en hexview el EBX y copiar tres lineas (1 AoB si no he entendido mal), darle a run (F9) cerrar el juego, abrirlo, cargar el proceso y repetir... no se si haciendo la pattern con muchos AoB podré solucionar esto porque no comprendo muy bien como funcionan, ni se que es lo que me pasa (cuando añado _player me da una addr "random").

Buenas a todos, decir que este tutorial he aprendido bastante, aunque tengo que seguir practicando, ya que hay juegos que intento buscar el tiempo o la vida por ejemplo y no soy capaz y veo "trainers" que si funciona y creo que se hacen de esta manera, aun asi tengo que mejorar!!!

Me pasa exactamente igual, no puedo seleccionar y me es imposible continuar con el tutorial.

Se que es post es un poco antiguo, pero me pueden ayudar con esto:
Miren tengo este problema, ya encontre la direccion y su pointer fijo. He creado el trainer usando la opcion de CE de generar trainer desde tabla. El trainer funciona bien, puedo reiniciar el juego y el trainer trabaja, pero mi problema es que al reiniciar la PC el trainer deja de funcionar :( , no se que hacer para evitar eso. he buscado el San Google y no he encontrado algo que hable de eso, Me pueden ayudar porfavor :D

y los juegos que tienen de proteccion themida como hacemos para desenpaquetarlos ? :D

Hola!

Desempacar themida es una tarea compleja y no siempre es posible hacerlo al 100%. Dependiendo del nivel de protección usado, el unpacking se puede hacer más o menos difícil.

La pregunta es: estás seguro de necesitar desempacarlo? Quizás existan otras formas de "atacar" el juego...  ;)

Saludos!

Hola man que tal soy nuevo en el foro como veras y gracias por responderme mi duda . es verdad lo que dices hace tiempo habia un programa llamado "Driver rarar pro" en la cual me bloqueaba la proteccion del juego y asi podia usar los hack detectados en verdad siempre quise saber como funcionaba su forma de bloquear la proteccion del juego pero el codigo no es open source . es privado asi me ayudas con eso te lo agradeceria  :D

---

como se hace eso con el CE ? gracias  :D

MOD EDIT: No hagas doble post. Si tu post es el último de thread, edítalo.

que buen tutorial man. soy nuevo en la comunidad. entendí un %30 de lo que escribiste. pero con práctica espero llegar a dominar todos los puntos.
se te ocurre algo para royal revolt 2?

---

Como ya he dicho, soy nuevo en este Foro. Aclaro también, que no se nada de hack, pero me interesa aprender. He visto como estos juegos benefician a los que mas tienen, además el precio para beneficios es en dólares. En ese sentido corren con ventaja los extranjeros, ya que a los Argentinos se nos hace difícil pagar en dólares.

He probado con cheat Engine lo básico. A través de escaneos conseguir la dirección de gemas, oro, etc. Pero al momento de cambiarlo resulta ser solo una ilusión.
Creo que suceden dos cosas.
1- Las direcciones son dinámicas o....
2- Solo cambio los valores en el juego pero no cambia nada en el servidor.(por eso la iluison.

Quisiera que me guíen para saber como este usuario llegó a esto (ver imagen)

(http://i64.tinypic.com/2j16cnq.jpg)
Es una captura tomada de un video donde las tropas de un Hit rompen cualquier edificio.

dejo otra imagen

Agradecería de su experiencia para guiarme. No pido que lo hagan, simplemente pido ayuda para que me guíen. Me gusta aprender. Saludos!

---

· No se debe escribir en mayúsculas
>aquí las reglas del foro (http://foro.elhacker.net/reglas.htm)
-Engel Lex

Buenas noches a todos, he buscado muchos tutoriales y no llego a efectuarlos bien... y me di por vencido, alguien tendrá un cheat engine configurado para que no lo detecten?