INTRODUCCION AL CRACKING CON OLLYDBG DESDE CERO La idea de esta INTRODUCCION AL CRACKING CON OLLYDBG DESDE CERO es la de dar una base para todos los que recién se inician en el arte del cracking con OLLYDBG, tratando de ser una introducción pero a su vez que proporcione una base fuerte para poder ingresar a la lectura y comprensión de tutoriales mas avanzados como los que se encuentran en el actual NUEVO CURSO de CRACKSLATINOS, el cual por supuesto sigue abierto para seguir agregando novedades, concursos y teorías como hasta ahora. La idea se genero a partir de que los newbies actuales que leen el llamado NUEVO CURSO de CRACKSLATINOS, se encuentran con que este se inicia en un nivel muy alto, y no pueden insertarse gradualmente en el mismo, por lo cual se sienten frustrados y muchas veces abandonan antes de empezar, la idea de esta INTRODUCCION es no repetir los grandes tutes que existen en ese curso que son ya mas de 500 y de un nivel espectacular, si no mas bien sentar la base para que el que termine esta introducción, le sea mas fácil leer cualquier tutorial, obviamente requerirá esfuerzo como todo en el cracking, pero la tarea nuestra es tratar de alivianar ese esfuerzo, sentando aquí las bases del cracking en OLLYDBG para que sea compresible y se pueda entender fácilmente.

PORQUE OLLYDBG? Aquí no entraremos a hacer grandes elucubraciones o reeditar viejas polémicas de SOFTICE vs OLLYDBG de cual es mejor ni nada de eso, creo que hasta los fanáticos de SOFTICE reconocen que es mas sencillo empezar con OLLYDBG, ya que muestra mayor información y es mas cómodo para aprender, la idea es ingresar al mundo del cracking, por la puerta del OLLYDBG, mas adelante cuando uno ya conoce, puede trasladar fácilmente a cualquier debugger lo aprendido pues cambian las formas de usar de los programas, pero no la esencia.

LO PRIMERO ES LO PRIMERO Exactamente lo primero es munirse de la herramienta que vamos a utilizar mayormente, para ello pueden hacer clic AQUI para bajarlo.

Como aquí estamos empezando desde cero pues, recién nos estamos haciendo del archivo, y ahora ya que es un archivo zipeado, lo unzipearemos con WINZIP preferentemente a una carpeta en nuestro disco rígido que podamos localizar fácilmente, una buena idea seria poner dicha carpeta en C:/ aunque funciona en cualquier lugar, yo la pondré en C:/.

Una vez descomprimido podemos entrar a la carpeta y ver

Allí esta el archivo ejecutable OLLYDBG.exe el cual ejecutaremos para arrancar el OLLYDBG y al cual para comodidad le haré un acceso directo en mi escritorio.

Bueno ya tenemos bajado y preparado para arrancar a nuestro OLLYDBG.exe, lo ejecutamos.

Nos aparece este cartel avisándonos que la DLL que esta en la carpeta de OLLYDBG es mas antigua que la de sistema, si apretamos SI, borrara la antigua de la carpeta del OLLY y usara la de sistema, yo a pesar de no ver grandes diferencias siempre prefiero elegir que use la propia antes que la de sistema, ya que fue concebido con esa dll, por lo tanto elijo NO.

Allí esta el OLLYDBG vacío, y como siempre el primer programa que abriremos mas que nada para mirar las diferentes partes del OLLYDBG y a vuelo de pájaro poder ubicarnos en sus diferente partes, es el famoso CRACKME DE CRUEHEAD que vendrá adjunto en este tutorial. Para abrir el archivo a debuggear en el OLLYDBG, vamos a FILE OPEN o hacemos clic en el icono

Se abrirá la ventana para que busquemos el archivo a debuggear en este caso es el crackme de CRUEHEAD.

Allí se abre el susodicho crackme y por ahora no importa que no entendamos lo que nos muestra ya mas adelante aprenderemos eso, la idea es ir mostrando las partes del OLLYDBG y ciertas configuraciones del mismo para que cuando en sucesivos tutes, diga, por ejemplo vayan al DUMP, sepan al menos donde esta, así que esto es mas que nada para ubicación, no es un tute profundo sobre OLLY.

Allí vemos la cuatro partes de la ventana principal del OLLYDBG

1)DESENSAMBLADO : También llamado listado, aquí el OLLY nos muestra el listado desensamblado del programa que vamos a debuggear, por DEFAULT el OLLY viene configurado para analizar el programa que vamos a debuggear al iniciar, esto se configura en OPTIONS-DEBUGGING OPTIONS.

O sea al estar marcada esa tilde en AUTO START ANALISIS OF MAIN MODULE el OLLYDBG analizara el programa y mostrara información adicional sobre el mismo.

Allí esta el listado inicial del crackme de CRUEHEAD analizado, y si arranca sin analizar debajo podemos ver la diferencia.

La ventana analizada muestra mas información, que aunque aun no sepamos bien que es, se ve mas completa, igual es bueno saber que de la ventana analizada se puede quitar el análisis, si uno no esta de acuerdo con el mismo o uno se da cuenta que el mismo esta equivocado lo cual puede ocurrir. Muchas veces el OLLYDBG muestra partes que no son listado correcto porque interpreto mal el código ejecutable como datos, en ese caso se ven unos DB como estos

En ese caso puedo quitar manualmente el análisis que el OLLYDBG ha realizado haciendo CLICK DERECHO en el listado y eligiendo ANALISIS-REMOVE ANALYSIS FROM MODULE

y en ese caso el listado se vera sin análisis pero correcto

Otra cosita que hace a la claridad para trabajar y que por lo menos a mi me gusta, aunque cada uno puede variar en estos temas es colorizar los JUMPS Y CALLS eso se hace haciendo clic derecho APPEARENCE – HIGHLIGHTING – JUMPS AND CALLS

El resultado es el siguiente

Allí vemos que en celeste quedan resaltados los CALLS y en amarillo los JUMPS, lo cual es mas claro para la vista. Bueno con eso nuestro listado queda mas fácil de interpretar, aunque aun no tengamos la mas remota idea de que significa, pero bueno hay que preparar antes las herramientas para poder ir de a poco aprendiendo 2)REGISTROS

La segunda ventana importante del OLLYDBG es la de los REGISTROS

Recordamos que la ventana de registros se encuentra en la parte superior derecha del OLLYDBG, allí muestra bastante mas información que los registros en si.

Tiene muchísima más información que aun no veremos, pero se puede cambiar el modo de visualización en tres formas. (VIEW FPU REGISTERS, VIEW 3D NOW REGISTERS y VIEW DEBUG REGISTERS) por default viene elegida la primera.

Por ahora no ahondaremos mucho en eso ya que nos preocuparemos más que nada en el tema REGISTROS y FLAGS, lo menciono para que sepan que hay varias vistas en el registro. 3)STACK O PILA:

Bueno allí vemos el llamado STACK O PILA aquí no hay mucha configuración posible solo la opción de mostrar la información relativa al registro ESP o al registro EBP.

Por default y lo que mas se utiliza es la vista relativa a ESP, pero para cambiar a la vista según EBP, haciendo clic derecho en el stack eligiendo GO TO EBP cambiamos y para volver GO TO ESP volvemos a la opción por default.

En sucesivas entregas explicaremos bien el funcionamiento del stack por ahora miramos como se puede variar su configuración solamente. 4) DUMP: La ventana del DUMP tiene muchas opciones de visualización, por DEFAULT nos muestra la visualización HEXADECIMAL de 8 columnas o bytes, la cual puede ser modificada haciendo CLICK DERECHO en el DUMP y eligiendo la opción deseada.

La opción por DEFAULT es la que generalmente mas se usa, aunque tenemos opciones para cambiar para mostrar desensamblado (DISASSEMBLE), Texto (TEXT) y diversos formatos (SHORT, LONG, FLOAT)

Y además la opción SPECIAL – PE HEADER que mas adelante en próximos capítulos veremos para que sirve esto que es muy útil.

Ya conocemos las partes que se ven en la ventana principal del OLLYDBG, aunque también hay más ventanas que no se ven directamente, se puede acceder a ellas, tanto por el menú, como por los botones de las vistas.

Veremos que es cada uno El botón L o VIEW-LOG nos muestra lo que el OLLYDBG escribe en la ventana del LOG lo cual puede ser configurado para mostrar diferentes tipos de información, por default en la ventana del LOG va guardando allí información sobre el arranque, y de la información escrita en el mismo por los diferentes BREAKPOINTS CONDICIONAL LOGS, lo cual se vera mas adelante, por ahora vemos allí ,la información del proceso que arranco, en este caso el crackme de cruehead, las dll que cargo, y ciertos tips sobre el análisis.

Una de las opciones mas importantes de esta ventana es la de loguear a una fila, para ciertos casos que deseemos guardar la información en una fila de texto, en ese caso CLICK DERECHO-LOG TO FILE.

El botón E o VIEW-EXECUTABLES nos muestra la listado de los ejecutables que utiliza el programa, exe, dlls, ocxs, etc

Aquí también el botón derecho tiene muchas opciones que por ahora no veremos ya que estamos mirando en forma general al OLLYDBG. El botón M o VIEW – MEMORY, nos muestra la memoria ocupada por nuestro programa, allí se ven las secciones del ejecutable, dlls que utiliza el proceso, así como el stack y diversas secciones allocadas por el sistema, y muchas veces al correr los programas, los mismos realizan nuevas allocaciones de memoria. En tiempo de ejecución.

Haciendo clic derecho podemos hacer SEARCH en la memoria para buscar en ella, strings, cadenas hexa, unicode etc, además nos da la posibilidad de colocar diferentes tipos de breakpoints en la secciones, como asi también la posibilidad de cambiar el acceso a las mismas con SET ACCESS ya profundizaremos en esto. El botón T o VIEW-THREADS nos da el listado de los THREADS del programa

Aunque no sabemos aun que es esto y la explicación llegara en los próximos capítulos es bueno ir familiarizándose en donde esta cada cosa, luego aprenderemos que es y como se usan mas adelante. El botón W o VIEW-WINDOWS nos muestra las ventanas del programa, como aun no corrió, no hay ventanas así que esta vacía.

El botón H o VIEW-HANDLES, nos muestra los handles por ahora localícenlo, ya explicaremos que es y para que sirve

El botón C o VIEW-CPU nos retorna a la ventana principal del programa. El botón / o VIEW-PATCHES nos muestra los parches si el programa ha sido modificado, por ahora esta vacío al estar sin cambios

El botón K o VIEW-CALL STACK nos muestra el call stack, que es el listado de los calls que entramos, hasta el punto donde el programa esta detenido.

El botón B o VIEW-BREAKPOINTS es el listado de los breakpoints comunes colocados en el programa, no muestra los hardware breakpoint ni los memory breakpoints aquí, solo los BP comunes.

El botón R o VIEW- REFERENCES nos muestra la ventana de referencias la cual nos da los resultados de cuando hacemos una búsqueda de referencias en el OLLY

El botón … o VIEW-RUN TRACE, nos muestra el listado si hemos hecho algún RUN TRACE en nuestra maquina, y tiene también la posibilidad de elegir LOG TO FILE, para guardar el resultado del traceo en un archivo txt

Bueno hasta aquí un paneo a vuelo de pájaro por los botones mas importantes, no detallamos explicación porque aun hay que aprender antes algo de ASM, y practicando el uso del OLLYDBG podremos ir aclarando mas profundamente para que sirve cada botón y cada OPCION, la idea es irse familiarizándose con donde están las cosas que veremos en las próximas entregas. COMO CONFIGURAR EL OLLYDBG COMO JIT ( JUST IN TIME DEBUGGER) Aclaro que no conviene tener configurado el OLLYDBG constantemente COMO JIT, solo conviene hacerlo en ocasiones especiales, ya que al estar como JIT capturara el error de cualquier programa de nuestra maquina y arrancara solo, lo cual puede resultar molesto si no estamos debuggeando o crackeando, por lo tanto les enseño como se configura para casos especiales, pero conviene dejarlo con la opción que trae por default que no esta como JIT. Para colocar el OLLYDBG como JIT vamos a OPTIONS-JUST IN TIME DEBUGGING

Y aprieto el botón MAKE OLLYDBG JUST IN TIME DEBUGGER y DONE

Para quitarlo, en el mismo lugar aprieto RESTORE JUST IN TIME DEBUGGER y DONE

Agregando PLUGINS al OLLYDBG El OLLYDBG trae la opción para agregar plugins que nos son necesarios para realizar cierta tarea, por ahora solo agregaremos el plugin COMMAND BAR para aprender como se agregan los mismos. Bajamos el plugin COMMAND BAR el cual puede ser bajado de AQUÍ y la mayoría de los plugins se hallan AQUI

Allí esta bajado en mi escritorio el plugin lo descomprimo con WINZIP entro a la carpeta que descomprimí a ver el contenido

Ahora antes que nada crearemos una carpeta para los PLUGINS en nuestra maquina, yo la creare en C:/ y la llamare PLUGINS nada mas. Voy a C y creo una NUEVA CARPETA

Allí esta, puede estar ubicada en cualquier lugar, pero a mi me gusta tener todo en C por eso la coloque allí, de cualquier forma debemos configurar el OLLYDBG para que reconozca esta carpeta como la que tendrá los plugins. Para ello en el OLLYDBG vamos a OPTIONS-APPEARANCE

Y en la ventana que se abre vamos a la pestaña DIRECTORIES

Vemos que en donde apunta al path de los plugins (PLUGIN PATH), en realidad nos esta apuntando a la carpeta donde esta el OLLYDBG.exe y podría dejarlo allí, pero a mi me gusta tener los plugins separados por lo tanto en donde dice PLUGIN PATH- BROWSE busco la carpeta que cree para mis plugins.

Allí elegí la carpeta PLUGINS que cree y sale este aviso

O sea que debo reiniciar el OLLY para que me reconozca la nueva carpeta de plugins, pero antes copio el contenido que baje del comand bar a mi carpeta de plugins.

Allí copie todo el contenido y lo pego en mi carpeta PLUGINS

Allí esta el contenido del plugin Command Bar en la carpeta PLUGINS, cada plugin que baje y agregue solo deberé copiar su contenido allí, muchas veces con copiar solo la dll es suficiente. Ahorra cierro el OLLYDBG si lo tenia aun abierto y lo reinicio. Vemos que en el menú PLUGINS me apareció el COMMAND BAR y las opciones del mismo.

A su vez en la parte inferior del OLLYDBG vemos la COMMAND BAR instalada

Es una barra para tipear comandos que nos facilitara mucho las cosas, mas adelante veremos su uso, por ahora lo importante es saber agregar plugins. Para quitar cualquier PLUGIN con solo quitar la dll correspondiente de nuestra carpeta PLUGINS y reiniciar el OLLYDBG, desaparecerá, les aconsejo que dejen siempre activa la COMMAND BAR. Arranco nuevamente el crackme de CRUEHEAD EN OLLYDBG Las teclas mas usadas en el OLLYDBG son: F7: Ejecuta una sola línea de código (si estas en un CALL entra al mismo a ejecutarlo por dentro) F8: Ejecuta una sola línea de código (si estas en un CALL no entra al mismo lo ejecuta completo sin entrar y sigue en la siguiente línea luego del CALL) Esos dos formas de tracear manualmente son verdaderamente diferentes y según cada caso usaremos F7 o F8 lo cual veremos más adelante. F2: Coloca un Breakpoint COMUN en la línea que marcas con el Mouse o esta grisada en el listado, para quitar el BP apretas nuevamente F2. Por ejemplo:

Quiero poner un BP en 40101A pues marco con el Mouse esa linea

Al hacer clic una sola vez se marca y queda grisada como vemos en la imagen, luego apreto F2.

Vemos que se pinta de rojo la zona de la dirección, eso significa que hay activo un BP o Breakpoint allí, si apreto F2 nuevamente se quita. F9: Para Correr el programa es similar a RUN, con esto el programa correrá, hasta que encuentre algún BREAKPOINT, o alguna EXCEPCION que lo detenga o FINALICE por algún motivo, al apretar RUN veremos en la esquina inferior del OLLYDBG la palabra RUNNING o sea que esta CORRIENDO.

Allí arranco el CRACKME DE CRUEHEAD, lo podemos ver correr

Si PAUSO la ejecución en OLLYDBG apretando F12 o DEBUG –PAUSE

Vemos que el OLLYDBG cambia a mostrar PAUSED o sea que esta PAUSADO, podemos volver a hacerlo correr con F9 o DEBUG-RUN. Para cerrar el programa que esta siendo DEBUGGEADO apreto DEBUG-CLOSE

Bueno esto a sido una mirada a vuelo de pájaro del OLLYDBG la cual profundizaremos mas adelante pues tiene muchísimas opciones y configuraciones las cuales seguiremos estudiando en las próximas entregas, es muy útil que bajen el programa lo configuren y miren donde están las cosas que muestra este tute, así como le agreguen el plugin para practicar, y hagan correr y pausar el CRACKME DE CRUEHEAD, prueben ponerle un Breakpoint y practiquen esas cosas para que en la segunda entrega estén mas familiarizados con el mismo y podamos avanzar lento pero seguro, y sin dudas. Un abrazo a todos los CRACKSLATINOS Hasta la parte 2 Ricardo Narvaja 07 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 2 Luego de haber visto a grandes trazos, la ubicación y las principales partes del OLLYDBG, debemos aprender el sistema de numeración utilizado y cual es el concepto de stack aunque sea para tener una idea, luego profundizaremos. SISTEMAS NUMERICOS Los tres sistemas numéricos que más se utilizan son el binario el decimal y el hexadecimal. El concepto básico que deben tener de ellos es el siguiente: BINARIO: Se representa los números con dos caracteres el 0 y 1 por eso se llama BINARIO. DECIMAL: Se representa todos los números con 10 caracteres (del 0 al 9) por eso se llama decimal. HEXADECIMAL: Se representa todos los números con caracteres del 0 al F ( del 0 al 9, mas A, B, C, D, E y F, o sea serian 16 caracteres en total). Normalmente a partir de aquí cuando diga un número y no diga a que sistema de numeración pertenece es porque es HEXADECIMAL que es el que utiliza OLLYDBG, si son decimales o binarios aclarare expresamente. Existen formulas matemáticas que no utilizaremos aquí, para convertir números de un sistema al otro, que no son muy simpáticas, pero llegado el momento, un cracker realmente usa la CALCULADORA DE WINDOWS, que es lo mas rápido y directo y no va a ponerse a hacer cuentas de potencias, sumas etc para convertir un numero de un sistema a otro. Abramos la CALCULADORA DE WINDOWS y preparémosla

Allí vemos en el menú VER como se puede cambiar a CIENTIFICA.

Allí vemos que por DEFAULT arranca en DECIMAL, y al lado tiene la opción de cambiar a HEXADECIMAL (HEX), OCTAL (OCT) y BINARIO (BIN). El Octal que representa la numeración con 8 caracteres no es muy usado en cracking pero la calculadora trae dicha opción incluida, si se llegara a necesitar. Pues para pasar un número de un sistema a otro es muy sencillo, pongo la calculadora en el sistema del número que quiero cambiar, por ejemplo si quiero cambiar 55 de DECIMAL a HEXA, pongo la calculadora en DECIMAL y tipeo 55.

Ahora cambio la calculadora a HEXA y automáticamente me lo convierte a ese sistema de numeración

Ahí esta 55 decimal equivale a 37. Resalte las letras A,B,C,D,E,F para ver que al pasar la calculadora a HEXA se nos habilita la posibilidad de teclear las mismas, que estaban deshabilitadas en modo DECIMAL. Creo que esta es la forma mas practica de manejarse con los sistemas de numeración, y poder pasar valores de uno a otro sin grandes complicaciones. NUMEROS NEGATIVOS en HEXADECIMAL

Esto es lo mas duro de entender por lejos tratemos de ir despacio. En el sistema de numeración hexadecimal, como podemos representar los números negativos, ya que no se puede poner el signo menos delante como hacemos en la tradicional numeración decimal ? Como hago para representar en formato hexadecimal -1 por ejemplo ? Pues aquí viene el problema y espero que se entienda. Solo tenemos la posibilidad de escribir en hexadecimal desde 00000000 hasta FFFFFFFF, como representaríamos los números negativos? Pues bien a un genio se le ocurrió que en vez de representar desde 00000000 hasta FFFFFFFF todos números positivos, usaríamos la mitad para los positivos y la otra mitad para los negativos. Los números positivos van entonces desde 00000000 hasta 7FFFFFFF y los negativos desde 80000000 hasta FFFFFFFF. POSITIVOS 000000000 es igual a 0 decimal 000000001 es igual a 1 decimal ……………………………….. ……………………………….. 7FFFFFFF es igual a 2147483647 decimal (que seria el máximo positivo) NEGATIVOS FFFFFFFF seria el -1 decimal FFFFFFFE seria el -2 decimal ……………………………… ……………………………… 80000000 seria -2147483648 decimal (que sería el máximo negativo) Podemos probar averiguar en la Command Bar el valor de 7FFFFFFF para ello usamos el signo de interrogación y a continuación el valor que deseamos pasar a decimal,

Vemos a la derecha que nos da el valor DECIMAL correspondiente, que es 2147483647 sin problemas. Ahora cuando deseamos averiguar el valor de 80000000 que es negativo, vemos que no nos lo muestra sigue dando el resultado para 7FFFFFFF (esto es un bug de la Command Bar), así que como podemos hallar su valor en OLLYDBG ?

Con este pequeño truquito. Vamos a los registros y marcamos EAX

Luego hacemos CLICK DERECHO-MODIFY

Nos aparece una ventana en la que podemos colocarle a EAX el valor que queremos, así que aprovechamos y usamos dicha ventana para hacer las conversiones, en el primer renglón tipeamos el valor HEXADECIMAL que queremos convertir y en el segundo renglón nos aparcera el resultado en DECIMAL. En este caso vemos que 80000000 corresponde al valor -214783648 decimal.

Si averiguo el valor de FFFFFFFF allí vale -1 decimal.

Por lo tanto en la ventana de modificar un registro podemos averiguar el valor de números negativos perfectamente, luego para salir podemos CANCELAR así no realizamos ningún cambio. CARACTERES ASCII Uno de los temas que debemos conocer también es la forma en que nuestro sistema escribe datos en la pantalla, para eso asigna a cada carácter un valor hexadecimal, de forma que puede interpretar los mismos como si fueran letras, números símbolos etc. De la teoría de ASM de Caos Reptante le copiamos la tablita jeje allí vemos a continuación el valor decimal, en la segunda columna el valor hexadecimal y en la tercera el carácter o sea por ejemplo si quiero escribir un espacio en OLLY, tengo que usar el 20 o 32 decimal, cualquier carácter que necesitemos, sea letra o numero podemos verlo en esta tablita.

Dec. Hex. Caract

Dec. Hex. Caract

Dec. Hex. Caract32 20 esp 64 40 @ 96 60 ` 33 21 ! 65 41 A 97 61 a 34 22 " 66 42 B 98 62 b 35 23 # 67 43 C 99 63 c 36 24 $ 68 44 D 100 64 d 37 25 % 69 45 E 101 65 e 38 26 & 70 46 F 102 66 f 39 27 ' 71 47 G 103 67 g 40 28 ( 72 48 H 104 68 h 41 29 ) 73 49 I 105 69 i 42 2A * 74 4A J 106 6A j 43 2B + 75 4B K 107 6B k 44 2C , 76 4C L 108 6C l 45 2D - 77 4D M 109 6D m 46 2E . 78 4E N 110 6E n 47 2F / 79 4F O 111 6F o 48 30 0 80 50 P 112 70 p 49 31 1 81 51 Q 113 71 q 50 32 2 82 52 R 114 72 r 51 33 3 83 53 S 115 73 s 52 34 4 84 54 T 116 74 t 53 35 5 85 55 U 117 75 u 54 36 6 86 56 V 118 76 v 55 37 7 87 57 W 119 77 w 56 38 8 88 58 X 120 78 x 57 39 9 89 59 Y 121 79 y 58 3A : 90 5A Z 122 7A z 59 3B ; 91 5B [ 123 7B { 60 3C < 92 5C \ 124 7C | 61 3D = 93 5D ] 125 7D } 62 3E > 94 5E ^ 126 7E ~ 63 3F ? 95 5F 127 7F �

Por lo demás la command bar cuando averiguamos el valor de un numero hexadecimal, nos proporciona también el carácter ASCII correspondiente si tuviera, veamos un ejemplo tipeemos en la command bar. ? 45

Vemos que 45 corresponde a la letra E mayúscula, si en la tabla anterior buscamos 45 en la columna del medio que corresponde a hexa vemos que es la letra E

69 45 E Por lo demas en la ventana del DUMP del OLLYDBG, tenemos una columna que muestra los caracteres ASCII, si miramos allí mismo en el crackme de CRUEHEAD la ventana del DUMP.

Vemos que al lado de la columna que representa los valores hexadecimales, esta la columna ASCII, donde podemos ver resaltadas algunas cadenas de texto compuestas por combinaciones apropiadas de caracteres ASCII. QUE ES EL STACK O PILA El stack o pila es una zona de la memoria, en la cual se van guardando datos que mas adelante deben ser recuperados. El nombre PILA es porque asemeja un mazo o pila de cartas o barajas que se encuentran en una mesa. En dicho mazo, si agregas una nueva carta solo podes hacerlo arriba de la pila y si quiero sacar una será la de más arriba de la pila de cartas. Esa es la característica principal del stack es como un mazo de cartas, la carta que agregas a la pila ira arriba, y será la primera que salga, cuando quites una. Ya veremos mas adelante en la explicación de las instrucciones la forma de modificar o agregar y quitar cartas en nuestro mazo, o sea nuestro querido STACK que como recordamos del tute anterior esta representado en la parte inferior derecha del OLLYDBG.

Bueno creo que ya tienen bastante para quemarse un rato mas la cabeza nos vemos en la parte 3 donde explicaremos que son los registros y los flags y para que sirven. Hasta la parte 3 Ricardo Narvaja 08 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 3 QUE SON LOS REGISTROS Y PARA QUE SIRVEN Ahora para que sirven y que son exactamente los registros? Bueno el procesador necesita asistentes en su tarea de ejecutar los programas. Los registros lo ayudan en ello, cuando veamos las instrucciones ASM veremos por ejemplo que no se pueden sumar el contenido de dos posiciones de memoria directamente, el procesador tiene que pasar una de ellas a un registro y luego sumarla con la otra posición de memoria, este es un ejemplo pero por supuesto ciertos registros tienen usos mas específicos veamos. ESP apunta al valor superior del stack, vemos en nuestro Crackme de Cruehead como ejemplo.

ESP vale 12FFc4 y si miramos el stack en OLLY en el mismo momento

Vemos que apunta al valor superior de nuestro stack o dicho en forma simpática, a la carta superior de nuestro mazo de cartas o barajas. EIP es otro registro muy importante apunta a la instrucción que esta siendo ejecutada en este momento veamos

Veamos en el listado del OLLYDBG, que al arrancar el crackme de Cruehead, este paro allí en 401000, que es la primera instrucción a ejecutar y por supuesto el valor de EIP cuando esta detenido allí será 401000.

Si apreto F7 ejecuta la primera instrucción y pasa a la siguiente.

EIP ahora vale 401002 y en al listado vemos que se ejecuto la primera instrucción y ahora estamos en 401002.

Los otros registros pueden tomar valores variables y sirven para asistir al procesador en las ejecuciones de las instrucciones, ECX es usado casi siempre como contador los demás son fluctuantes y asisten en la ejecución de programas como veremos en la explicación de cada instrucción. Recordamos donde el OLLYDBG nos mostraba el valor de los REGISTROS

Vemos a simple vista que son EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI y EIP Esos son los llamados REGISTROS de 32 bits OLLYDBG expresa el contenido en hexadecimal, vemos por ejemplo que EAX vale 00000000, y el máximo valor que podría tener es FFFFFFFF, si lo pasamos a BINARIO seria 11111111111111111111111111111111.

Vemos que son 32 bits cada uno con la posibilidad de ser 0 o 1 en numero binario, por eso se llama a estos, registros de 32 bits. En el lenguaje ASM se pueden operar con partes de los registros de 32 bits, en este caso EAX, puede ser subdividido. Veamos en el OLLY para más practicidad con un ejemplo:

Cambiare el valor de EAX a uno que yo quiera en este caso 12345678. Abro el OLLYDBG y allí mi programa será el CRACKME DE CRUEHEAD, aunque podría ser cualquiera. Una vez que arranca y para en el inicio hago clic derecho en EAX y elijo MODIFY

En la ventana que se abre escribo en la línea hexadecimal el valor 12345678

Queda así

Luego acepto con OK

Allí vemos como quedo cambiado al valor que yo deseaba, OLLYDBG tiene la particularidad de poner en ROJO los valores que se modifican. Como decíamos se pueden usar solo partes de EAX, en este caso AX seria el registro de 16 bits o sea las cuatro ultimas cifras de EAX, por lo tanto AX valdría en este caso 5678, corroborémoslo en OLLY en el commandbar tipeemos ? AX (ya que el signo de interrogación sirve también para hallar el valor de una expresión o de un registro)

Cuando apreto ENTER

Vemos que dice 5678 que es lo que suponíamos, AX son las ultimas cuatro cifras de EAX. También existen AL y AH, cuales son estos miremos en OLLYDBG ? AL

? AH

O sea si EAX=12345678 AX son las ultimas cuatro cifras

AH la 5 y 6 cifra y a su vez AL las ultimas dos cifras

También en la misma forma EBX se puede subdividir en BX, BH y BL y así sucesivamente existen subdivisiones para casi todos los otros registros. COMO CAMBIAR LOS VALORES DE LOS REGISTROS Ya vimos como se pueden cambiar valores de los registros en OLLYDBG, lo que hicimos en EAX se puede hacer en los otros registros de la misma forma, marcando el registro que deseamos cambiar de valor, luego haciendo CLICK DERECHO-MODIFY, salvo en el caso de EIP, dado que el mismo apunta a la instrucción que se esta ejecutando. Para cambiar EIP operamos de la siguiente forma: Ya que EIP siempre apunta a la instrucción que se va a ejecutar, elegimos una nueva instrucción en el listado.

Luego que esta marcada como en este ejemplo 40101A, hago en ella CLICK DERECHO-NEW ORIGIN HERE y cambiara EIP a 40101A, continuando el programa ejecutándose desde allí.

Como vemos queda EIP valiendo 40101A

QUE SON LOS FLAGS? Como vimos en el primer tutorial en OLLYDBG debajo de los registros se encuentran los flags o banderas.

Vemos que los flags son C P A Z S T D y O Vemos que solo pueden tener valores de cero o uno, que nos advierten que al ejecutar determinada instrucción, ha ocurrido algo, según el flag que sea.

Vayamos mirando que indica cada uno: EL FLAG O O FLAG OVERFLOW (DESBORDAMIENTO) Se activa cuando al hacer una operación, el resultado cambia de signo dando un valor incorrecto. Miremos en OLLYDBG este ejemplo, como siempre en el CRACKME DE CRUEHEAD de paso vamos practicando usar el OLLYDBG. Modifico como hicimos antes el valor de EAX a 7FFFFFFF que es el máximo positivo posible.

Ahora le sumare 1, lo cual excederá la posibilidad de EAX de mostrar un resultado positivo ya que 80000000 ya corresponde a un número negativo Para eso apreto la barra espaciadora que me permite escribir instrucciones.

Me sale esa ventana donde escribo ADD EAX,1.

Al apretar el botón ASSEMBLE vemos que cambia la instrucción que había antes en 401000 por la que yo escribí.

ADD EAX, 1 (ya lo veremos cuando enumeremos y expliquemos las instrucciones) seria sumarle a EAX el valor 1, y guardando el resultado en el mismo EAX. Veo que antes de ejecutar la línea con F7 el flag O esta en cero

Si ejecuto la instrucción con F7 para ver que es lo que ocurre, al realizar dicha operación veo que EAX al sumarle 1 se desborda y me muestra 80000000 lo cual traspasa la línea del cambio de signo. El FLAG O se activa poniéndose a 1 indicándome que la operación excedió el máximo resultado posible y esa es su función indicar cuando ocurra desborde al ejecutar una instrucción.

El FLAG A o AUXILIAR Tiene una función similar pero para cuando se realizan operaciones con otros formatos que por ahora no nos interesan. El FLAG P o PARIDAD Dicho flag se activa cuando ejecutamos una instrucción y su resultado es un valor, que pasado a numero binario tiene una cantidad par de unos, como por ejemplo 1010, o 1100 o 1111000 que tienen resultados cuya cantidad de unos total es par. Para probar esto ya que tenemos en el OLLYDBG escrito ADD EAX,1 y como ya ejecutamos esa línea para probar el flag anterior, pues la marcamos de nuevo y hacemos CLICK DERECHO-NEW ORIGIN HERE lo cual llevara EIP de nuevo a 401000 (volvemos atrás) y a que si apreto F7 se ejecute de nuevo la instrucción que escribimos ADD EAX,1.

Allí tenemos pues de nuevo justo antes de ejecutar la suma, con EAX valiendo 00000000 y el flag P valiendo 1, porque quedo así de la operación anterior, veamos que ocurre cuando le sumamos 1 a EAX nuevamente. Apretamos F7

Vemos que P nos marca 0 porque el resultado que muestra EAX=00000001 que en binario es 1 y tiene un solo 1 o sea un numero impar de unos por eso no se activa. Y vuelvo a hacer ahora click derecho en nuestro ADD EAX,1 y de nuevo CLICK DERECHO- NEW ORIGIN HERE para volver a sumar 1 y apreto F7.

Vemos que EAX que valía uno, al sumarle uno nuevamente, ahora vale 2 que es 10 en binario y sigue el resultado teniendo un solo uno por lo cual el flag P no se activo, si repito el procedimiento una vez mas, volviendo atrás y apretando F7 para sumarle 1 nuevamente a EAX.

Ahora EAX vale 3 que en BINARIO es 11 o sea el resultado tiene un numero par de unos por lo cual se activo el FLAG P o de paridad. Con eso vemos como funciona el susodicho FLAG, al ejecutar una operación solo mira el resultado y si el mismo en BINARIO tiene cantidad par de unos, se activa. El FLAG Z o FLAG CERO Uno de los más conocidos y usados en el cracking es el FLAG CERO el mismo se activa cuando ejecutamos una instrucción y el resultado es cero.

Podemos volver con CLICK DERECHO-NEW ORIGIN HERE a nuestro ADD EAX,1 de 401000, pero cambiemos ahora el valor de EAX a FFFFFFFF que es -1 decimal, de forma de que cuando apretemos F7 y ejecutemos ADD EAX,1 , sumemos -1 +1 el resultado sea cero a ver si se activa el FLAG Z. Vemos que al apretar F7, EAX quedo en cero y como el resultado es cero, se activo el FLAG Z poniéndose a uno.

Creo que queda claro que dicho flag, se activa cuando el resultado de una instrucción es cero ya veremos diversas formas de activarlo mas adelante. El FLAG S o FLAG DE SIGNO Se activa cuando el resultado de una operación es negativo, o sea si quiero probarlo cambio EAX a FFFFFFF8 que es -8 decimal

Y vuelvo con NEW ORIGIN HERE a mi ADD EAX,1 al apretar F7 y ejecutarlo, estoy sumando a -8 el valor 1, el resultado es FFFFFFF9 que es -7 decimal, el cual es negativo aun por lo cual debería activarse el flag de SIGNO probemos en OLLY.

Vemos que al apretar F7 y hacer la suma se activa el flag S de signo quedando a 1, queda claro como funciona, resultado negativo de una instrucción se activa el FLAG S. EL FLAG C o CARRY FLAG Se activa cuando se excede el máximo valor posible que se puede mostrar, si ponemos EAX a FFFFFFFF y le sumamos 1 como hicimos las veces anteriores veremos activarse el CARRY FLAG poniéndose a 1.

EL FLAG T , D e I No los explicaremos por ahora pues son bastante complejos, si lo haremos mas adelante, no tiene mayor interés por ahora, ya que vamos a explicar las instrucciones mas sencillas, así que los dejaremos para mas adelante. Bueno con esto tenemos una idea de que es cada registro y en que caso se activa cada FLAG, con esa información ya podremos en la tercera parte estudiar instrucción por instrucción ya que por ahora solo vimos la instrucción ADD para ayudarnos a comprender cuando se activaba cada FLAG. Se que esta parte y la que viene son las mas indigestas de todas así que léanla con paciencia, practiquen con el OLLY activar los FLAGS al ejecutar nuestro ADD EAX,1 y nos vemos en la parte 3 de esta INTRODUCCION. Es muy importante que queden bien grabados todos estos conceptos básicos, recomiendo leer practicar y releer hasta que no haya dudas. Hasta la parte 4 Ricardo Narvaja 10 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 4 INSTRUCCIONES Como ya venimos diciendo en las anteriores partes, la idea de esta introducción es ir aprendiendo a la vez que indigestándonos con la dura teoría, practicándola en OLLYDBG para ir conociendo el mismo, y de paso ir tomado confianza e ir mirando las posibilidades que tiene. Así como con los flags vimos en OLLYDBG que instrucciones los activaban, ahora veremos que ocurre al ejecutar cada instrucción en el mismo OLLYDBG lo cual da una idea mas cercana a la realidad y se hace mas llevadero. Veremos las instrucciones mas importantes si al mirar un listado uno encuentra alguna que no se definimos aquí, siempre se puede consultar un manual de ASM para ver que función cumple. NOP (NO OPERATION) Es la instrucción que al ejecutarla no hace nada ni provoca ningún cambio en registros, stack o memoria, por eso en ingles es NO OPERATION o sea que no hay operación alguna, y para que se usa dirán, muchas veces al cambiar una instrucción por otra, queda un hueco ya que la instrucción que escribimos es mas corta, y hay que rellenar con NOPS para que el procesador no encuentre basura y de error. También sirve para anular cualquier instrucción, si la reemplazo por nops el programa ejecutara los mismos en vez de la instrucción original y no hará nada lo que es comúnmente conocido como NOPEAR. Si abrimos nuevamente el crackme de cruehead.

Allí vemos el código original en el inicio, lo que haremos será nopear la primera instrucción PUSH 0, que es un comando de 2 bytes de extensión, para ello marcamos la línea con el mouse, y luego apretamos la barra espaciadora o bien hacemos CLICK DERECHO –ASSEMBLE.

Allí vemos que en el mismo menú nos confirma que es lo mismo apretar la barra espaciadora, esto nos abrirá una ventana para escribir la instrucción que queramos.

Escribo NOP y apreto ASSEMBLE.

Vemos que OLLY además de escribirnos un NOP, como es bastante inteligente, reconoce que el PUSH que había antes es un comando de DOS BYTES por eso para no desarmar el código siguiente nos agrega otro NOP para completar con el NOPEADO del PUSH. Si comparamos ambas imágenes vemos que donde estaba el PUSH 0 ahora hay dos NOPS que al ejecutarlos no hacen nada, esto lo podemos corroborar, apretando dos veces F7 hasta llegar al CALL siguiente, si miramos al apretar si cambia algún registro o algo en el stack, o un FLAG, vemos que todo esta igual , lo único que cambio fue EIP pues como sabemos apunta a la instrucción que se va a ejecutar y en este caso ahora es el CALL, pero no hay cambios en el resto de los registros ni stack, ni flags, ni memoria. Ahora veremos esos mismos 2 bytes que reemplazamos en el DUMP, para hallarlos allí, debemos buscarlos por la dirección de memoria, vemos que la misma es 401000 y 401001

Voy a la ventana del DUMP y hago CLICK DERECHO - GOTO EXPRESSION y pongo la dirección de memoria a partir de la cual quiero que muestre los bytes que contiene.

Por supuesto tipeo 401000

Los que vemos es

El rojo es original puesto POR OLLY ya que cuando cambiamos bytes, OLLY nos los recuerda mostrandolos en color rojo, allí vemos los dos 90 que pusimos y luego E8, FF y los siguientes bytes que ya pertenecen a la siguiente instrucción que es un CALL. Podemos en OLLY quitar lo que hemos escrito y volver al código original? Jeje, si podemos. En cualquiera de los dos, sea en el DUMP o en el listado, marcamos los dos bytes que escribí.

Ahora hago CLICK DERECHO-UNDO SELECTION

Y aquí no ha pasado nada, vuelve a aparecer el PUSH original

Lo mismo si miramos el DUMP, vemos que ahora están los bytes originales.

Bueno eso es todo en cuanto a la instrucción NOP sigamos adelante.

INSTRUCCIONES DE STACK Bueno habíamos dicho que el stack era como un mazo de cartas que se le agregaban o quitaban cartas por arriba del mismo. Por supuesto hay instrucciones para agregarle y quitarle cartas. PUSH La instrucción PUSH es la típica instrucción que agrega una carta o valor al stack Veámoslo en OLLYDBG la primera instrucción del programa original del crackme de cruehead era un PUSH.

En este caso es un PUSH 0, al ejecutarla lo que hará en este caso, será colocar el 0 en la posición superior del stack, sin sobrescribir lo que se encontraba antes lo cual quedara debajo. Veamos como esta el stack antes de ejecutar el PUSH, en mi maquina esta en esta dirección, en la de ustedes puede variar aunque el efecto será el mismo.

Este es el stack en mi maquina, la dirección 12FFc4 puede variar en su máquina, ya que el stack se puede acomodar en otra dirección en cada caso, y el contenido inicial a veces también puede variar o sea que ustedes pueden tener otro valor que 7c816d4f, pero no importa al ejecutar F7, el cero pasara a la parte superior del stack y el resto quedara abajo, veamos apreto F7.

Vemos que al ejecutar F7 fue realmente como si se agregara encima el cero que vemos resaltado allí, abajo en 12ffc4 sigue estando 7c816d4f, y no vario nada todos los mismos valores están en las mismas direcciones del stack.

La única diferencia que ahora el valor superior del stack es 12ffc0 y allí esta el cero que pusimos con el PUSH, fue realmente como agregar una carta a un mazo, se coloco arriba y dejo el resto que estaba antes sin cambiar nada debajo. Vemos también que el puntero ESP que muestra la dirección del valor superior del stack ahora marca 12FFc0.

Por supuesto el comando PUSH tiene variantes no solo puedo agregar números, si hago: PUSH EAX, agregare el valor de EAX en lugar del cero, podemos PUSHEAR cualquier registro, numero etc. Podemos PUSHEAR también el contenido de una dirección de memoria PUSH [401008] Veamos que se debe interpretar bien la diferencia con PUSH 401008 Sin corchetes Si hago PUSH 401008 lo que hará será colocar el número 401008 en el stack

Al ejecutarlo quedara así

En cambio si fuera PUSH [401008]

Los corchetes significan el contenido de la memoria en 401008 o sea que debemos ir en el DUMP a ver esa dirección y ver que hay alli. Con GOTO EXPRESSION 401008 vemos

Que los 4 bytes que hay allí son CA 20 40 00, ejecutemos con F7 el PUSH

Vemos que mando al stack el valor que leyó pero los bytes están al revés o sea nosotros vemos en el dump CA 20 40 00 y los puso al revés o sea 00 40 20 CA. Bueno esta es una propiedad del procesador, al leer o escribir contenidos de memoria siempre los bytes se toman al revés, y bueno quejas al inventor del procesador jeje. Pero la idea que debe quedar grabada es que sin corchetes el valor es simplemente un número, y con corchetes el valor refiere al contenido de una dirección de memoria. Ahora vemos que el OLLY cuando escribimos PUSH [401000] interpreto y escribió

PUSH DWORD PTR DS:[401008] Porque ocurrió eso

Es que si uno no aclara el OLLY interpreta que uno quiere leer los 4 bytes de esa posición de memoria, eso es DWORD leer los 4 bytes completos ya veremos las otras variantes en otras instrucciones. POP La instrucción POP es la inversa de PUSH lo que hace es quitar la primera carta o el primera valor del stack y lo coloca en la posición que indicamos a continuación del POP, por ejemplo, POP EAX tomara el primer valor del stack y lo quitara moviéndolo a EAX, y será como si quitamos una carta, ya que el valor que estaba debajo quedara como primero. Vemos arranquemos de nuevo el crackme de cruehead y en el inicio esta

Cambiemos dicha instrucción por POP EAX, marcamos la primera línea, apretamos la barra espaciadora y tipeamos.

Ahí esta el stack antes de ejecutar la instrucción esta

Y ESP apunta a 12FFc4 que es el valor superior del stack.

Y vemos que EAX esta a cero antes de ejecutar la línea en mi caso. Apreto F7

Vemos que en el stack desapareció nuestra primera carta, ahora el primer lugar lo ocupa la que entes estaba 2da y ESP apunta a 12ffc8.

Pero donde fue a parar nuestra carta se perdió?, noo como era un POP EAX fue a parar a EAX vemos en la imagen que EAX ahora vale 7c816d4f en mi caso y en el suyo tendrá el valor que antes estaba superior en el stack en vuestra maquina. Lo mismo si hubiera sido POP ECX el valor superior hubiera ido a ECX o al registro que eligiéramos. Bueno ya vimos las instrucciones que ponen o quitan una carta al stack ahora tenemos. PUSHAD PUSHAD guarda el contenido de los registros en la pila en un orden determinado. Así pues, pushad equivale a: push EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI. Veamos si es cierto lo que nos dice nuestro amigo CAOS REPTANTE en su tute de asm, jeje. Abrimos de nuevo el crackme de cruehead y ya sabemos que apretamos la barra para escribir y alli tipeamos PUSHAD.

Allí esta mi stack inicial y los registros antes de ejecutar el pushad son

Apreto F7 y veamos que paso en el stack

Vemos que hizo un PUSH a cada uno de los registros, el primero que agrego esta arriba de 12ffc4 que era el valor superior del stack antes de ejecutar, ahora hay un cero arriba que corresponde a PUSH EAX, luego hizo PUSH ECX y mando el 12ffb0 que estaba en ECX, luego envió consecutivamente los valores de los registros uno a uno al stack hasta el ultimo que fue PUSH EDI. POPAD

La inversa de PUSHAD es POPAD en este caso toma los valores del stack y los manda a los registros como si fuera un POP a cada uno. Así popad equivale a: pop EDI, ESI, EBP, ESP, EBX, EDX, ECX, EAX. Allí mismo donde quedo del ejemplo anterior escribamos un POPAD

Allí esta para ejecutarse el POPAD los registros están guardados en el stack y al apretar F7 vuelven del stack a sus lugares originales.

Allí esta el stack como era antes del pushad y los registros recuperan sus valores

La dupla PUSHAD-POPAD se usa mucho cuando se quiere guardar el estado de registros en un punto, realizar muchas operaciones que cambian registros y el stack, y luego con POPAD restaurar los registros y el stack al estado original. Existen algunas variantes como PUSHA equivale a: push AX, CX, DX, BX, SP, BP, SI, DI. POPA equivale a: pop DI, SI, BP, SP, BX, DX, CX, AX (los valores recuperados correspondientes a ESP y SP, no se colocan en los registros sino que se descartan). En el caso de PUSHA y POPA es similar a sus hermanas PUSHAD y POPAD salvo se que utilizan en programas de 16 bits lo cual no nos interesa ya que OLLYDBG es un debugger para programas de 32 bits.

INSTRUCCIONES PARA MOVER DATOS MOV Esta instrucción es lo que comúnmente llamaríamos MOVER, mueve el segundo operando al primero por ejemplo. MOV EAX, EBX Lo que hace es mover el valor de EBX a EAX, miremos en OLLY y nuestro bendito crackme de cruehead.

Ya no repetiré como se escribe una instrucción ya lo hemos visto, veamos los registros antes de ejecutar

En mi maquina EAX es 0 y ECX es 7c91eb94, como son valores iniciales en la suya pueden ser diferentes pero al apretar F7 lo importante es que el valor de EBX lo moverá a EAX, veamos apretemos F7.

Viola esta claro no? MOV tiene variantes por ejemplo MOV AL, CL Esto movería el valor de CL a AL veamos reinicio OLLYDBG y escribo

Los registros

Recordamos lo que vimos ya que AL son las ultimas dos cifras de EAX y CL las dos ultimas cifras de ECX, ejecutemos con F7

Vemos que sin tocar el resto de EAX y ECX el B0 se copio a AL, o sea las ultimas dos cifras de EAX. También podemos mover a algún registro el contenido de una posición de memoria o al revés.

En esta caso moveremos el contenido de 405000 a EAX y como dice DWORD serán los cuatro bytes lo que moveremos. Esta instrucción puede dar error si la dirección de memoria no existe, lo cual podemos ver fácilmente en el OLLY. Vamos al DUMP y hacemos GOTO EXPRESSION 405000

Vemos que existe y su contenido es 00 10 00 00 o sea al moverlo a EAX, dado que trabajamos con el contenido de una dirección de memoria se moverá al revés o sea 00 00 10 00 apretemos F7 a ver que pasa

Allí esta el 1000 que leyó de dicha dirección de memoria, ahora si quisiera escribir un valor en dicha dirección seria MOV DWORD PTR DS:[400500],EAX Reinicio el OLLYDBG y la escribo

En 405000 veo en el DUMP

Al apretar F7 oops

Me da una excepción y eso es porque la sección donde vamos a escribir no tiene permiso de escritura, lo cual impide cambiar bytes ejecutando instrucciones.

Bueno ya veremos como cambiar permisos de secciones mas adelante lo importante es que ya conocen la instrucción. Obviamente como podemos mover 4 bytes especificando la palabra DWORD si usamos WORD moverá 2 y si usamos BYTE moverá 1 . Veamos MOV AX,WORD PTR DS:[405008] En este caso moverá dos bytes del contenido de 405000 a AX, en este caso no podemos escribir EAX ya que como son solo 2 bytes los que movemos debemos usar el registro de 16 bits AX. Veamos que hay en el DUMP en 405008

Al apretar F7 debería mover solo esos 2 bytes a AX, veamos

Allí esta en AX, al revés como corresponde a leer de contenidos de memoria, el resto de EAX no ha sido cambiado solo lo correspondiente a AX. Lo mismo seria si usáramos BYTE MOV AL, BYTE PTR DS:[405008] En este caso movería a AL el ultimo byte solamente o sea el 08.

MOVSX (Move with Sign-Extension) Copia el contenido del segundo operando, que puede ser un registro o una posición de memoria, en el primero (de doble longitud que el segundo), rellenándose los bits sobrantes por la izquierda con el valor del bit más significativo del segundo operando. Aquí tenemos un par de ejemplos: La definición la sacamos del tute de CAOS ahora veamos un ejemplo en OLLYDBG para aclarar y usemos a nuestro amigo CRUEHEAD.

Como aun no se los dije porque soy muy malo y quería que siempre buscaran a mano, los valores de los operandos jeeje, OLLYDBG tiene una ventana de aclaraciones que esta justo debajo de el listado y arriba del DUMP.

Allí vemos que la ventana de aclaraciones nos muestra el valor de los operándoos de nuestra instrucción en mi caso BX vale F000 eso lo puedo corroborar en los registros

Y allí mismo veo que EAX vale cero, así que siempre el OLLYDBG nos ayuda a interpretar los operandos de la instrucción a ejecutar. (que malo soy jeje pero quise que fijen el concepto de donde buscar cada cosa antes de la comodidad jeje) Al apretar F7

Vemos que se copia el BX que era F000 a AX y que se rellena con FFFF ya que el numero es un negativo de 16 bits , si hubiera sido BX 1234 entonces quedaría EAX=00001234 ya que rellena con ceros al ser BX positivo. El tema de los positivos y negativos de 16 bits es similar a 32 bites se divide por la mitad el espacio 0000 a FFFF de 0000 hasta 7FFF son positivos y de 7FFF a FFFF son negativos vemos que si modificamos BX a 7FFF y ponemos EAX a cero y volvemos a ejecutar la instrucción

Copia 7FFF a AX pero rellena con ceros ya que 7FFF es positivo si repetimos pero con BX=8000 que es negativo,

Ejecuto nuevamente con F7 y

Copia BX a AX y rellena con FFFF ya que 8000 es negativo MOVZX (Move with Zero-Extend)

Igual a movsx, pero en este caso, los espacios sobrantes se rellenan siempre con ceros o sea no depende de si el segundo operando es positivo o no como en el caso anterior no haremos ejemplos porque es sencillo darse cuenta que todos los ejemplos anteriores darían en EAX 0000…… y a continuación los bytes de BX que se copiaron a AX. LEA (Load Effective Address) Similar a la instrucción mov, pero el primer operando es un registro de uso general y el segundo una dirección de memoria. Esta instrucción es útil sobre todo cuando esta dirección de memoria responde a un cálculo previo. Esto nos dice nuestro amigo CAOS y significa que en este caso por ejemplo reinicio OLLY.

Aquí es el único caso en que hay corchetes que no se mueve el contenido de la dirección de memoria que se calcula dentro del corchete si no la dirección en si. En mi caso ECX vale 12FFb0

Y lo que hace LEA es sumarle 38 en este ejemplo y mover ECX mas 38 que es igual a 12ffe8 a EAX En la ventana de las aclaraciones ya muestra ambos operándoos

Muestra que un operando es 12FFe8 que proviene de sumar ECX+38 y EAX vale cero antes de operar. Al apretar F7

Dicha dirección se mueve a EAX, hay que tener cuidado porque los corchetes nos llevan a pensar que deberíamos mover el contenido de la dirección 12ffe8 que debemos buscar en el dump como en el caso de la instrucción MOV, pero LEA solo mueve la dirección al primer operando no su contenido. XCHG (Exchange Register/Memory with Register) Esta instrucción intercambia los contenidos de los dos operandos. En este caso intercambia los valores si escribimos XCHG EAX,ECX El valor de EAX pasara a ECX y viceversa comprobémoslo en OLLY

Antes de ejecutar en mi maquina EAX vale cero y ECX vale 12FFb0

Al apretar F7 vemos que intercambian sus valores

También se puede usar para intercambiar con una posición de memoria siempre que tenga permiso de escritura dicha sección

Al ejecutar con F7

Nos pasa lo mismo que cuando quisimos hacer MOV a dicha dirección al no tener permiso de escritura nos genera una excepción. Bueno creo que como primera parte de las instrucciones ya tienen para divertirse y practicar, creo que los ejemplos si los van haciendo mientras leen aclaran bastante la cosa, en la siguiente parte seguiremos con mas instrucciones hasta terminar con las mas importantes y tratar de terminar esto que es lo mas duro. Hasta la parte 5 Ricardo Narvaja 13 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 5 INSTRUCCIONES MATEMATICAS INC Y DEC Estas instrucciones incrementan o decrementan respectivamente el operando, sumándole uno si es INC o restándole uno en el caso de DEC. Veamos en el OLLY, como siempre abrimos el OLLYDBG y el crackme de cruehead y en la primera línea escribimos

EAX en el estado inicial en mi maquina esta a cero, si no puedo cambiarlo a cero a mano

Así que al apretar F7 y ejecutar la instrucción se INCREMENTARA EAX en uno veamos apretemos F7

Lo mismo ocurre con DEC podemos escribirlo debajo del anterior

Al apretar F7 y ejecutar la instrucción se DECREMENTA EAX que estaba en 1 y volverá a 0.

También se pueden incrementar o decrementar el contenido de posiciones de memoria

Aunque en este caso la sección no tiene permiso de escritura y no dejara aumentar el contenido dando excepción.

Si la sección hubiera tenido permiso de escritura, vamos en el dump a la dirección 405000

Ya que el contenido al leerlo al revés es 00001000, si lo incrementamos seria 00001001 o sea quedaría así

Este fue el caso para DWORD sumándole UNO a los 4 bytes del contenido. En el caso de WORD el ejemplo sumaria solo a los últimos 2 bytes

Y en el caso de BYTE sumaria solo al último byte

ADD Add como ya vimos es la instrucción correspondiente a la suma, siempre suma ambos operandos y guarda el resultado en el primero. ADD EAX,1 es similar a INC EAX También puede sumar registros Veamos en OLLY

Antes de ejecutar la operación

En mi maquina EAX vale 00000000 y ECX vale 12FFB0 en sus maquina puede tener otros valores, pueden cambiarlos si quieren, pero al apretar F7 sumara ambos y guardara el resultado en EAX, veamos

Allí esta EAX esta en rojo pues fue el que se modifico y tiene el resultado de la suma. También podemos sumar a un registro el contenido de una memoria

En este caso no hay problema por el permiso de escritura ya que como EAX cambiara y guardara el resultado y el contenido de [405000] no cambiara ya que es el segundo operando, la operación no generara excepción. Antes de apretar F7 vemos que EAX vale 0 y el contenido de 405000 vale 00001000

Apreto F7 y se ejecuta la suma

Entonces EAX=0 mas 1000 se modifica EAX quedando el resultado allí que es 1000. Si hacemos al revés y escribimos

En este caso el resultado se guardara en el contenido de 405000 y esto modificara el mismo por lo cual al apretar F7 generara una excepción al no tener permiso de escritura.

ADC (ADD WITH CARRY) En este caso se suman ambos operandos y se le suma el valor del CARRY FLAG O FLAG C y se guarda en el primer operando.

Allí vemos que sumara EDX que vale 21 mas 3 mas el valor del flag C, que en este caso es cero, si apreto F7.

Veo que el resultado es 24, pero si repito la operación con el FLAG C puesto a 1 el cual se puede cambiar haciendo doble click en el mismo.

Allí lo cambie a uno y pongo todo como antes para repetir la operación solo cambiando el flag C.

Apreto F7 para que se realice la suma y ahora el resultado es 25

Ya que suma EDX =21 mas 3 mas el FLAG C que en este caso vale 1. SUB Es la resta o substracción o sea la operación contraria a ADD, lo que hace es restar el segundo operando al primero y guardar el resultado en el primer operando.

En mi maquina los registros valen antes de ejecutar

Al apretar F7 le restara a EAX que vale cero el valor 2

El resultado es -2 que en hexadecimal se representa FFFFFFFE si hacemos doble click en dicho valor

Vemos que corresponde al decimal -2. También se pueden restar registros, y posiciones de memoria en la misma forma que lo hicimos con ADD. SUB EAX,ECX Por ejemplo hará EAX-ECX y guardara el resultado en EAX Y SUB EAX,DWORD PTR DS:[405000] Restará a EAX el contenido de la posición de memoria 405000, guardando el resultado en EAX. En el caso inverso SUB DWORD PTR DS:[405000],EAX Ya que el resultado se guarda en el primer operando, si no tenemos permiso de escritura en la sección, nos dará una excepción. SBB Es la operación contraria a ADC, es este caso se restan ambos operandos y se le resta el valor del CARRY FLAG O FLAG C y se guarda en el primer operando.

Antes de ejecutar la operación ponemos EDX a 21 y el carry flag a 0

Al apretar F7 hará EDX-3 y le restara cero del FLAG C

Ahora su repito la operación con el FLAG C a 1

Apreto F7 y ahora hará EDX-3 y le restara 1 del FLAG C

En este caso el resultado es 1D. MUL Bueno hay dos instrucciones para realizar multiplicaciones, la primera de ellas es MUL, la cual no considera los signos de los números que va a multiplicar, y usa un solo operando el otro operando es siempre EAX aunque no se escribe y el resultado lo guarda en EDX:EAX que quiere decir esto veamos el ejemplo. Por ejemplo MUL ECX Esto multiplicara ECX por EAX y guardara el resultado en EDX:EAX y no considerara el signo de los operandos. Por ejemplo veamos en OLLYDBG

Pongo EAX a FFFFFFF7 y ECX a 9 si realizo la multiplicación en la calculadora de Windows veo que

El resultado es

Y no entra en EAX veamos que pasa en OLLY al apretar F7

Allí vemos en rojo que EDX y EAX cambiaron y como vemos guarda en EAX los bytes que entran allí y luego guarda los que no entran en EDX, en este caso el 8 que no puede mostrar EAX, lo guardo en EDX, por eso se dice que en este caso el resultado se muestra en EDX:EAX ya que usa ambos como si fueran un solo registro del doble de largo. En el caso MUL DWORD PTR DS:[405000] Multiplicara el contenido de 405000 por EAX y como siempre guardara el contenido en EDX:EAX sin considerar el signo de los operandos. Siempre que en OLLY queramos ver cuanto es el valor de un numero hexadecimal sin signo, hacemos doble click en cualquier registro

Como habíamos visto la segunda línea nos daba el valor con signo en este caso FFFFFFAF es -81 considerado con SIGNO, pero en operaciones como MUL donde los números se consideran SIN SIGNO el valor decimal se lee en la tercera línea la que dice UNSIGNED, allí vemos 4294967215 seria el valor tomando al numero como positivo o sin SIGNO. IMUL (multiplicación con signo) La instrucción IMUL no solo es multiplicar con signo de la misma forma que lo hacia MUL IMUL ECX Es igual que antes ECX por EAX y el resultado se guarda en EDX:EAX salvo que se considera el signo de los operandos. Además de la similitud con la instrucción anterior IMUL permite poner mas de un operando, lo que no estaba permitido en MUL. Del tute de CAOS Además de la utilización de los registros EAX y EDX, así como de sus subdivisiones, pueden especificarse otros orígenes y destinos de datos y puede haber hasta tres operandos. El primero, es el lugar donde se va a guardar el resultado, que debe ser siempre un registro, el segundo y el tercero son los dos valores a multiplicar. En estos ejemplos vemos como estas instrucciones con dos o tres operandos, tienen el mismo espacio para el resultado que para cada uno de los factores: F7EB imul ebx EAX x EBX -> EDX:EAX Este primer ejemplo es el conocido y similar a MUL salvo que se consideran los signos 696E74020080FF imul ebp, dword ptr [esi+74], FF800002 [ESI+74] x FF800002 -> EBP Este es el segundo ejemplo que pone veamos en este caso hay tres operandos, multiplica el contenido de ESI+74 por FF800002 y el resultado lo guarda en EBP, podemos hacerlo en OLLY Copio la linea imul ebp, dword ptr [esi+74], FF800002 al OLLY

Veo que al apretar ASSEMBLE me da error y eso es porque en el OLLY los números que empiezan por letras deben agregársele un cero delante si no, no los interpreta, corrijamos

Ahora apreto ASSEMBLE y lo acepta

Cambio el valor de ESI a 401000 para asegurarme que la dirección ESI mas 74 exista y se pueda leer su contenido

Veamos en la aclaración del OLLY

Alli nos dice que ESI + 74 es la dirección 401074 y que su contenido es C7000000, veamos en el dump con GOTO EXPRESSION 401074.

Y si, es cierto el contenido leído al revés seria C7000000, eso lo multiplicara por FF800002 y como el primer operando es EBP pues guardara allí el resultado imul ebp, dword ptr [esi+74], FF800002 Al apretar F7 vemos que se puso rojo EBP ya que ahora contiene el resultado

El resultado en la calculadora nos da C7000000 * FF800002

Pero como especificamos que se muestre en EBP pues solo muestra los bytes que caben allí, el resto los descarta. En el tercer ejemplo que hay solo dos operandos se multiplican ambos y el resultado se guarda en el primero. 0FAF55E8 imul edx, dword ptr [ebp-18] EDX x [EBP-18] -> EDX Como vemos la mejor opción para multiplicar números largos es usando IMUL con solo un operando pues en este caso el resultado lo guarda en EDX:EAX con la posibilidad del doble de largo lo cual no ocurre cuando usamos dos o tres operandos, dichas opciones son mas útiles en operaciones pequeñas. DIV (Unsigned Divide) / IDIV (Signed Divide) Estos son la contrapartida de MUL Y IMUL respectivamente DIV solo tiene un operando y no considera los signos y el resultado se guarda en EDX:EAX IDIV siempre considera los signos si usa un solo operando será como DIV y guardara en EDX:EAX y en el caso de dos operandos dividirá ambos y guardara en el primero, y en el de tres operandos dividirá el segundo y el tercero y guardara en el primero. No creo que sea necesario repetir los ejemplos pues son similares a los de MUL e IMUL. XADD (Exchange and Add) Es como realizar en una sola instrucción XCHG y ADD o sea que si tenemos XADD EAX,ECX

Allí vemos ECX que es 1 y EAX es 7 al apretar F7 se intercambian o sea que EAX pasa a valer 1 y ECX 9 luego se suman

Como vemos el resultado se sigue guardando en el primer operando, lo único que cambio fue que se intercambiaron los valores antes de sumarlos, vemos que ECX quedo valiendo 9 que era lo que valía EAX antes de intercambiarse y sumarse. NEG Esta instrucción tiene la finalidad de cambiar de signo el número representado o sea que si tenemos el número 32 en hexa y le aplicamos NEG el resultado será el negativo del mismo. Ejemplo

Escribo en OLLY NEG EAX y pongo en EAX el valor 32

Al apretar F7 quedara en EAX el negativo de 32 veamos

Allí vemos el resultado -50 en decimal como nos muestra la segunda columna corresponde a -32 en hexa.

Allí esta si tipeamos en la comandbar que nos de el valor de -32 hexa en decimal, nos dice -50 y nos aclara que se escribe FFFFFFCE ya que no se puede escribir el signo en OLLY. Pues como vemos la instrucción NEG nos convierte el operando en su negativo. INSTRUCCIONES LOGICAS Provienen de realizar operaciones lógicas entre dos operandos pasados a binario bit a bit y guardando el resultado en el primer operando AND El resultado es 1 si los dos bits son 1, y 0 en cualquier otro caso.

1 and 1 = 1 1 and 0 = 0 0 and 1 = 0

0 and 0 = 0 Vemos un ejemplo en OLLYDBG AND EAX,ECX

Pongamos ECX=0001200 y EAX=3500

Si lo hiciéramos a mano deberíamos pasar a binario ambos 1200 en binario seria 01001000000000 3500 en binario seria 11010100000000 Aplicándole la tablita de la operación AND bit a bit vemos que por ejemplo la ultima cifra

Al hacer AND entre dos ceros el resultado seria cero, así hay que hacer bit a bit y nos daría 01000000000000 ya que el resultado es uno solo cuando los dos bits son 1 y eso ocurre solo en

la columna resaltada.

Si ejecutamos F7 en el OLLY vemos el resultado en ECX que es 1000 que pasado a binario es

01000000000000

OR En esta instrucción realizamos el mismo proceso que la anterior solo que en vez de utilizar la tablita AND para hallar el resultado entre bits, lo hacemos con la tablita OR El resultado es 1 si uno o los dos operandos es 1, y 0 en cualquier otro caso.

1 or 1 = 1 1 or 0 = 1 0 or 1 = 1 0 or 0 = 0

XOR Aquí es similar solo que usamos la tablita de la función XOR para las operaciones entre bits El resultado es 1 si uno y sólo uno de los dos operandos es 1, y 0 en cualquier otro caso

1 xor 1 = 0 1 xor 0 = 1 0 xor 1 = 1 0 xor 0 = 0

NOT Simplemente invierte el valor del único operando de esta función

not 1 = 0 not 0 = 1

Ejemplo: not 0110 = 1001

Si tenemos por ejemplo EAX=1200 que en binario es 1001000000000 convertimos los 0 en 1 y los 1 en 0 considerando que es un numero de 32 bits y que al inicio tiene ceros o sea seria llenado de ceros delante hasta completar los 32 bits. 00000000000000000001001000000000 Al hacerle NOT quedaría 11111111111111111110110111111111 que en la calculadora de Windows vemos que es FFFFEDFF en hexa

En OLLY antes de apretar F7 pongo EAX a 1200

Apreto F7

Vemos que el resultado es el mismo Bueno aquí terminamos esta quinta parte veo que esto es un poco mas largo de lo que pensaba pero bueno vamos paso a paso, nos quedan ver las comparaciones, los saltos y los call y ret. Bueno paciencia que despacio se llega a ROMA Hasta la parte 6 Ricardo Narvaja 14 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 6 COMPARACIONES Y SALTOS CONDICIONALES En términos generales, las comparaciones entre dos operandos, y según el resultado de esa comparación la decisión si el programa saltara o no en un salto condicional posterior, suele ser lo primero que se menciona en cualquier tute básico que comienza desde cero de cracking. Sabemos que si el programa nos pide un serial para registrarnos, en algún momento deberá decidir si es correcto no y para ello deberá comparar y realizar uno o varios saltos y la dirección adonde saltará variará según si pusiste bien el serial o no. Ahora como funciona en profundidad la comparación y el salto es lo que veremos a continuación. Sabemos porque lo hemos visto ya en partes anteriores de esta introducción, que según el resultado una instrucción se activan o desactivan los flags, el caso mas conocido es el flag que se activa cuando el resultado de una instrucción es cero el FLAG Z y hemos visto diferentes formas de activar los flags según el resultado de una instrucción. CMP Esta es la instrucción mas conocida de comparación y lo que hace es comparar dos operandos, en realidad es una instrucción SUB, que no guarda el resultado de la resta en el primer operando, ambos operandos quedan igual, lo que cambian son los flags según el resultado. Como vimos si hacemos por ejemplo CMP EAX, ECX Siendo EAX y ECX iguales, se restan ambos, no se modifican, pero el resultado de la resta es cero lo que hace activar el flag Z, veamos el ejemplo en OLLYDBG.

Allí escribí la instrucción y ahora modificare EAX y ECX para que sean iguales.

A apretar F7 veo que EAX y ECX no modificaron su valor pero se activo el flag Z, al haber realizado una resta y ser su resultado CERO aunque no podamos ver el resultado ya que no lo guarda.

En realidad no nos importa el resultado numérico de la resta en si, sino que de alguna forma podemos saber según los flags si EAX era igual a ECX, o si son desiguales, cual es mayor. Como comentario ya que aun no hemos llegado a los saltos condicionales, los tienen dos posibilidades, deciden si saltar o no saltar según el estado de los flags, el mas claro ejemplo y que trabajaría en conjunto con la comparación anterior es el salto JZ que salta si el FLAG Z esta activo o a UNO y no salta si esta inactivo o a CERO. De esta forma se logra que el programa tome una decisión, si fueran dos seriales que esta comparando, por ejemplo en EAX esta el serial que vos ingresaste para registrar un programa y en ECX esta el serial correcto, el programa podría decidir con un CMP que si son iguales se activa el flag Z, y el salto JZ al ver el flag activo, nos llevara a una zona para usuarios registrados, y si el serial que tipeaste y esta en EAX no es igual al de ECX que es el correcto, seguí intentando jeje, el flag Z sigue a CERO, y no salta manteniéndote en la zona de usuario no registrado. Ya veremos los ejemplos más concretos al estudiar los saltos condicionales. De la misma forma con el flag S o de signo podemos ver si en una comparación el primer operando era mayor que el segundo, o al revés. Miremos el ejemplo Repitamos el CMP EAX, ECX pero ahora pongamos EAX mayor que ECX

Si apretamos F7

Vemos que el FLAG Z es cero por lo cual ya sabemos que no son iguales, y a la vez el flag S es cero lo cual quiere decir que al hacer la resta EAX-ECX el resultado es positivo, lo cual significa que EAX es mayor que ECX. De la misma forma si repetimos la operación con EAX menor que ECX

Y apretamos F7

Allí vemos que al dar la resta de EAX con ECX negativa ya que ECX es mayor, se activa el FLAG S que recordamos se activa con resultados negativos. Las diferentes posibilidades de comparación activaran los correspondientes flags y según lo que el programa necesite saltara o no de acuerdo a chequear la activación de uno o mas de dichos flags. También permite la comparación entre registros y posiciones de memoria utilizando DWORD, WORD y BYTE .

Allí compararía EAX con el contenido de 405000 y como siempre la ventana de aclaraciones del OLLY nos da el valor de cada operando en mi caso

Al apretar F7 en este ejemplo y EAX es menor que el contenido de 405000 que es 1000, dará un resultado negativo y activara el FLAG S.

Existen en forma similar CMP AX,WORD PTR DS:[405000] Y CMP AL,BYTE PTR DS:[405000] En el caso de comparar 2 bytes o 1 byte del contenido de la memoria. TEST (Logical Compare) El principio de esta instrucción es, en cierto modo, el mismo de cmp, es decir, una operación entre dos valores que no se guarda, sino que puede modificar el estado de algunos flags (en este caso, SF, ZF y PF) que determinan si debe efectuarse el salto que también suele acompañar a esta instrucción. La diferencia está en que en este caso, en vez de tratarse de una resta, se trata de una operación AND. Esto nos dice nuestro amigo CAOS en su tute de ASM veremos ejemplos para aclarar la definición, generalmente el comando TEST lo veremos en este formato TEST EAX,EAX Ustedes dirán para que quiere testearse contra si mismo el valor de EAX o el registro que sea? Pues se usa esta instrucción, para saber si EAX en este caso es cero o no, y como funciona? Escribamos en OLLY TEST EAX,EAX

La tablita de la operación AND era . El resultado es 1 si los dos operandos son 1, y 0 en cualquier otro caso.

1 and 1 = 1 1 and 0 = 0 0 and 1 = 0 0 and 0 = 0 Vemos que la única forma que el resultado sea cero es que ambos operandos sean cero (no

interesan en este caso los casos de bytes diferentes pues EAX esta operando contra si mismo, por lo que ambos bytes siempre son iguales) pues si EAX en binario tiene algún bit que es 1, al hacer AND contra si mismo daría 1 y ya no podría ser cero el resultado.

Pongamos EAX igual a CERO

En el OLLYDBG eso sea realiza fácilmente haciendo CLICK DERECHO en el registro a

modificar y eligiendo ZERO.

Allí esta apreto F7

Vemos que se activo el flag Z o sea como sabíamos la operación AND entre dos valores que son

cero es igual a cero y se activara. Si repito la operación con EAX diferente de cero

Apreto F7

Y el FLAG Z no se activa al ser el resultado diferente de cero. Si uso la calculadora puedo comprobar que 390 AND 390 da como resultado 390 En binario 390 es 1110010000

Como la operación AND si ambos operandos son CEROS dará como resultado cero y si son dos UNOS dará como resultado UNO, vemos que el resultado no cambiará o sea será 390 en hexadecimal, y no se activara el flag Z. Hay alguna instrucciones mas de comparación pero estas son las principales llego el momento de ver los saltos SALTOS Todos as instrucciones de salto tienen un solo operando que es la dirección adonde saltaría el programa, veamos los diferentes tipos aquí en la tabla y aclarémoslos.

JMP

Es el salto directo o incondicional, aquí no hay ninguna decisión SIEMPRE saltara a la dirección que nos muestra el operando por ejemplo veamos en OLLY

Al ejecutar ese salto el programa ira a 401031 y seguirá ejecutándose desde allí. Tenemos un par de lindas configuraciones del OLLY para los saltos que les enseñare aquí, así son mas visibles los mismos. Si vamos a OPTIONS-DEBUGGING OPTIONS

Y allí en la pestaña CPU

Marcamos estas tres tildes

Vemos que la información es mucho mayor ahora y mas visible

Vemos que OLLYDBG ahora nos muestra con una flecha roja que va a saltar y además a adonde va a saltar, exactamente a 401031. Si ejecuto ahora con F7

Se realizo el salto y EIP es 401031

Ya que EIP apunta a la instrucción que se va a ejecutar a continuación, en este caso 401031. JE o JZ Ambos son el mismo tipo de salto condicional y pueden escribirse de las dos formas ya vimos que JZ saltara cuando el flag Z sea cero.

Escribamos en OLLYDBG dos instrucciones una comparación y el salto así verificamos como funciona. Pongo EAX y ECX iguales

Al ejecutar la comparación se realiza la resta y como ambos son iguales se activa el FLAG Z al ser el resultado CERO.

La siguiente instrucciones es el salto condicional veamos

OLLYDBG ya nos avisa la decisión y como el FLAG Z esta activado nos muestra en rojo que va a saltar, si la indicación estuviera en gris quiere decir que la decisión es no saltar, en este caso saltara, apreto F7.

Allí vemos que salto y EIP ahora es 401031. Repitamos el ejemplo con EAX diferente de ECX

Al apretar F7 en la primera instrucción como el resultado no es cero, el flag Z no se activa.

Y vemos en OLLY

Que como el JE salta si el flag Z es UNO, en este caso no saltara, y la flecha del salto esta gris, al apretar F7 nuevamente

Vemos que no salto y siguió a continuación en 401004, esto que parece tan tonto es la base de la comparaciones y decisiones en todos los programas. Si repito el ejemplo anterior y llego al salto, nuevamente y no va a saltar

Sabemos que no salta porque el flag Z esta a cero, ahora que ocurre si hago doble click en el flag Z y lo cambio a 1.

Vemos que la flecha cambio a rojo y OLLYDBG saltara, independientemente de la comparación, manipulando directamente el flag, ya que la decisión se toma sobre el estado actual del mismo, si cambia el flag cambiara el salto. Los otros saltos los veremos rápidamente con un ejemplo cada uno JNE o JNZ Es el opuesto al salto anterior en este caso, salta si el flag Z no esta activo o sea si el resultado de la operación fue distinto de cero.

Allí escribo la comparación y el JNZ Si EAX y ECX son iguales se activa el FLAG 0 al ser la diferencia CERO

Y al revés que el JZ que saltaba al estar el FLAG Z activo este es el opuesto, salta cuando el FLAG Z es cero o esta inactivo. Se puede entender que si pongo EAX diferente de ECX, el resultado será diferente de cero y el flag Z quedara inactivo y allí si saltara. JS Como vemos en la tabla saltara si la comparación da un resultado negativo o sea si EAX en menor que ECX en el ejemplo anterior.

Al apretar F7

El FLAG S se pone a 1 y saltara al ser negativo,

Allí vemos que la flecha roja nos indica que saltara, en el caso que EAX sea mayor que ECX el flag S no se activara al ser un resultado positivo y el salto JS no saltara. JNS Es el opuesto al anterior saltara cuando el FLAG S este a cero o sea cuando el resultado sea positivo, en el ejemplo anterior cuando EAX sea mayor que ECX. JP o JPE En esta caso el salto condicional JP saltara cuando el FLAG P este activo y esto ocurrirá como habíamos visto cuando el resultado de la comparación tenga paridad par o par cantidad de unos al verlo en binario.

Ponemos EAX a 20 y ECX a 18 y apretamos F7

Como la diferencia entre EAX y ECX es 2 y este pasado a binario es 10 que tiene 1 solo uno o sea una cantidad impar de unos, el flag P no se activa y el JPE no saltara.

Ahora si cambio ECX a 17 y repito apreto F7

Vemos que al ser el resultado 3 que en binario es 11 y tiene un número par de unos, entonces allí si se activa el FLAG P y el JPE saltara.

JNP o JNPE Es el opuesto del anterior o sea este salta cuando el flag P esta a cero o sea la paridad es impar, en el ejemplo anterior hubiera saltado la primera vez cuando el resultado era 2 y no hubiera saltado cuando el resultado era 3, al revés del JP. JO

Este salta cuando hay overflow o capacidad excedida lo cual activa el flag O.

Aquí cambiamos la comparación porque para activar el FLAG O hay que hacer OVERFLOW y esto es posible mediante una suma.

Apreto F7

Y el JO saltara al haberse activado el FLAG O por OVERFLOW o capacidad excedida. JNO Es el opuesto al anterior este salta cuando el FLAG O esta a CERO o sea no hay OVERFLOW JB Salta si es mas bajo, veamos el ejemplo

Vemos que EAX es mas bajo que ECX o sea que debería saltar, al apretar F7

El flag C se activa, ya que tiene que al hacer la diferencia que da un numero negativo, en el bit mas significativo o sea el primero habrá acarreo y eso activa el FLAG C, y según eso decide el JB en resumidas cuentas si EAX era menor que ECX. JNB Es el opuesto de JB saltara si el FLAG C es cero o sea no hay acarreo porque el resultado fue positivo, lo cual supone que EAX fue mayor que ECX y al revés que el anterior este saltara en ese caso. JBE Este salta si es mas bajo o igual o sea testea dos flags a la vez ve si el FLAG C esta activo en ese caso salta, y también verifica si el FLAG Z esta activo con el cual también salta, o sea si EAX es igual a ECX saltara y si es menor también.

Ponemos como primer caso que EAX y ECX sean iguales

Apreto F7

Al ver que el flag Z esta activo salta

Si EAX es menor que ECX

Apreto F7

En este caso se activa el FLAG C al ser resultado negativo que usa un carry en el bit mas significativo, o sea salta cuando EAX es menor a ECX también En el ultimo caso que EAX es mayor a ECX repito el ejemplo apreto F7

Ambos flags Z y C están a cero por lo tanto no saltara

O sea la conclusos es que JBE salta si EAX es mas bajo o igual que ECX en el ejemplo. JNBE Es el opuesto al anterior, salta si el flag Z y el FLAG C son cero ambos o sea solo en el ultimo ejemplo anterior cuando EAX es mayor que ECX, allí ambos flags están a cero y este JNBE saltara. JL en este caso JL salta si es menor, pero en diferente forma, veamos aquí mira si FLAG S es diferente a FLAG O y en ese caso salta Veamos en los ejemplos cuando se da esto si ambos EAX y ECX son positivos siendo EAX mayor que ECX

Al apretar F7 no salta ya que EAX es mayor que ECX y el resultado es positivo lo que no activa el FLAG O ni el FLAG S.

Si EAX es menor que ECX pero ambos son positivos repito el ejemplo

Apreto F7

Y como S y O son diferentes salta o sea que salta cuando es menor si ambos son positivos, veamos otro caso.

En este caso EAX es menor que ECX, ya que es un número negativo veamos que pasa Salta perfectamente porque es menor pero que pasa si usamos estos dos mismos valores con el otro salto que parece realizar el mismo trabajo el JB

Al apretar F7

Vemos que el JB no salta quiere decir que JB compara ambos como si fueran positivos o SIN SIGNO mientras que si el salto debe considerar el signo de lo que compara se utiliza JL esa es la principal diferencia entre ambos.

Aquí vemos en esta los saltos condicionales según queramos considerar el signo de lo que comparamos o no, Vemos que JA, JB JBE y JAE consideran ambos operandos positivos mientras que JG, JL, JLE y JGE consideran los operandos con signo, JE y JNE se comportan igual en ambos casos. Creo que con esto hemos aclarado el tema de los saltos condicionales y las comparaciones, en la práctica mas adelante veremos su utilización en los programas lo cual nos será mucho mas liviano que esta pesada tarea de revisarlos a casi todos. Queda en la ultima parte de ASM por suerte ver los calls y ret, y los modos de direccionamiento ya casi llegamos al fin de lo duro paciencia jeje..

Hasta la parte 7 Ricardo Narvaja 16 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG Parte 7 Los CALL y RET He dejado algunas instrucciones para esta ultima parte porque creo que a esta altura ya tienen claro algunas cosas, y es mejor explicar estas ultimas instrucciones ya teniendo una pequeña base, ahora explicaremos los CALL y RET. Esta instrucción aunque parezca su funcionamiento sencillo, muchos de los newbies no comprenden realmente su funcionamiento, por eso quería dedicarle un espacio importante e insistir en repasar toldo lo anterior, pero ademas mirar de entender muy bien el funcionamiento de los CALL y RET yo creo que es algo muy importante para el cracking. Carguemos nuevamente nuestro crackme de ejemplo el CRACKME DE CRUEHEAD en OLLYDBG, Para practicar hagamos click derecho en el listado desensamblado en cualquier línea y elijamos GO TO – EXPRESSION

Y en la ventana que aparece tipeemos 401245

Nos llevara a dicha dirección en el listado desensamblado, donde hay un CALL para practicar.

Allí vemos el CALL que elegí para practicar, para poder ejecutarlo hago CLICK DERECHO-NEW ORIGIN HERE con lo cual EIP apuntara a 401245 y dicha dirección será la próxima que se ejecutará.

Allí vemos como cambiamos EIP

Volvamos a nuestro CALL

La instrucción CALL lo que hace es ir a ejecutar una subrutina o si quieren parte del programa cuya dirección esta dada por el valor del operando o sea en este caso del ejemplo: CALL 401362 significa que la próxima línea a ejecutarse será 401362 y cuando se termine de ejecutar la rutina que esta allí dentro, volverá a la instrucción siguiente a continuación del CALL que la llamo. En este ejemplo luego de ejecutarse el contenido del CALL 401362, volverá a 40124A y seguirá desde allí. Ahora hagamos unos ciertos movimientos con el OLLYDBG, que nos ayudan en los casos que estamos encima de un CALL como este. Si yo quiero mirar el contenido del CALL podría entrar al mismo con F7 y tracearlo por dentro, pero si quiero echar un vistazo a ver si el contenido me interesa para ser traceado o no, ya que también tengo como recuerdan la opción de tracear con la tecla F8, la cual en este caso ejecutara el CALL sin entrar al mismo y seguirá en 40124A sin ni siquiera enterarnos de lo que hizo el programa dentro del CALL.

Entonces cada vez que llegamos a un CALL y estamos traceando un programa se plantea una disyuntiva, será importante para entrar a tracearlo con F7? O lo salteo con F8 porque es un call secundario que no hace nada que me importe? Bueno, lo que OLLYDBG nos permite hacer es mirar sin ejecutar, a ver que veo dentro del CALL y si me interesa. Para ello hago click derecho en el CALL y elijo FOLLOW.

FOLLOW no ejecuta ninguna línea solo va a mostrarnos la próxima línea a ejecutarse, pero no cambia nada EIP seguirá en 401245, a la espera de nuestra decisión.

Cuando entro a mirar veo la rutina interna que obviamente empieza en 401362 que era el operando del CALL y donde terminará, pues en el primer RET que vea en este caso OLLYDBG escribe los RET como RETN, pero es lo mismo dicha instrucción es la finalización de la rutina y la vuelta a 40124A a la instrucción siguiente del CALL que nos trajo aquí. Es muy importante entender esto, ahora que vimos como podemos mirar dentro sin ejecutar volvamos a la línea actual presionando la tecla - del teclado numérico o sea la tecla MENOS, esto siempre nos lleva al paso anterior sin ejecutar nada también. Pues estamos en el CALL

Ahora si entraremos con F7, pero antes de entrar el CALL veamos el stack, esto es muy importante pues allí se almacenan los datos para que el programa sepa donde regresar cuando llega al RET.

En mi maquina este es el stack, en la suya los valores pueden variar pero el mecanismo será similar. Apreto F7 ahora

Allí entre en el CALL y estoy en 401362 pero a diferencia de la vez anterior que entre con FOLLOW ahora EIP cambio a 401362, lo cual quiere decir que estamos ejecutando esta rutina. Veamos que paso en el stack

Allí en la imagen resalte el stack como estaba antes y veo que se agrego una nueva carta arriba o sea al entrar en un CALL el sistema automáticamente hace un PUSH con la dirección de retorno, o sea donde volverá al llegar al RET y salir de la rutina. Vemos que la línea tiene el valor 40124A que es como sabemos la dirección de retorno. Por si alguno lo olvido recordemos que es la dirección siguiente al CALL inicial, allí se ve.

Bueno vemos que OLLY nos aclara aun mas el tema agregándonos información.

Nos dice RETORNO A 40124A desde 401362 O sea OLLY aun no sabe donde estará el RET que nos devolverá, pero sabe que la rutina empieza en 401362 y lo marca como que aquí empieza y terminara en un RET y volverá a 40124A. Apretemos F7 una vez vemos que ejecuta un PUSH 0 lo cual pone un CERO en el stack y abajo del mismo queda el indicador para el RET de la dirección de retorno.

El programa puede hacer mil operaciones dentro de la rutina hacer miles de PUSH, POPS lo que quiera, pero al llegar al RET deberá dejar arriba en el stack nuevamente el valor de la dirección de retorno, sigamos ejecutando con F8 para no entrar en los CALL y llegar al RET.

Allí llegue al RET y veo que como dije el stack tiene arriba nuevamente el valor donde retornara.

Como habíamos mencionado el RET es el final de la rutina y contrapartida de la instrucción CALL, si CALL nos trajo aquí, RET nos devolverá a la zona donde estábamos antes de entrar en esta rutina. Pero además RET quitara la dirección de retorno del stack que es un valor que al sistema ya no le interesa pues ya volvemos y luego la dirección ya no es útil más.

Apreto F7

Y vuelvo a 40124A y el stack quedo como estaba antes de ejecutar el CALL en mi maquina en 12FFc4.

Es de mencionar que si uno ejecuta un RET sin haber entrado en ningún call por ejemplo PUSH 401256 RET Lo que hará esto es poner en el primer lugar del stack el valor 401256, y como la siguiente instrucción es un RET, pues ella interpreta que el primer lugar del stack es una dirección de retorno de algún call anterior y aunque ello no haya ocurrido, al ejecutarlo nos llevara allí. Ahora reinicio el CRACKME DE CRUEHEAD Ahora haré otro ejemplo voy en el listado con GO TO – EXPRESSION a 401364 es una dirección que elegí para mostrar algo ya verán.

Ahora no cambiare EIP ni nada si no que apretare F2 que es un BREAKPOINT los cuales ya explicaremos mas adelante en detalle, lo importante es que cuando el programa ejecute esa instrucción OLLYDBG parara allí.

Allí esta puesto el BREAKPOINT ahora apreto F9 que es RUN para que el programa corra.

Vemos que nos sale la ventana del crackme, si no la ven, pues búsquenla con ALT mas TAB entre los programas que están corriendo. Allí se ve, el programa no paso aun por nuestro BREAKPOINT, vayamos en dicha ventanita a HELP - REGISTER

Nos sale la ventana para poner un NOMBRE Y UN SERIAL

Pongamos cualquiera

Y apreto OK

Nos sale una ventanita diciendo que no tuvimos suerte o sea que tipeamos el user y serial incorrecto (lo increíble seria que fuera el correcto jeje), y al aceptar dicha ventana para en nuestro BREAKPOINT. Si no les para prueben con el user y serial que puse yo.

Allí estamos en el medio de la ejecución del programa pero algo de información tenemos

Vemos allí unos cuantos RETURN TO …. Que el stack tiene almacenados allí, así que podemos pensar que el superior de todos, será donde volverá el programa al llegar a un RET ya que suponemos estamos dentro de un CALL (porque vemos que hay RETURN TO …… en el stack ) y al llegar a un RET ese RETURN quedara en la línea superior y volverá a 40124A . Como vemos también estamos en la misma rutina que analizamos antes cambiando el EIP, pero ahora dentro de la ejecución el programa, no suelta. Tratamos de llegar al RET apretando F8 como antes, en el call anterior al RET se para ya que nos debe mostrar algo que hace el CALL dentro que es una mensaje y que debemos aceptar para seguir.

Presionamos ACEPTAR

Y llegamos al RET y como supusimos el valor superior del stack es

La diferencia entre la vez anterior y esta es que la vez anterior al cambiar EIP e ir directamente allí, ejecutamos el CALL solo aislado, no el resto del programa, ahora al poner un BREAKPOINT el programa se ejecuto normalmente, y al pasar por allí paro, y si apreto F9 seguirá corriendo como si nada.

Además lo que quise mostrar es que a veces cuando estamos en el medio de la ejecución de un programa y paramos por algún motivo, la información del stack nos sirve para saber de donde fue llamado la rutina en que estamos y donde volverá, y si hay mas RETURN TO hacia abajo, también sabremos que son CALLS unos dentro de otros, o sea anidados, y que estamos dentro de un CALL que al llegar al primer RETURN TO, saldremos y al llegar al segundo pues saldremos de otro y así. Creo que esta claro, igual como es muy importante que entiendan esto aclararemos con otro ejemplo reiniciemos el OLLY y apretamos la barra espaciadora y escribamos como primera línea solo para entender esto CALL 401245

Alli esta ahora podemos practicar hacer FOLLOW para la rutina por dentro

Vemos que como modificamos el programa la rutina ahora empieza en 401245 y terminara en el RET de 401288 (que es un RETN10 un poco diferente a un RET común, pero no es eso el tema de esta explicación ya lo veremos mas adelante lo que quiero que vean es lo que pasa cuando entramos en un call como en este caso y dentro de la rutina entramos en un segundo CALL. Bueno ya hicimos FOLLOW y miramos ahora apretemos MENOS para volver y ahora si apretemos F7 para entrar ejecutando.

Allí estamos y EIP apunta a 401245 que es la próxima instrucción a ejecutarse

Y en el stack vemos que en el primer lugar esta el valor de retorno a la línea siguiente del call que escribimos a mano.

Vemos que el valor esta, pero OLLYDBG no nos aclaro RETURN TO 401005, porque ocurre esto, es bueno entenderlo para saber como funciona OLLYDBG, como nosotros agregamos el CALL después del análisis inicial que el OLLYDBG había hecho, pues de esta forma, le hemos cambiado el caballo en el medio del río y lo hicimos ahogar jeje, por lo cual si queremos arreglarlo, debemos hacer en el listado en cualquier línea CLICK DERECHO- ANALICE CODE, con lo cual lo volverá a pensar después de los cambios que hemos introducido.

Vemos que después de reanalizar el código

Bueno nos dijo que volverá a MODULE ENTRY POINT + 5

Dicho valor es 401000 que era el ENTRY POINT mas 5 =401005 Es muy importante esto porque muchas veces uno le dice a una persona que le pide consejo, fíjate los RETURN TO …… en el stack, pero resulta que uno mismo ha modificado cosas o el mismo programa se ha auto modificado al ejecutarse entonces el análisis inicial del OLLYDBG fallara en las aclaraciones y debemos actualizarlo al detenernos, o quitar el análisis como vimos si nos trae problemas en la parte 1. Bueno aclarado esto volvemos a donde estábamos

Apreto F7 para entrar en el segundo CALL

Vemos que arriba de donde guardo la dirección de retorno del primer call ahora guarda la segunda dirección de retorno de este, en este caso están consecutivos, pero podría haber valores numéricos intermedios productos de PUSH o operaciones diversas, lo importante es que el primer RETURN TO .. que hallamos de arriba hacia abajo es la dirección de retorno del ultimo CALL que entramos y la segunda que hallemos bajando será la dirección de retorno del call anterior que es el inicial que escribimos. Esta es la idea de calls anidados o uno dentro de otro, si yo por poner un BREAKPOINT o por algún motivo parara aquí en el medio de la ejecución del programa, aunque no haya venido traceando ni tuviera información de cómo se vino ejecutando el programa al ver el stack , puedo sacar como conclusión

1) CAI AQUÍ Y VEO UN RET un poco mas abajo, supongo que estaré dentro de un CALL para confirmarlo miro el stack

2) MIRO EL STACK

Al mirarlo y buscar desde arriba del stack hacia abajo y hallar el primer RETURN TO se que el programa al llegar al RET volverá a 40124A.

Y además de saber donde volverá se que estoy dentro de la ejecución del CALL ANTERIOR al punto de retorno, o sea que el programa llamo a la zona donde estoy desde 401245 usando un CALL que llama a la rutina de 401362. Y no solo se eso si no que se también que antes de llegar a ese CALL, había entrado antes en otro ya que hay otro RETURN TO …. Mas abajo

Ese me informa que luego de ejecutar todo saldrá a 401005 y además se que el programa provenía del CALL de la línea anterior o sea

Solo parando y mirando el stack ya determine que el programa provino de aquí que entro en ese call, luego fue a 401245, allí había otro call que me llevo a 401362 y de esa forma llegue a la zona donde estoy. Esa forma de pensar en el cracking es muy útil porque me hace reconstruir la forma que el programa fue llegando a cierto punto, que muchas veces no son dos calls uno dentro de otro si no que hay 30 calls uno dentro de otro y uno no puede tracearlos todos, así que si caigo en un punto, puedo hacer un análisis personal, y llegar a la conclusión de cómo el programa arribo al punto donde me encuentro en este momento. Espero que haya quedado claro, lo de los CALL Y RETS les sugiero practicarlos repasarlo, si tienen dudas preguntar porque esto es muy importante, iba a terminar a continuación con los métodos de

direccionamientos y algunas instrucciones que quedaron en el tintero, pero preferiría que le den buena importancia a entender esto y en la próxima parte continuamos con los temas pendientes. Hasta la parte 8 Ricardo Narvaja 18 de noviembre de 2005 .

INTRODUCCIÓN AL CRACKING EN OLLYDBG PARTE 8 Trataremos en esta parte de ver rápidamente algunas instrucciones importantes para el cracking que nos quedaron en el tintero para terminar con las mismas y empezar a crackear. INTRUCCIONES PARA LOOPS O CICLOS Ciertamente se pueden realizar ciclos en un programa con las instrucciones ya vistas o sea ejecutando varias instrucciones, poniendo un contador por ejemplo en ECX y al final una comparación de si es cero y un salto condicional que si no es cero vuelva a repetirse el ciclo se disminuya ECX y así se repetirá hasta que ECX sea cero seria algo así: Xor ECX,ECX Add ECX,15 Eso seria para inicializar el contador de nuestro loop que sera puesto a 15, aquí comienza el LOOP en si DEC ECX Para disminuir ECX cada vez que se ejecute el loop Luego la ejecución de las instrucciones que se deben repetir Y luego TEST ECX,ECX JNE salta hacia el inicio del LOOP O sea que al testear si ECX es cero la primera vez será 14 ya que lo decremente una vez y al no ser cero volverá a repetirse, y así se repetirá hasta que ECX sea cero donde saldrá fuera del LOOP y continuará con la instrucción siguiente. Escribámoslo en OLLYDBG

Allí lo vemos la zona resaltada en amarillo es el loop en si, que se repetirá hasta que ECX sea cero, y entre 401008 y 40100C se deberían escribir las instrucciones que el programa desea repetir que aquí no interesan pues solo vemos el mecanismo de iteración del LOOP por eso dejamos NOPS alli. Si lo traceamos vemos que al apretar F7, ECX se pone a cero

Apreto F7 nuevamente y le sumo 15 para establecer la cantidad de iteraciones en ECX.

Luego apreto f7 hasta llegar al DEC ECX el cual al ejecutarlo pone ECX en 14 Luego llegamos hasta la comparación TEST ECX,ECX que sabemos que verifica si ECX es cero

Al no ser cero no se activa el FLAG Z y el JNZ salta hacia 401007, donde vuelve a decrementar ECX quedando en 13, puedo tracear así haciendo los loops hasta llegar al momento que ECX vale CERO Vemos que al ejecutar la comparación con ECX igual a cero se activa el FLAG Z lo que hace que el JNZ no salte

Recordemos que JNZ es el inverso de JZ que saltaba cuando se activaba el FLAG Z, el JNZ es el opuesto no salta cuando se activa el FLAG Z.

Allí lo vemos la flecha en gris indica que no va a saltar, al apretar F7 nuevamente sale del loop a la instrucción siguiente

Esa seria una forma sencilla de loop con las instrucciones ya vistas, aunque hay instrucciones especiales para eso. LOOP La instrucción LOOP nos ayuda a hacer algunas de las tareas que vimos en el ejemplo anterior, reemplazamos

En donde estaba DEC ECX hacemos CLICK DERECHO – BINARY NOP con los cual NOPEARA esa instrucción, lo mismo donde estaban TEST ECX,ECX y JNZ 401007, todas esas instrucciones pueden ser reemplazadas por una sola que es la INSTRUCCIÓN LOOP la cual compara si ECX es cero, si no lo es salta al operando en este caso 401007 y además decrementa ECX . Hagamos en la primera línea, CLICK DERECHO-NEW ORIGIN HERE para ejecutar mi nuevo LOOP. Vemos que al apretar f7 pone ECX a cero luego le suma 15 igual que antes para marcar la cantidad de iteraciones o repeticiones. Ahora traceo y llego hasta la instrucción LOOP

Vemos que igual que antes al no ser ECX igual a cero, salta a 401007, pero no solo compara si es cero y salta, también vemos que decrementa ECX ya que volvió siendo 14. Si traceamos hasta que llega a LOOP pero valiendo ECX igual a cero veremos como se repite el ciclo.

En el momento que ECX vale cero ya no se repite mas el LOOP y al apretar F7 continua con la ejecución de la instrucción subsiguiente.

Luego tenemos variaciones de la instrucción LOOP estas son

LOOPZ salta o mantiene dentro del bucle mientras que el flag Z sea cero cada vez que se ejecute la instrucción LOOP, y la opuesta LOOPNZ mientras que el FLAG Z sea 1, en este tipo de ciclo hay ademas contador que se decrementa y se sale por alguna comparación anterior que ponga el FLAG Z a cero en el primer caso o a 1 en el segundo o porque ECX llegue a cero por cualquiera de ambos casos. INSTRUCCIONES PARA EL MANEJO DE CADENAS de BYTES Aquí vemos las mas importantes las aclaramos debajo MOVS Esta instrucción, lo que hace es mover el contenido de ESI al contenido de EDI, realmente no necesita ningún parámetro, pero al escribir en OLLY la instrucción MOVS y apretar ASSEMBLE, la completa (innecesariamente) al ensamblar y queda como

MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI] Allí vemos el ejemplo que escribí

Inicializo antes ESI con la dirección de donde se va a leer o ORIGEN y EDI con el DESTINO o donde se copiará Podemos mirar en el DUMP el contenido de ambos para ver como va a ser cuando lo ejecute En el DUMP puedo hacer GOTO EXPRESIÓN=40366C o bien lo mismo y mas rápido FOLLOW IN DUMP- INMEDIATE CONSTANT que mostrara en el dump la constante 40366C

Allí vemos los bytes que apunta ESI o sea los de ORIGEN o que van a ser copiados. Y EDI apunta a

Allí deberían copiarse seria el DESTINO. Si apreto F7 hasta que ejecuto el MOVS vemos que se copiaron los 4 bytes.

Así mismo como el comando MOVS mueve los 4 bytes o sea el DWORD, tambien existe MOVSW (mueve 2 bytes) y MOVSB (mueve un solo byte) en la misma forma que funciona MOVS. REP Es un prefijo que se agrega a ciertas instrucciones como la anterior y que significa que la instrucción se repetirá hasta que ECX sea cero, a la vez que cada vez que se ejecute la instrucción se decrementara ECX en uno y aumentaran ESI Y EDI en 4 para apuntar a los siguientes 4 bytes. Es muy util para copiar grandes cantidades de memoria de una zona del programa a otra. Modifiquemos el caso anterior y agreguémosle el REP

Además modifique la dirección de ORIGEN a 40365C para que copie desde allí, la dirección de destino sigue siendo 40369C, voy a la primera línea con NEW ORIGIN HERE y llego apretando F7 hasta el REP

La aclaración del OLLY nos muestra las direcciones de ORIGEN Y DESTINO y los contenidos que copiara, apreto F7

Allí se copiaron los 4 primeros bytes, pero no salimos de la instrucción ya que la misma se repetirá hasta que ECX sea cero y vemos que ahora ECX es 3, o sea disminuyo en uno, además ESI y EDI se incrementaron en 4, para apuntar a los 4 siguientes bytes.

Apreto F7 nuevamente

Allí se copiaron los siguientes 4 bytes y ECX quedo en 2

Si sigo apretando F7 una vez mas ECX será 1

Y nuevamente

Vemos que dejo de repetir y paso a la siguiente instrucción ya que ECX vale cero.

Vemos como se copiaron los bytes del ORIGEN al DESTINO y que se repitió 4 veces la operación gracias a la instrucción REP. Es de aclarar que esta vez, busque una sección de destino con permiso de escritura ya que si no fuera así, como en veces anteriores al ejecutar la instrucción nos daría una excepción. Además de la instrucción REP existen variantes como REPE o REPZ que repite hasta que el flag Z se pone a cero y REPNZ repite hasta que el flag Z no sea cero, o si ECX es cero también sale por cualquiera de las dos posibilidades, aunque estas variantes de REP no sirven para el caso de la instrucción MOVS si no para otras que veremos a continuación.

LODS Esta instrucción lo que hace es mover los bytes que apunta ESI, o sea su contenido a EAX

Vemos en este ejemplo que al llegar a LODS (que OLLY escribe como LODS DWORD PTR DS:[ESI]) Y vemos que ESI apunta a 40365C lo cual vemos en la aclaración del OLLY

Y en el DUMP miramos

Esos son los 4 bytes que moverá a EAX, apreto F7.

Al ejecutar con F7, vemos que EAX tomo ese valor.

También a LODS se le puede agregar delante el REP y como en el caso anterior repetirá hasta que ECX sea cero, y leerá a partir de ESI los bytes, y los movera a EAX. Al llegar a REP LODS

Nos muestra los bytes que apunta ESI y que serán transferidos a EAX si apreto F7

ECX se disminuyo a 3 y ESI se incremento 4 para apuntar a los siguientes 4 bytes que se moverán a EAX y así se repite hasta que ECX vale cero y sigue ejecutando la siguiente línea. También existen las versiones para copiar 2 bytes LODSW y para copiar 1 byte LODSB STOS En este caso COPIA al contenido de EDI, el valor que hay en EAX.

Al ejecutar este ejemplo y llegar a STOS

Nos muestra EAX y el destino EDI en su contenido se copiaran. Al ejecutar

Allí se copiaron al DESTINO, también al igual que los casos anteriores se le puede agregar REP delante para repetir y existen STOSW y STOSB para copiar dos bytes o un solo byte. CMPS Compara el contenido de ESI con el contenido de EDI

OLLY la escribe como CMPS DWORD PTR DS:[ESI],DWORD PTR ES:[EDI] Si llego traceando con F7 hasta el CMPS la aclaración del OLLY nos muestra lo que va a comparar

Como la comparación en si sabemos que es una resta de ambos y como en mi caso son iguales el resultado es cero y activa el FLAGZ

En este caso si se puede utilizar REPE o REPZ que comparara hasta que el FLAGZ sea cero o ECX sea cero en cualquiera de ambos estados saldrá del REPE.

En mi caso, de anteriores ejemplos había quedado en 40365C y 40369c lo que vemos en mi DUMP. Y escribo, poniendo ECX a 10 ya que en todos los casos al llegar ECX a cero teminará la repetición, solo que en el caso de REPE, también finalizara según el estado del FLAG Z.

Llego hasta el REPE apretando F7 y en mi caso ambos operandos son iguales por lo cual la diferencia será cero y se activara el FLAG Z .

Vemos que para REPE si el FLAG Z esta a 1 o sea son iguales no nos saca de la repetición, apreto F7 Si seguimos apretando llega el momento en que ambos operandos son diferentes

En ese caso al apretar F7 el FLAG Z se pone a 0 y sale de la repetición

Si hubiéramos llegado a ECX igual a cero, siempre comparando operandos iguales, en ese caso saldría al ser ECX igual a cero también. Como habíamos dicho existe también el REPNZ que salta al ser el flag Z igual a 1 o sea cuando en la comparación ambos operandos son iguales. Creo que con esto hemos hecho un estudio bastante detallado de las instrucciones mas importantes, solo dejamos para mas adelante las instrucciones de PUNTO FLOTANTE para no complicar por ahora la cosa, espero que lo hayan entendido y que practiquen cada instrucción hasta que sepan bien que hace sin dudar. MODOS DE DIRECCIONAMIENTO DIRECTO: Es el modo más comúnmente utilizado, para referirnos a una dirección de memoria, en la instrucción escribimos su valor.

mov dword ptr [00513450], ecx mov ax, word ptr [00510A25] mov al, byte ptr [00402811] CALL 452200 JMP 421000

En este caso no tenemos ningún problema de interpretar cual es la dirección de memoria donde el programa guardara, moverá, saltara o ejecutara una rutina pues esta a la vista. INDIRECTO:

mov dword ptr [eax], ecx CALL EAX JMP [ebx + 4] Estas instrucciones si las vemos aquí no nos dicen en que dirección se guardaran, o donde saltara o estará la rutina del CALL, solo estando parado debuggeando con OLLYDBG justo en esa instrucción y viendo los valores que en ese momento tienen los registros, se podrá saber y OLLYDBG nos los mostrara en la aclaración cual es la dirección.

En muchos programa se utiliza el direccionamiento indirecto como una forma de complicar el trabajo del cracker ya que el análisis que OLLYDBG hace al inicio del programa, no nos dará información de estas instrucciones ya que hasta que no llegue a ejecutarlas no sabrá cual es el valor circunstancial de los registros. Solo poniendo un BREAKPOINT o llegando traceando hasta alguna de estas instrucciones, en dicho punto se sabrá el valor de la dirección, hagamos un ejemplo, reiniciemos el OLLYDBG con el crackme de cruehead

Allí vemos un PUSH [ebp+8] Como estoy en el inicio o ENTRY POINT del programa no se cuanto valdrá EBPcuando llegue a esa instrucción, por lo cual no tengo ni idea de que pusheara allí, voy a la línea con GOTO EXPRESIÓN 401009 y apreto F2 para colocar un BREAKPOINT. Luego apreto F9 que es RUN y parara en el BREAKPOINT al pasar por alli.

Allí paro y OLLY en la aclaración nos muestra que en mi maquina EBP+8 es 12FFF8 ya que EBP vale en este momento 12FFF0 al sumarle 8 dará 12FFF8 en mi maquina, en la suya puede tener otro valor pero será igual siempre a EBP+8.

PUSH [ebp+8] es hacer PUSH el contenido de 12FFF8 si veo en el DUMP dicha posición de memoria con GOTO EXPRESIÓN 12FFF8

Y el contenido será

Por lo cual ese será el valor PUSHEADO si apreto F7 veo que lo coloca en el stack

El mismo caso se da en cualquier instrucción indirecta solo podemos calcular las direcciones que utilizara al estar justo ejecutando dicha instrucción. Existen otros Modos de direccionamiento pero en cierta forma ya fueron explicados junto con las instrucciones por lo cual no repetiremos ni agregaremos mas nada. Creo que el que sobrevivió a todo lo anterior y lo entendió bien tiene grandes probabilidades de éxito en el mundo del cracking no sin antes practicar y leer mucho pero, lo anterior es lo básico, a partir de la parte 9 ya ingresaremos en el apasionante mundo de la practica del cracking, por favor repasen bien las 8 partes estas a FULL. Hasta la parte 9 Ricardo Narvaja 20 de noviembre de 2005

INTRODUCCION AL CRACKING CON OLLYDBG PARTE 9 Bueno ya hemos terminado de explicar las instrucciones assembler y ahora se nos presenta una disyuntiva, por donde seguir, hay muchísimo que aprender y practicar, por lo cual trataremos de ir como siempre pasito a pasito, sin apuros usando lo que aprendimos, y agregando mas cosas que faltan aun. Por supuesto nuestra primera victima será el famoso CRACKME DE CRUEHEAD pero no nos limitaremos solo a ir viendo las distintas formas de crackearlo, si no también que nos iremos ubicando con conceptos que luego nos serán básicos a la hora de profundizar en el arte. Abramos el famoso crackme en OLLYDBG y orientémonos un poco antes de empezar. Veremos en el mismo crackme algunas definiciones que son útiles para cualquier programa. ENTRY POINT: Es la primera línea que se ejecuta del programa normalmente, no confundir con OEP (Original Entry Point) que es otra cosa que definiremos en partes posteriores de esta introducción, o sea si abrimos un programa en OLLYDBG, este para y lo analiza, allí donde termina de analizar y queda detenido es el ENTRY POINT del programa.

En nuestro caso del Crackme de Cruehead, el ENTRY POINT será 401000 y OLLYDBG nos muestra en el margen inferior que normalmente usa para avisarnos porque esta detenido un programa, que en este caso estamos detenidos en el ENTRY POINT.

Casi todos los programas (el 99 %), cuando arrancan en OLLYDBG se detienen en el ENTRY POINT, los que no lo hacen es porque tienen alguna modificación especial realizada para evitar que pare en el mismo, ese tipo de trucos veremos mas adelante, pero la idea es saber esto. Otro concepto que necesitamos y que usaremos en el de DLLs y sus APIS

Vemos que en ciertos puntos del programa el mismo nos muestra una CALL o JMP que salta en vez de a una dirección como normalmente vimos por ejemplo CALL 401020 o JMP 421367, en la imagen anterior vemos que el call por ejemplo es CALL LoadIconA Y a la derecha nos muestra cierta información, pero que es en este caso LoadIconA? El sistema WINDOWS utiliza para evitar que los programadores repitan las mismas rutinas que en casi todos los programas son usadas, un sistema de archivos de extensión DLL que son archivos ejecutables, pero además tienen la propiedad de tener FUNCIONES DE EXPORTACION O APIS que no son mas que funciones que pueden ser utilizadas por cualquier programa, para tener que evitar repetir lo mismo en todos los programas. Así en este caso llama a la DLL user32.dll y ella tiene una función denominada LoadIconA, que realizara cierto trabajo para facilitarme la programación. El caso mas sencillo de entender es la api MessageBoxA Si en la commandbar del OLLYBD tipeo

Nos muestra la dirección de dicha api, si voy a mirar a dicha dirección en el listado haciendo CLICK DERECHO y copiando la dirección que salio en sus maquinas ya que puede variar en cada una.

Allí tipeo la dirección que en mi maquina apareció

USUARIOS DE WINDOWS 98 no hace esto ya verán porque

Allí vemos que pertenece a la dll llamada USER32.dll y que no es mas que una rutina que termina en un RET, lo único que nos salva esto es de tener que agregar toda esta rutina en nuestro programa, así se hacen programas mas pequeños y se nos facilita la vida a los crackers jeje. Si apreto la tecla MENOS volveré al punto donde estaba anteriormente y puedo verificar también que si hago GOTO EXPRESIÓN y directamente tipeo MessageBoxA en dicha ventana nos lleva al mismo lugar,

Allí vemos la rutina de la api MessageBoxA correspondiente a USER32.dll Como verán tuve que tipear MessageBoxA y no messageboxa ya que el nombre de la api es reconocido por OLLYDBG si tipeamos en forma correcta sus mayúsculas y minúsculas, y la pregunta siguiente es pensar como se como se escribe una api cuales son mayúsculas y minúsculas en su nombre, pues es sencillo. Volvamos con MENOS al ENTRY POINT

Haciendo en el listado CLICK DERECHO-SEARCH FOR NAME (label) in CURRENT MODULE nos dará la lista de Apis o NAMES utilizadas por este CRACKME DE CRUEHEAD.

Para encontrar la que quiero no necesito bajar y buscarla a mano solo en esta ventana apretando la M

Vemos que el cursor se acomoda en la primera api que empieza con M si a continuación sigo tipeando letras del nombre de la api,

Arriba nos va marcando las letras que tipeamos y el cursor halla la api

Si hago click derecho encima del nombre de la api tengo diferentes opciones

Si elijo FOLLOW IMPORT IN DISSASSEMBLER nos llevara a la dirección de la api, este es otro método para llegar a la dirección, si no tenemos ganas de tipear en la comandbar.

Aquí vemos un común error que cometen muchos que recién se inician, si allí en la api hago SEARCH FOR NAME (LABEL) IN CURRENT MODULE

OLLYDBG buscara en este caso las APIS o NAMES correspondientes a USER32.dll ya que allí lo especifica busca en el MODULO que esta visible en el listado, CURRENT MODULE y el que esta visible cuando estamos en la api es USER32.dll lo podemos ver en el mismo OLLYDBG arriba

Aun cuando nosotros no estemos ejecutando en este momento la api y solo mirando al buscar NAMES saldran las de USER32.dll que no son las que en este momento nos interesan, por lo tanto si queremos volver a ver las apis del Crackme de Cruehead debemos apretar MENOS hasta volver a ver el listado del CRACKME por ejemplo en el ENTRY POINT y allí si, si hacemos SEARCH FOR NAMES nos mostrara las apis del mismo. PARA WINDOWS NT/2000, XP o 2003 A PARTIR DE AQUÍ EL TUTORIAL CONTINUA PARA SISTEMAS NT/2000 y XP, les recomiendo a los que tienen WINDOWS 95 o 98 pasarse a cualquiera de esos sistemas, que allí es donde OLLYDBG es mas potente, pero si no pueden hacerlo salteen esta parte y vayan a donde dice APENDICE PARA WINDOWS 98

Vemos que cuando estoy en la lista de apis del crackme otra opción es poner un BREAKPOINT en dicha api, asi cuando el programa llama a la misma parara, hagámoslo con CLICK DERECHO-TOGGLE BREAKPOINT ON IMPORT. También podríamos hacerlo directamente en la commandbar tipeando Bp MessageBoxA

Si ahora vemos la direccion de la api apreciamos que se ha puesto un BREAKPOINT en la dirección de inicio de la misma, de esta forma si la api es usada parara OLLYDBG en ella, apretemos F9 para correr el CRACKME DE CRUEHEAD y ver si para alli.

Vemos que aparece la ventanita y aun no paro vayamos a HELP-REGISTER

En la ventana tipeemos algún nombre y serial falso y apretemos OK Vemos que el OLLYDBG paro veamos porque En la esquina inferior derecha vemos que esta PAUSADO

Y en la esquina inferior izquierda siempre nos muestra el motivo porque paro.

Allí dice BREAKPOINT en USER32.MessageBoxA o sea que paro en nuestro BREAKPOINT en la API.

Vemos que OLLYDBG nos muestra información ya que cada api se llama con determinados parámetros que se pasan al stack antes de llamarla, y en este caso vemos En la primera línea la dirección de retorno del CALL que nos hizo llegar aquí en este caso 4013C1

Como vimos cuando explicamos CALL Y RET siempre se pasa al stack la dirección de retorno del mismo, y allí esta cuando llegue al RET de la api volverá a 4013c1. Luego abajo los parámetros de la misma nos muestran entre otras cosas ya que la api MessageboxA es la encargada de mostrarnos los típicos cartelitos de mensajes de Windows, el titulo del mensaje, el texto, el estilo etc. Ya vemos que el TEXTO es NO LUCK THERE, MATE que es el cartel que coloca el Crackme de Cruehead cuando el serial que introdujiste no es correcto. Pues allí estamos y el crackme esta a punto de mostrarnos el fatídico cartelito.

Para que vean que no le miento y que la api es la encargada de hacerlo, pongamos un BREAKPOINT en el RET 10 que es el final de la api, allí lo vemos debajo, en su maquina puede cambiar pero siempre es el primer RET a partir de la dirección de inicio de la api que vemos al ir bajando.

Allí tenemos la api cercada apretemos F9 o RUN.

Allí vemos el típico cartelito de la MessageboxA y como nos aviso OLLYDBG el titulo es NO LUCK! Y el texto NO LUCK THERE MATE! o sea que no tuvimos suerte con nuestro serial. Por supuesto al aceptar para en el RET de la api

Como vimos el proceso de aparición del cartel, ocurrió entre el inicio y final de la api, allí estamos en el RETN10. Ya que no aclaramos la diferencia entre en RETN 10 y el RET común lo haremos aquí en este caso si el RET fuera común, al ejecutarlo, volvería a la dirección de retorno 4013C1

Y al quitar el valor de la dirección de retorno de arriba del stack, este quedaría en mi caso en 12Fe90, en el caso del RETN10 vuelve a la misma dirección 4013C1, pero a ESP se le suma 10 con lo cual el stack debería quedar en 12fe90 mas 10 seria esp=12fea0 veamos apretemos F7. RETORNO DEL APÉNDICE PARA WINDOWS 98 desde aquí sigue para todos los SO.

Allí retornamos de la api al crackme y vemos que en el stack se cumplió lo que mostramos el RETN 10 le suma a ESP 10 mas de lo que valdría si retorna como RET solo.

La cuestión es que la decisión ya fue tomada y nosotros estamos en el horno, ya nos dijo mala suerte amigo, el serial que tipeaste no sirve. Apretemos F9 nuevamente

Vemos que para nuevamente en la api, y que por si no me di cuenta me va a decir que no tuve suerte jeje

Vemos que en este caso la dilección de retorno es 40137d veamos que hay allí con GOTO EXPRESIÓN 40137D en el listado o bien en la primera línea del stack CLICK DERECHO- FOLLOW IN DISASSEMBLER

Alli vemos que volveria a 40137D y que estamos dentro del call que llama a MessageboxA que esta justo arriba en 401378.

Vemos arriba que hay otro MessageBoxA pero con el mensaje de felicitación de que acertamos GREAT WORK, jeje si pudiéramos llegar allí en vez de al cartel de que no tuvimos suerte seria un primer gran paso.

Vemos que OLLYDBG en su análisis inicial nos muestra unos corchetes, que significa que eso es una rutina que empieza y termina allí, vemos que hay dos, una para el cartel de NO LUCK que empieza en 401362 y otra para el GREAT WORK que empieza en 40134D. Si vamos a 401362 que es el inicio de la rutina donde estamos (aun dentro del MessageBoxA) y hago click allí el OLLYDBG me muestra en las aclaraciones.

Quiere decir que OLLYDBG sabe que esa rutina ya que es DIRECTA es llamada desde 401245 veamos allí que hay CLICK DERECHO – GOTO CALL FROM 401245.

Hmm esta zona parece muy sospechosa hay una comparación y un salto y según el resultado de ese salto va al call de 401362 que es el que muestra NO LUCK y si no va al CALL 40134D que muestra GREAT WORK, esto no podemos perderlo pongamos un BREAKPOINT en dicho salto condicional.

Y quitemos los breakpoints en la api MessageBoxA por ahora, eso puede hacerse en la ventana B de breakpoints

Quito CON CLICK DERECHO-REMOVE los dos BREAKPOINTS y dejo solo el de 401243 que es el salto condicional.

Ahora doy RUN con F9 acepto el NO LUCK que estábamos antes y vuelvo a ingresar a poner el nombre y serial en este caso pondré, usen el mismo que yo, ya verán porque

Apreto OK

Vemos que de la comparación NO SALTARA al no ser EAX y EBX iguales y seguirá ejecutando en 401245 que nos llevara a CALL 401362 que sabemos que allí esta el cartel malo, si no recuerdan, hagan click en 401245 y con CLICK DERECHO –FOLLOW pueden ver adonde iria .

Allí vemos si ese salto condicional no salta pues, ira al cartel deqque el serial es malo, que pasa si cambio el salto condicional, haciendo doble click en el flag Z

Allí cambie el FLAG Z a 1 que seria como si EAX y ECX en la comparación hubieran sido iguales y la resta de la comparación hubiera sido cero y hubiera activado así el flag Z, el salto JE salta si el FLAG Z es uno, así que ahora saltara veamos.

Allí lo cambiamos y si vemos en 40124c con FOLLOW vemos que ira a

Jeje apretemos RUN o F9

O sea que esa comparación y ese salto condicional que invertimos es el punto de inflexión de la registración o validación del serial en este crackme, según si salta o no, pues sale el cartel bueno o malo, pero antes habíamos visto que había 2 carteles malos porque es eso, aquí no salio el primero, y eso es porque el crackme detecta el uso de números en el nombre (antes había puesto como nombre ricnar456) si es así te saca un primer cartel de NO LUCK, prueben nuevamente.

Al aceptar

Y recién al aceptar este primero, llega al salto condicional

Que muestra el mensaje definitivo. Como podemos recordar la primera vez que paramos en la api MessageBoxA en este tute fue por el primer cartel ese

Y la dirección de retorno era 4013C1

Allí vemos que el OLLYDBG en su análisis me muestra una rutina que comienza en 40137e y termina en 4013C1 justo donde retorna de la api. Vemos también otra ayuda de OLLYDBG en 4013AC hay un > que significa que hay un salto que apunta hacia esa dirección si hacemos click allí nos aclarara mas.

Allí vemos ora comparación y un salto condicional que nos llevan al cartel maldito pongamos otro BREAKPOINT allí.

Y demos RUN acepto el cartel malo anterior y voy a poner de nuevo

Al aceptar

Vemos que no saltara la primera vez que para hacia el cartel malo, aunque si compara cada letra que tipee a ver si son números parara una vez por cada letra, F9 nuevamente A la 7ma vez que apreto recordar que en ricnar456 el 4 es la séptima letra me quiere mostrar el cartel malo saltando

Habíamos visto que los JB saltan si es mas bajo y se activa el FLAG C, hago doble click en el FLAG C

Ahora ya no salta, apreto F9 y repito el mismo procedimiento para los otros dos números que puse en mi nombre fuerzo que nunca salte.

Luego de eso si llego a la comparación final y la cual debe saltar hago doble click en Z

Y al apretar F9

Ahora por supuesto todo esto lo hemos hecho en memoria cambiando FLAGS, como hacemos para guardar definitivos estos cambios y que el crackme acepte cualquier user y serial sin OLLYDBG. Vayamos al primer salto

Lo que nosotros hemos hecho en este salto es forzarlo mediante los flags a que no salte nunca a pesar de los valores de la comparación, eso es similar a NOPEAR el salto condicional, si hago click allí, apreto la barra espaciadora y escribo NOP.

Vemos que nunca saltara quito ese BREAKPOINT apretando F2

Ahora veamos el otro salto

En esta caso fue al revés lo forzamos a saltar siempre mediante la manipulación del FLAG Z, lo cual seria equivalente a cambiar el salto condicional por un JMP.

Allí siempre saltara, quitamos también el breakpoint y sin salir de OLLYDBG probamos si quedo bien, apreto F9

Al apretar OK

Igual recordamos que cuando escribimos en OLLY con la barra espaciadora o ASSEMBLE los cambios desaparecían al reiniciar, tenemos que hallar la forma de que los guarde de la memoria al archivo definitivo, eso se hace de la siguiente manera

CLICK DERECHO en cualquier parte del listado COPY TO EXECUTABLE-ALL MODIFICATIONS allí se nos abre esto

Elegimos COPY ALL para que copie los dos cambios que hicimos

Se nos abre otra ventana, allí hacemos nuevamente CLICK DERECHO-SAVE FILE

Lo guardamos con OTRO NOMBRE para tener el original para seguir practicando le pondré CRACKME 2

Cierro el OLLYDBG y veo que al lado de donde tenia el crackme esta el crackme2

Hago doble click en el crackme2 a ver si quedo bien modificado lo corro sin OLLYDBG.

Voy REGISTER

Apreto OK

Jeje ahí tengo el crackme parcheado pero aun no me conformare con esto, mas adelante veremos como trabaja con los seriales y como compara si en el nombre hay números, exhaustivamente y hallaremos seriales correctos para nuestro nombre que los acepte sin parchear pero para llegar a eso aun faltan algunos conocimientos y practicas anteriores. APÉNDICE PARA WINDOWS 98 Bueno usar OLLYDBG en w98 como ya les dije es bastante limitado, el mismo sistema no nos deja poner BREAKPOINTS en las apis directamente como en w98, por lo tanto el método será similar con la única limitación que ustedes no podrán poner BREAKPOINT en la api, si hacen CLICK DERECHO SEARCH FOR NAME (labels) in this module como dice allí la primera parte de la explicación para XP

Les saldrá la misma lista y de la misma forma apretando el nombre de la api llegaran hasta el nombre de la misma, pero en 98 no pueden hacer CLICK DERECHO-TOGGLE BREAKPOINT ON IMPORT ya que no permite poner BREAKPOINTS en las apis, si no que deberán hacer.

Creo que el menú es similar si no siempre tendrá la opción para BUSCAR LAS REFERENCIAS o sea los llamados a la api en el crackme.

Esto es limitadísimo comparado con la posibilidad de poner un BREAKPOINT en la API, porque si la API es llamada, si hay un BP en la API parara, en cambio en 98, la API puede ser llamada en alguna forma que engañe el análisis del OLLYDBG (y hay muchas formas créanlo) y no saldrá dicha llamada entre las referencias y no tendrán forma de saber de donde fue llamada la api ni parara. Igual pueden seguir este tute de la misma forma sabiendo que hay tres llamadas a la api MessageboxA y en vez de poner UN BREAKPOINT en la api, pongo un BP en cada referencia a la api, allí en el cuadro de referencias apreto F2 en cada una,

Al dar Run voy a HELP-REGISTER tipeo estos datos

Y al apretar OK parara

Luego en XP ponemos un BP en el RET de la api o donde termina la misma, eso equivale en 98 a poner un BP en el RET que esta justo debajo ya que no podemos entrar a la api.

Pues ya saben cuando el el tute dice que esta en el inicio de la api y ve a donde retorna ustedes saben que retorna en este caso a 4013C1 al ret que esta justo abajo y si es en otra referencia sera el RET que esta debajo correspondiente. Sabiendo esto ya pueden retornar a RETORNO DEL APÉNDICE PARA WINDOWS 98 desde aquí sigue para todos los SO. Y continuar el tute desde allí siempre sabiendo la diferencia principal que es que en W98 no podemos poner BPX o BREAKPOINTS en las apis si no en las referencias. Hasta la parte 10 Ricardo Narvaja 22 de noviembre de 2005

INTRODUCCIÓN AL CRACKING EN OLLYDBG PARTE 10 BREAKPOINTS EN OLLYDBG Esta parte la dedicaremos a entender los diferentes tipos de BREAKPOINTS en OLLYDBG, entendiendo por BREAKPOINTS las herramientas que trae OLLY para ayudarnos a detener la ejecución del programa en donde nosotros deseamos, para los cual usamos uno de los diferentes tipos de Breakpoint que estudiaremos a continuación, para lo cual usaremos como victima el inefable Crackme de Cruehead. BREAKPOINT COMUN o BPX Es el Breakpoint común que hemos utilizado hasta ahora, también llamado BPX por su similitud a la forma de tipearlo en SOFTICE, muchas veces se utiliza la sigla BPX como abreviatura de BREAKPOINT, aunque estrictamente en OLLYDBG se tipea BP. Normalmente se puede colocar marcando la línea que queremos ponerle el BPX y apretando F2, si apretamos F2 nuevamente se quitara. Miremos el CRACKME DE CRUEHEAD en el ENTRY POINT

Si marco por ejemplo 401018 y apreto F2, pues se marca en rojo la dirección para señalarnos que hay un BPX y además en la ventana B que es la lista de BPX que hemos colocado, se nos mostrara.

Vemos que nos muestra que esta activo

En la columna ACTIVE nos dice que ALWAYS que significa que parara SIEMPRE que pase por allí o sea que esta activo. Si hacemos Click derecho sobre el BPX podemos ver las opciones que tenemos para manejar el BREAKPOINT

REMOVE: para quitarlo de la lista totalmente DISABLE: Para que quede en la lista de BREAKPOINTS pero deshabilitado, o sea no parara allí cuando pase por esa dirección. EDIT CONDITION: Para transformarlo en un BREAKPOINT CONDICIONAL que mas adelante ya veremos que es. FOLLOW IN DISASSEMBLER: Para buscar la dirección en el listado del breakpoint que marcamos. DISABLE ALL o ENABLE ALL: Deshabilitar o habilitar todos, en este caso habilitar todos no aparece porque el único existente esta habilitado. COPY TO CLIPBOARD: para copiar al portapapeles los datos sobre el BPX marcado, si elegimos esta opción y pegamos aquí por ejemplo.

Elijo WHOLE LINE o sea que copie toda la linea, WHOLE TABLE copiara toda la lista de BREAKPOINTS. Breakpoints, item 0 Address=00401018 Module=CRACKME Active=Always Disassembly=OR EAX,EAX Lo copiado y pegado aquí muestra los datos de ese BREAKPOINT como la instrucción donde fue colocado, su dirección, si esta activo etc. Ya vimos que si doy RUN con F9, parara en la dirección del BPX si se ejecuta, en este caso para. Allí paro

Y OLLY nos dice que esta PAUSADO

Y a la izquierda nos muestra el motivo porque paro

Ahora estrictamente el BPX que es ?, veamos si realiza OLLYDBG algun cambio en el codigo al activarlo. Si hago click derecho FOLLOW IN DUMP-SELECTION

Podremos ver la direccion 401018 y su contenido en el DUMP

Aparentemente no hay cambios con respecto a los que vemos en el listado

Allí vemos tanto en el DUMP como en el listado los bytes 0B C0 correspondientes a la instrucción OR EAX,EAX asi que no hay cambios parece pero es así realmente? Reiniciemos el crackme y veamos que el BPX continúe puesto en 401018

Voy a escribir una línea que leerá de la memoria realmente el valor que hay allí.

Eso leerá el contenido de 401018 y lo moverá a EAX, veamos que dice la aclaración de OLLY

Tanto en el DUMP como en la aclaración nos muestra 0B C0 los bytes originales, pero aun desconfío, apreto F7 para ver que mueve a EAX.

Como no era que en 401018 estaban los bytes 0B C0 74 01 ?, alguien esta mintiendo aquí pues esos bytes al revés son 0174C00B y el valor que movió a EAX es 0174C0CC, o sea que realmente en 401018 no hay un B0 cuando pongo un BREAKPOINT, OLLYDBG lo reemplaza por el valor CC que mas adelante cuando veamos el estudio de las excepciones, veremos bien que significa, pero OJO a pesar de que OLLYDBG para no ensuciar el listado original, no lo cambia ni en el DUMP, ni en las aclaraciones, cada vez que ponemos un BP estamos colocando el byte 0CC en la dirección del BPX y eso como ven puede ser fácilmente detectado por un programa que verifique si en esa dirección hay un CC en vez del código original, y de esa forma detecta que hay un debugger y puede evitar que corra el programa saltando si encuentra un CC a la salida del mismo.

Así que no se confíen, recuerden siempre que si apretamos F2 cambiamos código aunque OLLY mantenga todo igual y el programa continúe, dicho BREAKPOINT puede ser detectado, si en algún programa ven que al colocarle un BREAKPOINT no corre pues quítenlo hay otras posibilidades en OLLYDBG para parar donde queremos. También un BREAKPOINT se puede tipear en la commandbar BP 401018

En NT, 2000, XP y 2003 no hay problemas para colocar BP en las apis como vimos en partes anteriores podemos poner un BP en la api MessageBoxA, tipeando

Lo escribimos respetando las mayúsculas y minúsculas del nombre de la api, en Windows 98 en cambio ya que no se puede colocar breakpoint en las apis se tipea.

Lo cual nos pone BREAKPOINTS en las referencias o llamadas que el programa haga a la api y que OLLYDBG pueda detectar, lo cual no es muy bueno, pero en 98 no hay otra posibilidad. Por supuesto el comando BPX existe también en XP aunque no es usado prácticamente, porque siempre es mas poderoso colocar un BP en la misma api que en las llamadas a la misma que OLLYDBG pueda detectar. Igual vemos que coloco algunas

Allí en la lista de BREAKPOINTS al apretar BPX MessageBoxA encontró tres llamadas a dicha api y le puso un BP a cada una. De cualquier forma aclaro que este comando no lo usare casi nunca al no trabajar en WINDOWS 98, y siempre que me refiera a un BREAKPOINT o BPX me refiero a tipear BP en la comandbar. La ultima forma de colocar un BP es con el Mouse haciendo doble click en la línea que queremos colocarlo, en la columna donde están los bytes de la instrucción, al hacer doble click nuevamente se quita.

BREAKPOINTS ON MEMORY (MEMORY BREAKPOINTS O BREAKPOINTS EN MEMORIA) Bueno pasemos a los MEMORY BREAKPOINTS o también llamados BPM por BREAKPOINT ON MEMORY (algunos viejos memoriosos no confundir con los BPM del SOFTICE que son otra cosa) Bueno como funcionan,al colocarlos OLLYDBG lo que hace es cambiarle el permiso de una sección o parte de la misma, según el permiso que le demos, podemos colocar BPM ON ACCESS que detendrá la ejecución, cuando se acceda al sector al cual le colocamos el BPM, o sea parara cuando ejecute esos bytes o cuando lea o escriba en los mismos. También existe el BPM ON WRITE que para solo cuando escribe en la zona que colocamos el BPM, veremos algunos ejemplos prácticos.

Allí estoy en el ENTRY POINT del Crackme de Cruehead, y pondré distintos BPM, para ver la utilidad de los mismos. En el DUMP voy a ver la dirección 4020CA con GO TO EXPRESIÓN : 4020CA

Allí la veo, puedo colocar un BPM ON ACCESS en los 4 bytes del contenido de la dirección 4020CA, y dar RUN, supuestamente parara o bien cuando lea de 4020CA, o cuando escriba en 4020CA o si ejecuta alguna instrucción en 4020CA, para colocar el BPM marco los bytes que quiero que abarque en este caso marco cuatro.

Ahí están marcados, hago click derecho BREAKPOINT-MEMORY ON ACCESS que es poner un BPM ON ACCESS en los bytes que marque, que en este caso son 4 pero podrían ser mas o menos según lo que nos convenga, o sea podemos marcar zonas mas grandes, y colocarles BPM en la misma forma.

Lo único molesto que tienen los BPM es que no figuran en la ventana B de breakpoints ni en ninguna parte en OLLY, por lo cual debemos recordar donde lo colocamos. A su vez OLLY permite solo un BPM a la vez por lo cual si colocamos un segundo, automáticamente borra el anterior. Bueno demos RUN y para en 401007 donde el programa trata de escribir en nuestra zona del BPM o sea en 4020CA.

Si vemos el motivo por cual paro, abajo en OLLYDBG nos dice

Esta por escribir el valor que esta en EAX al contenido de 4020CA, lo cual provoca que OLLYDBG pare, si recuerdan cuando tratábamos de escribir en la memoria y esta no tenia permiso de escritura, se generaba una excepción, pues eso es lo que básicamente hace OLLYDBG, al colocar un BPM ON ACCESS le quita el permiso de lectura y de escritura a esa zona, y al tratar de escribir o leer de allí, genera una excepción que detiene el programa, ya lo veremos mas claramente cuando veamos el capitulo de excepciones, pero es bueno que tengan una idea. Si apreto F7 ahora si guardara el valor ya que el mecanismo del OLLY es sofisticado y permite que una vez detenido, si se pueda escribir al apretar f7.

Allí esta guardo 400000 si doy RUN nuevamente como el BPM esta aun activo, parara si el programa vuelve a escribir o intenta leer este valor.

Vemos que ahora para allí, al tratar de leer de 4020CA en este caso nos dice MEMORY BREAKPOINT ON READING ya que paro al leer de allí.

Si apreto F7 lee el valor guardado y lo pasa a EAX

Apreto F9 a ver si alguna vez mas para.

Nuevamente para ON READING ya que lee el valor que hay en 4020CA y lo manda al stack con PUSH.

Ahora si quiero quitar el BPM que coloque hago click derecho en el DUMP y elijo BREAKPOINT-REMOVE MEMORY BREAKPOINT y con eso se quita, lo mismo como ya dijimos si colocamos uno nuevo.

En el caso anterior si al colocar el BREAKPOINT, hubiéramos elegido que sea ON WRITE o sea en escritura, OLLYDBG parara solo cuando escriba en la zona del BPM y no cuando lee. Otra opción que nos da OLLYDBG es colocar un BPM en una sección completa. Para ellos vamos a VIEW-MEMORY o a la ventana M que es lo mismo.

Allí vemos las secciones del crackme y mas abajo las secciones de las dlls y diferentes secciones utilizadas, podemos marcar la que deseemos por ejemplo, la sección que comienza en 401000 allí la vemos.

Hago click derecho en dicha sección y elijo SET MEMORY BREAKPOINT ON ACCESS.

Vemos que justo debajo tenemos la posibilidad de colocar también un BPM ON WRITE pero en este caso lo haremos ON ACCESS doy RUN.

Vemos que para en la siguiente línea veamos porque

Claro paro ON EXECUTION o sea el ejecutar, ya que pusimos el BPM en la sección que se ejecuta, pues al tratar de ejecutar alguna instrucción en dicha sección, para en este caso ON EXECUTION.

Ahora cambiaremos el BPM a la sección de KERNEL32 que esta a continuación del header, en mi caso es esta.

Le coloco un BPM ON ACCESS allí, así que parara cuando lea, escriba allí o cuando ejecute alguna instrucción en esa sección de KERNEL32, jeje doy RUN.

En mi caso para allí y si veo en el stack, veo que paro en una api

En este caso para al ejecutar una instrucción de la kernel32.dll y me funciono para saber cual es la primer api accedida desde el programa en dicha dll, si vemos la dirección de retorno en la primera línea del stack.

Si vemos adonde retornara con click derecho- FOLLOW IN DISASSEMBLER

Allí vemos que retornara a 401007 de la llamada a GetModuleHandleA que hay al inicio del programa.

Veo que un poco mas abajo hay una llamada a FindWindowA pero esa no parara pues corresponde a otra dll, en este caso a User32.dll. Si doy run nuevamente parara en la siguiente línea de la api ya que el BREAKPOINT ON ACCESS me hace parar en cada línea de la misma que se esta ejecutando, pues entonces lo quitare con REMOVE MEMORY BREAKPOINT como antes. Si quiero volver al programa, hago click derecho EXECUTE TILL USER CODE, o si no funciona en algún caso, puedo usar allí mismo EXECUTE TILL RETURN lo que me lleva hasta el RET y luego apreto F7 y vuelvo al programa.

En este caso EXECUTE TILL USER CODE funciona perfectamente ya veremos en que casos no funciona.

Si pongo un BPM de nuevo en la kernel32.dll parara en la siguiente api que se ejecute de esa dll y asi. También si no puedo colocar porque es detectado un BP MessageBoxA porque el programa detecta el CC como vimos antes podemos poner un BPM allí también y cumplirá la misma función, veamos el ejemplo

En mi maquina es 77D504EA así que voy allí en el listado con GOTO EXPRESIÓN, puedo tipear la dirección o el nombre siempre respetando mayúsculas y minúsculas.

Marco la primera línea

Y veo que también tengo la posibilidad de elegir poner un BPM ON ACCESS o ON WRITE, elijo la primera opción y doy RUN.

Voy a HELP –REGISTER y allí pongo un user y serial cualquiera

Al apretar OK

Para en la misma forma en la api que si hubiéramos puesto un BP allí y si los BP son detectados es otro metodo para parar alli, que aunque puede ser detectado por el programa, mirando el permiso de la zona si cambio, igual es menos probable que ello ocurra, al menos es otra alternativa y hay que conocerlas todas. Bueno para la parte siguiente nos quedan los HARDWARE BREAKPOINT y los MESSAGE BREAKPOINTS y el caso de los BPX CONDICIONALES que requiere más explicación, creo que por ahora tienen para practicar. Hasta la parte 11 Ricardo Narvaja 26 de noviembre de 2005