Manual de Cracking para Novatos


 

NOTA DEL AUTOR

Hiz, soy Antikton y voy a intentar explicaros cómo se crackea; pero antes voy a dejar unos puntos claros:

  1. Si no tienes ni puta idea de lo que es crackear, mejor que dejes de leer este fichero y lo borres.
  2. Si sabes lo que es pero no tienes ni puta idea de programación (lo que se dice nada de nada) y crees que vas a poder estar crackeando programas comerciales en unos minutos, gilipollas!!! tú te crees que esto es coser y cantar???
  3. Perdonad si me equivoco al escribir o sólo pongo los signos al final (como los ingleses) pero es la economización del lenguaje.
  4. Si tienes unos poquillos conocimientos de programación y te gustaría crackear, te felicito porque has dado con el manual adecuado (digo yo) pero necesitarás dos o tres meses para empezar a crackear tú solito :)
  5. Este documento con la información que en él aparece, es sólo para uso de aprendizaje. El autor no se hace responsable de lo que la gente haga con ello. ;)
  6. Bueno, comenzemos a crackear

El curso va a estar enfocado en crackear programas para Windows 95/98 de esos que piden un password o que piden un nombre y un código (o sea, la mayoría :)

GUIA DE ASSEMBLER ENFOCADA AL CRACKING

Antes de nada, si no sabes lo que es ASM o lo que es un Looping o un FOR...NEXT, etc. te recomiendo que dejes de leer este manual ya que no tienes el nivel suficente para leerlo

REGISTROS (Registers)
Los registros son básicamente sitios por defecto en dónde se guardan datos. Los únicos por los que os tenéis que preocupar son: (E)AX, (E)BX, (E)CX y (E)DX. (La (E) sólo es para cuando se debuguea en código de 32 bit) También están los registros de parejas:
DS:SI ; pueden ser usados como fuente (origen) para operaciones de cadenas.
ES:DI ; usado como el destino para las operaciones de cadenas.

Entender los registros no es muy importante para crackear, pero lo que si tienes que saber es que son variables para el almacenamiento de datos :)

FLAGS
Los Flags son esencialmente como los registros excepto que los Flags sólo pueden contener valores específicos, como verdadero o falso (1 o 0), etc.
Los flags son calculados por comandos como CMP y son usados para comprobar el resultado de una llamada (CALL), por ejemplo:

CMP AX,BX ; compara AX con BX, si son iguales el Flag 0 cambia

JZ 00124531 ; si el flag 0 ha cambiado, salta a 00124531, si no continua

LA PILA (STACK) Y LOS PUSH AND POP (PONER Y QUITAR)
Antes de cualquier función de llamada (a partir de ahora CALL), un programa debe PONER (a partir de ahora diremos PUSH) unos parámetros que la función espera encontrar en la pila (técnicamente llamado Stack). Los datos se colocan de una manera especial. Piensa lo siguiente. Piensalo como si fuera una "pila" (stack) de platos, el primer plato que ponemos (al hacer un montón) se queda abajo y será el último en coger; y el último en poner (el de arriba), es el primero en coger.
Recuerda esto cuando estés sobre una CALL, los parámetros son cogidos en orden inverso. Te pongo un ejemplo para que te quede claro:

La función API de Windows GetDlgItemTextA requiere los siguientes parámetros:

  1. Manejo de la ventana de diálogo (Handle Dialog Box)
  2. Identificador del Control
  3. Dirección del Buffer del Texto
  4. Tamaño máximo de la cadena

Por tanto, esto puede ser pasado de este modo (de forma inversa, para luego cogerlo ordenadamente):

MOV EDI,[ESP+00000220] ; Coge en EDI el Handle Dialog Box
PUSH 00000100          ; PUSH (4) - Tamaño máximo de la cadena
PUSH 00406130          ; PUSH (3) - Dirección buffer de texto
PUSH 00000405          ; PUSH (2) - Identificador de Control
PUSH EDI               ; PUSH (1) - Handle Dialog Box
CALL GetWindowText     ; Llama (CALL) a la función GetWin...

Fácil, no? esto será importante a la hora de crackear aplicaciones que piden números de serie. Si conocemos la dirección del buffer para nuestro número de serie (es decir, dónde se encuentra almacenado el número que le hemos metido en la memoria), en este caso 00406130, sólo hay que hacer un breakpoint y normalmente terminaremos alrededor del procedimiento que genera el número de serie bueno.

POP 
Se usa para borrar el primer "plato" de la pila. Normalmente, después de hacer uns PUSH y haber una llamada, se colocan varios POP para borrar los datos innecesarios.

AND
Uso: AND dest, orig
Fin: Lleva a cabo una operación de tipo AND de las dos entradas, reemplazando el dest con el resultado.
Ejemplo: AND BX, 03h
No hay mucho que decir. Esto es importante para cuando necesitemos hacer un generador de números de serie para un programa :)

CALL (Llamada)
Uso: CALL address (dirección)
Fin: Ejecuta una función en la dirección "address"
Ejemplo: CALL 10284312
Una vez que la función termine, el código continúa en la línea siguiente de CALL (es como un GOSUB)

CMP
Uso: CMP dest, orig
Fin: Resta el orig del dest y actualiza en Flag
Ejemplo: CMP AX, 03h
Esta instrucción es muy importante para nosotros (los crackers) :) Está colocado muchas veces en el programa para verificar algo; por ejemplo que el número de serie que introducimos es el mismo que el que tiene el programa o genera ;)

INT (Interrupción)
Uso: INT interrupción
Fin: Llama a una función general (normalmente de la BIOS)
Ejemplo: INT 10h
Esta función es muy común en programas de DOS, pero no lo veremos mucho ya que me voy a dedicar (como he dicho antes) al Cracking en W95. Normalmente los parámetros son guardados en los registros por defecto (AX, BX, CX, ...)

JMP (Salto)
Uso: JMP dirección
Fin: Equivale a un GOTO. Salta a la sección de código de la dirección.
Ejemplo: JMP 00402011
JMP es un salto incondicional. Tan simple como un GOTO :)
Hay muchas variantes. Las más importantes son:
JZ o JE » Salta si el Flag 0 es cambiado
JNZ o JNE » Salta si el Falg 0 no es modificado

Normalmente están después de una instrucción de CMP, por ejemplo:

CMP numseriebueno, numseriemalo ; compara los núm. de serie
JNE fueradeaki ; si no son iguales, salta a otra parte del código

MOV (Mover)
Uso: MOV dest, orig
Fin: Copia el byte o el valor de la palabra desde el orig al dest
Ejemplo: MOV AX, DX
Lo verás muy a menudo cuando estés stepping (ejecutando línea por línea). Una cosa, a lo mejor me confundo y lo llamo stepting o steping, pero me refiero a esto, para cuando lo veáis).
MOV es como si fuera LET dest=orig
Hay algunas variantes como MOVSX, pero es raro.

RET (Retorno)
Uso: RET
Fin: Para volver de una función (Como si fuera RETURN)
Ejemplo: RET
Normalmente lo verás el final de una función, y sólo dice que vuelva a la dirección de la llamada (CALL) para continuar.

LEA (Como LET)
Uso: LEA dest, orig
Fin: Hace que el dest sea igual que el orig
Ejemplo: LEA EAX, [EBP-34]
Hace que EAX=EBP-34, fácil, no?

CONFIGURACION Y USO DE SOFTICE

Para comenzar a usar SoftIce para Windows 95 (gracias a NuMega), tenemos que ver si se cargan las librerías; para ello comprueba que el fichero WINICE.DAT en el apartado "Examples of export symbols that can be included for Chicago" no tengan delante el punto y coma, y verifica que las rutas de los ficheros a tu windows sean correctas. Si quieres tener menos memoria ocupada, quita los puntos y comas sólo a KERNEL32.DLL, USER32.DLL y GDI32.DLL que son los más importantes. Lógicamente tendrás que reiniciar el ordenador y volver a cargar SoftIce.

USO Y TECLAS DE SOFTICE
La pantalla de SoftIce es parecida a la siguiente (por lo menos en la ver. 2, porque la v3.2 cambia):

---------------------
| Ventana Registros | R - editar ; Aquí están los valores de los registros
|-------------------| 
| Ventana Datos     | D - ver E - editar ; Es dónde vemos la memoria
|-------------------| hex. y dec. y la dirección
| Ventana C¢digo    | U - ver A - Inserta ; Vemos el código en ASM
|-------------------| conforme se va ejecutando
| Ventana Comandos  | ; Aquí pondremos los comandos
---------------------

Otras teclas importantes son:

F5 / Ctrl+D -> Ejecuta
F10 -> Paso a Paso
F11 -> Función en Función
t -> traza una llamada

COMANDOS PARA EL CRACKING
Bueno, para explicar los comandos que más usaremos (que son muy pocos) voy a deciros el proceso genérico para el cracking de un programa. Bien, resulta que cuando a un programa le damos a la opción del menu REGISTER (aparece en muchos programas), sale una ventana que nos pide, por ejemplo, el nombre y el código. Pues nuestra tarea será interceptar el lugar en donde el programa compara nuestro código con el generado por él mismo para comprobar si es correcto o erróneo.
Fácil, eh? pues sí, los programas sencillos sí.
Primera pregunta, ¿cómo interceptar cuándo el programa recoge dichos datos?
Para ello hay que colocar un BreakPoint.
Un BP sirve para detener el programa y ver el código ASM en la función que nosotros le digamos. Por ejemplo que se detenga cuando recoja el código que introducimos. Las dos funciones más usadas para recoger las cadenas que introducimos son: GetDlgItemTextA y GetWindowTextA

Bueno, para ver cómo se usa y cómo se crackea (que es el tema que nos ocupa) pasemos al siguiente apartado.

NUESTRO PRIMER CRACKING. | (from ED!SON tutorial)
Antes de arrancar W95 o W98, tenemos que arrancar en DOS y ejecutar WINICE el cual se encargara de arrancar el Windows.

PROTECCION POR NUMERO
Target: Task Lock 3.00
Protection Type: Una simple protección de introduzca un número
Tool Needed: SoftIce 2.0 o sup.

  1. Ejecutar el programa TaskLock ;)
  2. Buscar la opción REGISTER. Introducir un número al azar y pulsar OK.
  3. Ohh! no es correcto :( (todavía) ;)
  4. Volver a poner un número y antes de pulsar Ok hay que colocar un BreakPoint (BP) Para ello pasaremos a SoftIce pulsando Ctrl+D y pondremos: BPX GetWindowTextA pulsamos ENTER y saldremos de SoftIce pulsando de nuevo Ctrl+D y ahora sí, pulsamos OK y... :(
  5. ein! otra vez ese estúpido mensaje de número incorrecto !!! Bueno, está claro que la función que usa para coger el número no es GetWindowTextA
    Bueno, ponemos otra vez el numerito y pulsamos de nuevo Ctrl+D Ahora borraremos el BrakPoint de antes que no vale para nada con el comando
    BC 0 (es 0 porque es el primero. Si tuviéramos varios BP, podríamos listarlos con BL y ver el número que es, en nuestro caso, con BL pondría 00) BPX USER32!GetWindowsTextA C=01 Bueno, ahora probaremos con BPX GetDlgItemTextA damos a enter y salimos (Ctrl+D) pulsamos OK y... :)
  6. Bingo!!! ahora estamos dentro de SoftIce :)   Estamos al comienzo de la función GetDlgItemTextA, pero para ver desde dónde es llamada pulsamos F11:
    Ahora debes desconectar el BP, pon bd 0 (si necesitas activarlo después, que no lo necesitaremos es be 0)
  7. La primera línea que aparece es:
    CALL [USER32!GetDlgItemTextA]
    Por qué hay antes?? Para ello pulsaremos unas cuantas veces CTRL+flechaarriba hasta ver lo siguiente:

    RET ; final de la func. anterior
    PUSH EBP ; comienzo de la funcion
    MOV EBP, ESP ; ...
    SUB ESP, 0000009C ; ...
    PUSH ESI ; ...
    > LEA EAX, [EBP-34] ; EAX=EBP-34
    PUSH EDI ; ...
    MOVE ESI, ECX ; ...
    PUSH 32 ; Guarda: la long. m x.
    > PUSH EAX ; Guarda: dirección del buffer :)
    PUSH 000003F4 ; Guarda: ...
    PUSH DWORD PTR [ESI+1C] ; Guarda: ...
    CALL [USER32!GetDlgItemTextA] ; coge el texto y comienza la func.

    Los PUSH, como dije, son para guardar valores para su uso posterior :) Las líneas importantes les he puesto un > delante; observémoslas. Vemos que el buffer de texto se guarda en EAX y cu nto vale EAX? EAX=EBP-34
    Bien, ahora ponemos d ebp-34 para ver la memoria en ese valor. Jeje, vemos en la ventana de Datos el número que hemos puesto :)
  8. Ahora, lo que hay que hacer es buscar dónde se hace la comparación entre nuestro código y el código bueno. Para ello hay que ir paso por paso de instrucciones pulsando F10 hasta encontrar algo relacionado con EBP-34 (que es en dónde está nuestro número). Tras unos pocos F10 nos encontramos lo siguiente:

    > LEA EAX, [EBP+FFFFFF64] ; EAX=EBP-9C
    LEA ECX, [EBP-34] ; ECX=EBP-34 (Ahora nuestro número
    PUSH EAX ; Guarda EAX. está en ECX)
    PUSH ECX ; Guarda ECX
    > CALL 00403DD0 ; Llama a una función
    ADD ESP, 08 ; ...
    TEST EAX, EAX ; Chequea el resultado de la funcion
    JNZ 00402BC0 ; Salta si no es 0

    Yo veo claramente cómo se recoge una variable en EAX, otra en ECX (nuestro número), se llama a una función ( que suponemos que es la que genera el número bueno) y después es comparada.

    Bien, entonces ¿que se esconde bajo EAX (EBP+FFFFFF64) ? pues sí, el número correcto. Ponemos D EAX y aparecer  el numerito en la ventana de Datos ;) Ahora lo que tenemos que hacer es ponerle dicho numerito en el
    programa cuando lo pida y yá esta :)


URL's

Tengo que decir que dentro de poco haré un hueco en internet para ayudaros a los problemillas que tengáis. La URL ser  http://members.tripod.com/~antikton/cracking/

Bueno, ahora os pongo las URLs de los programas que he usado:



CIERRE DE EDICION

Bueno, en este primer número hemos aprendido asembler (enfocado al cracking), el manejo de SoftIce y a crackear un programa basado en protección por número. No está mal para ser el pimer número, pero ya iremos progresando poco a poco y a ver si alguien me echa una mano (antikton@rocketmail.com) En próximos números iremos aprendiendo a manejar editores hexadecimales, a tracear para crear generadores de números de serie y crackear programas más complejos (poco a poco).

Si no habéis entendido algo (porque no me haya expresado bien) o necesitáis cualquier cosa, o tenéis una sugerencia o lo que sea (dar ánimos para que saquemos el siguiente número, si no, no lo saco), házmelo saber mandándome un e-mail.

byez ;)

Web : http://antikton.home.ml.org

e-mail: antikton@rocketmail.com