En este tutorial vamos a tratar una versión del juego Othello para Windows, el programa necesita ser registrado ya que si no aparece una ventana recordandonos lo malvados que somos :), pero, pregunto yo, Quién es capaz de pagar por un juego como el Othello?, Bueno en la vida del señor hay de todo, y más extraño aún es dedicarse a hacer un keygen para este juego, pero bueno, todo sea por complacer a los chicos de WkT!, veremos a ver si por lo menos tiene un buen esquema de registro.

SoftIce para Windows
IDA Pro
ProcDump
Compilador de C (para el keygenerator) lcc-Win32 es mi preferido.

Bueno, como ahora se a puesto de moda eso de comprimir/encriptar los ejecutables para que los posibles lamers no se dediquen a fisgonear, el Deep Green Reversi no podía ser menos. Vamos a ver con que narizes lo han comprimido, normalmente antes de desensamblar nada yo uso el Procdump para ver los nombres de las secciones del ejecutable, si veo alguna sospechosa o que yo sepa que puede pertenecer a un compresor/encriptador ya se a lo que me enfrento y así no pierdo el tiempo desensamblado algo sin sentido ;). Pues nada, abrimos el ProcDump, click en PE Editor, seleccionamos el ejecutable (Reversi.exe) y luego click en el botón Sections. Veremos que hay un montón de nombres, si nos desplazamos hacia abajo veremos lo siguiente:

Foto 1

Anda, que te parece, tenemos con nosotros al más popular de los compresores de Windows que se utilizan hoy en día, el ASPack.La verdad que este compresor es un coñazo, ultimamente me lo encuentro hasta en la sopa. Pero no hay que preocuparse, no necesitamos tocar el ejecutable ya que vamos hacer un keygenerator y no un parche. Vamos a descomprimirlo de la manera más sencilla que existe, el ejecutable no será funcional, pero nos da igual ya que solo usaremos el archivo descomprimido para analizar el código que necesitemos para la generación del keygen. Hacemos click en Cancel y de nuevo click en Cancel.

Ejecutamos el Deep Green Reversi, cuando ya esté en marcha vamos al ProcDump, y hacemos click con el botón derecho sobre la lista de tareas, aparecerá un submenu, click en Refresh list (esto es para que aparezca el Deep Green Reversi en la lista de tareas del ProcDump), ahora lo buscamos en la lista de tareas, hacemos click con el botón derecho sobre él y luego click en Dump Full. En unos instantes el ProcDump nos pedirá donde guardar el volcado y con que nombre, yo lo puse junto con el original pero con el nombre raspack.exe.

Vale ya tenemos el volcado, ahora lo dejaremos por un rato y recurriremos a el para analizar el código más detenidamente, ya que vamos a buscar con el SoftIce donde empieza la rutina de cálculo del número de serie. Ejecutamos el Deep Green Reversi y vamos a la pantalla de registro (menu Help/About/I would like to register now/Enter registration Information) que es algo así:

Introducimos los datos, yo he utilizado los siguientes:

Name: Black Fenix
E-mail: [email protected]
Registration number: 5555 - 66666

Por supuesto que son falsos tanto el mail como el número de registro ;). Ahora ponemos el cursor justo encima del botón Register, antes de hacer click activamos el SoftIce (Ctrl+D). Ahora vamos a utilizar el método del breakpoint sobre la función del kernel HMEMCPY, como ya muchos sabrán esta función se utliza muy a menudo para copiar memoria o cadenas a otras partes de memoria, y es probable que se utilize para copiar las cadenas que nosotros habiamos introducido. Tecleamos lo siguiente:

BC *

BPX HMEMCPY

Con la primera línea borramos los posibles breakpoints anteriores, con la segunda ponemos un BreakPoint sobre HMEMCPY. Pulsamos G y rapidamente hacemos click sobre Register. Ahora SoftIce se activará, estamos dentro de la función HMEMCPY del kernel, ahora tenemos que buscar la dirección donde se copia la cadena, para ello iremos pulsando F12 hasta que salgamos de las funciones de Windows y entremos en el código del Deep Green Reversi. Cuando veamos que estamos en el código del Deep Green Reversi (mira la ventana de código y veras que dice REVERSI.EXE!...) verás que el código que tenemos delante son POPs seguidos de un RET, esto quiere decir que estamos al final de alguna función y que por lo tanto aquí no encontraremos nada, deberemos de ir pulsando F12 hasta que no veamos ningún POP seguido de un RET, eso ocurrirá cuando veamos el siguiente código.

Ahora vemos que EAX contiene el valor B, y B en decimal es 11, y 11 carácteres es la longitud del nombre que yo introduje (Black Fenix), si introdujiste otra cosa verás su longitud. Veamos estamos cerca, vamos a ver si pescamos algo util, vamos a comprobar que es lo que se esta guardando en ECX despues de la llamada, pulsa F8 para trazar una línea y ahora veras el contenido de ECX (en mi caso 198E660) mmmm... parece una dirección de memoria bastante lejana, ¿será la que buscamos? veamoslo, teclea

D ECX

8C 18 47 .. .. .. (en micaso)

Bueno no parecen datos útiles, a no ser que... ECX sea un puntero a un puntero a una cadena (en C -> **char), veamos, para comprobar a que apunta lo que apunta ECX teclea:

D *ECX

¿Que es lo que aparece en la ventana de datos? Pues claro, nuestro nombre, parece ser que querian despistarnos con el uso de punteros a punteros, pero nosotros somos más inteligentes y siempre comprobamos este tipo de situaciones ( ¿o no? ).Ahora vamos ha hacer un seguimiento de las operaciones que se realizen con el nombre, para ello usaremos un breakpoint de memória (BPM), así cuando se intente acceder a la posición donde se haya el primer caracter, el SoftIce se activará y veremos que calculos se hacen. Tecleamos:

BPM *ECX

y desactivamos el HMEMCPY con

BD 0

Ahora pulsamos G y rápidamente el breakpoint de memória surtirá efecto. SoftIce estará activo de nuevo, ahora tenemos la seguridad de que se está haciendo alguna operación con el nombre. El código que SoftIce nos muestra es el siguiente:

Vaya sorpresa, parece ser que el programa compara nuestro nombre (Black Fenix) con uno fijo ([Xorolc]), lo cual solo puede indicar que con ese nombre se consigue algo especial. Por el momento es probable que también se necesite un e-mail adecuado, y es probable que se use la misma rutina en la que estamos para compararlos, por lo que vamos a poner un BPX sobre la línea 505A85, tecleamos:

BPX 505A85

Pulsamos G y de nuevo se activará SoftIce en el breakpoint que acabamos de poner, si examinamos los contenidos de EDI y ESI veremos que apuntan al email que nosotros introducimos ([email protected]) y otro que parece el que buscamos '[email protected]'. Bueno parece que ya lo tenemos, pero si no quereis perder el tiempo mejor que no probeis estos nombres ya que para lo único que os servirá es para que el programa os muestros dos mensajes, uno dice : 'Do you feel guilty using this registration' (Te sientes culpables de usar esta manera de registro) si contestas que si, el programa te abrirá una conexión Internet para que te registres en línea, y si le dices que no te dirá 'This software will be disabled until you register', osea que el programa permanecerá desactivado hasta que te registres. Pues creo que toda esta mierda la ha puesto el programador para dar un poco por culo a los lamers que intentan pescar numeros de serie, pero quien sabe, la verdad es que ha mi me despitó un poco. Vamos a lo que ivamos, estamos en 505A85 y parece ser que este código es una rutina de comprobación de cadenas que se utiliza varias veces, por lo que vamos a salir de la rutina pulsando F12. Veremos el siguiente código:

Pulsaremos de nuevo F12, ya que estamos es un sitio donde solamente se llama a la rutina de comprobación y se retorna un valor en EAX y luego se reajusta la pila. Ahora veremos el siguiente código:

La verdad es que apartir de la primera línea de este código 4100BB hasta la 4102DD se hacen las comprobaciones necesarias para ver si hemos caido en la broma que el programador del Deep Green Reversi nos ha jugado con el nombre especial "[Xorolc]", por lo que vamos a continuar trazando con F10 hasta llegar al código de la línea 4102DD, pero antes desactivaremos todos los breakpoints tecleando:

BC *

Pues nada, a trazar linea a línea con F10 hasta llegar a la linea 4102DD, mientras vas trazando, puedes ir comprobando las direcciones a las que apuntan los registros, sobre todo EAX y EDX, iras viendo el mail, el nombre etc. Cuando llegues a la línea 4102DD verás que se carga en EDX la dirección del nombre, ahora vamos a ver que se va hacer con ella:

Vemos que se pasa el nombre como parametro a una función, por lo que esto puede ser algo interesante, vamos a a continuar trazando pero esta vez entraremos dentro de la función que se llama en la línea 4102F7, para ello iremos pulsando F8 hasta que entremos dentro de la función y veamos lo siguiente:

El código anterior es bastante fácil de comprender, primero se calcula la suma de todos los caracteres del nombre más la suma de los caracteres del email, luego se calcula un grupo de 4 digitos segun la suma resultante, este cálculo lo realiza la función en 50CFEC, que se llama dos veces, la primera vez se calculan 4 dígitos que no sirven para nada, es decir no forman parte del número de serie válido, la segunda vez esta función da como resultado el primer grupo de 4 dígitos válidos. Aquí esta la rutina en 50CFEC..

Esta rutina lo único que realiza es comparar el primer argumento pasado (0Ah) y compararlo con 0Ah, en caso afirmativo (esto siempre ocurre), se empujan 61h a la pila seguido de 1 (el valor empujado en ECX), luego pasa estos datos junto a la suma y el buffer previamente pasado a la rutina en 50CF5C, que es la que realmente hace el cálculo de los digitos tal y como podemos comprobar en su código, podemos ir trazando con F8 hasta llegar aquí:

Pues el código anterior es el corazón de la rutina de cáculo, su funcionamiento es bastante sencillo. Primero se comprueba que EDI, es mayor que 0Ah (10) y menor que 24h (36), si no es asi se salta al final de la rutina y se copia NULL al buffer de los dígitos (quedando una cadena vacía). Si EDI es 0Ah (cosa que siempre sucede). Luego verifica que la suma pasada es >= 0, si es inferior verifica el valor que se paso (flag calculado en la rutina anterior en ECX, que siempre es 1), si es no es 0 copia el caracter '-' como primer dígito del grupo (50CF82), incrementa el buffer y niega la suma quedando -1. Luego continua el cálculo de los dígitos a partir de 50CF88, El calculo es muy sencillo, lee la suma, la divide entre 0Ah (EDI) y el resto lo guarda en el buffer de dígitos (esto da un valor entre 0 y F), vuelve a leer la suma y divide de nuevo entre 0Ah, esta vez coge la parte entera y la guarda en la suma, comprueba si es diferente a 0 y en ese caso sigue calculando el resto de caracteres repitiendo este bucle de operaciones.
Una vez tiene los 4 dígitos en el buffer calcula su representación alfanumérica sumando 30h a cada caracter que sea inferior a Ah (10), los que sean superiores a este valor se sustituyen por la letra W (50CFB6), ya que no pertenecen al sistema decimal (base 10). Y para terminar añade el caracter nulo al final del buffer de dígitos para que sea una cadena imprimible (50CFC0) y retorna la dirección del primer carácter del buffer en EAX.Básicamente lo que hace la rútina de cálculo de los dígitos es pasar a la representación alfanumérica decimal, el valor de la suma hexadecimal pasada.

La primera vez que se realiza este cálculo no sirve para nada, ya que los dígitos resultantes no forman parte del número de série válido, quizas el programador estaba intentando despistarnos. La segunda vez que se hace el cálculo este si que es válido, pero se calculan los 4 primeros dígitos con la suma real + el valor 9C5h (ver línea 40DE53). Previamente se rellena una tabla en la pila con 5 DWORDs (ver lineas de 40DE18 a 40DE40 ). El valor que se obtiene de la tabla se pasa (40DE5A) como suma a la función que cálcula los dígitos, obteniendo así primer grupo válido de dígitos. Luego pasa a compararlos en el código siguiente a 40DE5A, tal y como podemos ver si continuamos trazando con F8:

Como puede comprobarse después de cálcular el primer grupo de dígitos se pasa a comprobar si los introducidos por el usuario eran iguales (lineas 40DE65 a 40DE87). En caso que no sean iguales se salta al final de la rutina y a partir de allí ya te imaginas lo que pasa (mensaje de error etc.) Si los dígitos eran iguales se coge la suma original (nombre+email) y se divide entre 5, y se usa el resto (EDX) como índice (línea 40DEA3) a la tabla que se rellenó en la pila. Con el valor que se obtiene de esta tabla se calcula el siguiente grupo de 4 dígitos de la misma manera que se hizo con el primero, se pasa a la función y esta devuelve un puntero al buffer donde están los dígitos. Luego se comparan con los introducidos (línea 40DEB6), actuando de acuerdo con la situación.

Ya tenemos suficiente información sobre el algoritmo de cálculo, por lo que vamos a pasar a ver el código fuente para el keygen, lo he realizado en C con el compilador lccWin32 que es una maravilla en cuanto a generación de código se refiere (4Kb). Podia haber prescindido de escribir la rutina computedigit() ya que como he dicho antes esta solo cálcula la representación alfanumérica decimal de la suma hexadecimal pasada, pero he preferido imitar el funcionamiento de la rutina original para poner en práctica mi algoritmica ;). Notese que podiamos haber usado el printf del C en vez de hacer nosotros la rutina (p. ej. printf(\n %d,sum+0x9c5) lo cambiariamos por computedigit(sum+0x9c5,digit1) ).

Curiosidades técnicas: si por algún motivo registras el programa a un nombre que no te gusta o simplemente quieres desregistrarlo, tan solo deberás borrar el fichero fileid.sys que el Deep Green Reversi crea en el directorio de Windows, este fichero a sido curiosamente ocultado bajo un nombre poco sospechoso, pero quíen se cree que un archivo SYS ocupe 1Kb?. Su contenido es bastante interesante, contiene el nombre del usuario, su e-mail y su código de registro todo ello en texto plano, sin encriptar. Para averiguar esto utilizé el Filemon, ya que quería probar el keygenerator a fondo con diversos nombres. ;).

#include <windows.h>
#include <stdio.h>
#include <string.h>

#define DIGITLENGTH 5

void computedigit(unsigned long suma, char *buffer);

int main()
{
unsigned long table[5]={ 0x00000D87,0X00002234,0x00002231,0x0000128B,0x000015AD};
unsigned long sum,length;
char digit1[DIGITLENGTH];
char name[80];
char email[80];

printf("\nDeep Green Reversi v4.3.7 / KeyGen by Black Fenix");
printf("\n-------------------------------------------------\n");
printf("\nEnter registration name:");
gets(name);
printf("\nEnter registration mail:");
gets(email);

// Borra el contenido de la cadena donde se almacenarán los digitos
ZeroMemory(digit1,DIGITLENGTH);

// convierte las cadena OEM a char, esto es necesario para los carácteres especiales (acentos etc.), el programa
// original no lo hace porque no es una aplicación de consola, la nuestra si lo es y por eso hace falta
OemToChar(name,name);
OemToChar(email,email);

length=strlen(name);

// calculamos la suma de caracteres del nombre
sum=0;

for (int i=0;i<length;i++)
{
sum=name[i]+sum;
}

length=strlen(email);

// calculamos la suma de caracteres del nombre + la del email
for (int i=0;i<length;i++)
{
sum=email[i]+sum;
}

// calculamos el primer grupo de 4 digitos, notese que el programa Deep Green Reversi realiza este calculo primeramente
// sin sumarle 0x9C5, dando un grupo de 4 dígitos que no utiliza para nada

computedigit(sum+0x9C5,digit1);

// lo imprimimos

printf("\nYour serial number is %s - ",digit1);

// obtiene valor de la tabla segun el resto de la división de la suma total entre 5, y con ello calcula
// el siguiente grupo de dígitos

computedigit((unsigned long)table[(sum % (unsigned char)5)],digit1);

// lo imprimimos
printf("%s\n",digit1);

// esperamos pulsación de tecla, es para poder ver/copiar el número ;)
getchar();
return 0;
}

void computedigit(unsigned long suma, char *buffer)
{
unsigned char val;
unsigned long cont=DIGITLENGTH-2;

do
{
// hace el módulo 10 de la suma
val =(unsigned char)(suma % 0xA);
// comprueba que el resto (módulo) sea válido < 0xA (10)
if (val>=10)
{
// no es válido, hacemos que el dígito sea igual a 'W'
val=0x57;
}
else
{
// es válido, le sumamos 30h para convertirlo en su representación alfanumérica
val=val+0x30;
}
// lo guardamos en el buffer
buffer[cont]=val;
// decrementamos contador
cont--;
suma=(suma / 0xA);
} while ((cont>=0) && (suma!=0));

}

You are inside Reversed Minds pages. por Mr. Silver / WKT! La información aquí vertida es exclusivamente para uso educacional, no puedo hacerme responsable del uso que se haga de esta, por lo que atiendo a la honradez de cada uno :), recuerda que debes comprar el software que utilices :)