Manual para crear Generadores de llaves (KEYGEN) by: Kansai

en: 23 Septiembre 2006, 07:25:36 am

------------------------------------------------------
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.
ltima modificacin: 25 Enero 2011, 01:02:34 pm por jep
En lnea
-.-.-.-

Kansai

Me das tu IP?


Mensajes: 28
Sexo:
K A N S A I

o
o

Re: Manual para crear Generadores de llaves (KEYGEN)

Respuesta #1 en: 23 Septiembre 2006, 07:27:29 am

------------------------------------------------------

BUENO, EMPECEMOS

Para este manual utilizaremos el como herramienta el OLLYDBG, y como el programa

objetivo usaremos el CRACKME de Cruehead, bajatelo de
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.

HEMOS LLEGADO A LA MITAD DE NUESTRO TRABAJO!!! Ahora me voy un rato a
comer algo y a descansar ya que llevo casi 2 horas mirando esta pantalla...

ltima modificacin: 07 Octubre 2006, 04:54:51 am por Kansai

En lnea
-.-.-.-

Kansai

Me das tu IP?

Mensajes: 28
Sexo:
K A N S A I

o
o

Re: Manual para crear Generadores de llaves (KEYGEN)

Respuesta #2 en: 23 Septiembre 2006, 07:28:24 am

------------------------------------------------------

BUENO, CONTINUEMOS

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 respectivamente. 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, conviertiendolo 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.

Les dejo el KEYGEN hecho por mi.

ltima modificacin: 24 Septiembre 2006, 07:01:37 am por Kansai

En lnea
-.-.-.-
 Kansai

Me das tu IP?

Mensajes: 28
Sexo:
K A N S A I

o
o

Re: Manual para crear Generadores de llaves (KEYGEN)

Respuesta #3 en: 23 Septiembre 2006, 07:29:54 am

------------------------------------------------------

Mi KEYGEN

Y aqui les dejo el codigo del KEYGEN que hice. Lo hice en JScript ya que no tendran que
compilarlo ni nada, solo copiarlo y pegarlo en un archivo de texto y guardar con extension
de htm.

Vean como solo realizando las operaciones que vimos obtiene el serial. A mi con Kansai
como nombre me salio 17915. Pruebenlo, el nombre puede tener hasta 6 o 7 letras.

Bueno, aqui esta el codigo.

Cdigo: [Seleccionar]
<html>
<head>
<title>KeyGen</title>
</head>
<body>
<form method="POST">
<p>Nombre:</p>
<p><input type="text" name="nom" size="25"> </p>
 <p><input type="submit" value="Generar" name="B1"
onClick="generar(this.form)" ;></p>
</form>
<script language="JScript">
function generar(Formu)
{
var nombre = Formu.nom.value;
var suma = 0;
for(i=0;i<13;i++)
{
letra = nombre.charCodeAt(i);
if(letra > 20)
{
if (letra < 65)
{
error();
return(0);
}
if (letra > 90)
{
letra -= 32;
}
suma += letra;
}
}
xorsuma = suma ^ 4660;
serial = xorsuma ^ 22136;
document.write("Nombre: " + nombre + "<BR>" + "Serial: " + serial);
}
function error()
{
document.write("Debe escribir el nombre con caracteres validos!!!");
}
</script>
</body>
</html>