> 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/medium/domain.md).
# Domain
## Información de la máquina
Domain es una máquina de nivel medio que combina técnicas clásicas de **enumeración de servicios**, **explotación web** y **escalada de privilegios** locales.
Durante su resolución, pondremos en práctica habilidades fundamentales en **reconocimiento activo**, descubrimiento de usuarios, fuerza bruta de contraseñas, explotación de servicios SMB y ejecución remota de comandos mediante una **webshell PHP**.
Además, en la fase final, llevaremos a cabo una escalada de privilegios aprovechando un binario con el bit **SUID mal configurado**, lo que nos dará acceso completo como **root** al sistema.
***
## Reconocimiento
La fase de **reconocimiento** es el primer paso a la hora de resolver una máquina. Su objetivo es recopilar la mayor cantidad de información posible sobre el sistema objetivo, permitiendo entender su estructura, tecnología y posibles vectores de ataque.
Empezaremos haciendo un ping a la máquina víctima para ver si está encendida y ante que nos enfrentamos.
Si recibimos respuesta, significa que la máquina está en línea. Además, observamos que el **TTL** (Time To Live) es **64**, lo que indica que es un sistema **Linux** (normalmente, los sistemas Windows tienen un TTL de 128).
#### **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 **`puertos` .**
El escaneo revela que los puerto 80,139,445 están abierto. Ahora realizamos un escaneo más detallado:
**1. `-p80,139,445` → Escaneo de puertos específicos**
Con `-p80,139,445`, le indicamos que **solo** escanee los puertos **80 (HTTP), 139, 445 (SAMBA)**.
**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:
Vemos una descripción de lo que es Samba.
***
## Enumeración y búsqueda de vulnerabilidades
En la fase de reconocimiento, detectamos que el puerto **139/tcp** está abierto. Este puerto está asociado al protocolo **NetBIOS Session Service**, que normalmente es utilizado por **Samba**, un servicio que permite compartir archivos e impresoras entre sistemas Windows y Linux.
La primera herramienta que utilizamos es **`smbmap`**, una utilidad muy útil para auditar permisos en comparticiones SMB sin necesidad de autenticarse (aunque también permite autenticación).
Dado que `smbmap` no ha sido útil en este caso, pasamos a utilizar **`rpcclient`**, una herramienta poderosa para interactuar con los servicios RPC de Windows/Samba. Permite realizar consultas y ejecutar funciones sobre el servicio sin autenticación, si el servidor lo permite.
Dado que `smbmap` no ha sido útil en este caso, pasamos a utilizar **`rpcclient`**, una herramienta poderosa para interactuar con los servicios RPC de Windows/Samba. Permite realizar consultas y ejecutar funciones sobre el servicio sin autenticación, si el servidor lo permite.
```bash
rpcclient -U '' 10.88.0.2
```
El parámetro `-U ""` intenta conectarse de forma anónima. Una vez dentro del entorno interactivo de `rpcclient`, podemos ejecutar distintos comandos para enumerar información sensible.
Por ejemplo:
```bash
enumdomusers
```
Este comando nos permite enumerar los usuarios del dominio o del sistema Samba si la configuración lo permite.\
Al ejecutar este comando, obtenemos dos nombres de usuario:
* `james`
* `bob`
Primero intentamos usar **Hydra**, una herramienta muy conocida para realizar ataques de fuerza bruta sobre múltiples servicios como SSH, FTP, SMB, etc.
El intento falla porque el servidor **no soporta SMBv1**, que es lo que utiliza `Hydra` por defecto para autenticar contra SMB. Esto nos obliga a buscar una alternativa más moderna y compatible.
Como alternativa a Hydra, usamos **NetExec**, una herramienta más actual que reemplaza al clásico **CrackMapExec (CME)**. NetExec permite interactuar con servicios como SMB, RDP, WinRM y más, facilitando tareas como la enumeración de usuarios, autenticación, ejecución remota de comandos, etc.
Durante la ejecución, NetExec nos muestra un aviso para usar la opción `--ignore-pw-decoding`, ya que algunas contraseñas contenían **caracteres especiales** que pueden interferir en el análisis si no se gestionan correctamente.
Además, aplicamos un filtro para **mostrar únicamente los inicios de sesión exitosos**, descartando todos los intentos fallidos para centrarnos en resultados relevantes.
* Conseguimos encontrar una **contraseña válida** para el usuario `bob`.
* La contraseña es: `star`
***
## Explotación de las vulnerabilidades
Tras haber descubierto que el usuario `bob` tiene como contraseña `star`, procedemos a conectarnos al servicio **SMB** para ver a qué recursos compartidos tenemos acceso y qué permisos nos han sido otorgados. Utilizamos la herramienta **`smbmap`**, que nos permite listar los recursos compartidos (shares) accesibles con credenciales específicas, así como los permisos asociados a cada uno.
Identificamos un recurso compartido llamado `html`, al cual el usuario `bob` tiene acceso con permisos de escritura. Ahora que sabemos que podemos escribir en el recurso `html`, utilizamos **`smbclient`**, una herramienta interactiva para conectarse a comparticiones SMB.
Creamos un archivo llamado `cmd.php` con el siguiente contenido:
```php
```
Este archivo permite ejecutar comandos directamente desde el navegador, pasando el parámetro `cmd` en la URL.
Una vez subido con `smbclient`, lo visitamos en el navegador y confirmamos que el código se ejecuta correctamente.
Con el acceso remoto confirmado (**RCE**), es momento de establecer una **reverse shell** para tener una conexión más completa con la máquina. Nos ponemos en escucha con **netcat** en el puerto 443.
Enviamos un payload desde el navegador con el parámetro `cmd`, usando una revershell en PHP, urlencodeando los & por %26.
Obtenemos acceso directo a la máquina como el usuario que ejecuta el servicio web, lo cual nos permite continuar con la enumeración local del sistema.
***
## Post Explotación y escalada de privilegios
Durante la fase de enumeración local del sistema, identificamos que el binario `nano` tiene el **bit SUID** activado.
Este permiso especial permite que el binario se ejecute con los **privilegios del propietario del archivo**, en este caso, **root**.
El bit SUID en un binario como `nano` implica que, **aunque lo ejecute un usuario sin privilegios, los cambios que se realicen dentro del editor afectarán como si los hubiese hecho el usuario root**.
Esto nos abre una vía de explotación muy directa: editar archivos del sistema protegidos, como `/etc/passwd`.\
Editamos la línea del usuario `root` para eliminar la `x`, lo que permite conectarse **sin necesidad de contraseña.**
Una vez modificado el archivo, simplemente ejecutamos. Como ya no hay contraseña definida para el usuario `root`, el sistema nos deja acceder directamente, otorgándonos **acceso completo (root shell)**.
Ya tenemos privilegios máximos.
***
## Conclusión
Esta máquina nos ha permitido simular un ataque realista partiendo desde el reconocimiento más básico hasta el acceso completo como **root**.
Durante la fase inicial, utilizamos **Nmap** para descubrir servicios activos como HTTP y Samba, lo que nos permitió centrar nuestra atención en el protocolo **SMB** (puertos 139/445). Gracias a herramientas como **rpcclient** y **NetExec**, logramos enumerar usuarios y obtener credenciales válidas a través de fuerza bruta.
Una vez dentro del servicio SMB, descubrimos un recurso compartido con permisos de escritura. Subiendo una **webshell PHP**, obtuvimos acceso remoto mediante RCE, lo que facilitó la conexión con **netcat** y la obtención de una shell interactiva.
Por último, identificamos que el binario `nano` tenía activado el bit **SUID**, lo que nos permitió editar el archivo `/etc/passwd` como si fuéramos root. Al eliminar la contraseña del usuario root, conseguimos acceso total al sistema, completando exitosamente la escalada de privilegios.