De nuevo entrado en linux, y siguiendo con la filosofia del ECD de no repetir tema, esta vez he decidido pegarme la pechada de escribir en cantidades industriales sobre un tema que segun veo dia a dia en el irc se esta poniendo muy muy de moda entre la coleccion de garrulines. Sease... Los CRACKMES. Esas pequeñas joyas de la programacion (existen en VB tb, no nos engañemos) en la que los programadores invierten sus recursos, tecnicas y conocimientos esperando que por lo menos este mas de una semana sin ser crackeado. A mi, tengo que reconocerlo me encantan, sobre todo esos en los que resulta que hay que meter una cadena como serial de mas de 30 caracteres pero luego se puede eliminar la comprobacion con un salto... jeje, son geniales.....o cuando miras el crackme 5 de no se quien , y resulta que es como el 4 que saco hace poco pero ha metido una deteccion del soft ice (que por otra parte nos la sabemos todos ya...). Realemente solo unos pocos se salvan en mi opinion a la hora de ser crackmes realmente, y esos pocos que se salvan... joer.. hay que reconocer que tienen calidad ademas de ser originales.

   Bueno, pues en el mundo linux, no ibamos a ser menos, y como tutorial este vez, venga un crackme!. Veremos como programarlo y como crackearlo, lo cual nos enseñara mas aun de que va esto de linux.

  La forma de programar el crackme va a ser la siguiente. se crea una aplicacion guarri, en C.. ni gtk ni tk ni X ni nada por el estilo.. vamos a lo mas basico. Algo que devuelva una cadena muy chula si lo crakeamos y despues nos vamos sacando protecciones de debajo del  sombrero y se las vamos poniendo. Ya se me esta ocurriendo un time limit, alguna nag... cosas asin.....

   No, y repito, No entrare en opciones del compilador para que aparezca o no referencias dentro del ejecutable, eso podria alargar demasiado este tutorial. Tampoco entrare en analizar si la en la compilacion el ejecutable sera  dinamico  o estatico, ni cosas de esas.. Solamente tratare en este tutorial aspectos relaccionados con la programacion de un pequeño crackme y el propio crackeo. Todos sabemos que el crackeo sera mas sencillo si compilamos el ejecutable en  con soporte para el debugger, si lo hacemos de forma dinamica, etc.. pero bueno, esos temas seran tratados en otro tutorial, o recurre a la ayuda del compilador. Simplemente decir que compilaremos y linkaremos de forma separada para evitar añadir info de simbolos al ejecutable.

gcc Crackme -o Crackme.o     (si no lo entiendes lee las paginas de manual de gcc)
ld -o Crackme Crackme.o -s   (si no lo entiendes lee las paginas de manual de ld)

  Nuestro pequeño crackme va a ser compilado de forma dinamica, esto es.. necesitara de ciertas librerias para funcionar pero reducira su tamaño. De ellas importara varias funciones como las de apertura de archivos en caso de que lleve, etc.. es como las DLL en un SO windows. Eliminaremos la posibilidad de desensamblar con el LINUX DISASSEMBLER en perl al eliminar toda info que no sea extrictamente necesaria para la ejecucion volviendo loco a OBJDUMP y quien sabe, tal vez con tiempo metamos alguna tecnica antidebug en linux.. 

  Pero ya basta de chachara.. al grano.

  Empezaremos por crear el bitxo este  a partir de una idea muy sencilla. Nada mas empezar pediremos un numero de registro que sera el que habilite o no la solucion al crackme.
(Si teneis intencion de crackearlo por vuestra cuenta antes de tragaos el tute no sigais leyendo, ya que a partir de aqui se muestran las primeras pistas.)

Lo primerito, esconder la cadena magica. para eso utilizaremos cualquier algoritmo que se nos pase por la cabeza.. mm entre ellos el xor 80 ...No escribire la cadena ya que eso saltaria a la vista para quienes echen una ojeada por encima  al tutorial , pero si que explicare como verla, ya que forma parte del codigo fuente.  Pillamos la cadena y a cada uno de los caracteres le restaremos 30 + su posicion en la cadena. No es un gran algoritmo de encriptacion, pero nadie sabe en teoria como esta oculta la cadena ya que se trata de una parte muy interna en la ejecucion del crackme. Esto hara que quede fuera de la vista para los mirones y no  nos estropeara el codigo fuente. Para mostrarla crearemos un bucle que apute a dicha cadena sumando 30+su posicion en la cadena, devolviendo la cadena original y mostrandola si se introduce el codigo correcto.

- 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) `gtk-config --cflags` crack.c -o crack `gtk-config --libs`

WkTCracKGeneratoR: WkTCracKGeneratoR.c
 $(CC) `gtk-config --cflags` WkTCracKGeneratoR.c -o WkTCracKGeneratoR `gtk-config --libs`

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

  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.

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