En el anterior articulo explicaba como se generar un crack una vez obtenidos los desplazamientos y los valores a modificar en dichos desplazamientos. Despues escribiamos un pequeño programa en C que realizaba las modificaciones sobre el ejecutable original, etc... 

    Bien, el caso es que realizar todas esas tareas a mano es un poco absurdo ya que se repiten una y otra vez. Mas o menos el proceso a seguir era este.... 
 

- Se crea una copia de seguridad del ejecutable antes de meterle mano, normalmente un archivo mismonombre.bak 
- se enreda sobre el ejecutable modificando los bytes adecuados hasta que se ve que queda completamente crackeado. 
- Se comparan ambos archivos obteniendo las diferencias. 
- Se genera un archivo en C que con esas diferencias modifique el archivo original 

        Vamos a intentar en este tutorial que todo eso (salvo el 2º paso) lo haga todo el linux, que nosotros solo tengamos que pasarle varios parametros y el genere el crack entero. Lo que se denomina un PatchMaker, Generador de Cracks o como os de la gana.... 

/*------------------- CORTA POR AKI------------------------*/ 
// Nombre de Archivo: mxaudiocrack.c 

#include <stdio.h>  //para acceso a archivos.. 

void 
Banner () 
{ 
  printf("\n\n"); 
  printf ("*------------------------------------------------------*\n"); 
  printf ("*--   Crack para Xaudio 1.0.5    By Mr. Jade[WkT!]   --*\n"); 
  printf ("*--       www.xaudio.com           kickme.to/wkt     --*\n"); 
  printf ("*------------------------------------------------------*\n"); 
  printf ("*--   Uso:  Copia este archivo en el directorio      --*\n"); 
  printf ("*--         donde se encuentra el ejecutable mxaudio --*\n"); 
  printf ("*--         y ejecutalo.                             --*\n"); 
  printf ("*------------------------------------------------------*\n"); 
  printf ("*---------         WkT! : Kickme.to/wkt       ---------*\n\n"); 
} 

int 
main (int argc, char * argv[]) 
{ 

  char *path_archivo = "./mxaudio"; 
  FILE *Archivo; 

  Banner (); 

  if ((Archivo = fopen (path_archivo, "r+b")) != NULL) 
  { 

    fseek (Archivo, 43804, 0); //offset de la intruccion TEST %EAX, %EAX 
    fputc(235,Archivo); // la nueva instruccion byte a byte: EB 10 
    fputc (16, Archivo); 

    fseek (Archivo, 1137626, 0); //offset de la cadena UNREGISTERED 
    fprintf (Archivo, "%s", "Mr.Jade WkT!"); 

    fseek (Archivo, 1137639, 0); //offset de la cadena REGISTERED TO: 
    fprintf (Archivo, "%s", "Cracked by: "); 

    fseek (Archivo, 0, SEEK_END);   //Final del archivo. 
     fclose (Archivo); 
    printf ("Xaudio 1.0.5 Crackeado!\n\n"); 
  } 
  else 
  { 
    printf ("Error: No se encuentra el archivo, o no se puede abrir.\n\n"); 
  } 

} 
/*-------------------- CORTA POR AKI-----------------------*/ 

Este era el archivo mxaudio.c y este otro su makefile: 

/*------------------- CORTA POR AKI---------------------------*/ 

CC = gcc 

all:  mxaudiocrack 

 mxaudiocrack: mxaudiocrack.c 
     $(CC)  mxaudiocrack.c -o mxaudiocrack  

clean: 
     rm -f *.o mxaudiocrack 

/*----------------- CORTA POR AKI---------------------------*/ 
 

   Bien, supongamos que hemos aplicado el mismo metodo para generar el crack pero para otro programa. Hemos tenido que seguir los mismo pasos una y otra vez.. y encima el codigo de este crack nos sirve para el nuevo crack, solo tendremos que cambiar el nombre del programa. el banner y los bytes desplazamientos a modificar.  Incluso el makefile nos puede servir si no fuera porque el nombre del archivo c lleva escrito mxaudio.... 
 

     Bueno, pues vamos a analizar todo esto y a crear una nueva tool para la comunidad linux, que nos facilite el trabajo y permita generar cracks de forma mas sencilla. Se trata de WkTCracKGeneratoR. 

- Nombre del ejecutable crackeado. 
- Nombre de la copia de seguridad sin modificar 

  La verdad es que sin estos datos no podemos hacer nada. Ahora vamos a añadirle un par de ellos mas...... 

- Nombre/nick del cracker que ha crackeado (esas redundancias....) el programa 
- Nombre del programa y version, claro.... si no a ver como nos aclaramos..... 

  Ahora  que esta algo mas completo, pasamos a definir que cosas se toman por defecto.... 

- Suponemos que el archivo a modificar tiene el mismo nombre que el archivo modificado, asi pues el crack generado buscara un archivo para crackear que tenga el mismo nombre que el parametro que se le pasa como Nombre del ejecutable crackeado. 
- El crack se generar en codigo C, y el archivo se llamara crack.c. Dentro contendra un banner con los datos del cracker y el nombre y version del programa para el que esta preparado el crack. 
-  Tambien se generara el Makefile para el archivo crack.c 
 

  Esto va bien, pero que muy bien.. ahora veamos que es lo que tiene que hacer el programa con esos datos y despues pasaremos a la programacion... 

- El programa busca y abre el archivo Ejecutable Crackeado. Si hay error sale con un aviso 
- El programa busca y abre el archivo Ejecutable Crackeado. Si hay error sale con un aviso 
- El programa abre el archivo crack.c sobreescribiendolo (cuidado con esto, no pierdas otros crack.c ya generados...). Si hay error sale con un aviso. 
- Se escribe sobre el archivo crack.c toda la parte inicial que sea fija, sease, los includes, la funcion banner, el main, la apertura del archivo, etc.. queda pendiente toda la parte de modificacion del programa. 
- Ahora empieza a comparar byte a byte los archivos binarios Programa Crackeado y Copia de Seguridad, y en cada byte diferente escribe el codigo necesario en crack.c para modificar dicho byte . 
- Una vez finalizado este proceso termina de escribir el archivo crack.c 
-Escribe tambien el archivo Makefile (cuidado con esto no perdais otros makefiles del mismo directorio. Si hay error sale con un aviso. 
- Cierra todos los archivos abiertos, dice adios con la manita y sale. 

  Estos serian todos los pasos a realizar por WkTCracKGeneratoR, pasemos ahora a programarlo paso a paso..... 
 

  El programa empezaria mas o menos asi...... 
/*-----------------Corta por aqui----------------------------*/ 
//Archivo: WkTCracKGeneratoR 
 

// Esta linea incluye las funciones necesarias para el acceso a archivos. 
#include <stdio.h>  //para acceso a archivos.. 

/* Ahora  definimos la funcion que mostrara el baner, algo sencillo pero que aclare que programa se esta ejecutando. Simplemente mediante varios printf sacamos un texto en consola. */
void Banner () 
{ 
  printf ("*----------------------------------------------------*\n"); 
  printf ("*--  WkTCracKGeneratoR    By Mr. Jade[WkT!]   --*\n"); 
  printf ("*--                 kickme.to/wkt                  --*\n"); 
  printf ("*----------------------------------------------------*\n"); 
  printf ("*----------------------------------------------------*\n"); 
  printf ("*--------         WkT! : Kickme.to/wkt       --------*\n\n"); 
} 
 

/*Este snippet nos devolvera el tamaño de un archivo. */
long fsize(FILE *fp) 
{ 
      long pos, size; 

      pos = ftell(fp); 
      fseek(fp, 0L, SEEK_END); 
      size = ftell(fp); 
      fseek(fp, pos, SEEK_SET); 
      return size; 
} 
 

/*  Definimos la funcion main como una funcion que devolvera un valor entero, asi despues un frontend sabra si el comando se ha ejecutado con exito o cual ha sido el error. */
int main (int argc, char * argv[]) 
{ 
 

/*Definicion de las variables que manejara el programa. */
 char ErrorAbrir[] = "\nError al abrir %s\n\n";//Cadena a mostrar en caso de error 

  FILE *ArchivoCrackeado;  //Puntero al archivo crackeado 
  FILE *ArchivoOriginal;        //Puntero al archivo original 
  FILE *ArchivoGenerado;   //Puntero al Archivo crack.c 

  char Caracter;                  //Guardara el valor del caracter leido. 
  long Maximo; 
  long Contador=0;        //encargado de apuntar al desplazamiento. 

//Mostramos el baner 
Banner (); 
 

/* Es hora de parsear la linea de comandos en busca de los parametros necesarios para la ejecucion.   En caso de que no se introduzcan los 4 parametros, sale mostrando la sintaxis correcta y muestra un ejemplo. */
  if (argc < 4) 
   { 
    fprintf (stderr, "USO: WkTCracKGeneratoR ArchivoCrackeado ArchivoOriginal  Programa  Cracker\n"); 
    fprintf (stderr, "Ejemplo: WkTCracKGeneratoR mxaudio mxaudio.bak  Xaudio1.5  Mr.Jade\n\n"); 
    return (1); 
  } 

/*  Si todos los parametros son introducidos ahora comprobaremos si estos son validos.  Empezamos por comprobar los nombres de archivo. Si los archivos no se pueden abrir, muestra una cadena avisando del error. */
//En primer lugar el archivo ya crackeado 
  if ((ArchivoCrackeado = fopen (argv[1], "r")) == NULL) 
  { 
    fprintf (stderr, ErrorAbrir, argv[1]); 
    return (10); 
  } 

//Despues el archivo original. 
  if ((ArchivoOriginal = fopen (argv[2], "r")) == NULL) 
  { 
    fprintf (stderr, ErrorAbrir, argv[1]); 
    return (11); 
  } 

//y despues el crack.c 
  if ((ArchivoGenerado = fopen ("./crack.c", "w")) == NULL) 
  { 
    fprintf (stderr, ErrorAbrir, argv[1]); 
    return (12); 
  } 

/* Si todo ha ido como es debido se abran abierto todos los archivos. Si no es asi, se saldra con un mensaje de error y la funcion main devolvera un numero relaccionado con dicho error. Tomare como 0 una salida correcta, 1 una salida sin realizar acciones debido a la falta de parametros, 10, 11, 12, respectivamente si sucede un error en a la hora de abrir los archivos Programa Crackeado, Programa Original, y crack.c . 

 Ahora toca empezar a escribir sobre el archivo fuente crack.c la parte que es fija al comienzo, que son los includes, la definicion del main, etc.. pero con una salvedad, en el banner se deben incluir el nombre del cracker y el nombre y version del programa que son introducidos en la linea de comandos. Pondre en negrita la parte que quedara escrita en negrita para no confundir... ya que parar incluir caracteres como las " o la  / es necesario incluir el caracter  / antes, que si no se nos lia el compilador y no llena la pantalla de warnings.. Esto lo entendereis si leeis el capitulo relacionado con el print en algun libro o tutorial de C. La funcion fprintf es como el printf pero la salida la hace al archivo indicado en el handle ArchivoGenerado, en este caso es crack.c . */

  fprintf(ArchivoGenerado, "#include <stdio.h>  //para acceso a archivos..\n"); 
  fprintf(ArchivoGenerado, "void\n"); 
  fprintf(ArchivoGenerado, "Banner ()\n"); 
  fprintf(ArchivoGenerado, "{\n"); 
  fprintf(ArchivoGenerado, "  printf (\"*---------------------------------------*\\n\");\n"); 

/*   Fijaos bien en la ultima linea, en donde se repite dos veces el caracter / .uno esta en negrita y otro no, ya que uno esta puesto para que el fprintf no lo tome como un caracter de control, si no que debe coger el siguiente caracter y escribirlo en el archivo. */

/*  Ahora incluimos en el banner los parametros craker y programa version en estas lineas.... */
  fprintf(ArchivoGenerado, "  printf (\"*--\\n\");\n"); 
  fprintf(ArchivoGenerado, "  printf (\"*--   Crack para  %s\\n\");\n", argv[3]); 
  fprintf(ArchivoGenerado, "  printf (\"*--   Cracker     %s\\n\");\n", argv[4]); 
  fprintf(ArchivoGenerado, "  printf (\"*--\\n\");\n"); 
// El %s va a ser sustituido por las cadenas corrrepondientes.... 

//Seguimos ahora con mas parte fija en todos los archivos crack.c 
   fprintf(ArchivoGenerado, "  printf (\"*--------------------------------------*\\n\");\n"); 
  fprintf(ArchivoGenerado, "  printf (\"*-WkTCracKGeneratoR  By Mr. Jade[WkT!]\\n\");\n"); 
  fprintf (ArchivoGenerado,"  printf (\"*--                kickme.to/wkt \\n\");\n"); 
  fprintf (ArchivoGenerado,"  printf (\"*--------------------------------------*\\n\\n\");\n"); 
  fprintf(ArchivoGenerado, "}\n"); 
  fprintf(ArchivoGenerado, "\n"); 
  fprintf(ArchivoGenerado, "int\n"); 
  fprintf(ArchivoGenerado, "main (int argc, char * argv[])\n"); 
  fprintf(ArchivoGenerado, "{\n"); 
  fprintf(ArchivoGenerado, "\n"); 

// Sustituye la cadena del path al archivo. 
  fprintf(ArchivoGenerado, "  char *path_archivo = \"%s\";\n", argv[1]); 
  fprintf(ArchivoGenerado, "  FILE *Archivo;\n"); 
  fprintf(ArchivoGenerado, "\n"); 
  fprintf(ArchivoGenerado, "  Banner ();\n"); 
  fprintf(ArchivoGenerado, "\n"); 
  fprintf(ArchivoGenerado, " if ((Archivo = fopen (path_archivo, \"r+b\")) != NULL)\n"); 
  fprintf(ArchivoGenerado, "  {\n"); 
  fprintf(ArchivoGenerado, "\n"); 

/* Ahora estamos dentro del bucle que se encarga de modificar el ejecutable en el codigo fuente del crack, esto es, dentro de la condicion IF si el archivo se ha abierto correctamente. Mediante un bucle vamos a recorrer los dos archivos ejecutables comparandolos byte a byte. En caso de que no coincidan , escribiremos un par de lineas en el crack.c que se encargaran de modificar dicho byte cuando el crack sea ejecutado. */

  Maximo = fsize(ArchivoOriginal); 
  Contador = 0; 
      while (Contador < Maximo) 
      { 
       Caracter=fgetc (ArchivoCrackeado); 
       if  (Caracter!=fgetc(ArchivoOriginal)) 
        { 
         fprintf(ArchivoGenerado, "fseek (Archivo, %i, 0);", Contador); 
         fprintf(ArchivoGenerado, "fputc(%i, Archivo);\n", Caracter); 
        } 
      Contador++; 
      } 
 

/*Saltamos hasta el final del fichero. Esto evite que el archivo quede truncado al cerrarlo en modo escritura. */
fprintf(ArchivoGenerado, "  fseek (Archivo, 0, SEEK_END);\n"); 

// Cerramos el archivo ejecutable y avisamos.... 
 fprintf(ArchivoGenerado, "   fclose(Archivo);\n"); 
 fprintf(ArchivoGenerado, "   printf (\"El archivo %s ha sido crackeado con exito.\\n\\n\");\n",argv[1]); 

/*Una vez realizadas las modificaciones, salimos del IF  y pasamos a la siguiente parte. */
  fprintf(ArchivoGenerado, "  }\n"); 
  fprintf(ArchivoGenerado, "  else\n"); 
  fprintf(ArchivoGenerado, "  {\n"); 
  fprintf(ArchivoGenerado, "    printf (\"Error: No se encuentra el archivo, o no se puede abrir.\\n\\n\");\n"); 

/*Aqui es donde se añadiria codigo en caso de que nos interese realizar alguna accion mas si el archivo no puede abrirse. */
  fprintf(ArchivoGenerado, "  }\n"); 
  fprintf(ArchivoGenerado, "\n"); 
  fprintf(ArchivoGenerado, "}\n"); 
  fprintf(ArchivoGenerado, "\n"); 

//Cierra los archivos abiertos 
  fclose(ArchivoCrackeado); 
  fclose(ArchivoOriginal); 
  fclose(ArchivoGenerado); 

// Saliendo...... 
 return(0); 
} 

/*-------------------  Corta por aqui  ------------------*/ 
 
 

Bien, el pograma esta escrito, ya solo falta el Makefile, pero esta vez vamos a dar soporte al Makefile para que compile tambien los cracks generados. 

/*------------  Corta por aqui y guarda como: Makefile--------*/ 
 

CC = gcc 

all:  WkTCracKGeneratoR 

crack: crack.c 
 $(CC)  crack.c -o crack  

WkTCracKGeneratoR: WkTCracKGeneratoR.c 
 $(CC)  WkTCracKGeneratoR.c -o WkTCracKGeneratoR  

clean: 
 rm -f *.o WkTCracKGeneratoR crack 

/*---------------- Corta por akin--------------------*/ 

Ahora, para borrar anteriores compilaciones, y recompilar de nuevo: 

make clean

Para compilar WkTCracKGeneratoR : 

make

Para compilar el crack generado: 

make crack

  Vamos ahora a crear nuestro primer crack con esta tool, para eso recurrimos de nuevo al xaudio recien crackeado.  Cada uno tendra que modificar las lineas de path segun tenga instalado. Este fue mi linea de comando: 

./WkTCracKGenerator /usr/local/bin/mxaudio /tmp/mxaudio.bak Xaudio1.0.5 Mr.Jade 

Y este fue el resultado: 

*/-----------------  Archivo crack.c ---------------*/ 
#include <stdio.h>  //para acceso a archivos.. 
void 
Banner () 
{ 
  printf("*--------------------------------------*\n"); 
  printf ("*--\n"); 
  printf ("*--   Crack para  Xaudio1.0.5\n"); 
  printf ("*--   Cracker     Mr.Jade\n"); 
  printf ("*--\n"); 
  printf ("*-------------------------------------*\n"); 
  printf ("*-   WkTCracKGeneratoR  By Mr. Jade[WkT!]\n"); 
  printf ("*--           kickme.to/wktk\n"); 
  printf ("*-------------------------------------*\n\n"); 
} 

int 
main (int argc, char * argv[]) 
{ 

  char *path_archivo = "/usr/bin/local/mxaudio"; 
  FILE *Archivo; 

  Banner (); 

 if ((Archivo = fopen (path_archivo, "r+b")) != NULL) 
  { 

fseek (Archivo, 43804, 0); 
fputc(-21, Archivo); 

fseek (Archivo, 43805, 0); 
fputc(16, Archivo); 

fseek (Archivo, 1137626, 0); 
fputc(77, Archivo); 

fseek (Archivo, 1137627, 0); 
fputc(114, Archivo); 

fseek (Archivo, 1137628, 0); 
fputc(46, Archivo); 

fseek (Archivo, 1137629, 0); 
fputc(74, Archivo); 

fseek (Archivo, 1137630, 0); 
fputc(97, Archivo); 

fseek (Archivo, 1137631, 0); 
fputc(100, Archivo); 

fseek (Archivo, 1137632, 0);
fputc(101, Archivo); 

fseek (Archivo, 1137633, 0); 
fputc(45, Archivo); 

fseek (Archivo, 1137634, 0); 
fputc(87, Archivo); 

fseek (Archivo, 1137635, 0); 
fputc(107, Archivo); 

fseek (Archivo, 1137636, 0); 
fputc(84, Archivo); 

fseek (Archivo, 1137637, 0); 
fputc(33, Archivo); 

fseek (Archivo, 1137639, 0); 
fputc(32, Archivo); 

fseek (Archivo, 1137640, 0); 
fputc(67, Archivo); 

fseek (Archivo, 1137641, 0); 
fputc(114, Archivo); 

fseek (Archivo, 1137642, 0); 
fputc(97, Archivo); 

fseek (Archivo, 1137643, 0); 
fputc(99, Archivo); 

fseek (Archivo, 1137644, 0); 
fputc(107, Archivo); 

fseek (Archivo, 1137645, 0); 
fputc(101, Archivo); 

fseek (Archivo, 1137646, 0); 
fputc(100, Archivo); 

fseek (Archivo, 1137647, 0); 
fputc(32, Archivo); 

fseek (Archivo, 1137648, 0); 
fputc(98, Archivo); 

fseek (Archivo, 1137649, 0); 
fputc(121, Archivo); 

  fseek (Archivo, 0, SEEK_END); 
  fclose(Archivo); 
  printf ("El archivo %s ha sido crackeado con exito.\n\n", path_archivo); 

  } 
  else 
  { 
    printf ("Error: No se encuentra el archivo, o no se puede 
            abrir.\n\n"); 
  } 

} 
 

*---------------- Corta por aki--------------*/ 

 Ahora compilamos con make crack, ejecutamos y listo. 
 
 

  Para despedirme quiero decir que esto solo es un ejemplo, y que cualquiera con un poco de cerebro podria mejorarla y mucho. En tus manos esta, nosotros bastante hemos hemos escribiendo esto y publicando las  fuentes. Con este tutorial no he querido potenciar el trafico de cracks en la comunidad linux, ni facilitar el trabajo a los que estan empezando con el crackeo en linux. Todo lo contrario. Solo sigo con la labor de aumentar el numero de herramientas para la gente que utiliza este SO, y que esto os sirva para poner en movimiento esas 4 neuronas y os entre el gusanillo de la creacion. No espereis a que os den todo hecho, si algo no lo encontrais, animaos y hacedlo vosotros mismos. 

  AH! y recordad que si quereis usar un programa, debeis pagar la correspondiente licencia, no seais malos..... . (Por eso abandone windows y me pase a linux, entre otras cosas....) 

  El codigo fuente presentado en el tutorial no es del todo funcional. No se trata de un error, si no de asegurar que tu intencion es la de aprender, y no la del abuso del codigo aqui desarrollado. Los fallos son basicos y estan a la vista de todos. 
  Wkt!  no se hace responsable de los posibles daños que este programa puede causar en TU maquina debido un mal uso por TU parte. WkT! no continuara con el desarrollo de este generador de cracks asi que no nos abrases a correos pidiendo una nueva version. Actualizala tu. Como mejoras a simple vista se podrian incluir las de compilacion automatica, y que el propio programa genere un targz con el crack, la fuente , el  Makefile y un archivo de info especificando la version de programa, manejo del crack. etc.. Ademas, si te lo curras y te queda un generador mas chachi que los jelogüin nos lo pasas, no seas egoista.. ;) 

  Los Makefiles incluidos puede que te sirvan o no. Cada uno debe buscarse las habas para que el programa funcione. No queremos fomentar la aparicion de garrulines(*). Si encuentras problemas para poner en marcha el programa, y sin embargo has sido capaz de crackear  alguna joya de esas  de shareware que abundan por ahi, considerate incluido en el apartado "garrulines". Si realmente tienes problemas para compilar debido a la falta de conocimientos en C, te recomiendo cualquier libro de C (que anda que no hay) en el que explique el uso de Makefiles. 

  Mr.Jade odia a los garrulines(*). 
  Mr.Jade odia que programas de este tipo caigan en manos de garrulines(*). 
 
 

(*)QPR: Que Pague Rita, modelo de licencia propuesto por sotabastos en heraclio.fournier para erradicar todo tipo de licencia que no sea GPL o GNU 

(*)garrulines: Dicese del tipico personaje que lee 4 tutoriales y crackea un prg utilizando 3000 tools  bajadas de internet que lo hacen todo de forma automatica y luego, explotanto de gusto, se lo cuenta hasta a  la BSA. En definita, esos que tienen borrado el numero de la tecla F10 del teclado debido a su ....como lo diria....  capacidad de lectura de manuales como el del Soft Ice.