Capítulo IV: Crackeando la Realidad V1.2

 

1.- Saludos

 

            Hola, de nuevo, soy RAZiEL del [K-FoR], en primer lugar, me gustaría dar la bienvenida a los nuevos miembros del grupo; DEK_OiN, PROFESOR X, y cómo no, TXELI. Si queréis visitar nuestro site: www.pagina.de/Kfor; y por supuesto, para cualquier sugerencia, crítica constructiva o duda, escribidme a raziel@telepolis.com.

 

            Si, bien, desde la primera parte del tutorial, os he estado enseñando cómo hacer nuestro KeyGen (suponiendo que ya teníamos el código encargado de generar nuestro serial), ahora haremos lo contrario, intentaremos buscar la rutina de nuestro serial, en programas específicos, interpretarlo (para ello, tenéis que tener conocimientos de ensamblador, por supuesto), y una vez ahí, ya os podréis poner solos a hacer un buen generador de llaves.

 

            Os recomiendo que imprimáis este manual desde ya; puesto que la mayor parte del tiempo estaremos en SICE; y no es recomendable que hagáis nada con el ordenador que no sea, por supuesto Crackear.

 

            ¿No tenéis remota idea de ensamblador?, pues en eso no puedo entretenerme demasiado por dos razones:

 

·         El tutorial, se haría eterno.

·         Muchos Crackers buenos han hecho y traducidos buenos manuales en Ensamblador; es por eso que os recomiendo que los bajéis. Os recomiendo el ASM por AESOFT y el tutorial sobre SICE de Black Fénix, son sin duda, dos de los mejores manuales que existen ahora mismo (al menos para mí).

 

 

2.- ¿Cómo saber si estamos en la rutina de Serialización?

 

            Lamentablemente, esto es algo que depende del programa, por lo que no se pueden establecer reglas exactas, para decir, que estamos dentro de la rutina, para eso hace falta, tener las ideas claras, conocer el programa, cuanto más mejor, y como dirían algunos crackers: Sentir el código.

 

            Sin embargo, aunque no hay reglas, si hay algunos “trucos”, para reconocer la rutina de Serialización:

 

1.- Buscando Caracteres sospechosos [Extraido del Capítulo IV de ESTADO+PORCINO]

 

“ El 80% de las rutinas de verificación intentan localizar el carácter ‘-’  (2D en Hexa)o el carácter ‘+’ (2B en Hexa). No me preguntéis, por qué, pero lo hacen. Sólo hace falta buscar un 2Dh o un 2Bh y con un poco de suerte aterrizaremos en plena rutina de verificación. Debemos buscar una comprobación con 2Dh o bien 2Bh, pero las comprobaciones pueden ser de muchos tipos, sólo buscaremos la parte final de la comprobación.

 

A la hora de la creación de la rutina de Serialización; es probable, que se añadan Números Mágicos; un número del agrado del programador (quizás el número de veces que su jefe le ha jodidio) y que realmente es el corazón del dicho programa...

 

Resumiendo, buscaremos “2Dh” y “2Bh”. En caso de existir demasiadas ocurrencias, será mejor decantarse por otro método de ataque. Al final, es el olfato de Cracker el que te indica si estás en la ocurrencia correcta o no...”

 

2.- El Truco del Almendruco

 

Este truco, lo he usado infinidad de veces, y funciona, aunque, no sea con el 100% de los programas, debido a que no todos tienen este “sistema de protección”, veréis, hay veces que nuestro Serial se genera al lado de nuestros datos introducidos, por eso, sólo buscando nuestro nombre, por ejemplo, con SICE, encontramos la rutina de forma tan descarada...

 

El truco funciona tanto si eres torpe interpretando código, como si eres el tío mas despistado...

 

El truco, es una estupidez, pero funciona SIEMPRE. Por ejemplo; en un programa ponemos un BPX en GETDLGITEMTEXTA y acto seguido validamos nuestro nombre: RAZiEL... traceamos un poco y 1 minuto después nos da por buscar nuestro serial con la función S... y lo encontramos...

 

¿Qué hacemos ahora?, pues sencillo, sin cambiar la ventana de datos hacemos EXACTAMENTE lo mismo pero con otro  nombre, por ejemplo ITO, y vamos traceando desde el principio, sin perder de vista la ventana de datos, y poco a poco se irá realizando la TRANSFORMACIÓN, eso indica, claro está, que nos estamos paseando por la rutina de Serialización, ¿o no?.

 

Bien; pues empecemos, puesto que llevo mucho tiempo que no crackeo algo y hago su Generador de llaves, concretamente desde una consulta que tuve sobre FullDisk 4.1. por cierto, si queréis poner en práctica el truco del almendruco, os recomiendo dicho programa, pues es lo que llamamos prototipo, para éstos casos J, lo podéis sacar de la página de www.shareware.com, al igual que otros, programas “interesantes”... Pero eso sí, si queréis hacer el Keygen, sentaos en una sillita, cómodos, y desconectad el teléfono pues no se hace en 2 minutos precisamente...

 

3.- Crackeando la Realidad...

 

            En ésta parte del tutorial, os enseñaré, ejemplos de rutinas de serialización. Prescindiremos de todos los comentarios que podríamos hacer sobre el programa, y directamente  buscaremos la rutina de verificación del Serial...

 

            Nuestra Víctima de Hoy: Install-Us

 

Este Tipo de programa; Me ha marcado siempre, hará 6 años, cuando estaba aprendiendo a programar en VB, cuando me dio por distribuir mis aplicaciones de forma Freeware, cogí un programa llamado HS-Install, de un CD de esos que venden por menos de 1000 Pts y está repleto de programas basura... Lo cierto es que, claro, era Share, pero no te lo decía el muy cabrón hasta que no habías compilado tu proyecto, pues salía un ventanazo diciendo: ESTA INSTALACIÓN SE HA HECHO CON UNA SHAREWARE...

 

Por aquellos días, no pude solucionar dicho problema, pero ahora que tengo la posibilidad de Solventar dicho error, con un programa, que además, me recomendó Dek_Oin, y con el cual mi gran amigo el PROFE distribuye su magnífica compilación...

 

            La dificultad no es extremadamente alta, pero hay que tener en cuenta ciertas cosillas interesantes...

 

Ten en cuenta que este tutorial está realizado únicamente con fines educativos, y que no puedo hacerme responsable del mal uso que se pueda hacer de la información aquí expuesta. Si te gusta el programa CÓMPRALO.

 

Nombre del Programa:

 Install-Us 3.7 Build 2

Página Web:

http://www.Install-us.com

Tiempo a Emplear:

Unas 3 Horas

Dificultad:

Newbie - Aficionado - Avanzado - Experto – Élite

 

            En Primer lugar, deciros, que intentéis localizar la Rutina de Serialización, VOSOTROS MISMOS!, que no es difícil; es más; Os daré algunas pistas sobre éste programa que me parecen interesantes:

 

·         Si La longitud de Nuestro UserName y Key Son Inferiores a ocho caracteres; No calcula el Serial, nos echa directamente para fuera.

·         Cuando Nuestra Key Se genera, se le añade una coletilla, sea cual sea el Nombre introducido se le añade la letra ‘a’ minúscula al final.

·         El uso de números mágicos como: 16E360h; 05F5E0FFh; 989680h...

·         Al final de la comprobación nos modela nuestro Serial, dependiendo de ciertas condiciones (Si el número es negativo; Si es Inferior o superior a cierta cantidad...).

·         Tened Cuidado con EDX!!!, no es Constante... sigue un patrón...

·         Solo Aclararos que en EBX, nace, crece, se reproduce y muere nuestro Serial; así, que no le perdáis la pista un segundo...

·         Siempre es manipulado nuestro Username; Sólo nuestro Key es evaluado con el correcto al Final de la rutina.

 

Si tenéis alguna duda mandadme un Mail que no recibo ninguno últimamente, que sea vuestro espíritu cooperativo; últimamente noto una postura de pasividad por vuestra parte, y creo que la gente no está siendo emprendedora...

 

Aquí tenéis la comprobación de longitudes tanto del UserName como del Key:

 

            ...

00472CD4                 call    sub_403CFC > Coge la longitud de nuestro UerName

00472CD9                 cmp     eax, 8 > La compara con 8

00472CDC                 jl      472D55 > Si es menor; BAD CRACKER L

...

00472CF4                 call    sub_403CFC > Coge la longitud de nuestra Key

00472CF9                 cmp     eax, 8 > La compara con 8

00472CFC                 jl      472D55 > Si es menor; BAD CRACKER L

            ...

 

Aquí tenéis la parte “Interesante” del código:

 

...

00472AC7                 mov     bl, [eax+2] > Coge el tercer Carácter

00472ACA                 mov     eax, [ebp+var_4]

00472ACD                 movzx   eax, byte ptr [eax+6] > Coge el Séptimo Carácter

00472AD1                 imul    ebx, eax > Los multiplica, y se almacena el resultado  en EBX

00472AD4                 mov     eax, [ebp+var_4]

00472AD7                 call    403CFC > Almacena la longitud del UserName en EAX

00472ADC                 mov     edx, [ebp+var_4]

00472ADF                 movzx   eax, byte ptr [edx+eax-3] > Coge el tercer Carácter comenzando por Detrás

...

 

Las fórmulas como la que aparecen en 472ADF, pueden hacer que te líes al principio, no obstante, os daré un pequeño truco, sobre cómo deducirlas; al menos yo lo empleo...

 

1.- Hacemos un estudio previo:

 

Probamos distintos nombres, y vemos qué devuelven:

 

·         Prueba 1

 

Si introducimos un USERNAME: RAZIEL 1234

En Eax quedará almacenado el “2”

 

·         Prueba 2

 

Si introducimos un USERNAME: ROCKISDEAD

En Eax se almacenará la letra “E”

 

¿Cómo se puede deducir que coge el tercer carácter comenzando por detrás?; Sencillo, Sustituimos los datos que tenemos; llamemos X a EDX, como una ecuación a la orden del Día, y saquemos conclusiones:

 

En EAX se ha almacenado antes la longitud de nuestro nombre; ya tenemos una incógnita menos;

 

2.- Sustituimos:

 

·         En Prueba 1

 

[EDX + EAX - 3] = ¿? > Nuestra ecuación pasa a ser...

[X + 11 3] = 9 > Siendo 9 el número de posición que se almacena en EAX (Devuelve “2”)

Haciendo operaciones: X = 1 ¿Verdad?, comprobemos el segundo caso...

 

·         En Prueba 2

 

[X + 10 3] = 8 > Siendo 8 el número de posición que se almacena en EAX (Devuelve “E”)

Haciendo operaciones: X = 1; Coincide con el de Arriba... por tanto debe existir una relación entre ambas...

 

3.- Sacas conclusiones:

 

Dependiendo de la longitud se devuelven unos u otros valores, pero X siempre será 1; por tanto, tras pensar 0.5 segundos obtendrías que, Para un nombre cuya longitud de 16; si los cálculos no nos fallan:

 

            [1 + 16 3] = 14

 

Es decir, se devolvería el carácter 14; con lo cual observamos que siempre se devuelve el tercer carácter comenzando por atrás...

 

Sigamos con la rutina:

 

            ...

00472AE4                 mov     edx, [ebp+var_4]

00472AE7                 movzx   edx, byte ptr [edx+6] > Coge el séptimo carácter

00472AEB                 imul    edx > Los multiplica y almacena en EAX

00472AED                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472AEF                 mov     eax, [ebp+var_4]

00472AF2                 movzx   eax, byte ptr [eax+4] > Coge en quinto carácter

00472AF6                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472AF8                 mov     eax, ds:off_4D0234

00472AFD                 mov     eax, [eax]

00472AFF                 mov     eax, [eax+58Ch]

00472B05                 mov     eax, [eax+0Ch]

00472B08                 mov     edx, [ebp+var_4]

 

Aquí podríamos ponernos a deducir otra fórmula; Hacedlo vosotros, yo os adjunto ya la solución

 

00472B0B                 movzx   eax, byte ptr [edx+eax-1] > Coge el Sexto Carácter

00472B10                 mov     edx, [ebp+var_4]

00472B13                 movzx   edx, byte ptr [edx+7] > Coge el Octavo Carácter

00472B17                 imul    edx > Los multiplica y almacena en EAX

00472B19                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472B1B                 mov     eax, [ebp+var_4]

00472B1E                 movzx   eax, byte ptr [eax+1] > Coge el 2º Carácter

00472B22                 mov     edx, eax

00472B24                 imul    edx, eax  > Lo eleva al cuadrado

00472B27                 add     ebx, edx > Suma a EBX el resultado de la operación anterior

00472B29                 lea     edx, [ebp+var_8]

00472B2C                 mov     eax, ds:off_4D0234

00472B31                 mov     eax, [eax]

00472B33                 mov     eax, [eax+590h]

00472B39                 call    sub_421C84

00472B3E                 mov     eax, [ebp+var_8]

00472B41                 call    sub_4077C4

00472B46                 mov     edx, [ebp+var_4]

 

Otra Formulita…

 

00472B49                 movzx   eax, byte ptr [edx+eax-1] > Coge el tercer Carácter

00472B4E                 mov     edx, [ebp+var_4]

00472B51                 movzx   edx, byte ptr [edx] > Coge el primer carácter

00472B54                 imul    edx > Los multiplica y almacena el resultado en EAX

00472B56                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472B58                 mov     eax, [ebp+var_4]

00472B5B                 call    403CFC > Almacena la longitud del UserName en EAX

00472B60                 mov     edx, [ebp+var_4]

 

Formula…

 

00472B63                 movzx   eax, byte ptr [edx+eax-4] > Coge el Cuarto Carácter por el final

00472B68                 mov     edx, [ebp+var_4]

00472B6B                 movzx   edx, byte ptr [edx+3] > Coge el Cuarto Carácter

00472B6F                 imul    edx > Los Multiplica  y almacena el resultado en EAX

00472B71                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472B73                 mov     eax, [ebp+var_4]

00472B76                 call    403CFC > Almacena la longitud del UserName en EAX

00472B7B                 mov     edx, [ebp+var_4]

 

Formula…

 

00472B7E                 movzx   edi, byte ptr [edx+eax-1] > Coge el último Carácter por el final

00472B83                 lea     edx, [ebp+var_8]

00472B86                 mov     eax, ds:off_4D0234

00472B8B                 mov     eax, [eax]

00472B8D                 mov     eax, [eax+590h]

00472B93                 call    sub_421C84

00472B98                 mov     eax, [ebp+var_8]

00472B9B                 call    sub_4077C4

00472BA0                 push    eax

00472BA1                 mov     eax, [ebp+var_4]

00472BA4                 call    sub_403CFC

00472BA9                 pop     edx

00472BAA                 sub     eax, edx

00472BAC                 mov     edx, [ebp+var_4]

 

Formula...

 

00472BAF                 movzx   eax, byte ptr [edx+eax-1] > Coge el cuarto Carácter por el final

00472BB4                 imul    edi, eax > Los Multiplica

00472BB7                 add     ebx, edi > Suma a EBX el resultado de la operación anterior

00472BB9                 imul    eax, ebx, 64h > Multiplica EBX por 64h (“100”) y almacena dicho resultado en EAX

00472BBC                 add     ebx, eax > Suma a EBX el resultado de la operación anterior

00472BBE                 dec     ebx > Resta 1 a EBX

00472BBF                 sub     ebx, 16E360h > Resta a EBX 16E360h(“1.500.000)...

00472BC5                 lea     edx, [ebp+var_8]

00472BC8                 mov     eax, ds:off_4D0234

00472BCD                 mov     eax, [eax]

00472BCF                 mov     eax, [eax+590h]

00472BD5                 call    sub_421C84

00472BDA                 mov     eax, [ebp+var_8]

00472BDD                 call    sub_4077C4  > De estas 2 Llamadas se obtiene el valor “3” (Cte)

00472BE2                 imul    ebx > Multiplica EBX por 3, y lo almacena en EAX

00472BE4                 add     eax, eax > Se suma a sí mismo dicho resultado

00472BE6                 lea     eax, [eax+eax*4] > Hace dicha operación y se almacena en EAX el resultado

00472BE9                 mov     ebx, eax > Se almacena en EBX; Nuevo Serial…

00472BEB                 mov     eax, 5F5E0FFh > almacenamos en EAX 5F5E0FFh (99.999.999)

00472BF0                 sub     eax, ebx > Restamos a dicha cantidad EBX

00472BF2                 mov     ebx, eax > El Nuevo resultado queda almacenado en EBX

00472BF4                 test    ebx, ebx

 

Ya tenemos nuestro Serial casi transformado, pero ahora vienen unas comprobaciones muy curiosas:

 

...

00472BF6                 jge     short loc_472BFA

00472BF8                 neg     ebx

 

·         Si nuestro Serial es positivo: Salta, en caso contrario le cambia el signo; y continúa...

 

...

00472BFA                 cmp     ebx, 989680h

00472C00                 jge     short loc_472C08

00472C02                 add     ebx, 989680h

 

·         Compáralo con 989680h (10.000.000), si es menor súmale dicha cantidad, si es mayor; salta...

 

...

00472C08                 cmp     ebx, 5F5E0FFh

00472C0E                 jle     short loc_472C16

00472C10                 sub     ebx, 5F5E0FFh

 

·         Compara EBX con 5F5E0FFh, si es menor, ya lo tenemos!,  en caso contrario resta a 5F5E0FFh EBX y el resultado será el el Key correcto...

 

...

00472C16                 lea     edx, [ebp+var_C]

00472C19                 mov     eax, ebx

00472C1B                 call    sub_407794

00472C20                 mov     edx, [ebp+var_C]

00472C23                 mov     eax, esi

00472C25                 mov     ecx, offset unk_472C6C

00472C2A                 call    sub_403D48

 

·         Durante éstas líneas tenemos nuestro Serial correcto en EBX, pero falta un último detalle, el cual obtendremos en la Instrucción de abajo; (Le añade a nuestro Serial, su distintivo, una ‘a’ y listo)...

 

...

00472D1F                 push    eax > Muestra nuestro Key Correcto en EAX

                        ...

 

4.- Finalizando y Agradecimientos...

 

            Si habéis conseguido Hacer vuestro primer KeyGen con vistas a programas que se comercializan; Enhorabuena, a partir de éste capítulo, siento deciros que me retasaré para escribir los siguientes, ya no tendré tiempo de ponerme 3 o 4 Horas delante del Ordenador, por cuestiones que no vienen al caso,  para hacer otro KeyGen y sacar la rutina.

 

            Os lo recomiendo como Ejercicio, Haced el KeyGen!!! Las soluciones saldrán, en un capítulo que estoy preparando... si me la mandáis, os pondré en dicho capítulo,  junto a vuestro código; ya sea en VB o D...

 

            Por cierto, si habéis hecho las Fórmulas, os habréis dado cuenta que EDX siempre vale 1; pero ¿porqué es bueno hacerlas?, sencillo, ya que hay programas que no la mantienen constante; éste no es el caso, por supuesto.

 

Si tenéis dudas sobre el KeyGen, adjunto mi código fuente con mi KeyGen, que está ubicado en nuestra site; visitadla: www.pagina.de/kfor, y aunque sea para decidme que habéis leido mi tuto, por favor mandadme un Mail, pues últimamente, no veo “movimiento”, por vuestra parte, ¿No os interesa el Tut?, pues si es así, dejaré de escribirlo...

 

            Sin mas demora, tengo que marcharme por hoy, pues tengo que levantarme muy temprano, no sin antes dar las gracias a lso miembros de mi grupo K-FoR, así como a Karpoff, y todos los Crackers que escriben tutoriales en Español y hacen que los programas sean un poco menos comerciales cada día... a todos ellos:

 

 Gracias; RAZiEL

 

Porque somos muchos...

 

 

 

www.000webhost.com