Curso desde 0 con x64dbg by Ángel Zarza

CAPÍTULO 03. REGISTROS, QUE SON Y PARA QUE SIRVEN

TABLA DE CONTENIDO

CAPÍTULO 03. REGISTROS, QUE SON Y PARA QUE SIRVEN .................................................... 1

TABLA DE CONTENIDO ................................................................................................................. 1
REGISTROS, QUE SON Y PARA QUE SIRVEN ............................................................................ 2
REGISTROS ............................................................................................................................... 2
TRABAJANDO CON EIP ............................................................................................................ 9
¿QUE SON LOS FLAGS?......................................................................................................... 10
FLAG ZF o ZERO FLAG ........................................................................................................ 11
FLAG OF O FLAG OVERFLOW (DESBORDAMIENTO) ....................................................... 14
FLAG CF O CARRY FLAG .................................................................................................... 16
FLAG PF O PARIDAD ........................................................................................................... 16
FLAG SF O SIGNO................................................................................................................ 18
FLAG AF O AUXILIAR ........................................................................................................... 19
FLAGS TF, DF IF ................................................................................................................... 19
REGISTROS DE SEGMENTO .................................................................................................. 19
DESPEDIDA 20

1
 REGISTROS, QUE SON Y PARA QUE SIRVEN

Vamos a explicarlo de una forma clara. Los registros, estos pequeños ayudantes que sin ellos no
haríamos nada. Voy a usar mis típicas metáforas para explicar el concepto.

Imaginar que tenemos una empresa, la cual consta de varias secciones de trabajadores encargados
de llevar las distintas partes de la misma. En este caso hablaremos de los contadores que llevan
las cuentas de esta empresa. Esta empresa hace un pedido de 30.000 tornillos para fabricar coches.
Las facturas del costo de los tornillos tienen que ser llevadas a los contables para administrar el
dinero. Saber cuánto van a ganar o perder al hacer la inversión.

Pues bien, el programa analizado es la empresa y los registros son los contables. No puedes hacer
ninguna operación sin pasar por ellos.

REGISTROS

Esta categoría se divide en varias secciones, veamos la siguiente tabla.

TIPOS DE
FUNCIÓN
REGISTROS
Un registro de segmento tiene 16 bits de longitud y facilita un área de
Registros de segmento
memoria para el direccionamiento conocida como el segmento actual.
Este registro está compuesto por 16 bits y contiene el desplazamiento
Registros de apuntador
de la siguiente instrucción que se va a ejecutar. Los procesadores
de secciones
80386 y posteriores tiene un IP1 ampliado de 32 bits llamado EIP.
Permiten al sistema acceder a datos del segmento de la pila. Los
Registros apuntadores procesadores 80386 tiene un apuntador de pila de 32 bits llamado ESP.
El sistema maneja de manera automática estos registros.
Son los caballos de batalla del sistema y pueden ser direccionados
como una palabra o como una parte de un byte. Los procesadores
Registros de propósito
80386 y posteriores permiten el uso de todos los registros de propósitos
general
general más sus versiones ampliadas de 32 bits llamados EAX, EBX,
ECX y EDX.
Sirven para el direccionamiento de indexado y para las operaciones de
Registros de índices
sumas y restas.
Sirven para indicar el estado actual de la máquina y el resultado del
Registro de banderas
procesamiento. De los 16 bits de registro de bandera 9 son comunes a
(FLAGS)
toda la familia de los procesadores 8086.

El objetivo es conocer un poco las secciones, datos y operaciones que nos podemos encontrar en
un procesador y profundizar en las que más necesitemos.

IP (Puntero de Instrucciones o Instruction Pointer)

1

2
Veamos un ejemplo más práctico sobre Registros de banderas (FLAGS). Abramos nuestro
CRACKME. Y observemos al registro ESP, este apunta a la parte superior del STACK.

ESP vale 0019FF84 y si miramos el stack en x64dbg vemos que efectivamente apunta a la dirección
señalada en ESP. Que como ya sabemos es la primera “carta” de nuestro mazo.

Otro registro importante es EIP, que apunta a la instrucción que está siendo ejecutada en ese
momento, observemos.

3
Como podemos ver en x64dbg, apunta a la primera dirección de memoria que se está ejecutando
en ese momento.

Si ejecuto la siguiente instrucción en el listado con F7 observemos como cambia el valor de EIP y
pasa a apuntar a la siguiente dirección de memoria del listado.

4
Y en el registro ahora apunta a:

Los registros restantes pueden tomar valores variables y sirven para asistir al procesador en las
ejecuciones de las instrucciones. ECX es usado como contador, las demás son fluctuantes y asisten
en la ejecución del programa. Dicho de otra forma, los registros restantes son los becarios de esta
“empresa”.

Un repaso rápido de los registros de propósito general que muestra x64dbg son EAX, EBX, ECX,
EDX, EBP, ESP, ESI, EDI, EIP.

Estos son los llamados registros de 32 bits, también denominados registros de propósitos generales.

Vamos a ver cómo podemos corroborar esto. Los registros muestran los valores en hexadecimal y
como ya sabemos el máximo valor hexadecimal que podemos tener es FFFFFFFF. Así que abramos
la calculadora y escribamos FFFFFFFF en la casilla hexadecimal para ver qué es lo que ocurre.

5
Observamos que salen 32 dígitos binarios que pueden ser 0 o 1. Por eso los llamamos registros de
32 bits. Los registros se pueden subdividir en varias secciones, en este caso vamos a poner de
ejemplo a EAX.

Vayamos a x64dbg y practiquemos.

Modificaremos el valor de EAX, para cambiarlo BOTÓN DERECHO > MODIFICAR VALOR.

Y cambiamos el valor que contiene por ABCD1234 y pulsamos “Aceptar”.

Si te has dado cuenta, cuando modificamos un valor, x64dbg nos muestra en rojo el valor alterado.

6
Bien, una vez modificado vamos a probar lo siguiente. Como hemos dicho EAX se puede subdividir,
vamos a dividirlo en la sección AX, la cual es una sección de 16 bits, porque es la mitad de una
sección completa de 32 bits.

Vamos a la calculadora, ingresamos AX y observamos como el valor apunta a los últimos 4 dígitos
del registro EAX.

Con esto deducimos que AX son las 4 últimas cifras de EAX. Pero esto no acaba aquí. ¿Cómo
haríamos para mostrar 8 bits del registro de EAX? Ya vimos como mostrar 16 bits ahora le toca el
turno a los pequeñines. Entonces EAX se puede dividir en AX, AL, AH.

Ingresemos AL y AH a ver qué sucede.

7
Observamos que AL apunta a los últimos 8 bits que serían 34 y AH apunta a 12 que serían los 8 bits
restantes. Veamos un ejemplo para entenderlo mejor.

EAX ABCD1234

ABCD = Primeros 16 bits

1234 = Últimos 16 bits (AX)

12 = Primeros 8 bits (AH)

34 = Últimos 8 bits (AL)

Todos los registros se pueden dividir, ejemplo ECX se puede dividir en CX, CH, CL y así con todos
los demás.

8
TRABAJANDO CON EIP

Este registro no se puede modificar de la misma forma que los demás, ya que apunta a la instrucción
que se ejecuta en ese momento.

Para cambiar EIP nos vamos al listado y con BOTÓN IZQUIERDO marcamos una nueva dirección,
luego BOTÓN DERECHO > ESTABLECER NUEVO ORIGEN AQUÍ.

Como observamos si nos vamos al registro EIP veremos que ha cambiado al nuevo punto de origen
que nosotros le indicamos. El programa seguirá ejecutándose desde el nuevo punto de origen
marcado.

9
¿QUE SON LOS FLAGS?

Como ya vimos en anteriores entregas, debajo de los registros tenemos los FLAGS. En archivos de
32 bits se denominan EFLAGS y en archivos de 64 bits se denominan RFLAGS. En el CRACKME
observamos que se denomina de esta forma (EFLAGS) y para comprobar la denominación en un
archivo de 64 bits abrimos cualquier archivo de 64 bits, en este caso yo abrí un WordPad para ver
el ejemplo, obviar la demás información que aparece en pantalla al abrir un archivo de 64 bits y
centraros solo en lo que os muestro.

Archivo de 32 bits:

Archivo de 64 bits:

10
Ahora que ya tenemos claro este aspecto podemos continuar, como observamos en el CRACKME
DE CRUEHEAD aparecen los siguientes FLAGS:

Tenemos que los FLAGS son ZF, OF, CF, PF, SF, TF, AF, DF, IF.

FLAG ZF o ZERO FLAG

Es uno de los más usados, este se activa cuando ejecutamos una instrucción y su resultado es 0.

Cambiemos nuestro registro EAX para ver un ejemplo práctico, para ello nos situamos en el registro
y con BOTÓN DERECHO > MODIFICAR VALOR lo establecemos en FFFFFFFF que es igual que
decir -1 en decimal.

Nota: El valor hexadecimal inicial puede ser distinto al que podéis ver vosotros en vuestros
ordenadores.

11
Ahora vallamos al listado de instrucciones y en la primera instrucción pulsemos BARRA
ESPACIADORA o es su defecto BOTÓN DERECHO > ENSAMBLAR. En el recuadro que nos
aparece escribamos “ADD EAX, 1” y pulsemos en aceptar. Con esto lograremos sumar 1 al valor
de EAX cuando se ejecute la instrucción.

12
Una vez aceptado el recuadro nos pasara a la siguiente instrucción y no queremos eso, así que
cancelaremos el siguiente recuadro.

Como observamos ya nos cambió la instrucción por la nueva.

Ahora tan solo nos queda ejecutar la línea con F7 o STEP INTO para ver qué sucede, pero antes
de ejecutar la línea forcemos el FLAG ZF a 0, para eso es tan sencillo como pulsar dos veces con
CLICK IZQUIERDO sobre el FLAG, como vemos el FLAG ZF ahora está en 0.

13
Ahora ejecutemos la línea y veremos que se activó ZF a 1 al cambiar a un valor positivo:

Con esto queda claro que este FLAG se activa como resultado de una operación cuyo valor sea 0
o diferente de 0.

FLAG OF O FLAG OVERFLOW (DESBORDAMIENTO)

Este flag se activa cuando al hacer una operación, el resultado cambia de signo dando un valor
incorrecto.

Probemos un ejemplo en x64dbg, para ello abrimos nuestro CRACKME y en la sección de registros
coloquemos en EAX el valor 7FFFFFFF, que como ya sabemos es el máximo positivo posible.

Nota: A partir de este momento no volveré a explicar pasos anteriores, para así agilizar el trabajo y
hacerlo menos tedioso.

14
Ahora le sumaré 1, lo cual hará que se desborde al no poder mostrar un número positivo y se active
el flag OF. Pulsemos BARRA ESPACIADORA sobre la primera instrucción y escribamos “ADD EAX, 1”.

Pulsamos en Aceptar y el siguiente recuadro que aparece pulsamos en Cancelar.

Ahora solo nos queda ejecutar la línea con F7 o STEP INTO para ver qué es lo que sucede.

Como vemos al sobrepasar el número positivo a un número negativo el flag OF se activa pasando
de 0 a 1, indicando que hubo desbordamiento.

15
FLAG CF 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.

FLAG PF 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 comprobar esto vayamos a x64dbg y reiniciemos nuestro CRACKME. En la primera instrucción
volvamos a escribir “ADD EAX, 1”, y en el registro EAX cambiemos el valor hexadecimal a 00000000,
el flag PF modifiquemos su valor a 1.

16
Procedamos a ejecutar la primera línea con F7, observemos como EAX pasa a valer 00000001 y
PF pasa a 0, ya que en binario no es número par: “0000 0000 0000 0000 0000 0000 0000 0001“.

Volvamos a ejecutar la primera instrucción “00401000”, CLICK DERECHO > ESTABLECER NUEVO
ORIGEN AQUÍ y F7 para ejecutar la primera línea. Vemos que ahora el flag PF conserva su valor a
0, ya que ahora EAX pasa a valer 00000002 y en binario es número impar de 1s (00000010).

17
Volvamos a repetir el proceso y observemos que EAX ahora cambia a 00000003, que en binario
sería “0000 0000 0000 0000 0000 0000 0000 0011” y observamos que es número par por lo tanto
el flag PF se activa pasando su valor a 1.

Nota: Como curiosidad, x64bdg marca en verde el registro que corresponde a la instrucción que se
está ejecutando en ese momento.

FLAG SF O SIGNO

Se activa cuando el resultado de una operación es negativo, si quiero probarlo cambio EAX a
FFFFFFF8 que es -8 decimal y el flag SF lo establecemos en 0 y agregamos a la primera instrucción
“ADD EAX, 1”.

Nota: El CRACKME lo volví a reiniciar. Si no queréis reiniciar podéis establecer nuevo punto de
origen en la primera instrucción.

18
Y probamos a ejecutar la primera línea a ver qué sucede con F7.

Analicemos lo que sucedió, el valor de EAX ha pasado a FFFFFFF9 que en decimal es -9, con lo
cual debe activarse el flag SF al ser un valor con signo negativo.

FLAG AF O AUXILIAR

Tiene una función similar al flag OF pero para cuando se realizan operaciones con otros formatos
que por ahora no nos interesan.

FLAGS TF, DF IF

Estos tres amigos son bastante más complejos que los anteriores, como de momento sería
saturaros de información, los dejaremos para capítulos posteriores donde los veremos más
despacio y con ejemplos prácticos.

REGISTROS DE SEGMENTO

Un registro de segmento tiene una longitud de 16 bits y facilita un área de memoria para
direccionamientos conocidos como el segmento actual. Los registros de segmento son GS, ES, CS,
FS, DS, SS.

Ahora está bien que solo sepamos que son esas siglas y porque están ahí.

19
 DESPEDIDA

Es muy importante que practiquéis todo lo aprendido, repetir los pasos de modificar los registros,
las instrucciones como ADD EAX, 1 y todo lo enseñado. Una buena base es de gran importancia
para avanzar sin dar palos de ciego.

Estos primeros capítulos son los más engorrosos y aún nos queda un poco para lo bueno, así que
paciencia y mucho ánimo.

Nos vemos en la 4ª parte, suerte chic@s.

Curso inspirado en los de Ricardo Narvaja.

Correo: angel.zarza91@gmail.com

Ángel Zarza, 28 de Septiembre 2018

20