C

 Capítulo VI: Apocalipsis V1.2

1.- Saludos

 

            De Vuelta a las Andadas con la sexta parte de este “cursillo”... Aunque creo que ya no necesito presentación; soy RAZiEL del K-FoR, para quien no me conozca; como todos sabéis acepto cualquier tipo de crítica constructiva y estoy abierto a sugerencias; escribidme a Raziel@telepolis.com; y por supuesto visitad nuestra site: www.pagina.de/kfor

 

            Ya está disponible la versión 4.0 de la Compilación de Tutoriales 2000 así, que bajadla lo antes podáis, unos 12.5 MB...

 

            Me gustaría aclarar una cosita: hice un Keygen de un programa (Toggle Disk, creo), y para que os acostumbrarais al uso de bucles, en vez de usar la función para el paso de minúsculas a Mayúsculas directamente, lo hice mediante bucles... Por favor, no me seáis tarugos, y si queréis ahorraros trabajo, usad esas funciones... (solo es una recomendación)...

 

2.- Timadores y Timos...

 

            A los que siguieron el capítulo anterior, deciros, que la empresa Toggle usa el mismo algoritmo para todas sus aplicaciones, lo que ocurre, es que varía la constante utilizada para el cálculo del serial... AFA fue el que me lo corroboró haciendo el KeyGen del Toggle Quick Scroll; noble programa, por cierto...

 

            Éste es un fragmento de su Mail, os puede parecer interesante:

 

Buenas RAZiEL

Te envío el keygen que hecho para el Toggle Quick Scroll.
El algoritmo que yo vi en este programa es prácticamente
el mismo que el que tu comentas en el tutorial. Solo que la
cifra inicial con la que comienza la suma es distinta, en
este caso es 1309d--->77981.

 

Sólo espero que reflexionéis acerca de este hecho, y que saquéis algunas conclusiones... nosotros a lo nuestro...

 

3.- Unas últimas Recomendaciones...

 

            Veréis, la víctima hoy aquí presente, no es de las que podríamos denominar “llevaderas”, es un auténtico bodrio, debido, a que no encuentras una pista clara de lo que hace en ningún momento...

 

            En éstos casos os recomiendo que uséis PAPEL y LÁPIZ (Que todavía no los habíamos usado), y analicéis muy pero muy detenidamente el comportamiento del programa... exprimiéndoos las neuronas hasta el punto de caer desmayados por el agotamiento...

 

            Por ejemplo: un posible ejercicio para que saquéis conclusiones:

 

            1, 3, 5, 7, 11, 13, 15, 17, 19

 

            ¿Cuál es la relación existente entre éstos números? Sencillo, ¿verdad? Son todos los números primos comprendidos entre el uno, y el 20, pues bien, cosas tan “chorras” como éste son las que tendremos que llevar hoy a la práctica...

 

4.- Crackeando, de nuevo, la realidad...

 

            Este programa tiene la extracción de Serial muy sencilla, únicamente con un HMEMCPY y varios F12 la consigues sin esfuerzos, es por esto por lo que me pareció interesante estudiarla, sin darme cuenta que me metía en la boca del lobo...

 

            Nuestra Víctima de Hoy: AceFTP 1.24a

 

Bien, este programa, es una alternativa al CuteFTP, que últimamente está fallando mas que una escopeta de feria, por lo que os recomiendo éste como alternativa; o el Internet Neighborhood, (cuyo Keygen, también podéis hacer, por supuesto)...

 

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:

AceFTP 1.24ª

Página Web:

http:://visic.com

Tiempo a Emplear:

Unas 5 Horas

Dificultad:

Newbie - Aficionado – Avanzado+ - Experto – Élite

 

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

 

·          El programa pasa nuestro nombre a Mayúsculas previamente al cálculo de nuestro Serial...

·          El Uso de una Pequeña Constante que tendremos hasta el la sopa: “FJ7ESTYULPVBNMCRY567AA8234452734

·          Se creará otra constante partiendo de la inicial, que dependerá según el nombre...

·          Se juega mucho con las posiciones de los caracteres a lo largo de toda la rutina de serialización...

·          Nuestro Serial tendrá una pinta de: xxxxxx-xxxxxx-xxxxxx-xxxxxx

 

Os recomiendo nuevamente que imprimáis el manual si tenéis la intención de estudiar el código desde SICE.

 

La Rutina:

 

004B7EF3                 lea     eax, [ebp+var_34]

004B7EF6                 mov     edx, [ebp+var_10] > Nuestro Nombre

004B7EF9                 mov     ecx, [ebp+var_20]

004B7EFC                 mov     dl, [edx+ecx-1] > Coge un carácter de Nuestro Nombre (Empezando por la IZQ)

004B7F00                 call    403DFC

004B7F05                 mov     eax, [ebp+var_34] > Nuestro Carácter

004B7F08                 mov     edx, [ebp+var_18] > Nuestra Constante

004B7F0B                 call    4041BC > Si el carácter está en la cadena, devuelve en EAX su posición, sino un 0

...

004B7F12                 jle    4B7F31 > Salta sí el carácter no está en la cte ( devuelve la posición 0) …

004B7F37                 jnz     4B7EF3 > Vuevle al inicio del bucle, si todavía no se ha evaluado todo nuestro nombre

            ...

 

Ésta parte es muy, pero que muy Interesante... Fijaos..

 

·          Se va cogiendo carácter a carácter nuestro nombre pasado a Mayúsculas (Comenzando por la izquierda)... la llamada a 4041BC comprueba si nuestro carácter está en el CTE “FJ7ESTYULPVBNMCRY567AA8234452734  y nos devuelve la posición de dicho carácter en EAX... en caso de que nuestro carácter no esté en la susodicha constante se produce un salto justo después de la llamada (JLE 4B7F31) , y sigue evaluando nuestro nombre hasta que no haya mas caracteres para evaluar ...

 

·          No os confundáis!!!: Aunque en la CTE haya caracteres repetidos, siempre se coge el primero que se encuentra (evaluando siempre por la izquierda)...

 

·          Los caracteres que están en la CTE se almacenan en otra variable aparte...

 

En mi caso

 

·          Name RAZiEL > RAZIEL

·           Constante (CTE)FJ7ESTYULPVBNMCRY567AA8234452734

 

·          La nueva variable sería: RAEL

 

Seguimos con la rutina...

 

...

004B7F3C                 mov     edx, [ebp+var_14] > Nuestra Nueva Variable (“RAEL”)

004B7F47                 call    403ED4 > La longitud de nuestra nueva variable “RAEL” se almacena en EAX

004B7F4F                 cmp     [ebp+var_2C], 18h > Compara que el tamaño de nuestra Variable no excede de “24”

004B7F53                 jge    4B7F90 > Sino, Salta a la instrucción pertinente

004B7F55                 mov     eax, 18h

004B7F5A                 sub     eax, [ebp+var_2C] > Resta a “24” el tamaño de Nuestra variable…

 

004B7F6B                 lea     eax, [ebp+var_34]

004B7F6E                 mov     edx, [ebp+var_18]

004B7F71                 mov     ecx, [ebp+var_20]

004B7F74                 mov     dl, [edx+ecx-1]

004B7F78                 call    403DFC

004B7F88                 inc     [ebp+var_20]

004B7F8B                 dec     [ebp+var_30]

004B7F8E                 jnz     4B7F6B

 

004B7F90                 mov     eax, [ebp+var_10] > Nos muestra otra Variable

004B7F9F                 jle    4B7FB7 > Salta al cálculo del Serial si se comprueba que están los 24 Caracteres...

 

En este apartado

 

Se coge nuestra variable “RAEL”, y se le resta su longitud  a “24” en Decimal... ¿Porqué?, sencillo, nuestro serial va a tener 24 dígitos... y lo que hace el programa para generar el serial es:

 

·          En caso de que la longitud de nuestra variable iguale o sobrepase 24 se pasa directamente al siguiente apartado [004B7F53]

 

·          Sino; Tras el resultado de (18h – Longitud de Nuestra Variable); coge tantos caracteres de la CTE como tenga dicho resultado (Comenzando por la Izquierda), y los almacena. Esto lo hace el Bucle [004B7F6B-004B7F8E]

 

·          Se creará otra variable TOTAL, que se obtendrá de: Nuestra variable “RAEL” + el resultado de los caracteres escogidos...

 

En mi caso, 4 Caracteres de la Variable y 20 de la CTE

 

RAEL + FJ7ESTYULPVBNMCRY567. Nos la muestra en [004B7F90]

 

Seguimos:

 

...

004B7FD3                 lea     eax, [ebp+var_34]

004B7FD6                 mov     dl, [ebp+var_19]

004B7FD9                 call    403DFC

004B7FDE                 mov     eax, [ebp+var_34] > Nuestro primer carácter de la variable TOTAL

004B7FE1                 mov     edx, [ebp+var_18] > La CTE del programa...

 

OK; Básicamente las líneas que os adjunto abajo son propiamente la transformación a nuestro serial, tal y cómo lo hace el programa...

 

El Algoritmo en Cuestión hace lo siguiente:

 

·          Coge la primera letra de nuestra variable TOTAL; y mediante una llamada, por ahí perdida, averigua su posición en la CTE del programa... Bien; con ésta información hace lo siguiente:

 

·          Eleva al cuadrado ese resultado

·          Le resta al total obtenido la posición en la CTE de nuestro carácter...

·          Divide el número obtenido entre 20h (“32” en Decimal) Coge el resto de dicha división... Le suma 1; y obtiene un valor x, con el que trabajaremos...

·          Con ese valor x; busca en la CTE del programa; el carácter cuya posición empezando por la izquierda es esa; esa es la letra que pondrá en primer lugar...

 

Con el segundo carácter hará exactamente lo mismo, con la salvedad que le sumará la posición del carácter anterior también antes de dividir, y de buscar la posición en la cadena...

 

Así hasta el final de nuestra constante TOTAL... ; Obtendremos un número y se le añadirán los guiones pertinentes cada 6 caracteres para que nuestro serial obtenga la forma xxxxxx-xxxxxx-xxxxxx-xxxxxx

 

Éste es parte del código que corresponde a lo que he explicado arriba:

 

...

004B7FF5                 mov     eax, [ebp+var_24] > En EAX tenemos la posición que ocupa el carácter en la CTE

004B7FF8                 imul    [ebp+var_24] > Lo eleva al Cuadrado

004B7FFB                 sub     eax, [ebp+var_24] > Le resta la cantidad inicial

004B7FFE                 add     eax, [ebp+var_28]

...

 

004B7FFE: Suma el resultado global del carácter anterior evaluado con lo que tenemos almacenado en EAX; en caso de no haber sido evaluado ninguno; se suma “0” Inteligente, ¿verdad?

 

004B8001                 pop     edx

004B8002                 mov     ecx, edx

004B8004                 cdq > Se prepara para la división llena EDX de 0000 para que no haya confusiones...

004B8005                 idiv    ecx > Realiza la división ENTERA (En ECX está almacenado 20h)

004B8007                 mov     [ebp+var_24], edx > El resto de dicha división se mueve a EBP+24

004B800A                 inc     [ebp+var_24] >Incrementamos ese valor en 1...

004B800D                 mov     eax, [ebp+var_24]

004B8010                 mov     [ebp+var_28], eax

           

Cómo no sé si lo habéis entendido, haré manualmente las primeras dos transformaciones...

 

Veamos, tenemos una variable TOTAL que contiene: RAELFJ7ESTYULPVBNMCRY567

            La CTE de nuestro programa: FJ7ESTYULPVBNMCRY567AA8234452734

 

            PASO A PASO...

 

            Cogemos el primer carácter de nuestra Variable TOTAL: “R

            Vemos su posición en la CTE: 16

            Multiplicamos 16² =  256

            Restamos a 256 la cantidad inicial: 256 - 16 = 240

            Sumamos todo el resultado del carácter evaluado anteriormente (como es el primero, no sumamos nada)...

            Dividimos 240 entre 32 = 7

            Nuestro Resto es 16 y le sumamos 1; 16 + 1 = 17

            Miramos la posición 17 en la CTE y es una “Y” bien esa será la primera letra se mi serial.

 

            Si lo hacemos con el segundo carácter:

 

            Cogemos el primer carácter de nuestra Variable TOTAL: “A

            Vemos su posición en la CTE: 21

            Multiplicamos 21² =  441

            Restamos a 441 la cantidad inicial: 441 - 21 = 420

            Sumamos todo el resultado del carácter evaluado anteriormente (17) 420 + 17 = 437

            Dividimos 437 entre 32 = 13

            Nuestro Resto es 21 y le sumamos 1; 21 + 1 = 22

Miramos la posición 22 en la CTE y observamos que es una “A

 

Pues mi Serial tendrá el siguiente aspecto: YAxxxx-xxxxxx-xxxxxx-xxxxxx

 

            Y así hasta un total de 24 Veces... si lo conseguís os habréis ahorrado unos 29.95 Dólares...

 

            ¿Entendido, chavales?

           

5.- El KeyGen de los BUCLES...

 

            Bueno;  Por si sigue perdurando alguna duda: Aquí tenéis mi código en Delphi

             

procedure TForm1.Button1Click(Sender: TObject);

var

Cte, Var1, Z, Var2, C, Var3: String;

I, X, Y, a,b,e,d : Integer;

begin

Y:=1;

X:=1;

Cte:='FJ7ESTYULPVBNMCRY567AA8234452734';

Var1:=Uppercase(Edit1.text); // Pasa a Mayúsculas //

 

If Edit1.text='' then

begin

Showmessage ('Introduce Algún Carácter Para Que Pueda Calcularle el Serial');

exit;

end;

 

// Este bucle es el encargado de ver si los caracteres de nuestro nombre están en la CTE //

 

For x:= 1 to strlen(pchar(Var1)) do

    begin

          For I:=1 to strlen(pchar(Cte)) do

               begin

                 If (Var1[x] = Cte[I]) then // Si están en la constante //

                  begin

                  Var2:=Var2+Var1[x]; // Crea una nueva variable y añade los caracteres que estén //

                  break; // Para evitar que se el carácter está repetido se vuelva a añadir; salimos del bucle cada vez //

                 end;

               end;

          end;

 

Var2:=Var2+CTE; // Añadimos a la variable creada nueva, la CTE entera //

Var1:='';

 

For I:=1 to 24 do // Con este mini bucle cogemos los 24 primeros caracteres obtenidos //

begin

C:= Var2[I];

Var1:=Var1+C;

end;

 

// Segundo Bucle importante; Va paso a paso, haciendo las operaciones para que el serial se genere, es la reversión exacta del código en ASM //

 

For I:= 1 to strlen(pchar(Var1)) do

begin

     For X:=1 to Strlen(pchar(Cte)) do

     begin

 

          If (Var1[I]=Cte[x]) then

          begin

          a:=x;

          a:=a*a;

          a:=a-x;

          a:=a+ e;

          b:=a mod 32;

          b:=b+1;

          Var3:= Var3 + Cte[b];

          e:=b;

          break;

          end;

     end;

end;

 

// Añadimos los guiones //

 

Var2:='';

 

For I:=1 to 24 do

begin

 

     If (I=7) or (I=13) or (I=19) then

     begin

     Var2:=Var2+ '-';

     end;

     Var2:=Var2+ Var3[I];

 

end;

edit2.text:=Var2;

 

end;

           

6.- El Fin del Principio...

 

Con esto llega a su fin el Inicio a los KeyGens; Pero es el fin para mí, pues espero que los seguidores de este curso sigan haciendo Keygens, tan a gusto como yo los he hecho...

 

            Solo deciros que las soluciones a los ejercicios podréis encontrarlas en los próximos días; así como el PROGRAMA DE COMPLEMENTACIÓN HUMANA (La guía de todas las instrucciones de ASM), que haré, para que no tengáis pegas acerca de cualquier instrucción en ASM... y alguna otra cosa mas de la que me olvido...

 

            Estoy pensando en hacer un “crack-keygen-me” para que le hagáis el Keygen...

            Esas son algunas recomendaciones que me han hecho varios Crackers... y cómo no, voy a llevarlas a la práctica...

Gracias a todos los que habéis seguido este curso; y a todos los que me habéis bombardeado a críticas, aunque no hayan sido muchas, creo que deberían de haber sido más...

            Gracias a todo al K-FoR y a todos los miembros de Tutoriales 2000...

            Aquí termina mi trabajo, comienza el vuestro... RAZiEL

            Gracias a Todos.

 

Porque somos muchos...

 

 

           

           

           

 

           

www.000webhost.com