INTRODUCCION Este manual esta dedicado a explicar como crear un generador de llaves o KEYGEN, por lo que primero hay

que explicar que es. Un generador de llaves (KEYGEN en ingles) es un programa que, como dice su nombre, genera una clave para registrar los famosos programas "TRIAL". Estas claves o seriales pueden depender un nombre o pueden ser independientes, en este manual tratare sobre los que dependen del nombre. Seguro se han encontrado con programas que te piden para registrarlos tu nombre y el serial, y que al comprar el programa te envian un serial de acuerdo a tu nombre. Bueno, en este manual se explicara como crear un KEYGEN para obtener ese serial para cualquier nombre que se le indique. Hay que decir que un crack comun para estos programas, es decir, parchearlo para que acepten cualquier cosas como serial es mucho mas facil de hacerlo que crear un KEYGEN, asi que muchos se preguntaran para que hacer uno. Bueno, yo encuentro mas desafiante (y gratificante) hacer un KEYGEN que un simple parcheo, ademas como lei en algun texto sobre cracking, al hacer un KEYGEN "realmente se est cumpliendo con la filosofa crack (ingeniera inversa) al comprender el programa", al mismo tiempo se adquieren mas conocimientos, ya que se requiere un analisis mas profundo del programa, hay muchas otras ventajas, como no tener que crackear una futura version del programa (que tenga el mismo algoritmo de generacion de claves), y tambien ocupa menos espacio que el programa crackeado, lo que hace mas facil difundirlo. Este manual va dedicado a las personas que tengan un conocimiento basico de cracking, con que sepan que son las CALL y los JMP y como cambiar de un JE a un JNE, ya sirve, si no, existen muchisimos cursos de cracking basico que pueden leer, tambien seria conveniente que tengan algun conocimiento basico de OLLYDBG. Tambien es necesario conocer algun lenguaje de programacion (cualquiera) para crear el KEYGEN, al decir conocer me refiero a saber como introducir y mostrar texto, saber sumar, multiplicar y otras operaciones aritmeticas, es decir, tambien bastaria aqui un conocimiento basico del lenguaje. BUENO, EMPECEMOS Para este manual utilizaremos el como herramienta el OLLYDBG, y como el programa objetivo usaremos el CRACKME de Cruehead,

bajatelo de

http://foro.portalhacker.net/url.php? urlc=http://rapidshare.de/files/34113588/CRACKME.EXE.html

Para crear el KEYGEN necesitamos saber el algoritmo de generacion de las claves, y este algoritmo lo obtenemos invirtiendo lo que hace el programa para verificar el codigo, en este CRACKME el algoritmo es bastante sencillo por lo que no sera tan complicado obtenerlo, pero en los programas comerciales suelen ser mas complejos, y mientras mas complejos son, mas tiempo y esfuerzo llevan y mas gratificante es obtenerlo. Y como dice el titulo de esta seccion. Bueno, empecemos. Primero abramos el crackme y entremos en Help > Register y ponemos nuestro nombre y un numero cualquiera como serial, asi:

y, a no ser que acierten la clave les saldra el mensaje de error

Salgan del programa y abran el OLLY. Ahora abrimos el crackme con OLLY y hacemos click derecho en el listado y vamos en Search for > All referenced text strings

En la ventana que aparece encontramos dos veces el texto del mensaje de error "No luck there, mate", damos doble clic sobre el primero y aperecemos en 401370.

Como podemos ver, el mensaje esta dentro de un CALL que empieza en 401362, dando click en esa direccion vemos debajo del listado este mensaje "Local call from 00401245"

Ahora sabemos la direccion en donde se llamo al CALL, entonces vamos ahi.

Aca ya podemos ver en 401241 el CMP que verifica que nuestro serial es valido, como podemos ver es muy facil hacer que el programa acepte cualquier serial cambiando el JE de 401243 a un JNE, pero no cambiaremos nada del codigo del programa ya que no es lo que buscamos, puede ser mucho mas facil y rapido, pero yo elijo algo mas dificil y gratificante. Ahora ponemos un Breakpoint (voy a llamarlos BP) en el CMP, haciendo click sobre el y presionando F2, y corremos el programa apretando F9 y volvemos a poner nuestro nombre y un numero cualquiera como serial y al dar OK aparecemos en el CMP y vemos en 401228 que aparece nuestro nombre (se guarda en el STACK), y en 401233 aparece el numero que pusimos como serial. Entonces tenemos que ver el CALL de 40122D, para ver que hace el programa con nuestro nombre, damos click en el CALL y vemos que apunta a 40137E, asi que vamos ahi.

Aqui hay un MOV, que lo que hace es guardar nuestro nombre en el registro ESI, ponemos un BP en 401382, volvemos a correr el programa apretando F9, aceptamos el mensaje de "No Luck" del crackme y volvemos a registrarnos con nuestro nombre el numero cualquiera y aparecemos nuevamente en el BP de 401382, pero ya podemos ver en la ventana de registros que la ESI tiene el valor ASCII de nuestro nombre. En 401382 hay un PUSH, que lo que hace es guardar el valor de ESI, (nombre que pusimos) en la pila (STACK), despues veremos para que. Bueno, les explicare lo que hacen las lineas de abajo. En 401383 hay un MOV que lo que hace es pasar la primera letra del nombre guardado en ESI al registro de un byte AL, yo puse como nombre Kansai, asi que la primera letra que pasa es K, abajo hay un TEST que verifica que AL no sea cero, es decir que su valor sea una letra, pongan un BP aqui y aprieten F9 y vean en la ventana de registros que la AL (los dos ultimos numeros de EAX) tienen el valor de su primera letra, pero en hexadecimal, en mi caso aparece 4B utilizando la calculadora de windows veo que 4B en decimal es 75, que es el valor de la K, (prueben a escribir ALT + 75 con su teclado y

veran que escribira K). Debajo de esta linea hay un JE que salta si AL no vale nada, ahora por supuesto no saltara. Debajo hay un CMP y luego un JB que como vemos, lo que hacen es comparar la letra con 41 (en decimal 65), o sea la letra A y si es menor te llevara al mensaje de error ya que ha sido utilizado un caracter no valido en el nombre. Debajo hay otro CMP pero con un JNB que compara si la letra es mayor a 5A (en decimal 90), o sea Z y salta si es mayor (o sea una letra minuscula), en mi caso no saltara ya que K (75) es mayuscula y por lo tanto menor que 90, despues veremos que pasa si la letra es minuscula), debajo hay un INC que una vez terminado el proceso anterior borra la primera letra de ESI, asi "Kansai" quedara "ansai". Debajo hay un JMP, que como sabemos siempre salta, en este caso salta a 401383, volviendo a repetir, como vimos, aqui el MOV pasaba la primera de ESI a AL, pero ahora el primer valor de ESI es la segunda letra, en mi caso "a", y sigue el mismo proceso anterior, pero al llegar a 40138D, en donde se comparaba si era minuscula, ahora la letra a (97) es mayor a 90 por lo que si saltara a la direccion que apunta el JNB de abajo, o sea 401394, en donde hay un CALL que apunta a 4013D2, asi que vamos a ver que hay ahi. Aqui hay un SUB, que le resta a AL, 20 (en decimal 32) que es la diferencia entre una letra minuscula a una mayuscula, como la "a" es 97 si se le resta 32 queda 65, que es la letra "A". Lo que se hace aqui es pasar las letras minusculas a mayusculas, en mi caso pasa la "A" a "a", debajo hay un MOV que remplaza la letra cambiada al STACK, recordemos que en 401382 se paso el valor de ESI, que en ese momento era "Kansai" al STACK, y lo que ahora sucede es que cambia la primera "a" por lo que quedaria en el STACK asi "KAnsai". Debajo hay un RETN que te devuelve a la linea que esta debajo de donde se llamo al CALL, nos lleva a 401399 en donde hay otro INC ESI, que hace lo mismo que el anterior. El valor de ESI quedaria entonces de "ansai" a "nsai". Se repite nuevamente con todas las letras, cambiando las minusculas a mayusculas y saltara al mensaje de error si encuentra un caracter no valido (menor a 65). Despues de la ultima letra, el valor del STACK que originalmente era "Kansai" sera "KANSAI", vemos como todas las letras se quedaron en mayusculas. Tambien vimos como el ESI originalmente valia "Kansai", luego fue variando a "ansai", "nsai", "sai", "ai" y "i". Cuando llega al INC que borra la ultima letra (la "i"), el ESI valdra 0, y como en 401383 vimos que se pasa la primera letra de ESI a AL, ahora AL no tendra ningun valor. Y

tambien vimos en 4013C8 un TEST que comprobaba si AL valia algo, y como ahora no vale nada, el JE que tiene debajo saltara a 40139C. Aqui hay un POP, que guarda el valor que esta guardado en la parte mas alta del STACK a ESI, por lo que ESI ahora sera "KANSAI". Debajo hay un CALL que apunta a 4013C2, aqui hay un XOR EDI,EDI., cuando se hace un XOR entre dos valores iguales el resultado siempre es 0, por lo que pone a EDI a 0, debajo hay otro XOR que pone EBX tambien a 0. Debajo hay un MOV que pone a BL (los dos ultimos numeros de EBX) la primera letra de ESI, en mi caso K. Debajo hay otro TEST parecido al que vimos anteriormente que verifica que BL valga algo, y cuando ya no valga nada, saltara el JE que tiene abajo, pero ahora no saltara. Debajo de este JE hay un ADD que lo que hace es sumar el valor de EBX (recordamos que los dos ultimos numeros de EBX son BL, que ahora valen 4B, o sea la letra K) a EDI, y se guarda el valor en EDI. Como EDI vale 00000000 y EBX 0000004B ahora EDI vale la suma de estos dos, o sea 0000004B, debajo esta el INC que ya sabemos que hace, y debajo de este el JMP que salta de nuevo 4013C6 en donde estaba el MOV que pasaba la primera letra de ESI a BL, ahora la primera letra de ESI es 41, en decimal 65 (A), por lo que BL sera 41. Se repite el proceso anterior sumando EDI que vale 0000004B a EBX que vale 00000041, el resultado como dije se guarda en EDI, por lo que valdra ahora 0000008C. Se repite este proceso hasta la ultima letra y ahora con todas las letras sumadas, EDI vale en mi caso 0000016E. Ahora el JE que esta debajo del TEST saltara a 4013D1 ya que BL no vale nada. Aqui hay un RETN que te devuelve a la linea que esta debajo de donde se llamo el CALL, o sea 4013A2. Aqui se realiza un XOR entre EDI y 5678 (en decimal 22136), el resultado se guarda en EDI (en mi caso quedara 000057CF) y en la linea de abajo se pasa este valor de EDI a EAX. Debajo hay un JMP que lleva al RETN, que a su vez te devuelve a la linea debajo de donde se llamo este CALL, recuerdan donde era?, bueno te devuelve a 401232. Bueno, hemos terminado el analisis de este primer CALL y ya sabemos lo que hace. - Primero comprueba que los caracteres introducidos para el nombre sean validos y pasa todas las letras a mayusculas. - Despues suma el valor de todas las letras (ya mayusculas).

- Por ultimo, realiza un XOR entre esta suma y el numero 5678 (en decimal 22136). Todo esto que sabemos sera esencial para hacer el KEYGEN. Nos habiamos quedado en la linea 401232, aqui hay un PUSH que guarda el valor de EAX en el STACK. En la linea de abajo vemos el numero que pusimos como serial, y el PUSH lo guarda tambien en el STACK. Ahora viene el segundo CALL, veamos lo que hace con el numero que pusimos. Este CALL apunta a 4013D8, vamos ahi y encontramos un XOR EAX,EAX, que como sabemos pone el EAX a cero.

Debajo hay dos XOR mas, que ponen a cero EDI y EBX respectivament e. Debajo hay un MOV que guarda en ESI el numero que pusimos, yo puse "12345". Debajo hay un MOV que guarda 0A (en decimal 10). Debajo hay un MOV que guarda en BL el primer numero, en mi caso 1, y debajo esta el famoso TEST (acompaado de su JE) que verifica que BL no valga 0. Debajo del JE se realiza una resta (SUB) entre BL y 30 (48 en decimal), el resultado de esta resta se guarda en BL. Esta resta se realiza para obtener el valor real de los numeros, ya que estos estaban guardados en su valor ASCII, por ejemplo 1, su valor ASCII es 49, si se le resta 48 (30 en HEX) queda 1, vieron? Debajo se realiza una multiplicacion (IMUL) entre EDI y EAX y el resultado se guarda en EAX:EDI. En este momento no ocurrira nada, ya que EDI vale 0. Debajo se realiza una suma (ADD) entre EDI y EBX, en mi caso EDI sera ahora 00000001. Debajo estan los ya conocidos INC acompaado de JMP. Se vuelve a repetir esta vez valiendo BL 02 despues de la resta. Despues EDI se vuelve a multiplicar con EAX (que vale 10 en decimal) y al resultado se le suma 2 (el valor de BL), en mi caso. Creo que ya se han dado cuenta para que esto de multiplicar los numeros por 10 y sumarlos. Si no se acuerdan, les recuerdo que esa es la forma de pasar un numero de hexadecimal a decimal. Seguro que ahora se acordaron.

Despues de hacer esto con todos los numeros el JE (el acompaante del TEST) salta a 4013F5. Aqui EDI en mi caso vale 3039, conviertiendol o a decimal adivinen cuanto sale, adivinaron, 12345, si quieren comprobarlo con el suyo borren todos los BP anteriores y pongan uno aqui (en 4013F5), aprieten F9 y miren el valor de EDI. Bueno, aqui se realiza un XOR entre EDI y 1234 (en decimal 4661) y el resultado se guarda en EDI. Debajo hay un MOV que guarda EDI en EBX y luego viene el RETN que nos devuelve a 40123D. Ya terminamos con el segundo CALL, fue mucho mas sencillo que el primero, verdad? Ahora solo queda comparar. Vemos un POP que devuelve a EAX el valor del primer XOR, entre la suma de las letras de nuestro nombre y el numero 5678 (en decimal 22136). Estos dos numeros con los que se realizaron los XOR, el 5678 con el nombre y el 1234 con el numero, son los "numeros magicos", estos numeros son inventados por los programadores para hacer la ecuacion que genere las claves para darles sus seriales a sus clientes. Y llegamos al CMP que verifica que EAX (el resultado del XOR con 5678) y EBX (el resultado del XOR con 1234) sean iguales, si lo son el JE salta al mensaje de "Great work" y si no al de "No luck". Bueno, ahora tenemos lo necesario para crear nuestro KEYGEN. Repasemos lo que sabemos. - Todas las letras del nombre se pasan a mayusculas y se suman sus valores ASCII. - Se hace XOR entre el resultado y el numero magico 5678. - Se obtiene el valor real de los numeros y se pasan a decimal. - Se hace XOR entre nuestro numero y el numero magico 1234. Bueno, para crear el KEYGEN necesitamos hacer un programa que haga lo siguiente. - Le pida al usuario su nombre. - Pase todas las letras a mayusculas y muestre un mensaje de error si se encontro un caracter no valido (menor que 65) en el nombre. - Sume el valor ASCII de todas las letras del nombre.

- Realize un XOR entre el resultado y el numero magico, en decimal, 22136. - Realize un XOR entre el resultado del anterior y el numero magico, en decimal 4661. - El resultado de este es el serial, ya solo tiene que mostrarlo al usuario. Ya esta. Solo hay que hacer un programa que realize esto y ya tenemos nuestro KEYGEN. Como ven esto se puede hacer con cualquier lenguaje de programacion. Hay que aclarar que este algoritmo es bastante sencillo a pesar de todo, solo se sumo las letras y se realizo un par de XOR. En los programas comerciales se encontraran con verdaderas ecuaciones y los seriales tendran gran cantidad de letras, numeros y hasta simbolos, mientras que en el que hicimos, el serial solo es un numero de 5 cifras. Pero cuanto mas complicado es el trabajo, mas gratificante es el resultado. Bueno, espero que les halla servido este manual, perdonen la ortografia, ya se que no puse ningun acento.