> For the complete documentation index, see [llms.txt](https://4lec4st.gitbook.io/4lec4st/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://4lec4st.gitbook.io/4lec4st/writes-ups/tryhackme/easy/red.md).
# Red
## Información de la máquina
La máquina **Red** pertenece a la plataforma **TryHackMe (THM)** y tiene un nivel de dificultad **Easy**.\
El reto nos permite practicar distintas fases de un pentesting real, comenzando con vulnerabilidades web y culminando en la explotación de un binario vulnerable a nivel de sistema.
Durante el proceso se abordan técnicas de **LFI (Local File Inclusion) con filtros de PHP**, análisis de archivos sensibles en el sistema (`.bash_history` y `.reminder`), el uso de herramientas de fuerza bruta como **Hashcat** y **Hydra** para autenticación en SSH, así como la manipulación de procesos en ejecución para obtener shells interactivas. Finalmente, se explota la vulnerabilidad **CVE-2021-4034 (PwnKit)** en `pkexec` para alcanzar privilegios de administrador (root).
***
## Reconocimiento
Empezaremos haciendo un primer reconocimiento para ver los puertos abiertos en el sistema.
**1. `-p-` → Escaneo de todos los puertos (1-65535)**
Por defecto, `nmap` solo escanea los **1000 puertos más comunes**.\
Con `-p-`, forzamos a que escanee **los 65535 puertos** de la máquina objetivo, lo que puede ser útil para encontrar servicios que corren en puertos poco convencionales.
**2. `--open` → Filtrar solo los puertos abiertos**
Cuando escaneamos un sistema, muchos puertos pueden estar cerrados o filtrados por un firewall.\
Este parámetro hace que `nmap` **solo muestre los puertos abiertos**, reduciendo el ruido y facilitando el análisis.
**3. `-sS` → Stealth Scan (Escaneo Sigiloso con SYN)**
Es conocido como **"TCP SYN Scan"**, y funciona de la siguiente manera:
* `nmap` envía un paquete **SYN** (solicitud de conexión).
* Si el puerto está abierto, el servidor responde con **SYN-ACK**.
* En lugar de completar la conexión con un **ACK**, `nmap` responde con un **RST (Reset)**, interrumpiendo la comunicación.
**4. `--min-rate 5000` → Velocidad mínima de paquetes (5000 por segundo)**
Por defecto, `nmap` ajusta dinámicamente la velocidad de los paquetes según la respuesta de la red.\
Con `--min-rate 5000`, obligamos a `nmap` a **no enviar menos de 5000 paquetes por segundo**, acelerando el escaneo.
**5. `-n` → Deshabilitar resolución DNS**
Normalmente, `nmap` intenta resolver el nombre de dominio de las IPs escaneadas (DNS lookup).\
Con `-n`, evitamos esta resolución de nombres, lo que **acelera el escaneo** y evita que los servidores DNS registren nuestra actividad.
**6. `-Pn` → Omitir detección de host (Host Discovery Off)**
Por defecto, `nmap` envía paquetes ICMP (ping) para ver si un host está activo antes de escanearlo.\
Si un firewall bloquea los pings, `nmap` puede marcarlo como "host down" y no escanearlo.
**7. `-oG`** **→ Exportar el contenido en formato grepeable**
Todo el resultado del escaneo lo exportaremos en un archivo llamado **`puertos` .**
El escaneo revela 2 puertos abiertos, puerto 22(SSH) y puerto 80(HTTP). Ahora realizamos un escaneo más avanzado sobre estos 2 puertos
**1. `-p22,80` → Escaneo de puertos específicos**
Con `-p22,80`, le indicamos que **solo** escanee los puertos **22 (SSH)** y **80 (HTTP)**
**2. `-sCV` → Escaneo de versiones y scripts básicos**
Este parámetro en realidad es **dos combinaciones en una**:
* **`-sC`** → Activa los **NSE scripts por defecto** en `nmap` (similar a usar `--script=default`).\
Ejecuta scripts básicos para enumerar información del servicio detectado, como banners, versiones, etc.
* **`-sV`** → Realiza **fingerprinting de versiones**, intentando identificar la versión exacta del software en cada puerto abierto.
**3. `-oN` → Guardar el resultado en formato Normal**
Por defecto, `nmap` muestra los resultados en pantalla, pero con **`-oN targeted`**, guardamos el resultado en un archivo en **formato legible para humanos**.
Esta es la página web que se presenta inicialmente
## LFI base64 filter
Comencé probando la técnica clásica de Local File Inclusion (LFI) utilizando rutas relativas con `../../../`, pero esta aproximación no arrojó ningún resultado útil.
Tras varios intentos, identifiqué que la aplicación permitía el uso de filtros internos de PHP, en particular el filtro que convierte el contenido en **base64**.
Este filtro codifica el archivo solicitado en base64, lo que nos permite extraer su contenido de manera legible tras decodificarlo.
```bash
vuln.php?page=php://filter/convert.base64-encode/resource=/etc/passwd
```
Para validar su funcionamiento utilicé `curl`, concatenando la salida con `base64 -d` para decodificarla. De esta manera, confirmamos que el LFI es funcional y que podemos leer archivos del sistema.\
Al revisar `/etc/hosts`, encontramos referencias a dos usuarios locales: **Red** y **Blue**.
## .bash\_history & .reminder in User Blue
Al continuar revisando archivos del sistema, localizamos el historial de comandos del usuario **Blue** (`.bash_history`). Dentro de él aparecían varias instrucciones relevantes que hacían referencia a un archivo oculto llamado **.reminder**.
Al inspeccionar el archivo **.reminder**, observamos que contenía una **contraseña en texto claro**, posiblemente utilizada por este usuario para autenticarse en distintos servicios.
## Auth Blue
Para autenticarnos como el usuario **Blue**, replicamos los pasos observados en su `.bash_history`. Esto incluía crear un archivo llamado **.reminder** que contenía la contraseña previamente identificada.
Posteriormente, utilizando **Hashcat**, generamos una lista de posibles combinaciones derivadas de la contraseña encontrada, lo que nos permitió obtener variaciones dinámicas de la misma.
El siguiente paso fue emplear **Hydra** contra el servicio **SSH**, usando al usuario *Blue* junto con el diccionario generado por Hashcat.\
La contraseña resultó ser **dinámica**, es decir, cambia de forma periódica en el tiempo.
Una vez obtenida la contraseña válida, conseguimos autenticarnos con éxito como el usuario **Blue** a través de SSH.
Tras acceder a la sesión, fue posible visualizar la **primera flag del reto**.
## Auth Red
Durante la enumeración del sistema ejecutamos `ps -faux`, con lo que pudimos listar los procesos activos y sus respectivos usuarios.
En la salida observamos que el usuario **red** estaba ejecutando una **bash** redirigida a través del puerto **9001**, asociada al dominio `redrules.thm`.
Para interceptar esa conexión, añadimos una entrada personalizada en `/etc/hosts`, apuntando el dominio `redrules.thm` hacia nuestra propia dirección IP.
Tras configurar la escucha en el puerto **9001** y esperar la conexión entrante, conseguimos obtener una **shell interactiva** como el usuario **red**.
Dentro de esta sesión, fue posible acceder a la **segunda flag** del reto.
## Auth Root -> pkexec 0.105 version (CVE-2021-4034)
En una segunda fase de enumeración, detectamos la presencia de un directorio **.git** en el directorio personal del usuario **red**.
Dentro de este repositorio se incluía una copia del binario **pkexec**.
Al revisar la versión del binario, confirmamos que correspondía a **pkexec 0.105**.
Investigando esta versión en bases públicas de vulnerabilidades, encontramos que está asociada al **CVE-2021-4034 (PwnKit)**, un exploit de escalada de privilegios en `pkexec`.
{% embed url="" %}
Localizamos en GitHub un exploit funcional para esta vulnerabilidad.
Clonamos el repositorio que contenía el código del exploit.
Renombramos el archivo para simplificar su uso.
Fue necesario modificar en el exploit la ruta hacia `pkexec`, ya que en la máquina víctima no coincidía con la ruta predeterminada del script.
Transferimos el exploit a la máquina víctima montando un servidor HTTP con `python3 -m http.server` en nuestro host y descargándolo mediante `wget`.
Al ejecutar el exploit, obtuvimos una **shell como root**, logrando la escalada de privilegios.
Con los privilegios de administrador, finalmente accedimos a la **flag final**.
***
## Conclusión
La máquina **Red (THM)** demuestra cómo una vulnerabilidad aparentemente pequeña —un **LFI filtrado en base64**— puede convertirse en la puerta de entrada para el compromiso total del sistema.\
El recorrido pasa por varias fases clave:
* **Explotación inicial** mediante LFI y decodificación de archivos en base64.
* **Acceso a credenciales** en archivos de usuario (`.bash_history` y `.reminder`).
* **Autenticación en SSH** con credenciales dinámicas obtenidas por fuerza bruta.
* **Aprovechamiento de procesos expuestos** para obtener acceso al usuario Red.
* **Escalada de privilegios** mediante el exploit público del **CVE-2021-4034 (PwnKit)**.
En conjunto, la máquina enseña buenas prácticas de enumeración, la importancia de revisar archivos de configuración e historiales de comandos, y el riesgo de contar con binarios vulnerables en el sistema.\
Al finalizar, se logra el acceso completo como **root**, confirmando todas las flags y concluyendo con éxito el laboratorio.