Hardcoded serial

Material

En este primer tutorial emplearemos un crackme con una protección de Hardcoded hecho por RedH@wk para Crackslatinos (concretamente para un curso de Ricardo Narvaja)

Antes de nada veamos unas nociones básicas sobre hardcoded

  • Este sistema de protección utiliza un código que esta dentro del programa

  • A veces os podréis encontrar ese código en las string de referencia, pero no las probéis hasta que no estéis seguros por que algunos programadores ponen códigos falsos que al ingresarlos se ejecuta un código maligno para evitar mentes curiosas

Bueno ya podemos empezar este tutorial, en este tutorial crackearemos el programa de las 2 formas que existen para un hardcoded: Romper la Puerta y Hacer una copia de las llaves.

Antes de nada vamos a ver con que lenguaje esta programado y que compilador se ha usado en este programa, así que abrimos el PEiD y le damos al boton de “…” para cargar el programa y vemos lo siguiente:

0

Vemos que esta programado en ASM y con el compilador MASM32/TASM32, hecho esto ya podemos empezar

Rompiendo la Puerta

Primero abriremos el programa y veremos como se comporta, veremos que hay 2 botones y una caja de texto, metemos un serial cualquiera en la caja de texto y aceptamos y vemos que nos sale lo siguiente:

1

Bueno vemos que nos sale un mensaje de error, ya tenemos algo de lo que tirar para parchear el programa (si no saliese nada tendríamos que usar las API’s), vamos al OLLYDBG (File > Open) y abrimos el programa y en el lugar donde sale el código en ASM hacemos clic con el 2º botón Search for > all referenced text String

2

Y vemos como nos aparece el mensaje de error:

3

Así que pinchamos 2 veces sobre él y nos llevará a:

4

Ahí vemos el mensaje de error que en realidad empieza en la dirección de memoria: 00401074 y vemos que justo debajo esta el mensaje de felicitación, y vemos que en ambos mensajes pone al final algo de MessageBox que es una API que lo que hace es crear el cuadro del mensaje. Y también vemos que encima de los mensaje de error tenemos un salto y una comparación (podemos probar ya a cambiar ese salto pero preferimos estar seguros de que ese es el salto condicional que nos interesa, así que sigamos), para estar seguros de que es ese el CMP que nos interesa vamos a poner un BreakPoint, para ello pulsamos sobre la línea del CMP y pulsamos F2 o bien hacemos doble clic pero sobre la traducción en hexadecimal, en este caso 3BDA, y vemos como se nos pone en rojo la dirección de memoria:

5

Ahora pulsamos F9 o vamos a Debug > Run o bien le damos al botón que tiene forma de Play debajo de los menús ( el 4º empezando por la izquierda), de esta manera se ejecutará el programa (si no lo veis minimizad todo, que este programa no aparece en la barra de tareas) volvemos a poner un serial cualquiera y apretamos Verificar y nos llevará al OLLY (Si no se pone la pantalla del OLLY automáticamente restauradlo desde la barra de tareas) esto quiere decir que ese CMP se lleva acabo al apretar el botón verificar por lo tanto es el responsable de comparar el serial correcto con el falso, así que procederemos a parchearlo, nos ponemos encima de la línea del salto condicional y vemos esto:

6

Vemos que nos dice que si EBX y ECX son iguales el programa saltará (Vemos como se nos muestra una línea que indica la dirección de memoria 00401087 que es donde saltará si se produce ese salto) al mensaje de felicitación, ahora si, vamos a parchearlo, procederemos a cambiar el JE por JNE o JNZ (que ya hemos visto en el manual anterior que es lo mismo), es decir, saltará al mensaje de felicitación si EBX y EDX NO son iguales, así que para parchearlo hay 2 posibilidades, o bien hacemos doble clic sobre el texto (lo que sale en amarillo) y allí hacemos los cambios, o seleccionamos la línea hacemos clic con el 2º botón y elegimos Assemble y ahí hacemos los cambios (Vemos como el 74 se ha cambiado por 75), ahora quitamos el BreakPoint anterior (para ello podemos hacer doble clic de nuevo sobre las instrucciones en hexadecimal o bien hacemos clic sobre el botón B que esta debajo de los menús [el 7º empezando por la derecha] de esta manera se nos mostraran todos los BreakPoint que hemos puesto, elegimos el que queramos quitar hacemos clic con el 2º botón sobre el y elegimos Remove) y ejecutamos de nuevo el programa (F9 o las demas opciones que expliqué antes)

7

Y ya hemos roto la puerta.

Aclaración: En la parte teórica (que fue el manual 1) expliqué que para parchear había 2 formas mas (la de los NOP’s y la de hacer operaciones que dejen el programa como estaba, como por ejemplo las instrucciones INC y DEC), en este caso no podremos hacerlo ¿Por qué? Un programa ejecuta las instrucciones se realizan desde arriba hacia abajo

6

Si en este caso empleásemos ese camino veremos como realiza la comparación, pasaría por los nop’s (o por las instrucciones que dejan el programa como estaba antes) sin hacer nada y llegaría la zona de mensaje de error por lo que no conseguiríamos nuestro objetivo (si el mensaje de felicitación estuviese encima del de error si nos serviría) :latigo:

Ahora para guardar los cambios de forma permanente lo podemos hacer desde un editor hexadecimal o desde el mismo OLLY. En este caso lo haremos desde el OLLY.

Pinchamos sobre cualquier parte de donde se muestra el código ASM, hacemos clic con el 2º botón y elegimos Copy to executable > all modifications (aunque solo hayamos realizado un cambio) en el siguiente cuadro elegimos Copy all y nos aparecerá otra ventana dentro del OLLY en esa ventana hacemos clic con el 2º botón y elegimos Save File y elegimos otro nombre diferente al original para no sobrescribir y guardamos.

Haciendo una copia de llaves

Cargamos de nuevo el Crackme, hacemos lo propio para ver las String referencias (en el lugar donde sale el codigo en ASM hacemos clic con el 2º boton Search for > all referenced text String) y demos doble clic de nuevo sobre el mensaje de error, apareceremos sobre el mensaje de error y si miramos mas arriba vemos otra API que se llama GetDlgTextItemA (esta API sirve para obtener el texto), así que colocaremos un BreakPoint (ya sabéis como hacerlo) por que sospechamos que esa API es la responsable de coger el texto que nosotros metemos para compararlo con el serial correcto.

8

El BreakPoint se puede poner al inicio de la API (como me gusta hacer a mi) o sobre el CALL (que al fin y al cabo ahí es donde empieza realmente la API), una vez puesto el BreakPoint ejecutamos el programa con el F9 (si no veis el programa minimizad todo) metemos un texto cualquiera y le damos a verificar, ahora el programa parará y nos iremos al OLLY y tracearemos un poco (para ello tenemos 2 botones, el F7 si queremos entrar dentro de los CALL’s cuando los haya, o el F8 si no queremos entrar en los CALL’s) y nos vamos fijando en todas las ventanas del OLLY, traceamos un poco saltándonos la call de la API GetDlgItemTextA (con F8) y vemos que debajo hay 2 MOV’s el 1º mueve un valor a EBX y el segundo mueve otro valor a EDX y debajo esta la comparación, así que suponemos que los valores que se mueven a EDX y EBX son los de nuestro serial cualquiera y el del serial correcto.

Vayamos a examinar el primer MOV pulsaremos F7 o F8(para saltarnos el call de la API) y nos colocamos sobre el mov, debajo de donde se muestra el código en ASM y encima del DUMP encontramos esta ventanita (puede ser que la tengáis que hacer mas grande por que a veces al iniciarse el OLLY aparece muy pequeña, casi escondida)

9

Vemos que se mueve el valor 506C6452 a EAX (Esta claro que eso es uno de las 2 serial, ¿pero como sabemos cual es? Hay 2 maneras, una corta y otra larga, pero como es mejor saberlo todo voy a explicar las 2 formas)

Forma larga

Los procesadores Intel usan little endian, así que pone los números hexadecimales al revés, es decir, el numero 506C6452 realmente es: 52646C50, veamos cual es el valor ASCII de este número Hexadecimal, abrimos la calculadora de Windows, vamos al menú Ver > Científica (De esta manera vemos que aparecen mas opciones) a la izquierda del todo, debajo de donde metemos los numero marcad Hex (y vemos como las letras desde la A hasta la F se activan) ya que el número que vamos a introducir es hexadecimal, e introducimos las 2 primeras cifras (en hexadecimal 2 cifras siempre son una letra/símbolo/número en ASCII) que en este caso es 52.

10

Aclaración: Si, si, esta es la calculadora de Windows, lo que pasa que en el campo tengo un Windows modificado y esta calculadora es una versión Plus

A continuación marcamos la opción de Dec (de decimal) y el número se nos transformará a decimal, que es 82, ahora vamos al bloc de notas y mientras apretamos ALT pulsamos las tecla 5 y 2 (el 5 y el 2 no a la vez, mientras tengáis pulsado ALT pulsáis primero 5 y luego 2, si no os va con la numeración de arriba de las letras probad con los números de la derecha del teclado :latigo: ), y vemos que se escribe una “R” si convertimos el siguiente número a hexadecimal que es 64, nos saldrá que en decimal es 100, hacemos lo del ALT y nos escribe “d” (en el código ASCII hay que distinguir entre minúsculas y mayúsculas) y si seguimos así, la siguiente letra será “l” y la siguiente será “P”. Vamos que ese serial es RdlP y como supondréis es el que introduje yo, es decir, el incorrecto, así que sabemos que en EBX se guarda nuestro serial y lógicamente en EDX se guardará el serial correcto.

Nota: El proceso de conversión de hexadecimal a decimal no se tiene que hacer a la fuerza con la calculadora de Windows, puedes usar cualquier otra que permita conversiones entre sistemas numéricos o incluso realizar la conversión a mano, y tampoco hace falta hacer lo del ALT, hay tablas del código ASCII por la red (lo que pasa que en el campo no tengo Internet y no me se la tabla de memoria)

Forma corta

En el lugar donde se nos mostraba los valores que se iban a mover, nos situamos sobre DS:[0040300C]=506C6452 (cuando un numero aparece entre [] significa que es una posición de la memoria y en este caso significa que la posición de memoria [0040300C tiene el valor 506C6452) pulsa sobre él con el 2º botón y elegimos Follow in Dump:

11

Y apareceremos en:

12

Ahí vemos como es efectivamente RdlP.

Ahora pinchamos sobre el 1º mov (si es que no lo estábamos ya) y pulsamos F7 para tracear y llegamos al 2º mov (que como ye hemos deducido es donde se moverá el serial correcto) y miramos nuevamente abajo y vemos lo siguiente:

13

Se moverá la posición de memoria 0040204B que contiene el valor de 38393839 al registro EDX. Y sigamos el camino que sigamos (la conversión manual o 2º botón en DS:[0040204B]=38393839 y luego Follow in Dump) daremos con la misma solución.

P.D Lo cierto es que me ha quedado bastante largo este tutorial, pienso que es por que al ser el primero he explicado con muchos detalles como hacer cosas como poner los BreakPoint’s como ejecutar el programa, como modificar el código ASM, etc.… espero que el próximo sea mas corto.

18 de agosto de 2007

Introducción al Cracking

EDICIÓN 2015

Después de pensármelo bastante voy a publicar una serie de manuales y tutoriales que hice para la comunidad de crackers en la que estuve involucrado (CracksLatinos). Los textos que publicaré intentaran sufrir la menor cantidad de modificaciones posibles.

Estos textos eran para aydar a los más novatos del grupo a coger una base y que pudiesen compartir sus conocimientos conforme vayan haciendo investigaciones.

Estos textos están datados en 3 épocas distintas, la mayoría son del 2007, antes de empezar la universidad y justo después de acabar el instituto, así que pido perdón por los errores que puedan haber en la edición original, tanto en las nociones teorícas como en la programación de las herramientas, ya que aprendí a programar (es una forma de decirlo, solo sabía escribir código, programar aprendí en la Universidad, con POO, métrica, calidad del código, patrones etc) en 1º-2º de la ESO, pero al no disponer de internet no pude mejorar hasta bastante tiempo después .

Otros textos datan del año 2009 y los últimos textos (que los los menos explicativos) datan de alrededor del 2011-2012.

Es posible que haya incoherencias en los textos puesto que no voy a publicar todos, publicaré solamente aquellos de un nivel introductorio.

Antes de cada tutorial añadiré las herramientas necesarias para poder seguir el mismo, no serán versiones actualizadas de las herramientas sino que serán las herramientas que yo usé en su día.

EDICIÓN 2007

Esta primera parte va a estar dirigida a aclarar las cosas antes de empezar, trataremos definiciones, herramientas a utilizar y mi motivación personal.

¿Qué es Cracking?

El Cracking se basa en la ingeniería inversa, que consiste en estudiar un programa para saltarse sus mediadas de protección. Mucha gente, sin saberlo, tiene pensamiento de cracker (como decía Joe Cracker), seguramente muchos de vosotros, al igual que a mi, de pequeños desmontaban los aparatos electrónicos para saber que hay dentro o como funciona el susodicho aparato.

Herramientas a utilizar y niveles de dificultad

Dentro del cracking hay diversos niveles de dificultad, desde programas que se crackean en 1 minuto hasta programas que puedes tardar meses, las protecciones que vamos a estudiar son 2, los hardcoded y los nombres/Serial.

Hardcoded: Estas medidas de seguridad ya apenas se usan por ser las mas fáciles de saltar, consiste en un código que el programa lleva dentro de sí

Nombre/Serial: Es la protección que usan la mayoría de programas, por lo general suelen ser mas difíciles que los hardcoded, aunque siempre hay excepciones. Estos sistemas no se basan en un código fijo, sino que al introducir el nombre, el programa hace una serie de operaciones con él y luego lo compara con el código que has metido.

Yo dentro de los Nombre/Serial opino que hay 3 modalidades (por decirlo de alguna manera), algunos dicen que con el fin de conseguir lo que tú quieres da igual lo que hagas (el fin justifica los medios) pero yo lo que siempre intento hacer es crackearlos de la manera mas limpia y utilizando la inteligencia, que traducido al lenguaje cracking significa hacer un keygen o en su defecto sacar el serial. (aunque no siempre se puede debido a la complejidad de algunos algoritmos), a continuación paso a explicar brevemente esas tres “modalidades” que nombro arriba.

Romper la puerta: esto quiere decir parchear el programa, también se conoce como la “Método del 74/75” (mas adelante entendereis por qué), esta es la mas fácil, solo hay que encontrar los saltos condicionales que hacen aparecer el mensaje de error de que has introducido el serial equivocado y parchearlos (Esta técnica también se puede usar en los hardcoded). Ejemplo(El código esta simplificado para que lo entendáis mejor):

CMP EAX,EBX

JNE 00401000

Esto es la estructura mas fácil que os podéis encontrar, en la primera línea lo que hace es comparar EAX y EBX (EAX y EBX son como variables, realmente se llaman registros, donde se almacenan datos del programa, hay mas “variables” como ECX, EBP, etc. eso ya se verá) y si no son iguales el programa salta a la dirección de memoria 00401000 que es el lugar donde se encuentra el mensaje de error, y justo debajo de ese salto supondremos que esta el mensaje de felicitación por haber introducido el serial correcto, así que lo que se tendría que hacer es cambiar el JNE(Saltar si no son iguales) por JE(Saltar si son iguales) de esta manera introduciendo cualquier nombre y cualquier serial registraremos el programa (a no se que acertemos el serial, ya que si acertamos el serial EAX y ECX serán iguales por lo tanto en el programa parcheado que hemos cambiado JNE por JE no nos dejaría registrarnos), y diréis ¿Qué tiene que ver esto con el 74/75? Esto se explica con la equivalencia Hexadecimal del lenguaje ASM. JE=74 y JNZ=75.

1

2

Nota: Esta estructura admite 2 soluciones más mediante el parcheo.

  1. (Os recuerdo que el pc lee el programa secuencialmente de arriba hacia abajo, dicho esto explico esta forma de parcheo) Podemos cambiar el JNZ por NOP (no hacer nada) y como la zona de felicitación esta justo debajo del JNE (por que nosotros lo suponemos en este ejemplo) entonces hará la comparación, pasará por los nops sin hacer nada y finalmente llegará a la zona de de felicitación.

3

Aclaracion: Si os habéis dado cuenta en las imágenes de los saltos condicionales JE y JNZ a la izquierda aparecían 4 números agrupados en grupos de dos, en el de JNZ a aparecía 75 16 esto son 2 Bytes, cada par de números en hexadecimal es 1 Byte (ojo solo en el sistema hexadecimal) pues para no alterar el programa ha cambiado esos 2 bytes en 1 línea por 2 byte en 2 líneas, de ahí que el programa haya colocado 2 Nop’s en vez de 1.

Nota: encima de los saltos condicionales y de los nop’s esta la comparación.

  1. Muchos dicen que poner NOP’s en un programa es ensuciarlo así que lo que prefieren hacer es poner instrucciones que dejen el programa como estaba, como por ejemplo:

4

Aclaración: INC = Incrementar en 1, DEC = Decrementar en 1, ya supongo que sabréis en que consiste esto, primero incremento EAX en 1 y luego lo Decremento en 1, por lo que se queda tal cual estaba al principio.

Después de esta “extensa” explicación prosigo con las demás “modalidades”

Copia de llaves: Esta táctica consiste en, mediante un “debugeo en vivo”, encontrar el serial para nuestro nombre.

Llave Maestra: Finalmente llegamos a la “modalidad” de mayor dificultad, esta quizás es la que mas se ajuste a la definición de Cracking, ya que hacer un keygen significa que comprendes el algoritmo de generación de las claves y por lo tanto has cumplido las bases de la ingeniería inversa.

Pasamos a las herramientas a utilizar

  • La herramienta esencial que utilizaremos será OLLYDBG que es un Depurador, es decir, un programa usado por los programadores para testear sus propios programas para buscar agujeros de seguridad, pero nosotros lo usaremos para hacer ingeniería inversa.

  • La segunda herramienta será un editor Hexadecimal, el que queráis como Hiew o UltraEdit.

  • Usaremos otras herramientas que ya se irán mencionando y se proporcionará el link cuando sea necesario.

Configuración del OLLYDBG

Vamos a Options>Debugging Options y a la pestaña CPU, allí seleccionamos las siguientes casillas: Show direction of jumps, Show jump path y Show grayed path if jump is not taken luego sobre donde se nos muestra el código en ASM hacemos clic con el 2º botón y elegimos Apparence > Highlighting > jumps’n’jumps.

Interface del OLLYDBG

5

Código: Aquí es donde se muestra el código ASM del fichero que hayamos cargado, a su vez esta formado por varias parte, a la izquierda del todo se encuentran las posiciones de memoria, lo siguiente por la derecha son los Bytes (grupos de 2 en el sistema hexadecimal) lo siguiente por la derecha es la tradución a ASM de esos bytes y lo último son comentarios.

DUMP: El Dump es como si abriesemos el archivo con un editor hexadecimal, aquí se nos muestra las posiciones de memoria, los bytes y la traducción en ASCII de esos bytes.

Pila o Stack: Aquí es donde se irán guardando datos que el programa luego necesitará, la Pila o el Stack es como un mazo de cartas, cuando dejas una carta, la dejas arriba del todo y cuando sacas una la sacas de arriba del todo, las ordenes para quitar y poner valores son: PUSH, PUSHAD, POP, POPAD, PUSHA, POPA, etc… La Pila o Stack se divide en 3: de izquierda a derecha son: Posiciones de memoria, Valor colocado y Valor ASCII.

Registros y Banderas: Los registros son lugares en donde se guardan valores, estos registros son: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI, EIP (este ultimo indica la posición de memoria que se ejecutara a continuación), Ahora veamos como se dividen los registros, imaginemos que EAX = 00112233, los últimos 4 valores se llaman AX (solo en EAX, en EBX será BX, en ECX será CX, etc…), de esta manera AX=2233 y por ultimo AX se divide en AH=22 y AL=44. Las banderas son como apoyos del programa, el programa hace una comparación y dependiendo del resultado se activa una u otra bandera, veamos las banderas:

  • C: Es el Carry flag se activa cuando se sobrepasa el maximo valor permitido, es decir, mayor a FFFFFFFF.

  • P: Bandera de Paridad se activa cuando el numero que se somete a operaciones convertido a binario tiene un número PAR de unos.

  • Z: Bandera Zero, se activa cuando ejecutamos una instrucción y el resultado es 0.

  • S: Es la Bandera de Signo y se activa cuando el numero es negativo.

  • O: Es la bandera de desbordamiento de datos (overflow).

Hay más flags, pero de momento con estos está bien.

Instrucciones básicas en ASM

INC: incrementa en 1, por ejemplo, INC EAX, esto es igual a EAX + 1.

DEC: Decrementa en 1, por ejemplo, DEC EAX, esto es igual a EAX - 1.

ADD: ADD EAX,1 es igual a INC EAX, de esta manera ADD EAX,6 es igual a EAX+6.

SUB: SUB EAX,1 es igual a DEC EAX, de esta manera SUB EAX,4 es igual a EAX-4.

NOP: No hace nada.

JE: Salto condicional que salta si los 2 registros cormprobados son iguales.

JNE: Salto condicional que salta si los 2 registros comparados no son iguales.

CMP: Compara 2 registros, ejemplo CMP EAX;EBX.

TEST: Es otro tipo de comprobación, pero se utiliza para saber si lo comprobado es 0.

PUSH: Pone el valor que hay a continuación del Push en la pila/snack, ejemplo Push 30, de esta manera colocará el valor 30 en la Pila/Stack.

POP: Quita el ultimo valor de la Pila/Sntck y lo coloca en el registro que haya a continuación, ejemplo POP EAX, esto hará que se retire el ultimo valor de la Pila/Stack y se coloque en EAX.

MOV: Mueve un valor de un lugar a otro, ejemplo MOV EAX,EBX Mueve el valor de EBX a EAX (y no al reves).

MUL: MUL es una multiplicación normal y corriente que no considera el signo, solo utiliza un operando, por que el otro operando siempre va a ser EAX, y el resultado se va a guardar EDX:EAX, esto quiere decir que EAX guarda las cifras que pueda y las que no quepan se guardan en EDX. Ejemplo: Mul EBX, multiplicará EAX * EBX y se guardará en EDX:EAX.

IMUL: IMUL es igual que la anterior con la excepción de que ahora considera el signo del número.

DIV: Como MUL pero para la división.

IDIV: Como IMUL pero para la división.

NEG: Se encarga de cambiar el signo del número.

CALL y RET: Estas instrucciones son MUY IMPORATANTES cuando hay un call lo que hace el programa es llevarte a una subrutina, es decir, el call te lleva a una zona del programa en donde se ejecutara un determinado código y acabará la ejecución cuando encuentre una instrucción RET. Cuando llega al RET el programa seguirá ejecutando la linea que hay por debajo del CALL, Puede ser que dentro de un CALL haya otro CALL a esto se le llama CALLs ANIDADOS.

Operaciones lógicas

Las operaciones lógicas se suelen hacer siempre a nivel de bits, es decir, en el sistema binario, así que veamos unos ejemplos:

OR: Se activa cuando al menos, uno de los bits es 1.

1 or 1 = 1

1 or 0 = 1

0 or 1 = 1

0 or 0 = 0

Veamos ahora una operación más compleja con OR:

10010011110010011101111000111101

00001101001110101001111001100001

10011111111110111101111001111101

AND: El resultado es 1 SOLO cuando los 2 bits son 1

1 and 1 = 1

1 and 0 = 0

0 and 1 = 0

0 and 0 = 0

Veamos ahora la operación compleja con AND:

10010011110010011101111000111101

00001101001110101001111001100001

00000001000010001001111000100001

XOR: El resultado es 1 SOLO cuando uno de los dos bits es 1 (si los 2 bits son 1 el resultado no será 1)

1 xor 1 = 0

1 xor 0 = 1

0 xor 1 = 1

0 xor 0 = 0

Operación compleja con XOR:

10010011110010011101111000111101

00001101001110101001111001100001

10011110111100110100000001011100

NOT: Esta función lo que hace es si un bit es 1 transformarlo en 0 y si es 0 ponerlo a 1:

not 1 = 0

not 0 = 1

operación compleja con NOT:

1010100110 = 0101011001

Saltos Condicionales

Antes de los saltos condicionales tiene que haber una comparación para saber si el salto se tomará o no.

CMP: Esta instrucción ya la vimos, lo que haces es comparar 2 valores, esta instrucción en realidad es una instrucción SUB que no se guarda en los registros, si los 2 valores son iguales se activará el Flag Zero (ya que el resultado es 0) y dependiendo de si es mayor o menor se activara el Flag de signo.

TEST: Esta instrucción ya la vimos, pero muy por encima, esta función en realidad es un AND que tampoco se guarda en los registros, se suele usar para comparar el mismo registro, ejemplo: TEST EBX,EBX ¿Por qué? Supongamos que EBX=1001101, la comparación entonces será

1001101

1001101

1001101

Vemos que el resultado es el mismo, ¿pero y si EAX=0000000?

0000000

0000000

0000000

Seguimos viendo que el resultado es el mismo, pero al contrario que en el ejemplo anterior (que toma un valor, pero ese valor nos da igual) aquí nos dice que vale 0, de esta manera hemos comprobado que EAX=0. Resumiendo, comparar un registro consigo mismo sirve para saber si ese registro es 0 (Esto se utiliza bastante en los algoritmos de generación de las claves)

Ahora si, vamos con los saltos condicionales

  • JE,JZ: Salta si es igual.

  • JNE,JNZ: Salta si no es igual.

  • JS: Salta si el signo es negativo.

  • JNS: Salta si el signo es positivo.

  • JMP: Salta siempre.

  • JP,JPE: Salta si hay un numero par de 1s.

  • JNP,JOP: Salta si hay un numero impar de 1s.

  • JO: Salta si se ha excedido la capacidad.

  • JNO: Salta si no se ha excedido la capacidad.

  • JB,JNAE: Salta si esta por abajo.

  • JNB,JAE: Salta si esta por encima.

  • JBE,JNA: Salta si esta por abajo o igual.

  • JNBE,JA: Salta si esta por encima o igual.

  • JL,JNGE: Salta si es menor que.

  • JNL,JGE: Salta si es mayor que.

  • JLE,JNG: Salta si es menor o igual que.

  • JNLE,JG: Salta si es mayor o igual que.

Todos los saltos condicionales se componen por la instrucción del salto seguido de la posición de memoria a la que saltará

BreakPoint

Un breakpoint es la ruputra en la ejecución de un programa, por lo general el programa se queda parado en el punto donde hayamos colocado el breakpoint hasta que demos la orden de continuar. Hay varios tipos de BreakPoint.

BreakPoint común, se suele escribir BreakPoint o BPX para abreviar

BP memory on acces, se utiliza cuando queremos que el OLLY pare al leer algo de la memoria

BP memory on write se utiliza cuando queremos que el OLLY pare al escribir algo en memoria

Hardware BreakPoint, se suelen escribir BPH y solo se pueden colocar 4 BreakPoint a la vez

Condicional BreakPoint se usan para que el OLLY pare cuando se den unas determinadas condiciones

Aún quedan algunos tipos más de BreakPoint pero ya se verán

Un BreakPoint común se pone seleccionado la línea a la que queremos ponérselo y luego a F2 o bien haciendo doble clic sobre se nos muestra las instrucciones en Hexadecimal, a la derecha de la posición de memoria y los BreakPoint se quitan haciendo clic sobre el botón B:

10

Eligiendo el breakpoint que quieras quitar y luego a Remove

WIN32 API

Las API’s son funciones ya creadas que lo programadores pueden utilizar en sus programas, dicho de otra manera, son funciones que vienen con el Sistema operativo y facilitan la tarea al programador, las API’s generalmente vienen en los archivos DLL del sistema, las mas importantes son Kernel32.dll y User32.dll (el 32 es por que estas API’s son para los sistemas de 32 bits y de ahí que se llamen Win32 API’s). Por ejemplo si queremos mostrar un mensaje, tenemos 2 posibilidades, o bien hacer nosotros mismo el mensaje o bien llamar a la API MessageBoxA.

Las API’s que mas se usan para coger texto son: GetDlgItemTextA y GetWindowTextA en los tutoriales ya iremos viendo mas.

Mi motivación personal

Puede sonar raro pero mi motivación personal para meterme en este mundo fue el videojuego Pokemon (concretamente los primeros pokemons, edición roja, azúl y amarilla). En estas ediciones había bastantes fallos y bastantes rumores como por ejemplo las islas fallo (error real), el valle de toguei (rumor) o el camión del SS ANNE (rumor) y es que a veces, el juego ayudaba a crear ese ambiente de rumores.

76

89

En la primera foto vemos lo que supuestamente es el valle de toguepi. En la segunda vemos esas extrañas hierbas que siempre me intrigaron, pensando que si estaban ahí es porque se podía pasar a ese lado. La tercera es como el profesor OAK pasa por esa hierba. La cuarta es missigno, al no tener ningún pokemon al que elegir y haber entrado en una pelea mi pokemon es missigno. Este último quizás es el mayor rumor, missigno, que más tarde cuando ya era un poco mayor desemsamble el código ensamblador de Pokemon Azúl.

En el juego pokemon cada pokemon tenia asignado un numero en Hexadecimal, estos números hexadecimales no podían ir desde 0 a F por que eso solo son 16 pokemon, así que lo que hicieron es ir desde 00 a FF (es decir desde 0 hasta 255), pero como todos los que hemos jugado a pokemon sabemos,en las primeras ediciones solo había 151 pokemon (Aunque hay rumores que dicen que iban a haber más pokemons) ¿Entonces que? Sobraban 105 huecos en donde debía ir algún pokemon ¿Sabéis que pokemon ocupa esos espacios? Es Missigno.

Agradecimientos

Bueno aprovecho para agradecer aquí a las personas para no tener que agradecer en cada tutorial

  • Ricardo Narvaja: Por sus magníficos conocimientos sobre cracking, su afán por enseñar y también quiero nombrar a toda la escuela de Cracker que siguen a Ricardo ;)

  • RedH@wk: por sus Crackme’s

  • Joe Cracker: Por sus crackme’s que son muy originales y aún me quedan por resolver unos cuantos.

  • Makkako: Por sus tutoriales

  • Caos Reptante: Por su magnifico manual de ASM

15 de Agosto de 2007