DockerLabs Fácil Linux Debian

Injection

DockerLabs · Gobuster → SQLi Login Bypass → SSH → SUID env PrivEsc

// ruta Nmap Gobuster SQLi Bypass SSH Dylan SUID env ROOT ✓
01

// Planificación & objetivo

paso 01
Objetivo del ejercicio
Injection es una máquina de la plataforma DockerLabs con dificultad Fácil, basada en Linux Debian. Expone SSH en el puerto 22 y un servidor web Apache con una aplicación PHP en el puerto 80.

Esta máquina introduce una vulnerabilidad web clásica y una de las más prevalentes en la industria: la SQL Injection (SQLi). El objetivo es explotar un formulario de login vulnerable para obtener credenciales, acceder al sistema via SSH y escalar privilegios mediante un binario con el bit SUID mal configurado.
paso 02
Resumen de fases
FaseTécnica / HerramientaResultado
Despliegueauto_deploy.shMáquina activa 172.20.0.3
ReconocimientoNmap -sCPuertos 22 y 80, PHPSESSID detectado
Enum. WebGobuster dirindex.php + config.php
ExplotaciónSQL Injection (login bypass)Usuario Dylan + contraseña en claro
Acceso inicialSSH con credenciales SQLiShell como dylan
Post-explotaciónfind SUID/usr/bin/env con SUID
Escaladaenv /bin/sh -pShell root ✓
02

// Reconocimiento & despliegue

paso 03
Despliegue de la máquina
Desplegamos la máquina con auto_deploy.sh. El script levanta el contenedor, configura la red interna injection_net, levanta un proxy web en localhost:8080 → 172.20.0.3:80 y nos sitúa dentro del entorno kali-pentesting. IP asignada: 172.20.0.3.
Deploy
$ sudo bash auto_deploy.sh injection.tar Máquina desplegada, su dirección IP es ——> 172.20.0.3 Web (proxy): http://localhost:8080
captura — despliegue● ● ●
Despliegue máquina Injection
captura — entorno kali-pentesting activo● ● ●
Entorno kali-pentesting con proxy web activo
03

// Escaneo & análisis

paso 04
Escaneo de puertos — Nmap
Lanzamos Nmap con scripts NSE (-sC). Resultado: SSH en el 22 y HTTP en el 80 con Apache. Nmap detecta además una cookie PHPSESSID sin el flag httponly — indicador de que hay una aplicación PHP con gestión de sesiones, y que la cookie podría ser robada via XSS. El título HTTP muestra "Iniciar Sesión" — hay un panel de login en el puerto 80.
Nmap
# nmap -sC 172.20.0.3 PORT STATE SERVICE 22/tcp open ssh 80/tcp open http |_http-title: Iniciar Sesión | http-cookie-flags: | PHPSESSID: httponly flag not set
captura — nmap output● ● ●
Output nmap Injection con PHPSESSID detectado
// hallazgos nmap
Puerto 80 con panel de login PHP. Cookie PHPSESSID sin httponly — la aplicación web es el vector principal de ataque.
paso 05
Fuzzing de directorios — Gobuster
Aplicamos fuzzing con Gobuster para descubrir recursos ocultos. Encontramos dos archivos PHP: index.php (Status 200, Size 2921) — el panel de login principal — y config.php (Status 200, Size 0) — archivo de configuración accesible pero que devuelve respuesta vacía, probablemente contiene credenciales de base de datos hardcodeadas aunque el servidor no las renderiza directamente.
Gobuster
# gobuster dir -u http://172.20.0.3 -w /usr/share/seclists/Discovery/Web-Content/DirBuster-2007_directory-list-lowercase-2.3-medium.txt -x php,html,txt index.php (Status: 200) [Size: 2921] config.php (Status: 200) [Size: 0] server-status (Status: 403) [Size: 275]
captura — gobuster output● ● ●
Gobuster descubriendo index.php y config.php
// hallazgo
Panel de login en index.php. config.php accesible con respuesta vacía — el servidor procesa PHP pero no muestra output, típico de archivos de configuración con credenciales de BD que no deben exponerse. El vector de ataque es el formulario de login.
04

// Explotación & acceso inicial

paso 06
SQL Injection — Login Bypass
El formulario de login en index.php construye una query SQL con los datos introducidos por el usuario sin sanitizarlos. Probamos un payload clásico de SQL Injection para bypassear la autenticación:

User: admin
Password: ' or '1'='1

El payload cierra la cadena de la contraseña con ', añade la condición OR '1'='1' que siempre es verdadera, y hace que la query devuelva el primer usuario de la base de datos independientemente de la contraseña real. El servidor responde revelando el nombre del usuario y su contraseña en texto claro: Dylan / KJSDFG789FGSDF78.
SQLi Payload
# Campo User: admin # Campo Password: ' or '1'='1 # Query resultante (vulnerable): SELECT * FROM users WHERE user='admin' AND password='' or '1'='1' # '1'='1' siempre es TRUE → devuelve el primer usuario
captura — formulario login con payload● ● ●
Formulario login con payload SQLi introducido
captura — resultado SQLi: usuario y contraseña expuestos● ● ●
Resultado SQLi mostrando usuario Dylan y contraseña
Usuariodylan
ContraseñaKJSDFG789FGSDF78
OrigenSQL Injection
paso 07
Conexión SSH — Acceso como dylan
Con las credenciales obtenidas de la SQLi, nos conectamos por SSH como dylan. El servidor emite el aviso habitual de OpenSSH moderno sobre algoritmos post-cuánticos — es informativo, no bloquea la conexión. Obtenemos shell como dylan.
SSH
# ssh dylan@172.20.0.3 dylan@172.20.0.3's password: KJSDFG789FGSDF78 dylan@f5db0aee451c:~$ ← acceso inicial obtenido
// acceso inicial conseguido
Shell obtenida como dylan. Iniciamos enumeración post-acceso para escalar a root.
05

// Post-Explotación & privesc

paso 08
Enumeración — sudo y binarios SUID
Primer paso tras obtener acceso: sudo -l. El sistema responde "sudo: command not found" — sudo ni siquiera está instalado en este sistema. Vector cerrado.

Pasamos al segundo vector: búsqueda de binarios con el bit SUID activado. El comando find / -perm -4000 lista todos los ejecutables que corren con los privilegios de su propietario (normalmente root). Entre los resultados destaca /usr/bin/env — un binario que normalmente no debería tener SUID.
sudo + SUID
dylan@host:~$ sudo -l -bash: sudo: command not found dylan@host:~$ find / -perm -4000 2>/dev/null /usr/lib/dbus-1.0/dbus-daemon-launch-helper /usr/lib/openssh/ssh-keysign /usr/bin/passwd /usr/bin/mount /usr/bin/env /usr/bin/newgrp /usr/bin/su /usr/bin/chsh /usr/bin/umount /usr/bin/gpasswd
captura — sudo no instalado● ● ●
sudo command not found en dylan
captura — find SUID mostrando /usr/bin/env● ● ●
find SUID listando binarios incluyendo env
// vector identificado
/usr/bin/env con bit SUID activado → escalada via GTFOBins sección SUID.
paso 09
Consulta GTFOBins — env SUID
Consultamos GTFOBins para la entrada de env en la sección SUID — a diferencia de las máquinas anteriores donde usamos la sección Sudo, aquí el vector es el bit SUID. GTFOBins documenta que env con SUID puede escalar privilegios ejecutando env /bin/sh -p. El flag -p es crítico: indica a /bin/sh que no descarte los privilegios efectivos heredados del binario SUID, manteniendo el uid efectivo de root.
captura — gtfobins env SUID● ● ●
GTFOBins entrada env sección SUID
paso 10
Escalada de privilegios — env SUID
Ejecutamos el comando de GTFOBins. env corre con SUID de root, lanza /bin/sh -p que preserva el uid efectivo de root. Obtenemos shell como root. Verificamos con whoami.
PrivEsc
dylan@host:~$ env /bin/sh -p # whoami root
captura — shell root obtenida● ● ●
Shell root obtenida via env SUID
// root obtenido ✓
Escalada completada. Shell como root obtenida via env /bin/sh -p con bit SUID.
06

// Reporte & conclusiones

vulnerabilidades
Vectores explotados
VulnerabilidadImpactoMitigación
SQL Injection en formulario loginBypass autenticación + credenciales expuestasUsar prepared statements / queries parametrizadas. Nunca concatenar input del usuario en queries SQL
Contraseña en texto claro en respuesta webCredenciales SSH expuestas directamenteNunca devolver contraseñas en respuestas HTTP. Hashear con bcrypt/argon2
Cookie PHPSESSID sin httponlySesión robable via XSSConfigurar httponly y secure en todas las cookies de sesión
SUID en /usr/bin/envEscalada completa a rootAuditar regularmente binarios con SUID. env no debe tener SUID nunca
lecciones
Lecciones aprendidas
Injection introduce la vulnerabilidad web más conocida del mundo — la SQL Injection. Un simple payload de una línea bypasea completamente la autenticación y expone credenciales reales del sistema. La lección más importante: nunca confiar en el input del usuario sin sanitizar. El segundo aprendizaje es la diferencia entre los vectores de escalada — aquí no hay sudo, lo que obliga a buscar binarios SUID. env con SUID es un error de configuración grave y evitable: en un sistema bien securizado, los únicos binarios con SUID deben ser los estrictamente necesarios (passwd, su, mount).
07

// Glosario

SQL Injection (SQLi)
Vulnerabilidad que permite a un atacante interferir en las queries SQL que una aplicación hace a su base de datos. Ocurre cuando el input del usuario se concatena directamente en la query sin sanitizar. El payload clásico ' or '1'='1 cierra la cadena original e inyecta una condición siempre verdadera, haciendo que la query devuelva todos los registros. Es la vulnerabilidad #3 en el OWASP Top 10. La solución definitiva son las prepared statements (queries parametrizadas) donde los datos nunca se mezclan con el código SQL.
SUID — Set User ID
Bit especial de permisos en Linux que hace que un ejecutable corra con los privilegios de su propietario en lugar del usuario que lo ejecuta. Si un binario tiene SUID y su propietario es root, cualquier usuario del sistema puede ejecutarlo con privilegios de root. Es necesario en binarios como passwd (necesita escribir en /etc/shadow) pero es un riesgo grave en cualquier otro binario que permita ejecutar comandos arbitrarios.
GTFOBins — env SUID
env es un comando que ejecuta otros programas en un entorno modificado. Con SUID activado, GTFOBins documenta que env /bin/sh -p escala privilegios. El flag -p es fundamental: indica a /bin/sh que preserve el uid efectivo heredado del binario SUID. Sin -p, la mayoría de shells descartan los privilegios elevados por seguridad al detectar que el uid real y el efectivo difieren.
Prepared Statements
Mecanismo de las bases de datos que separa el código SQL de los datos del usuario. En lugar de construir la query concatenando strings, se define primero la estructura de la query con marcadores (? o :param) y luego se pasan los datos por separado. El motor de base de datos trata los datos siempre como datos — nunca como código — eliminando completamente el riesgo de SQL Injection.
httponly flag (cookies)
Atributo de seguridad en cookies HTTP que impide el acceso a la cookie desde JavaScript (document.cookie). Cuando está ausente (como en esta máquina), un atacante que explote una vulnerabilidad XSS puede robar la cookie de sesión y suplantar al usuario. Siempre debe activarse en cookies de sesión junto con el flag Secure (solo HTTPS).
find -perm -4000
Comando para buscar todos los binarios con el bit SUID activado en el sistema. -perm -4000 busca archivos donde el bit 4000 (SUID) esté presente. 2>/dev/null redirige los errores de permisos al vacío para no contaminar la salida. Es uno de los primeros comandos a ejecutar en la fase de post-explotación cuando sudo no está disponible.