# Radare2

### Introducción a Radare2

**Radare2 (r2)** es una potente herramienta de **ingeniería inversa**, **análisis binario** y **modificación de ejecutables**. Su versatilidad permite analizar binarios, depurarlos y modificarlos directamente a nivel de **bytes**.

Algunas de sus principales características son:

* **Desensamblado y Análisis**: Permite visualizar código en ensamblador.
* **Depuración**: Compatible con GDB y otros depuradores.
* **Edición de Binarios**: Modificación en caliente de ejecutables.
* **Automatización**: Soporte para scripting con Python y r2pipe.

### Cargar un Binario en Radare2

Para modificar un ejecutable, es necesario cargarlo en Radare2 con permisos de escritura:

```sh
radare2 -A -w binario
```

* **`-A`**: Análisis automático.
* **`-w`**: Permiso de escritura para modificar el binario.

### Navegación y Búsqueda en el Binario

#### Ver el Punto de Entrada

```sh
pdf @ main
```

Este comando nos muestra el **desensamblado** de la función `main`.

Si queremos buscar llamadas a funciones específicas, podemos usar:

```sh
aaa  # Análisis profundo del binario
axt sym.factor2  # Buscar referencias a la función factor2
```

Esto nos indicará en qué parte del código se está llamando `factor2`.

#### Identificar Direcciones de Funciones

Para ver la dirección de una función específica:

```sh
pdf @ sym.factor1
```

Nos devolverá algo como:

```assembly
CODE XREF from sym.factor1 @ 0x22d2(x)
```

### Modificación de Llamadas a Funciones

Vamos a cambiar una llamada a `factor2` para que en su lugar se ejecute `factor1`.

#### Identificar la Dirección de la Llamada

En el desensamblado de `main`, encontramos:

```assembly
0x000023dc      e8fafeffff     call sym.factor2
```

Esto significa que en la dirección `0x000023dc` se está llamando `factor2`.

#### Obtener la Dirección de `factor1`

Ejecutamos:

```sh
pdf @ sym.factor1
```

Nos indica que `factor1` está en:

```assembly
CODE XREF from sym.factor1 @ 0x22d2(x)
```

Ahora, debemos calcular el **desplazamiento relativo** para modificar la instrucción `call`.

### Cálculo del Desplazamiento Relativo

Las instrucciones `call` en x86-64 utilizan direcciones relativas. La fórmula para calcular el desplazamiento es:

```
Desplazamiento = Destino - (Origen + Tamaño de la instrucción)
```

Sabemos que:

* `factor1` = **0x000022d2**
* `call` en **0x000023dc**
* Tamaño de la instrucción `call` = **5 bytes**

Cálculo:

```
0x22d2 - (0x23dc + 5) = -0x33A
```

Convertimos `-0x33A` a **little-endian** en 4 bytes:

```
c6 fc ff ff
```

#### Modificar los Bytes en el Binario

Ahora sobrescribimos la instrucción `call` en `0x000023dc`:

```sh
s 0x000023dc  # Moverse a la dirección
wx e8 c6 fc ff ff @ 0x000023dc  # Escribir los nuevos bytes
wq  # Guardar y salir
```

Para verificar los cambios:

```sh
pd 5 @ 0x000023dc
```

Salida esperada:

```assembly
│           0x000023dc      e8c6fcffff     call sym.factor1
```

### Comprobación y Ejecución del Binario Modificado

Ahora ejecutamos el binario modificado:

```sh
./binario_modificado
```

Si la modificación fue exitosa, `factor1` será llamada en lugar de `factor2`.

### Conclusión

Hemos visto cómo usar **Radare2** para: ✅ Navegar en un binario y encontrar referencias a funciones. ✅ Calcular el desplazamiento relativo de una instrucción `call`. ✅ Modificar bytes a nivel de ensamblador para cambiar la lógica de ejecución.

Este proceso es clave en el **análisis y modificación de binarios**, permitiendo realizar **parches** o incluso crear **exploits** para auditorías de seguridad.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dise0.gitbook.io/h4cker_b00k/herramientas-tecnicas/ingenieria-inversa/radare2.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.