> 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/dockerlabs/easy/winterfell.md).
# Winterfell
## Información de la máquina
Winterfell es uns máquina con dificultad fácil que expone múltiples vectores de ataque accesibles desde un entorno sin autenticación. Comenzaremos obteniendo acceso inicial a través del servicio SMB, utilizando credenciales descubiertas mediante enumeración web y fuerza bruta. Posteriormente, en la fase de escalada de privilegios, aprovecharemos configuraciones inseguras de `sudo` que nos permiten ejecutar binarios como `python3` y `bash` para pivotar entre usuarios y, finalmente, obtener una shell con privilegios de root.
***
## Reconocimiento
Empezamos con el escaneo de nmap para ver puertos abiertos en la máquina víctima.
**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 65,535 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 **`allPorts` .**
El escaneo revela que el puerto 22,80,139,445 está abierto. Ahora realizamos un escaneo más detallado:
**1. `-p80` → Escaneo de puertos específicos**
Con `-p80`, le indicamos que **solo** escanee los puertos 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**.
Al parecer tenemos una web por el puerto 80, por lo que vamos a visitarla:
***
## Enumeración y búsqueda de vulnerabilidades
Usamos **Gobuster**, una herramienta rápida de fuerza bruta que permite descubrir directorios y archivos ocultos en servidores web. Funciona probando muchas rutas posibles a partir de una lista de palabras (wordlist). Si el servidor responde positivamente a alguna de esas rutas, quiere decir que existe, y así podemos encontrar recursos que no están visibles al usuario común.
En el escaneo con Gobuster, se descubrió un directorio accesible en la ruta `/dragon`. Dentro de este directorio, había un archivo llamado `EpisodiosT1`. Es posible que esté expuesto de forma accidental, y puede contener información útil para un atacante
Al abrir el archivo `EpisodiosT1`, se observa una lista de palabras o frases. Por su formato y contenido, estas podrían funcionar como contraseñas (por ejemplo, frases comunes o nombres relacionados con una serie). En este tipo de pruebas, cualquier archivo de texto es sospechoso si contiene entradas línea por línea.
Copiamos esa lista de posibles contraseñas a un archivo local, para usarla más adelante en ataques de fuerza bruta o prueba de credenciales. Esto es una práctica común en pentesting: recolectar posibles credenciales para su posterior uso.
Los puertos **139 y 445** indican que está activo el servicio **SMB (Server Message Block)**, usado comúnmente en sistemas Windows (aunque también en Linux con Samba). Utilizamos **enum4linux**, una herramienta que permite obtener información como usuarios, grupos y recursos compartidos de SMB sin necesidad de autenticarse.
El escaneo con `enum4linux` reveló al menos un usuario válido del sistema llamado `jon`. Esta información es clave para intentar ataques de autenticación, como fuerza bruta o password spraying.
***
## Explotación de vulnerabilidades
Usamos **crackmapexec** (CME), una herramienta muy útil para pentesters, que permite probar credenciales contra servicios como SMB. Se toma el nombre de usuario `jon` y se prueba la lista de contraseñas del archivo que habíamos guardado antes para ver si alguna es válida.
Una de las combinaciones probadas es aceptada por el sistema. Por lo tanto, ahora tenemos unas credenciales válidas: usuario `jon` y contraseña `seacercaelinvierno`. Esto nos da un punto de acceso inicial.
Utilizamos **smbclient**, una herramienta de línea de comandos para interactuar con recursos SMB. Con las credenciales recién descubiertas, listamos los recursos compartidos disponibles y vemos uno llamado `shared`. Intentamos acceder a este recurso usando el usuario `jon`.
Se logró acceder al recurso `shared` y dentro hay al menos un archivo disponible. Lo descargamos localmente para revisarlo, buscando cualquier información sensible como contraseñas, rutas, o pistas sobre otros usuarios o servicios.
El archivo contiene una cadena codificada en **Base64**, una forma simple de ocultar información. La decodificamos fácilmente y obtenemos una nueva contraseña para el usuario `jon`, que es `hijodelanister`. Podría ser más reciente o válida para otros servicios.
Con las nuevas credenciales `jon:hijodelanister`, intentamos acceder al sistema a través del servicio **SSH**. Si la autenticación tiene éxito, significa que ahora tenemos acceso directo al sistema con una shell interactiva como el usuario `jon`.
***
## Post Explotación y escalada de privilegios
Una vez dentro, se realiza **post-explotación**, que incluye revisar archivos en busca de pistas. Se encuentra un archivo con un mensaje o advertencia sobre una herramienta oculta, lo que puede indicar un binario personalizado o script con permisos especiales.
Se detecta un archivo llamado `.mensaje.py`. Al ejecutar `sudo -l`, el sistema nos muestra que `jon` puede usar `sudo` para ejecutar ese script **y el binario `python3`** como el usuario `aria`, sin necesidad de contraseña. Esto abre la puerta para escalar privilegios.
Consultamos GTFOBins, una base de datos que muestra cómo abusar de binarios comunes con privilegios elevados. Python3 permite obtener una shell si se ejecuta con permisos de otro usuario, como `aria`.
Editamos el script `.mensaje.py` para incluir el código necesario para obtener una shell. Al ejecutarlo con `sudo -u aria`, obtenemos acceso como el usuario `aria`.
Ya con acceso como `aria`, revisamos de nuevo los permisos con `sudo -l`. Se revela que `aria` puede ejecutar otros comandos o binarios como otro usuario, en este caso `daenerys`. Esto permite una nueva escalada de privilegios.
Desde la cuenta `aria`, accedemos al directorio `/home/daenerys` (quizá porque tiene permisos de lectura). Dentro hay archivos visibles que contienen una palabra: `drakaris`. Dado el contexto, parece una contraseña que podríamos probar para `daenerys`.
Intentamos autenticarnos como el usuario `daenerys` con la contraseña `drakaris`. La autenticación tiene éxito, por lo que ahora tenemos control de esa cuenta, que podría tener más privilegios en el sistema.
Desde la cuenta de `daenerys`, ejecutamos de nuevo `sudo -l` y encontramos que podemos ejecutar **`bash` como otro usuario**, probablemente **root**, y hay un archivo oculto también relevante.
Hacemos el mismo procedimiento que con python3 y como resultado, obtenemos una **shell de root**, lo que significa que ya tenemos el control completo del sistema y se considera que la máquina está totalmente comprometida.
***
## Conclusión
La explotación de esta máquina nos ha permitido aplicar técnicas fundamentales en un proceso de pentesting, desde la enumeración de servicios expuestos y extracción de credenciales hasta la escalada de privilegios utilizando configuraciones permisivas en `sudo`. Este escenario refuerza la importancia de proteger los servicios SMB, evitar la exposición de archivos sensibles en aplicaciones web y controlar estrictamente los permisos de ejecución en entornos Linux para prevenir accesos no autorizados.