> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/es/useful-resources/exploit-development/linux-buffer-overflow-custom.md).
# Desbordamiento de búfer en Linux - Personalizado
Notas personalizadas de desbordamiento de búfer en Linux para construir exploits, controlar el flujo de ejecución, elaborar payloads y documentar la metodología de corrupción de memoria.
## Primer ejemplo de binario personalizado (Pdmenu/exim):
Descarga la máquina arrancar
> El primer ejemplo se centra en explotar el binario legítimo exim-4.84-7, que tiene una vulnerabilidad identificada como CVE-2016-1531. Esta vulnerabilidad permite a un atacante ejecutar comandos con privilegios abusando de ciertas variables de entorno.
* En este caso, cuando accedemos al usuario Paul, se le **Pdmenu** asigna con ciertas funcionalidades (listado de directorios, edición de archivos, ejecución de ping, etc.):
* Para escapar de este menú, **editamos un archivo**, por ejemplo (etc/host):
* En este caso, **vi** se utiliza como editor de texto:
* Al consultar **gtfobins**, si filtramos por vi, obtenemos los comandos para salir de Pdmenu y **ejecutar una shell**:
* Filtramos los **SUID** archivos y encontramos uno llamado exim:
* Con la **searchsploit** herramienta, buscamos posibles vulnerabilidades para este binario:
* Ahora descargamos el script y lo servimos con **python3** para que pueda cargarse después de comprometer la máquina:
* Ejecutamos el script y, efectivamente, se explota la vulnerabilidad de este binario, obteniendo así **acceso root**:
## Segundo ejemplo (desbordamiento de búfer):
Descargue la máquinaUbuntuvulnerableInstale la herramientaPeda
> El segundo ejemplo trata de un **Desbordamiento de búfer** en un [binario](https://hack4u.io/wp-content/uploads/2023/04/custom) personalizado en una máquina Linux de 32 bits con protecciones activas y ASLR habilitado. En este caso, nos centramos en explotar ret2libc en un binario que tiene permisos SUID y pertenece a root. Mediante el desbordamiento de búfer, demostramos cómo inyectar comandos privilegiados y elevar los privilegios de usuario.
\***Desbordamiento de búfer** implica sobrescribir ciertos registros del sistema y, dado que el binario es creado por el usuario y pertenece al grupo root, **se ejecutará como un usuario privilegiado**:
* El binario llamado "custom" espera una **entrada de cadena** y, cuando se ejecuta, no ocurre nada:
* Pero si introducimos una **cadena muy larga**, devuelve un error (core dumped):
Enviamos una **cadena corta** de AAAAAAAA y no **aparecen errores**:
* Para analizar el binario en profundidad, utilizaremos la **gdb-peda** herramienta.
* Pero si enviamos **muchos caracteres**, obtenemos el siguiente error:
1. Lo primero que hay que hacer es **determinar el número total de cadenas** necesarias para sobrescribir el registro (EIP).
* El primer método consiste en utilizar un **patrón (pattern)** que crea una cadena **diseñada espacialmente** (en estos casos, 300 caracteres) que ejecutamos en el binario:
* En la respuesta de **EIP**, sabemos que la **cadena visible inferior** es "AA8A":
* El **automático** modo de hacerlo es con `pattern offset $eip` comando:
* Para comprobarlo, utilizamos **python3** enviando 112 caracteres A y después los 4 B finales:
```bash
r $(python3 -c 'print("A"*112 + "B"*4)')
```
* En efecto, ahora confirmamos la cola gracias a **EIP** que detecta los 4 últimos B:
2. Una vez que conocemos el número máximo de cadenas, **comprobamos el ASLR** que determinará si hay **aleatoriedad en las direcciones de memoria** o no:
/- Con el siguiente comando filtramos las cadenas que nos interesan específicamente para ejecutar el binario 10 veces y ver si cambia cada vez, y para ver si la **biblioteca C** es aleatoria o no:
Efectivamente es "aleatoria"
3. El problema con estos binarios de **32 bits** a menudo es que si ejecutamos ahora, por ejemplo, **1000 veces** A y filtramos por una cadena fija, vemos que cada vez, **se repetirá al menos una vez**:
4. El objetivo ahora es encontrar primero **EIP** cadenas (**system + exit + bin/\_sh**), que siempre serán fijas y necesarias para ejecutar una **Bash como root** como en el siguiente ejemplo, pero en Python:
* Creamos un **punto de interrupción** para que el flujo del programa se detenga manualmente:
* Inyectamos las direcciones **EIP** de (system/exit/bin/\_sh):
5. Una vez que vemos que hay **aleatoriedad**, necesitaremos utilizar **fuerza bruta** hasta que **base/\_libc/\_addr** sea igual al valor deseado:
/- Con lo siguiente veremos las **bibliotecas que se están ejecutando** (en este caso **libc.so**):
* Con **readelf**, filtramos la biblioteca y buscamos las variables inyectadas previamente, que son (**exit y system**) con los códigos:
* Y para encontrar la cadena **/bin/sh**, hacemos lo siguiente, añadiendo un **0x00** al principio:
El siguiente script de Python3 **automatizará toda la fuerza bruta** hasta que **base/\_libc/\_addr** sea igual:
```python
#!/usr/bin/python3
import subprocess
from struct import pack
import sys
offset = 112
before_eip = b"A" * 112
# Desbordamiento de búfer personalizado de Linux
base_libc_addr = 0xb7595000
system_addr_off = 0xb7d86db0
exit_addr_off = 0xb7d7a9e0
bin_sh_addr_off = 0xb7ea7b2b
system_addr = pack("
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://hacking-notes.jord4n.pro/es/useful-resources/exploit-development/linux-buffer-overflow-custom.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
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.
