# Metodología Básica de Explotación Binaria

{{#include ../../banners/hacktricks-training.md}}

## Información Básica de ELF

Antes de comenzar a explotar cualquier cosa, es interesante entender parte de la estructura de un **binario ELF**:

{{#ref}}
elf-tricks.md
{{#endref}}

## Herramientas de Explotación

{{#ref}}
tools/
{{#endref}}

## Metodología de Desbordamiento de Pila

Con tantas técnicas, es bueno tener un esquema de cuándo cada técnica será útil. Ten en cuenta que las mismas protecciones afectarán diferentes técnicas. Puedes encontrar formas de eludir las protecciones en cada sección de protección, pero no en esta metodología.

## Controlando el Flujo

Hay diferentes formas en las que podrías terminar controlando el flujo de un programa:

- [**Desbordamientos de Pila**](../stack-overflow/) sobrescribiendo el puntero de retorno desde la pila o el EBP -> ESP -> EIP.
- Podría ser necesario abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
- O a través de **Escrituras Arbitrarias + Escribir Qué Dónde para Ejecución**.
- [**Cadenas de Formato**](../format-strings/)**:** Abusar de `printf` para escribir contenido arbitrario en direcciones arbitrarias.
- [**Indexación de Arreglos**](../array-indexing.md): Abusar de una indexación mal diseñada para poder controlar algunos arreglos y obtener una escritura arbitraria.
- Podría ser necesario abusar de un [**Desbordamiento de Entero**](../integer-overflow.md) para causar el desbordamiento.
- **bof a WWW vía ROP**: Abusar de un desbordamiento de búfer para construir un ROP y poder obtener un WWW.

Puedes encontrar las técnicas de **Escribir Qué Dónde para Ejecución** en:

{{#ref}}
../arbitrary-write-2-exec/
{{#endref}}

## Bucles Eternos

Algo a tener en cuenta es que generalmente **solo una explotación de una vulnerabilidad puede no ser suficiente** para ejecutar un exploit exitoso, especialmente algunas protecciones necesitan ser eludidas. Por lo tanto, es interesante discutir algunas opciones para **hacer que una sola vulnerabilidad sea explotable varias veces** en la misma ejecución del binario:

- Escribir en una **cadena ROP** la dirección de la **función `main`** o la dirección donde está ocurriendo la **vulnerabilidad**.
- Controlando una cadena ROP adecuada, podrías ser capaz de realizar todas las acciones en esa cadena.
- Escribir en la **dirección `exit` en GOT** (o cualquier otra función utilizada por el binario antes de finalizar) la dirección para **volver a la vulnerabilidad**.
- Como se explicó en [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** almacenar 2 funciones aquí, una para llamar a la vulnerabilidad nuevamente y otra para llamar a **`__libc_csu_fini`** que volverá a llamar a la función de `.fini_array`.

## Objetivos de Explotación

### Objetivo: Llamar a una Función Existente

- [**ret2win**](./#ret2win): Hay una función en el código que necesitas llamar (quizás con algunos parámetros específicos) para obtener la bandera.
- En un **bof regular sin** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) solo necesitas escribir la dirección en la dirección de retorno almacenada en la pila.
- En un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/), necesitarás eludirlo.
- En un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), necesitarás eludirlo.
- Si necesitas establecer varios parámetros para llamar correctamente a la función **ret2win**, puedes usar:
- Una [**cadena ROP**](./#rop-and-ret2...-techniques) **si hay suficientes gadgets** para preparar todos los parámetros.
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (en caso de que puedas llamar a esta syscall) para controlar muchos registros.
- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros.
- A través de un [**Escribir Qué Dónde**](../arbitrary-write-2-exec/) podrías abusar de otras vulnerabilidades (no bof) para llamar a la función **`win`**.
- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección.
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones.
- [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe.

### Objetivo: RCE

#### A través de shellcode, si nx está deshabilitado o mezclando shellcode con ROP:

- [**(Stack) Shellcode**](./#stack-shellcode): Esto es útil para almacenar un shellcode en la pila antes o después de sobrescribir el puntero de retorno y luego **saltar a él** para ejecutarlo:
- **En cualquier caso, si hay un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** en un bof regular necesitarás eludirlo (filtrar).
- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) es posible saltar a la dirección de la pila ya que nunca cambiará.
- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) necesitarás técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para saltar a ella.
- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), necesitarás usar algún [**ROP**](../rop-return-oriented-programing/) **para llamar a `memprotect`** y hacer que alguna página sea `rwx`, para luego **almacenar el shellcode allí** (llamando a read, por ejemplo) y luego saltar allí.
- Esto mezclará shellcode con una cadena ROP.

#### A través de syscalls

- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Útil para llamar a `execve` para ejecutar comandos arbitrarios. Necesitas ser capaz de encontrar los **gadgets para llamar a la syscall específica con los parámetros**.
- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) están habilitados, necesitarás derrotarlos **para usar gadgets ROP** del binario o bibliotecas.
- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) puede ser útil para preparar el **ret2execve**.
- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) y [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar varios registros.

#### A través de libc

- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Útil para llamar a una función de una biblioteca (generalmente de **`libc`**) como **`system`** con algunos argumentos preparados (por ejemplo, `'/bin/sh'`). Necesitas que el binario **cargue la biblioteca** con la función que te gustaría llamar (libc generalmente).
- Si **compilado estáticamente y sin** [**PIE**](../common-binary-protections-and-bypasses/pie/), la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente.
- **Sin** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y conociendo la versión de libc** cargada, la **dirección** de `system` y `/bin/sh` no van a cambiar, por lo que es posible usarlas estáticamente.
- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **pero sin** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, conociendo la libc y con el binario usando la función `system`** es posible **`ret` a la dirección de system en el GOT** con la dirección de `'/bin/sh'` en el parámetro (necesitarás averiguarlo).
- Con [ASLR](../common-binary-protections-and-bypasses/aslr/) pero sin [PIE](../common-binary-protections-and-bypasses/pie/), conociendo la libc y **sin que el binario use la `system`**:
- Usar [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver la dirección de `system` y llamarla.
- **Eludir** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) y calcular la dirección de `system` y `'/bin/sh'` en memoria.
- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **y** [**PIE**](../common-binary-protections-and-bypasses/pie/) **y sin conocer la libc**: Necesitas:
- Eludir [**PIE**](../common-binary-protections-and-bypasses/pie/).
- Encontrar la **versión de `libc`** utilizada (filtrar un par de direcciones de funciones).
- Revisar los **escenarios anteriores con ASLR** para continuar.

#### A través de EBP/RBP

- [**Pivotar Pila / EBP2Ret / Encadenamiento EBP**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controlar el ESP para controlar RET a través del EBP almacenado en la pila.
- Útil para **desbordamientos de pila off-by-one**.
- Útil como una forma alternativa de terminar controlando EIP mientras abusas de EIP para construir la carga útil en memoria y luego saltar a ella a través de EBP.

#### Varios

- [**Redireccionamiento de Punteros**](../stack-overflow/pointer-redirecting.md): En caso de que la pila contenga punteros a una función que se va a llamar o a una cadena que se va a utilizar por una función interesante (system o printf), es posible sobrescribir esa dirección.
- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) pueden afectar las direcciones.
- [**Variables No Inicializadas**](../stack-overflow/uninitialized-variables.md): Nunca se sabe.

{{#include ../../banners/hacktricks-training.md}}