Cómo crear un Keygen (user y pass).

Para este manual utilizaremos como herramienta el OLLYDBG, y como el programa objetivo usaremos el CRACKME de Cruehead. Puedes bajarlos de aquí:
http://www.filestube.com/5b2496800a99625803e9,g/CrackMe.html
http://www.ollydbg.de/download.htm
Para crear el KEYGEN necesitamos saber el algoritmo de generación de las claves, y este algoritmo lo obtenemos invirtiendo lo que hace el programa para verificar el código. En este CRACKME el algoritmo es bastante sencillo por lo que no será tan complicado obtenerlo, pero en los programas comerciales suelen ser más complejo, y mientras más complejo sea, más tiempo y esfuerzo lleva.
Empecemos.
Primero abrimos el Crackme y entramos en Help > Register y ponemos nuestro nombre y un número cualquiera como serial, así:

y, a no ser que aciertes la clave, te saldrá el mensaje de error:

Sal del programa y abre el OLLYDBG.
Ahora abrimos el Crackme con OLLY y hacemos click derecho en el listado, y vamos a Search for > All referenced text strings.

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

Como podemos ver, el mensaje está dentro de un CALL que empieza en 401362. Haciendo click en esa dirección, vemos debajo del listado este mensaje "Local call from 00401245".
Ahora sabemos la dirección en donde se llamó al CALL. Entonces, vamos ahí.

Aquí ya podemos ver en 401241 el CMP que verifica que nuestro serial es válido. Como podemos observar, es muy fácil hacer que el programa acepte cualquier serial cambiando el JE de 401243 a un JNE, pero no cambiaremos nada del código del programa, ya que no es lo que buscamos. Puede ser mucho más fácil y rápido, pero yo elijo algo más difícil y gratificante.
Ahora ponemos un Breakpoint (voy a llamarlos BP) en el CMP, haciendo click sobre él y presionando F2, y ejecutamos el programa apretando F9 y volvemos a poner nuestro nombre y un número cualquiera como serial y, al dar OK, aparecemos en el CMP y veremos 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 qué hace el programa con nuestro nombre. Hacemos click en el CALL y vemos que apunta a 40137E, así que nos dirigimos ahí.

Aquí hay un MOV, que lo que hace es guardar nuestro nombre en el registro ESI. Ponemos un BP en 401382, volvemos a ejecutar el programa apretando F9, aceptamos el mensaje de "No Luck" del Crackme y volvemos a registrarnos con nuestro nombre y un número cualquiera, y aparecemos nuevamente en el BP de 401382. Sin embargo, 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, (el nombre que pusimos) en la pila (STACK), que después veremos para qué.
Ahora explicaré lo que haréis en las líneas 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, así 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. Poned un BP aquí y aprieten F9 y mirad en la ventana de registros que la AL (los dos últimos números 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, (probad a escribir ALT + 75 con su teclado y veréis que escribirá K).
Debajo de esta línea 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), es decir, la letra A y si es menor te llevara al mensaje de error, ya que ha sido utilizado un carácter 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), es decir, Z y salta si es mayor (osea, una letra minúscula). En mi caso, no saltara ya que K (75) es mayúscula y, por lo tanto, menor que 90. Después veremos qué pasa si la letra es minúscula). Debajo hay un INC que, una vez terminado el proceso anterior, borra la primera letra de ESI. Así, "Kansai" quedara "ansai".
Debajo hay un JMP, que como sabemos siempre salta. En este caso salta a 401383, volviendo a repetir. Como vimos, aquí 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 minúscula, ahora la letra "a" (97) es mayor a 90, por lo que si saltara a la dirección que apunta el JNB de abajo, es decir 401394, en donde hay un CALL que apunta a 4013D2. Así que vamos a tener que ver que hay ahí.
Aquí hay un SUB, que le resta a AL, 20 (en decimal 32) que es la diferencia entre una letra minúscula a una mayúscula. Como la "a" es 97, si se le resta 32, queda 65, que es la letra "A". Lo que se hace aquí es pasar las letras minúsculas a mayúsculas, en mi caso pasa la "A" a "a", debajo hay un MOV que remplaza la letra cambiada al STACK. Recordad 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 quedaría en el STACK así "KAnsai".
Debajo hay un RETN que te devuelve a la línea que está 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 quedaría entonces de "ansai" a "nsai".
Se repite nuevamente con todas las letras, cambiando las minúsculas a mayúsculas y saltara al mensaje de error si encuentras un carácter no valido (menor a 65). Después de la última letra, el valor del STACK que originalmente era "Kansai" será "KANSAI", vemos como todas las letras se quedaron en mayúsculas. También vimos como el ESI originalmente valía "Kansai", luego fue variando a "ansai", "nsai", "sai", "ai" y "i". Cuando llega al INC que borra la ultima letra (la "i"), el ESI valdrá 0, y como en 401383 vimos que se pasa la primera letra de ESI a AL, ahora AL no tendrá ningún valor. También vimos en 4013C8 un TEST que comprobaba si AL valía algo, y como ahora no vale nada, el JE que tiene debajo saltara a 40139C.
Aquí hay un POP, que guarda el valor que está guardado en la parte más alta del STACK a ESI, por lo que ESI ahora será "KANSAI". Debajo hay un CALL que apunta a 4013C2, aquí 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 también a 0.
Debajo hay un MOV que pone a BL (los dos últimos números 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 últimos números de EBX son BL, que ahora valen 4B, osea 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, es decir, 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 será 41. Se repite el proceso anterior sumando EDI que vale 0000004B a EBX que vale 00000041. El resultado se guarda en EDI, por lo que valdrá ahora 0000008C. Se repite este proceso hasta la última letra y ahora con todas las letras sumadas. EDI vale en mi caso 0000016E.
Ahora el JE que está debajo del TEST saltara a 4013D1, ya que BL no vale nada.
Aquí hay un RETN que te devuelve a la línea que está debajo de donde se llamo el CALL, o 4013A2. Aquí 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 línea 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 línea debajo de donde se llamo este CALL (¿recordáis?). Bueno, te devuelve a 401232.
-------------
Hasta aquí hemos conseguido:
- Comprobar que los caracteres introducidos para el nombre sean validos y pasar todas las letras a mayúsculas.
- Sumar el valor de todas las letras (ya mayúsculas).
- Realizar un XOR entre esta suma y el número 5678 (en decimal 22136).
Todo esto era esencial.
---------
En la línea 401232, hay un PUSH que guarda el valor de EAX en el STACK. En la línea de abajo vemos el número que pusimos como serial, y el PUSH lo guarda también en el STACK. Ahora viene el segundo CALL. Veamos lo que hace con el número que pusimos.
Este CALL apunta a 4013D8. Si vamos ahí, nos encontramos un XOR EAX,EAX, que como sabemos pone el EAX a cero.

Debajo hay dos XOR más, que ponen a cero EDI y EBX respectivamente. Debajo hay un MOV que guarda en ESI el número 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 número, en mi caso 1, y debajo esta el famoso TEST (acompañado 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, la cual se realiza para obtener el valor real de los números, 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. Debajo se realiza una multiplicación (IMUL) entre EDI y EAX, y el resultado se guarda en EAX:EDI. En este momento no ocurrirá nada, ya que EDI vale 0. Debajo se realiza una suma (ADD) entre EDI y EBX, en mi caso EDI será ahora 00000001. Debajo están los ya conocidos INC acompañado de JMP. Se vuelve a repetir esta vez valiendo BL 02 después de la resta. Después 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.
¿Por qué multiplicar los números por 10 y sumarlos? Si no os acordáis, esa es la forma de pasar un número de hexadecimal a decimal. (Es para que vayáis comprendiendo por qué hacemos lo que hacemos).
Después de hacer esto con todos los números, el JE (el acompañante del TEST) salta a 4013F5. Aquí, EDI, en mi caso, vale 3039, convirtiéndolo a decimal. ¡¿Y cuánto sale?! 12345. Si queréis comprobarlo con el vuestro, borrad todos los BP anteriores y poned uno aquí (en 4013F5), aprieten F9 y mirad el valor de EDI. Bueno, aquí 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.
Y ya hemos terminado con el segundo CALL.
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 número 5678 (en decimal 22136).
Estos dos números con los que se realizaron los XOR, el 5678 con el nombre y el 1234 con el número, son los "números mágicos", estos números son inventados por los programadores para hacer la ecuación 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".
------------
Recapacitación:
- Todas las letras del nombre se pasan a mayúsculas y se suman sus valores ASCII.
- Se hace XOR entre el resultado y el numero mágico 5678.
- Se obtiene el valor real de los números y se pasan a decimal.
- Se hace XOR entre nuestro numero y el numero mágico 1234.
----------
Para HACER el KEYGEN hay que usar lenguaje de programación, evidentemente. Estas son las condiciones de dicho programa:
- Que pida al usuario su nombre.
- Que pase todas las letras a mayúsculas y muestre un mensaje de error si se encontró un carácter no valido (menor que 65) en el nombre.
- Que sume el valor ASCII de todas las letras del nombre.
- Que realice un XOR entre el resultado y el numero mágico, en decimal, 22136.
- Que realice un XOR entre el resultado del anterior y el número mágico, en decimal 4661.
- Que el resultado de este es el serial, ya solo tiene que mostrarlo al usuario.
-------------------------
Aquí pongo el código del KEYGEN de modelo. Hecho en JScript. No hace falta compilarlo, sólo copiarlo y pegarlo en un archivo de texto y guardar con extensión de htm.
Comprobad como solo realizando las operaciones que vimos, se obtiene el serial. Con Kansai como nombre me salió 17915. Probadlo. El nombre puede tener hasta 6 o 7 letras.

Código:

<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>

Spoiler:

Qué friki, y en definitiva, ¿Para qué sirve los expuesto?

Sirve para que la gente "no friki" tenga los programas que están en el mercado sin pagar ni un céntimo. Bendita ignorancia.

KuDo escribió:Sirve para que la gente "no friki" tenga los programas que están en el mercado sin pagar ni un céntimo. Bendita ignorancia.

Oh, disculpe. Pero ese celeberrimo texto es infumable. Si un no friki, como yo, pasa y lo ve se quedará igual. Pasará de leerse si no pones una pequeña introducción explicando su utilidad. Además es ilegal, esto no debería estar en un foro porque os la podéis cargar.

Dentro de lo que cabe, no es tan ilegal como el Crack. Para hacer un keygen (generador de claves) hay que comprender la dinámica del programa. A diferencia de los Cracks (parches que sustituyen archivos originales del programa por otros piratas), que sí son totalmente ilegales.
Perdona por el "infumable texto" jajaja: tienes razón sobre lo de una pequeña introducción como explicación. Pero no tengo que ser friki por eso ¬¬

Hombre, lo de friki lo decía por el programa en general. En fin, gracias.

KuDo escribió:

Código:

<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>

Argg! Pero esto que es! Me persigue el javascript! Bastante tuve con aprobar el año pasado...
Dentro o fuera de ley creo que puede resultar bastante utíl para aprender

buena aportacion kudo, si señor, de algo tiene que servir que tu teclado este gastado xDDD

Eso es verdad. Necesito otro, aunque no mire para escribir, porque las teclas se me quedan pilladas de lo duras que están ya.
Pero si me compro otro, tiene que ser como este: luminoso y de la misma forma. Sólo yo sé utilizar este tipo de teclado xDDDDDD