> For the complete documentation index, see [llms.txt](https://shinki-organization.gitbook.io/dw/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://shinki-organization.gitbook.io/dw/write-ups/quickstart/maquinas-medio/stack-write-up.md). # Stack write-up ## **Verificamos conexión con la máquina víctima**

## **Escaneo de puertos abiertos y explotación de vulnerabilidades** Utilizamos **Nmap** para escanear los puertos abiertos de la máquina víctima con el siguiente comando: ```bash sudo nmap -p- -sCVS --min-rate=5000 -vvv -Pn -n -O 172.17.0.2 ```

El escaneo indica que el puerto 22 (SSH) y el 80 (HTTP) están abiertos. Por lo que ingresamos la IP de la máquina víctima y observamos lo siguiente:

Si inspeccionamos el código fuente encontramos un mensaje para `Bob` que revela que si contraseña se encuentra en la ruta `/usr/share/bob/password.txt`.

Ahora usamos la herramienta llamada **Gobuster** para enumerar posibles rutas ocultas, para ello ejecutamos lo siguiente: ```bash gobuster dir -u http://172.17.0.2/ -w /usr/share/wordlists/dirbuster/directory-list-lowercase-2.3-medium.txt -x txt,html,php,py,bak ```

Esto revela la ruta `http://172.17.0.2/file.php` y `http://172.17.0.2/note.txt`. El contenido de la nota es el siguiente:

Esto nos indica que se está usando la función `str_replace()` la cual busca y remplaza texto dentro de una cadena. Así que vamos a inspeccionar ahora la ruta `http://172.17.0.2/file.php`. Lo que probablemente este haciendo la función `str_replace()` es remplazando los caracteres `../` para así impedir que se puedan acceder a archivos fuera de la ruta `/var/www`. Así que lo que podemos hacer es probar a introducir lo siguiente: ```bash http://172.17.0.2/file.php?FUZZ=/....//....//....//....//etc/passwd ``` Si ahora quitase los caracteres `../` la cadena quedaría `/../../../../etc/passwd`, permitiendo así acceder al archivo `/etc/passwd`. Así que ahora solo nos quedará buscar el parámetro y comprobar funciona el bypass, para ello utilizaremos la herramienta **Wfuzz** ejecutando lo siguiente: ```bash wfuzz -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-lowercase-2.3-medium.txt -u "http://172.17.0.2/file.php?FUZZ=/....//....//....//....//etc/passwd" --hl 0 ```

Esto nos indica que la vulnerabilidad se explotó correctamente y que el parámetro podemos explotarla usando el parámetro `file`. Por lo que ingresamos lo siguiente en el navegador: ```bash http://172.17.0.2/file.php?file=/....//....//....//....//etc/passwd ```

Así que ahora veremos el contenido del archivo `/usr/share/bob/password.txt` ingresando `http://172.17.0.2/file.php?file=/....//....//....//....//usr/share/bob/password.txt` en el navegador.

Esto indica que la contraseña del usuario `bob` es `llv6ox3lx300`. Así que iniciamos sesión en la máquina víctima por el servicio SSH. ## **Escalada de privilegios** Una vez dentro de la máquina víctima nos encontramos con el binario `/opt/command_exec`, el cual al ejecutarlo nos pide una contraseña:

Lo que haremos ahora será pasarnos el binario a nuestra máquina y hacer ingeniería inversa para inspeccionar el código del programa. Para ello, ejecutamos lo siguiente en nuestra máquina: ```bash scp bob@172.17.0.2:/opt/command_exec . ```

A continuación utilizaremos la herramienta **ghidra**, la cual nos ayudará a descompilar el programa. Para inicializarlo solo tenemos que ejecutar `ghidra` si ya lo tenemos instalado. Ahora abrimos un nuevo proyecto en **ghidra** e importamos el binario **command\_exec**. Después de importarlo hacemos clic sobre command\_exec dos veces y nos aparecerá lo siguiente:

Hacemos clic en `Yes`.

Y seleccionamos la opción de `Decompiler parameter ID`. Una vez hecho esto esperamos un poco para que el programa traduzca del lenguaje máquina a un lenguaje de programación. Una vez ya se haya descompilado el programa, nos aparecerá la función main en C a la izquierda de la pantalla.

Si nos fijamos en el código, lo que hace es primero es inicializar las variables `local_98`, `local_58` y `local_c`. Esto hace que las direcciones de memoria del stack, que es donde se guardan las variables locales y argumentos, se vea así. ```scss … direcciones más bajas … [rbp – 144 … rbp – 81] ← local_98 (64 bytes) [rbp – 80 … rbp – 5 ] ← local_58 (76 bytes) [rbp – 4 … rbp – 1 ] ← local_c ( 4 bytes) … direcciones más altas … ``` Luego se inicializa el valor de la variable `local_c = 0x1234`, que al seguir la convención `little endian` se guardara como `0x34 0x12 0x00 0x00`. Después nos pide la contraseña y guarda lo que escribamos en la variable `local_58`, escribiendo el primer byte en rbp -80 y siguiendo por el byte rbp -79. Después se llega a un condicional que comprueba que el valor de la variable `local_c` sea `0xdead`, y en caso de que la condición sea cierta nos permitirá ejecutar un comando como usuario `root`. Así que para vulnerar este programa lo que haremos será escribir 76 bytes cuando nos pida la contraseña y luego escribiremos `\xad\xde` es el valor que queremos que tenga `local_c` para ejecutar un comando como usuario root. Esto sobrescribirá el valor antiguo de la variable `local_c` ya que el programa al recoger la variable `local_58` con la función `gets` no especifica cuantos bytes puede recoger como máximo, por lo que si escribimos más de 76 bytes lo siguiente que escribamos se empezará a guardar dentro de la variable `local_c`. Por lo tanto, ahora ejecutaremos este comando que pasará como entrada al programa 76 A más el valor en hexadecimal de `dead` y luego ejecutará un comando que dará permisos SUID al binario `/bin/bash`: ```bash python3 -c "import sys; sys.stdout.buffer.write(b'A'*76 + b'\xad\xde\n' + b'chmod u+s /bin/bash\n')" | ./command_exec ```

Y ya seríamos usuario `root`.