> 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/hack-the-box/easy/support.md).
# Support
## Información de la máquina
Support es una máquina Windows de dificultad Fácil que cuenta con un recurso compartido SMB que permite la autenticación anónima. Tras conectarse al recurso compartido, se descubre un archivo ejecutable que se utiliza para consultar el servidor LDAP de la máquina en busca de usuarios disponibles. Mediante ingeniería inversa, análisis de red o emulación, se identifica la contraseña que el binario utiliza para enlazar el servidor LDAP y se puede utilizar para realizar consultas LDAP adicionales. Se identifica un usuario llamado `support` en la lista de usuarios, y se descubre que el campo `info` contiene su contraseña, lo que permite una conexión WinRM a la máquina. Una vez en la máquina, se puede recopilar información del dominio mediante `SharpHound`, y `BloodHound` revela que el grupo `Shared Support Accounts`, al que pertenece el usuario `support`, tiene privilegios `GenericAll` en el controlador de dominio. Se realiza un ataque de Delegación Restringida Basada en Recursos y se recibe un shell como `NT Authority\System`.
***
## Reconocimiento
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 127, lo que indica que es un sistema Windows.
{% hint style="success" %}
Esto sucede porque Hack The Box virtualiza las máquinas, lo que a menudo reduce el TTL en un punto respecto al valor estándar.
En entornos reales tendrían los siguientes valores:
TTL Linux **→** 64
TTL Windows **→** 128
{% endhint %}
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 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 muchos puertos abiertos. Ahora haremos un escaneo más detallado.
**1. `-p` → Escaneo de puertos específicos**
Con `-p`, le indicamos que **solo** escanee los puertos que queremos
**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**.
## SMB Enumeration
Comenzamos explorando el servicio **SMB (Server Message Block)**, que permite compartir archivos e impresoras en entornos Windows. Al hacer una enumeración inicial, descubrimos que el **nombre del dominio** es `support.htb`, lo cual es útil para futuras autenticaciones o ataques dirigidos al Active Directory.
En realidad, probablemente se quiso decir que se añadió `support.htb` en el archivo `/etc/hosts`, no en `/etc/passwd`.\
Este paso es necesario para que nuestro sistema reconozca el dominio `support.htb` y lo asocie con la IP correspondiente de la máquina víctima.
Usamos **smbclient**, una herramienta de línea de comandos para interactuar con recursos compartidos de SMB, con una sesión **anónima (null session)**.
Con la misma sesión anónima, accedemos al recurso **support-tools** y descargamos el archivo comprimido UserInfo.exe.zip.
## Binary Analysis
Extraemos el archivo `.exe` con la herramienta **unzip**:
```
unzip UserInfo.exe.zip
```
Esto nos da un ejecutable llamado **UserInfo.exe**, que será objeto de análisis estático para encontrar credenciales embebidas.
**dnSpy** es una herramienta de análisis y depuración de ejecutables escritos en .NET. Permite **descompilar y examinar código fuente en C# o VB.NET**, facilitando la lectura de funciones, clases y lógica de ejecución de binarios.\
Es una utilidad de escritorio y debe ejecutarse en **Windows**.
{% hint style="success" %}
Tenemos que usarlo en windows
{% endhint %}
{% embed url="" %}
Abrimos `UserInfo.exe` en dnSpy y exploramos su estructura. Dentro de una clase relacionada con autenticación LDAP, encontramos la función `LdapQuery`, que realiza peticiones al servicio de directorio.\
En esta función hay una llamada sospechosa a `getPassword()`, lo que sugiere que la contraseña está **almacenada o generada de forma interna**.
Al seguir la definición de `getPassword()`, llegamos a una clase llamada `Protected` que contiene un bloque de código que implementa un **algoritmo de descifrado**.\
Este tipo de implementación es común cuando los desarrolladores intentan "proteger" contraseñas incrustadas en aplicaciones .NET, aunque en la práctica se pueden revertir fácilmente.
Como alternativa a ejecutar el binario, **tradujimos el código de descifrado a Python**, lo cual permite realizar un análisis estático y ejecutar el algoritmo en nuestro entorno local de forma controlada y segura.
El código convertido a Python permitió descifrar correctamente el valor cifrado, obteniendo **la contraseña original en texto claro**, que posiblemente corresponde a una cuenta del dominio.
Probamos las credenciales con el usuario ldap y vemos que son correctas.
## Auth support
### ldapsearch
`ldapsearch` es una herramienta de línea de comandos que permite consultar datos en un **servidor LDAP**, como es el caso de un **Active Directory**.\
Se usa para **enumerar objetos del dominio**, como usuarios, grupos, unidades organizativas (OUs), etc.
Entre los resultados obtenidos por `ldapsearch`, observamos una entrada con el atributo **`info:`**, que no es común ni esencial para objetos de usuario.\
Este campo contiene una **cadena de texto plano** que parece una contraseña.
Probamos el usuario `support` con la contraseña obtenida en el campo `info`, contra el servicio **WinRM (Windows Remote Management)** utilizando una herramienta como **NetExec (nxc).**
En la salida obtenemos el mensaje `!Pwned`, lo cual indica que la autenticación fue **exitosa** y que las credenciales son válidas para acceder al sistema.
### Shell support
Utilizamos **Evil-WinRM**, una herramienta que permite abrir una **shell remota en Windows** a través de WinRM.
## Domain Admin access
### Bloodhound
**SharpHound** es el *collector* oficial de **BloodHound**, una herramienta de reconocimiento y análisis para entornos Active Directory.\
SharpHound se encarga de recolectar datos sobre relaciones de confianza, sesiones activas, membresías de grupos, ACLs, delegaciones, etc., en formato `.json` o `.zip`, los cuales se cargan luego en la interfaz de BloodHound para su análisis visual.
{% embed url="" %}
Transferimos el archivo SharpHound.exe y ejecutamos el comando en la sesión de Evil-WinRm.
```powershell
.\SharpHound.exe -c All
```
Esto generará un archivo `.zip` que contiene toda la información recolectada del dominio.
{% embed url="" %}
En BloodHound detectamos que un grupo llamado **Shared Support Account** tiene el permiso **GenericAll** sobre el objeto del **controlador de dominio** (por ejemplo, `DC=support,DC=htb`).\
El permiso **GenericAll** otorga **control total** sobre ese objeto, incluyendo la posibilidad de modificar atributos sensibles.
Este tipo de relación puede explotarse usando un ataque de **Resource-Based Constrained Delegation (RBCD)**.
### Resource-Based Constrained Delegation attack
El **Resource-Based Constrained Delegation (RBCD)** es un ataque que permite a un atacante **impersonar usuarios privilegiados (como Domain Admins)** hacia un servicio que controla, si tiene permisos para modificar su atributo `msDS-AllowedToActOnBehalfOfOtherIdentity`.
Pasos generales del ataque:
1. **Crear una máquina o cuenta controlada por el atacante** (Computer Account).
2. **Asignarse permisos en el objeto víctima** (por ejemplo, el controlador de dominio), usando `GenericAll`, para modificar `msDS-AllowedToActOnBehalfOfOtherIdentity`.
3. **Usar S4U2Self + S4U2Proxy** para solicitar un **TGS en nombre de otro usuario**, como `administrator`, contra el servicio controlado por el atacante.
Este ataque es muy potente porque **no requiere acceso directo a las credenciales de administradores**, solo una mala configuración de delegación y control sobre el objeto víctima.
{% embed url="" %}
#### **1. Creación de una cuenta de máquina con PowerMad**
Para iniciar un ataque de **RBCD** necesitamos una cuenta controlada por nosotros (el atacante). Esto lo conseguimos con [**PowerMad.ps1**](https://github.com/Kevin-Robertson/Powermad), un script PowerShell que nos permite crear objetos tipo *Computer* en Active Directory desde un contexto con privilegios mínimos (por ejemplo, un usuario común puede crear hasta 10 máquinas por defecto).
```powershell
Import-Module .\Powermad.ps1
New-MachineAccount -MachineAccount 4lec4st -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
```
Esto crea una máquina llamada `4lec4st` con contraseña definida, y nos permite operar sobre ella para los siguientes pasos.
#### **2. Recolección de información con PowerView**
Usamos [**PowerView.ps1**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1), una herramienta fundamental para el reconocimiento y abuso de entornos Active Directory.
Primero confirmamos que la máquina `4lec4st` se haya creado correctamente y recuperamos su SID (Security Identifier):
```powershell
Get-DomainComputer 4lec4st
$ComputerSid = Get-DomainComputer 4lec4st -Properties objectsid | Select -Expand objectsid
```
```
Get-DomainComputer 4lec4st
```
#### **3. Configuración de delegación en el controlador de dominio**
Creamos una nueva ACL utilizando el SID de la máquina que controlamos, indicando que puede actuar en nombre de otros objetos:
```powershell
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$ComputerSid)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
```
Aplicamos esta ACL al controlador de dominio (`dc`) usando el atributo `msds-allowedtoactonbehalfofotheridentity`:
```powershell
Get-DomainComputer dc | Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes}
```
**Verificamos que la delegación se haya configurado correctamente:**
```powershell
Get-DomainComputer dc -Properties 'msds-allowedtoactonbehalfofotheridentity'
```
Una salida no vacía (por ejemplo, `{1, 0, 4, 128...}`) confirma que se aplicaron los cambios.
#### **4. Obtención de un Service Ticket con Impacket (getST)**
Para completar el ataque, usamos la herramienta `getST.py` de **Impacket**, incluida en la carpeta `examples/`. Esta permite solicitar un ticket de servicio (TGS) en nombre de otro usuario (por ejemplo, `Administrator`) usando **S4U2Self + S4U2Proxy**, ya que el sistema cree que la máquina `4lec4st` está autorizada a actuar en su nombre.
{% embed url="" %}
Hacemos uso de la herramienta como nos ponen en el repositorio.
#### **5. Exportación del ticket y acceso al sistema**
Exportamos la variable de entorno `KRB5CCNAME` apuntando al archivo `.ccache` obtenido y mediante `psexec.py` obtenemos acceso al sistema.
Tenemos acceso al sistema y podemos ver la flag final.
***
## Conclusión
La máquina *Support* de Hack The Box representa un ejemplo clásico pero bien estructurado de una cadena de explotación en entornos Windows corporativos con Active Directory, destacando la importancia de la defensa en profundidad y la segmentación de privilegios. A través de una sencilla enumeración SMB con autenticación anónima, se obtiene acceso a un binario que, tras ser analizado, revela credenciales embebidas usadas para consultas LDAP. Este acceso permite descubrir credenciales adicionales, lo que finalmente facilita el acceso remoto mediante WinRM.
Una vez dentro, el uso de herramientas como SharpHound y BloodHound revela relaciones de privilegio mal configuradas que permiten escalar hasta el controlador de dominio. A partir de ahí, se ejecuta exitosamente un ataque de delegación restringida basada en recursos (RBCD), consiguiendo acceso como *NT AUTHORITY\SYSTEM*, el nivel más alto de privilegio en un sistema Windows.