Hola gente de taringa! les enseñare a como crear un hack para warrock
Para empezar necesitamos tener Microsoft Visual C++ 2008 Express Edition que pueden descargar del siguiente link: http://visual-basic-6-sp6.malavida.com/
Tamaño del fichero: 128.92 MB
Contraseña: blackworth
Compatibilidad: Porbado en windows xp 32 bits sp2, sp3, windows 7 enterprise 64 bits Importante: REQUIERE TENER INSTALADO .NET FRAMEWORK 2.0 O SUPERIOR.
Índice
Introducción a VC++
Preparativos
Hack básico
Apéndice (otros)
Introducción a VC++
En este tutorial utilizaremos el Visual C++ 2008 Express, cuya descarga es gratis (buscad en google).
Esto no significa que no podáis hacerlo con otros programas/versiones, cualquier Visual C++ (2005, 6, etc.) funcionan, igual que el Borland entre otros. Esto es más cuestión de gustos.
Yo me quedo el Visual C++ 2008 Express debido a su alta estabilidad y en lo general alto rendimiento (pero ya digo, va a gustos).
Visual C++, a groso modo, es una adaptación del C++ a la sistema operativo Windows. Me explico, incorpora ciertos métodos únicos de windows, un editor visual (para creación de ventanas), un compilador (para crear los .exe, .dll, etc.)
Nota: C++ es "Case Sensitive", es decir, distingue entre mayusuculas y minísculas.
Nota: C++ siempre lleva ; al final de un comando.
Preparativos
Inciamos el VC++ y le damos a File->New->Project (o en español: Archivo->Nuevo->Proyecto).
Allí le damos a Visual C++ (menú izquierdo) -> Win32 Console Application (en español, creo: Aplicación de Consola de Win32, o algo parecido. -> Le damos un nombre (y si queremos cambiamos el directorio donde se crea) -> Le damos a OK.
le damos a Next > (Siguente >
hacemos:
Le damos a DLL
Le damos a Empty Project (Proyecto Vacio)
Le damos a Finish (Finalizar)
]
Ya tenemos nuestra primera DLL, PERO, no intentemos compilar ni nada porqué daría errores!
Ahora necesitamos crear los archivos donde escribiremos el codigo del hack. Para ello nos dirigimos a Project->Add New Item (Proyecto->Agregar nuevo elemento). Allí seleccionamos C++ File (.cpp) (Archivo C++ (.cpp)) y le damos un nombre. Yo le pongo main (que significa principal) con el objetivo de diferenciarlo de los otros, pero esto va también a gustos.
Hack Básico!
Este codigo es el básico de una DLL. (Nota: Todo lo que preceda a // (y esté en la misma línea), significa que es un "comentario" y que en consecuencia en compilador no lo interpretará, es decir, es como si no estuviera. Lo mismo que poner /* y luego */, lo que se encuentra ahí al medio es un comentario.
Primero debemos incluir unas referencias básica a windows. Lo haremos con este código, ARRIBA DE TODO del archivo, y SIEMPRE arriba de todo:
Código:
#include <windows.h>
#include <stdio.h>
Luego ponemos también el código, en cierto modo básico, de una DLL.
Código:
BOOL WINAPI DllMain(HINSTANCE module, DWORD dwReason, LPVOID lpvReserved) /*La función básica, inicía la DLL. */
{
if(dwReason == DLL_PROCESS_ATTACH) /*Esto comprueba que la DLL se haya inyectado correctamente.*/
{
/*Si llegamos aquí significa que todo ha ido bién./*
}
return TRUE;
}
Luego escribimos esto:
Código:
void LosHacks() /* Esto es el "Thread" de los hack, ahora lo explico */
{
while(1){
Sleep(50); /* Para evitar un sobreuso de la PC */
}
}
Un Thread no es más que una función que se ejecuta independientemente del programa. Es decir, que siempre está en funcionamiento hasta que se cierra el programa.
Además, el while(1) lo que hace es repetir lo que hay dentro siempre cada 1 milisegundo hasta que se termina el programa y en consecuencia el Thread.
Ahora debemos inciar el Thread. Como es lógico esto solo se hará si la DLL se ha inyectado bién, y por lo tanto irá en la función de inicialización (DllMain).
Si os perdéis tenéis el codigo al final del tema.
Añadimos esto:
Código:
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)LosHacks, NULL, NULL, NULL);
Aquí hay poco ha explicar, simplemente creamos un Thread con el parámetro de inciarlo normalmente.
Ya podemos proseguir con la creación del hack. Añadiremos de momento un hack simple, como puede ser el de Stamina.
Hay muchos métodos de hacerlo, sin embargo, yo os explicaré el más "facil", efectivo, y seguro:
Esto irá en el Thread de LosHacks()
Nota: Este no es el código definitivo de los hacks, luego será mejorado. Las address NO son las actuales.
Código:
DWORD dwPlayerPointer = *(DWORD*)0x002200;
if(dwPlayerPointer != 0){
*(float*)(dwPlayerPointer + 0x2A4) = 100;
}
Explico:
Primera Linea: Esto es la Address del Player (Player Address). Lo que hacemos el leer el contenido de la Address y lo guardamos en la dwPlayerPointer
Segunda Linea: Esto es una mera comprovación que sirve para evitar que el hack (y el warrock) se cuelguen. Si el valor es 0, significa que no se a leído bién, y en consecuencia, que no continuamos
Tercera Línea: Si os fijais, primero decimos el tipo de valor que vamos a grabar (editar). En este caso float, luego, decimos que queremos editar la Address del Player (dwPlayerPointer) más el Offset (puntero), que en este caso es 0x2A4. Lo que procede al = es el nuevo valor de la address.
Mucha gente se debe preguntar una cosa: <<¿Pero la Stamina no se tenia que "congelar"?>>.
Claro, si os acordáis, esto es un Thread, por lo que cada 1 milisegundo se efectua lo que hay dentro, es decir, cada 1 milisegundo se cambia el valor de la stamina a 100.
También se que mucha gente preferirá que la Stamina se pueda activar y desactivar, por lo que vamos a añadir un poco de codigo:
Al principio de todo del archivo, debajo de los #include:
Código:
bool stamina=false;
Lo que acabamos de hacer es crear una variable boolean. Esto significa que hemos creado una variable (que tal como indica su nombre se llama asi porque puede variar) y que solo puede tener 2 valores:
false => falso
true => verdadero
Veréis que pone =false; esto significa que por defecto esta desactivada (cambiadla a =true para que esté activada por defecto. El ; de al final de todo es obligatorio al final de cada sentencia en C++.
¿Y de que nos sirve esto? Fácil, haremos una simple comprovación condicional (lo que viene a ser un if(...){}):
Si el valor de la variable "stamina" es true (verdadero):
Código:
/* Nota: Eliminad el antiguo codigo de la stamina y poned este, pero NO pongáis los dos */
if(stamina==true){
DWORD dwPlayerPointer = *(DWORD*)Player_Pointer;
if(dwPlayerPointer != 0)
*(float*)(dwPlayerPointer + 0x2A4) = 100;
}
Tal como véis dentro del IF pone <<stamina==true>>. Notaréis que hay 2 = (==), esto es simplemente porqué indicamos "Comparación de Igualdad", de no ser así no funcionaria.
Vale, muy bién, pero... ahora debemos poner algo para activar y desactivar, ¿no?.
Vamos a poner "Hotkeys" (teclas):
En el Thread de LosHacks() añadimos:
Código:
if(GetAsyncKeyState(VK_F6) &1){ /* VK_F6 indica la tecla F6 */
stamina = !stamina;
}
Todas las teclas en C++ van precedidas de VK_ y sigue el nombre de la tecla en mayusculas.
Analizemos lo de dentro:
Lo primero debería estar claro (stamina =). Esto indica que queremos cambiar o asignar un valor a stamina.
Lo que sigue (!stamina): Fijaros en el signo de exclamación (!). Esto indica "lo contrario de" lo que viene a continuación. Es decir, si stamina fuera true (verdadero) estaríamos escribiendo esto stamina = !true;, que es lo mismo que stamina = false;. Simplemente porqué lo contrario de true es false, y a la inversa.
Este codigo que puede parecer tan bueno tiene un problema MUY grave:
Que emos dicho, que esto se ejecuta cada 1 milisegundo, esto significa que cada 1 milisegundo se comprueba si estamos pulsando el botoón. Que es lo que pasa, ¿es alguien capaz de pulsar solo durante 1 milisegundo una tecla?. La respuesta es evidentemente no. Esto conlleba a que aveces pulsar una tecla y que se active/desactive sea una tarea ardua. Hay muchas formas de solucionarlo, pero las analizaremos más tarde.
Ya tenemos nuestro Primer hack funcional.
Le damos a Buil->Build Solution (en castellano no se como se debe llamar, quizás compilar, ya lo comprobaré).
Nuestra DLL se encuentra ahora en la carpeta "Debug" encontrada dentro de la carpeta en la que guardamos el Proyecto.
Auí tenemos el codigo Final:
Código:
#include <windows.h>
#include <stdio.h>
bool stamina=false;
void LosHacks()
{
while(1){
if(GetAsyncKeyState(VK_F6) &1){ //F6
stamina = !stamina;
}
if(stamina==true){
DWORD dwPlayerPointer = *(DWORD*)0x002200;
if(dwPlayerPointer != 0)
*(float*)(dwPlayerPointer + 0x2A4) = 100;
}
Sleep(50);
}
}
BOOL WINAPI DllMain(HINSTANCE module, DWORD dwReason, LPVOID lpvReserved)
{
if(dwReason == DLL_PROCESS_ATTACH)
{
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)LosHacks, NULL, NULL, NULL); //create the new Thread
}
return TRUE;
}
Esto ya está acabado, ahora os explicaré como hacerlo algo más:
Apéndice
Creación de hacks como Zoom (que no se tienen que "congelar" y hacks normales (sin pointer ni offset, no DMA)
Es muy, pero que muy sencillo hacer esto:
El codigo consiste en cambiar el valor solo cuando sea verdadera (true) la variable, asi que, es tan sencillo como al final del codigo de cambiar añadir que la variable es false. Pongamos un ejemplo:
Código:
//Al principio
bool zoom=false;
//En el Thread LosHacks()
if(zoom){
DWORD dwZoom = *(DWORD*)0x002200;
*(float*)(dwZoom) = 0;
zoom = false; /* Establecemos zoom a false, así que ya no se volverá a cambiar el valor del zoom. */
}
Introduzco un nuevo concepto:
¿Os fijas que el IF es solo (zoom), que he omitido el ==true? Esto es porqué automáticamente se interpreta que if(zoom) es lo mismo que if(zoom==true)
Optimizando el hack!
¿Os habéis planteado nunca que pasaría si tenemos cosa de 20 Address y el warrock actualiza?¿Iríamos una por una cambíandolas?
NO, la respuesta es NO!
Para ello crearemos un nuevo archivo, (Ya sabéis Proyecto->Añadir Nuevo Elemento). PERO esta vez será un Header File (.h) (Archivo de Cabezera (.h))
Lo nombraremos, por ejemplo, define (como antes, es para diferenciarlo, pero a vuestro gusto)
El primer paso de todo es añadir un vinculo (include) a este archivo en el main.cpp (primer archivo).
Esto es muy sencillo. Vamos al primer archivo (main.cpp) y debajo de los otros #include ponemos lo siguiente:
Código:
#include "define.h"
En este caso ponemos define, pero esto dependrá del nombre de tu archivo.
Que debemos poner en el nuevo archivo:
Basicamente pondremos esto:
#define "Nombre_Del_Hack" 0x"ADDRESS"
Por ejemplo:
Código:
#define zoom_address 0x000022
#define spawn1_address 0x000032
Es importante que debajo de todo de este archivo dejemos una línea en blanco. Parece una tontería muy grande, pero ciertos compiladores dan error en caso de no hacerlo!
¿Y esto es todo? No no no...
Os acordáis que antes, en el codigo de cambiar el valor (como por ejemplo el codigo de la stamina) pusimos:
Código:
DWORD dwPlayerPointer = *(DWORD*)0x000222;
Pues en vez de este 0x000022 pondríamos el nombre del #define de la address del Player:
Código:
//En el define.h
#define Player_Pointer 0x000222
//En el main.cpp
DWORD dwPlayerPointer = *(DWORD*)Player_Pointer;
Ahora cada vez que el warrock actualize solo tendremos que ir aquí (en el define.h) e irlas cambiandolas de forma mucho más sencilla!