Taller de Cracking desde 0 [Parte 1]

¿Qué es esto ?

Este Taller de Cracking desde 0 va orientado a todas esas personas que ya tienen un poco de teoria sobre este mundo del Cracking pero le falta practica y es que por este motivo no han querido continuar en este Arte, que suele ser considerado algo complejo.
Gracias a todos los esfuerzos de los crackers que publican sus tutoriales en la red es que lo he plasmado aquí en un resumen, por lo tanto este texto va a ir dirigido hacia esa gente con conocimientos teoricos sean pocos o mucho, para que de sus segundos pasos y logre entender los conceptos con la práctica.

Estamos seguros, que a gente avanzada también le puede ayudar a recordar o aprender cosas nuevas, así que esperamos que os guste y que les pueda ayudar a "empezar a caminar mas lejos"...

Como todo, hay que empezar por lo más básico, asi que si no tienes teoria (conceptos basicos) , no podras entender algunas cosas planteadas aquí, asi que trata de no ser solo practico y anda leete algo de teoria , o con la Introduccion al Cracking desde 0 posteada por mí tambien te podra servir ya que este taller va de la mano con ese texto.

¿Como trabajaremos?

En cada leccion ire colocando codigos fuente de pequeños programas (primeras lecciones) , o sino posteare programas previamente ya compilados subidos por mí o descargados desde la red para poder trabajar.


¿Que herramientas voy a utilizar en este taller?

- Como es un taller , lo que se realizara aqui son full practicas por lo tanto necesitaremos algunas herramientas principales , que tendran que conseguir . Conforme avance este taller se iran necesitando mas herramientas , las cuales ire poniendo los links de descargas , asi que no preocupeis por eso .

Herramientas Principales :

- Fasm : Compilador gratuito del Lenguaje Ensamblador (ASM)

- OllyDbg : Debugger



1.- FASM - No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
   1.1.- Instalación
            Hacemos anticlick en el archivo rar que descargamos y luego seguimos los sgts pasos :

            *Click en Extraer Archivos
           

            *Colocamos la ruta de instalacion en la nueva ventana que nos aparece , y luego presionamos en el boton Aceptar
           

   1.2.- Compilando
            Nos vamos a la ruta donde instalamos el FASM y lo ejecutamos :

           

           

            Copiamos o programamos un codigo en lenguaje en Ensamblador , aqui un Ejemplo :

include  'C:\FASM\INCLUDE\WIN32AX.inc' ; Ruta donde tenemos instalado el FASM ,
                                       ; para incluir el archivo win32ax.inc
.code
start:
invoke SHAddToRecentDocs, 0, 0 ; llamamos a la api SHAddToRecentDocs para eliminar los documentos recientes
;------------------------
invoke ExitProcess,0 ;Terminamos
.end start

            Copiamos el codigo y lo pegamos en el FASM , luego lo guardamos y en la ventana para guardar le pones cualquier     
            nombre en este caso "tempo" (Borra los archivos recientemente abiertos) y el FASM le pondra automaticamente la             
            extension .asm :


            Una vez guardado el archivo , lo compilamos presionando la tecla CTRL+F9 o sino nos vamos a la pestaña Run y
            seleccionamos Compile :

           

            Nos vamos al directorio donde guardamos el archivo .asm y veremos nuestro .exe :

           

   1.3.- Probando si el compilado fue correcto
            Seguimos con el programa que compilamos anteriormente , ahora comprobaremos si funciona
            Veremos los archivos recientemente abiertos :

           

            Ejecutamos nuestro archivo compilado, y vemos si funciono :

           

            Con esto ya podemos a pasar al taller en sí ...


1.- Debugeando nuestro primer programa

- El codigo del programa a utilizar es el sgte :

include 'C:\FASM\INCLUDE\WIN32AX.inc'    ; Ruta donde se encuentra el FASM
 
.data
   cuerpo db 'Hola Diosdelared', 0
   titulo db 'Coder : Bocvk', 0
 
.code
start:
 
   mov eax, 2	      ; Esto equivale a eax = 2 en decimal = 2 hexadecimal
   mov ebx, 0x123     ; Esto equivale a ebx = 123 (el 0x adelante indica que es número hexadecimal)
 
   push 0	      ; Mete a la pila 0 (NULL)
   push titulo	      ; Mete a la pila el contenido de la variable "titulo"
   push cuerpo	      ; Mete a la pila el contenido de la variable "cuerpo"
   push 0	      ; Mete a la pila 0 (NULL)
   call [MessageBoxA] ; Esta api extrae cuatro elementos de la pila , segun a esto imprime en una ventanita un msg
		      ; con un titulo y con un cierto tipo de botones .
 
   mov ecx, NULL      ; ecx=0
   mov cx, 2	      ; cx=2
   mov ch, 5	      ; ch=5
		      ; al final de estas tres ultimas linea dara este resultado : ecx=00050002
 
   push 0
   call [ExitProcess] ; Esta api , finaliza el programa
 
 
.end start

- Ejecutamos el OllyDbg :


- Ahora abrimos nuestro programa previamente compilado , esto se puede hacer de dos formas :
    * Desplegando la pestaña File > Open ( F3)

   

    * Presionando el botón de Abrir en la parte inferior de los menus

   

  Se nos abrira un nueva ventana para buscar y seleccionar el programa a abrir con el OllyDbg ( debugear ) , y luego damos click
  en el botón Abrir.

   

- Ahora nos aparecera el codigo del programa en ASM ( en la sub ventana de desamblado ), en este caso tal como nosotros lo programamos ya que utilizamos tambien el lenguaje Ensamblador :


- El codigo ya esta comentado (previamente analizado) , pero ahora vamos analizarlo interactivamente , a esto se le llama tracear que quiere decir ejecutar linea por linea de codigo fuente , esto ya esta explicado en las teorias pero bueno por unica vez les dire como hacerlo , presionando F7 o F8 (son diferentes asi que aqui apliquen algo de teoria).

- Comenzamos presionando F8 en la primera linea :

00402000 >/$  B8 02000000   mov     eax, 2

  *Movemos a eax el valor 2 en hexadecimal (el olly convierte todo lo que es decimal en hexadecimal) , vamos a los registros a comprobarlo .

   

- Pasamos a la segunda linea y volvemos a presionar F8 :

00402005  |.  BB 23010000   mov     ebx, 123

  *Movemos a ebx el valor 123 en hexadecimal , vamos a los registros a comprobarlo .

   

- Continuamos con la tercera linea y presionamos F8 :

0040200A  |.  6A 00         push    0                                ; /Style = MB_OK|MB_APPLMODAL

  *Guardamos el valor 0 en la pila , ¿para que? : sirve como parametro a la api MessageBox al igual que los tres sgts valores que guardaremos en las 3 lineas que continuan , vayamos a la pila aver si enrealidad guardo este 0 :

   

- Cuarta linea , presionamos F8

0040200C  |.  68 11104000   push    00401011                         ; |Title = "Coder : Bocvk"

  *Guardamos el valor que contiene la dirección 00401011 , en los comentarios podemos ver lo que contiene :
Title = "Coder : Bocvk" , en caso de que no aparezca lo que contiene dicha dirección en los comentarios de la ventana de desamblado , los podemos ver en la pila :

   

- Quinta linea , presionamos F8

00402011  |.  68 00104000   push    00401000                         ; |Text = "Hola Diosdelared"

  *Guardamos el valor que contiene la dirección 00401000 , en los comentarios o en la sub ventana de Información Adicional podemos ver lo que contiene :
Text = "Hola Diosdelared", en caso de que no aparezca lo que contiene dicha dirección donde se ha indicado , los podemos ver en la pila :

   

- Sexta linea , presionamos F8

00402016  |.  6A 00         push    0                                ; |hOwner = NULL

  *Guardamos el valor 0 en la pila , ¿para que? : es un parametro de la Api MessageBox , que indica el tipo de botones a utilizar en este caso ninguno debido al valor 0, vayamos a la pila aver si enrealidad guardo este 0 :

   

- Setima linea , y nos encontramos con un call esto quiere decir que se va a dirigir a una subrutina a realizar operaciones entre otras cosas , la mayoria de Apis realizan sus operaciones en un call , asi que en este caso no entraremos al call ya que lo unico que hará es sacar los valores (parametros) que le indicamos , lo pasamos el call presionando F8 para que se ejecute dicha Api y nos aparece una ventana y hacemos click en el botón Aceptar para continuar en el OllyDbg:

   

- Octava linea , presionamos F8

0040201E  |.  B9 00000000   mov     ecx, 0

  *Movemos el valor 0 al registro ecx ,es decir ecx=0 , veamos en los registros :

   

- Novena linea , ahora aplicamos la teoria sobre los tamaños de los registros , presionamos F8 aver que pasa :

00402023  |.  66:B9 0200    mov     cx, 2

  *Movemos el valor de 2 a cx , es decir cx=2 ( ecx = 00000002 ), comprobemoslo :

   

- Decima linea , presionamos F8 :

00402027  |.  B5 05         mov     ch, 5                            ; /ExitCode

  *Movemos el valor de 5 a ch , es decir ch=5 ( ecx = 00000502 ) :

   

- Las dos ultimas lineas que quedan las ejecutamos con F8 y hara que el programa termine ...


2.- Modificando el programa interactivamente para poder continuar debugeando

- El codigo del programa a utilizar es el sgte :

include 'C:\FASM\INCLUDE\WIN32AX.inc'

.data
   cuerpo db 'Parchame : IsDebuggerPresent', 0
   cuerpo1 db 'Me quitaste mi proteccion xD',10,13,10,13
	   db '          Eres buen cracker =)',0
   titulo db 'Sin Parchar', 0
   titulo1 db 'Parchado', 0

.code
start:

call [IsDebuggerPresent]  ; Esta api , devuelve el valor 1 a EAX si el programa esta siendo debugeado
cmp eax,1		  ; Compara a EAX con 1
je salir		  ; Si los valores comparados anteriormente son iguales salta a la subrutina salir
       
   push 0	       ; Mete a la pila 0 (NULL)
   push titulo1        ; Mete a la pila el contenido de la variable "titulo"
   push cuerpo1        ; Mete a la pila el contenido de la variable "cuerpo"
   push 0	       ; Mete a la pila 0 (NULL)
   call [MessageBoxA]  ; Esta api extrae cuatro elementos de la pila , segun a esto imprime en una ventanita un msg
		       ; con un titulo y con un cierto tipo de botones .
   
   push 0
   call [ExitProcess] ; Esta api , finaliza el programa

salir:		       ; sub rutina

   push 0
   push titulo
   push cuerpo
   push 0
   call [MessageBoxA]

   push 0
   call [ExitProcess]

.end start

- Ejecutamos el OllyDbg y abrimos el programa previamente compilado :



- Si tratamos de ejecutar el programa con el Olly (presionando la tecla F9) , se daran cuenta que tenemos que parchar el programa para poder continuar debugeando , ¿porque? , lo que pasa es que se esta utilizando la Api IsDebuggerPresent la cual determina si el programa esta siendo debugeado o no y segun eso hace algo (depende del programador) , en este caso hice que apareciera esto :



- Bueno reiniciamos el OllyDbg , presionando CTRL+F2 o sino nos vamos a la pestaña Debug / Restart



- Ahora vamos a ejecutar linea por linea para saber como podemos arreglar este problema que tenemos .

- Primera linea , presionamos F8 (para los curiosos , para entrar al call presionan F7 y analizan el codigo) :

00402000 >/$  FF15 66>call    dword ptr [<&KERNEL32.IsDebugger>; [IsDebuggerPresent

  *Llama a la Api IsDebuggerPresent , cuanto ejecutamos dicha linea el valor del registro EAX cambia a 1 , esto quiere decir que 
   el programa esta siendo debugeado :

 

- Analizamos la segunda y tercera linea antes de ejecutarlas, ya que estas trabajan juntas ( cmp y salto ) :

* Compara a eax con 1

00402006  |.  83F8 01 cmp     eax, 1

*Si los valores comparados son iguales se ejecuta el salto (JE)

00402009  |.  74 1C   je      short 00402027

- El salto  en la tercera linea en caso de que se ejecutara nos lleva a la direccion 00402027 , asi que veamos que hay en dicha direccion , presionamos CTRL+G y ponemos la direccion que encontramos :

 

- Luego presionamos el boton OK y caemos aquí :

 

- Analizamos unas cuantas lineas que siguen desde donde hemos caido :

  *Imprime una ventanita con el msg : Parchame

00402027  |> \6A 00   push    0                                ; /Style = MB_OK|MB_APPLMODAL
00402029  |.  68 5C10>push    0040105C                         ; |Title = "Sin Parchar"
0040202E  |.  68 0010>push    00401000                         ; |Text = "Parchame : IsDebuggerPresent"
00402033  |.  6A 00   push    0                                ; |hOwner = NULL
00402035  |.  FF15 98>call    dword ptr [<&USER32.MessageBoxA>>; \MessageBoxA

  *Cierra el programa

0040203B  |.  6A 00   push    0                                ; /ExitCode = 0
0040203D  \.  FF15 62>call    dword ptr [<&KERNEL32.ExitProces>; \ExitProcess

- Eso quiere decir que la decision final la tiene el salto JE (entonces lo podriamos parchar para que no se ejecute dicho salto pero esto lo veremos mas adelante) o tambien podemos cambiar el CMP (la comparacion la cambiamos por cualquier valor diferente de 1 pero luego lo veremos); pero si nos ponemos a recordar sobre que hacian las primeras lineas , nos damos cuenta que cuando ejecutamos la primera linea el valor de EAX cambiaba a 1 y luego era comparado por 1 segun a eso salta o no , entonces desde donde comienzan las cosas es desde la Api IsDebuggerPresent (primera linea), como no hemos ejecutado ningun linea tan solo la primera , entonces nos vamos a los registros y modificamos el valor de EAX haciendo doble click en dicho registro y reemplazando 1 por 0.







Luego podemos seguir analizando el resto del codigo con F8 , pero bueno en este programa ahora ya no ahi codigo por analizar simplemente presionamos F9 para ejecutar el programa con el debugger y nos aparece la ventana que hemos roto la proteccion



3.- Invirtiendo Saltos

include 'C:\FASM\INCLUDE\WIN32AX.inc'

.data
   cuerpo db 'Parcha el salto JE', 0
   cuerpo1 db 'Práctica 3 del Taller',10,13,10,13
           db '       Owned',0
   titulo db 'Sin Parchar', 0
   titulo1 db 'Parchado', 0

.code
start:

mov eax,2                 ; Movemos el valor de 2 a EAX => EAX=2
cmp eax,5                 ; Compara a EAX con 5
je mensaje                ; Si los valores comparados anteriormente son iguales salta a la subrutina mensaje

   push 0
   push titulo
   push cuerpo
   push 0
   call [MessageBoxA]

   push 0
   call [ExitProcess]  ; Esta api , finaliza el programa

mensaje:                 ; sub rutina

   push 0              ; Mete a la pila 0 (NULL)
   push titulo1        ; Mete a la pila el contenido de la variable "titulo"
   push cuerpo1        ; Mete a la pila el contenido de la variable "cuerpo"
   push 0              ; Mete a la pila 0 (NULL)
   call [MessageBoxA]  ; Esta api extrae cuatro elementos de la pila , segun a esto imprime en una ventanita un msg
                       ; con un titulo y con un cierto tipo de botones .
   
   push 0
   call [ExitProcess]
.end start

- Ejecutamos el OllyDbg y abrimos el programa previamente compilado :


- Vamos a analizar llinea por linea de nuestro programa (por que es pequeño o sino la cosa sería diferente ya veremos luego) :

- Presionamos F8 en las dos primeras lineas

00402000 >/$  B8 02000000   mov     eax, 2
00402005  |.  83F8 05       cmp     eax, 5

   

   

00402008  |.  74 1C         je      short 00402026

  *Primera linea : Hace a EAX=2
  *Segunda linea : Compara EAX con 5
  *Tercer linea , no la ejecutamos con F8 , solo la analizaremos ya que trabaja con la comparación que se hizo anteriormente ,
    este salto se ejecuta si los valores que tiene la comparacion son iguales , osea 2=5 nunca , entonces no se ejecutara este
    salto a menos que cambiamos el valor de EAX a 5 pero eso ya lo vimos asi que ahora vamos aprender algo nuevo , invertir los 
    saltos que quiere decir que modificaremos este salto por su inversa (en este caso un salto que se ejecute cuando los valores 
    no son iguales) , la inversa del salto JE es JNE .

- Bueno ahora nos ponemos en la tercera linea y le hacemos doble click para modificarla (cambiamos JE por JNE) :

   

   

    *Observación : El Olly cambia el salto JNE por JNZ que es lo mismo (revisen las teorias) , al igual pasa con JE y JZ

- Una vez modificado presionamos en el boton Assemble , ya esta modificado , comprobamos en el Olly aver si ejecuta el salto :

   

- Ahora vamos a guardar los cambios que hicimos para no volver hacer todo el trabajo de nuevo xD :

    *Hacemos anticlick en la linea que modificamos :

   

    *Click en Selection (Guardamos solo la modificacion que hemos hecho en la linea que tenemos seleccionada) , si hicieramos
      Click en All Modifications (Guardamos todas las modificaciones hechas al programa) , en este caso no es necesario :

    *Ahora nos aparece una ventana , hacemos anticlick y luego click en Save File , luego se nos abrira una ventana para
      guardar el programa con las modificaciones hechas :

   

   

    *Ahora ejecutamos el programa guardado (PARCHADO.EXE) , aver si en realidad lo parchamos xD

   

Observación :
- En vez de cambiar el salto JE por JNE , se podria cambiar por el salto JMP (el mas usado) que no pones condicione para saltar (ejecutarse) pero siempre es bueno cambiar un salto por su inversa , ya es cosa de ética xD



Escrito 100% por Mi
Salu2
Bocvk