Clonando bosques AD con LudusHound: de BloodHound a laboratorio en minutos

Si estás en un Red Team y aún no conoces Ludus, estás regalando horas de vida configurando laboratorios a mano como si estuviéramos en 2005.

Ludus es un framework open source para automatizar la creación de entornos de Active Directory, usando Ansible + Vagrant + VirtualBox/VMware/Proxmox.

¿Por qué es especial? Porque combina lo que ya sabes (roles de Ansible, provisioners de Vagrant) con plantillas modulares para crear:

  • Controladores de dominio (DCs)
  • Miembros de dominio (workstations, servidores)
  • Usuarios, grupos, GPOs, OUs
  • Relaciones de confianza entre dominios

Todo con un solo archivo YAML, versionable y compartible. Tipo este ejemplo:

lab_name: hackplayers-lab
network:
  domain: hackplayers.local
  net: 192.168.56.0/24
  gateway: 192.168.56.1

nodes:
  - name: DC1
    type: domain_controller
    ip: 192.168.56.10
    ram: 4096
  - name: WS1
    type: workstation
    ip: 192.168.56.20
    ram: 2048

users:
  - name: adminuser
    password: 'P@ssw0rd123!'
    groups:
      - Domain Admins
  - name: juanito
    password: '12345678'
    groups:
      - Domain Usersnetwork:
Básicamente Ludus te crea el entorno en las típicas fases
  • Fase 1: Vagrant crea las máquinas virtuales (VirtualBox, VMware o Proxmox).
  • Fase 2: Ansible promueve DCs, une workstations, crea usuarios, OUs, GPOs.
  • Fase 3: Scripts custom (PowerShell) afinan detalles: ACLs, shares, backdoors si quieres.

Resultado: un bosque operativo, con Kerberos, LDAP, GPOs… como el de tu cliente, pero sin auditorías ni IDS.

¿El problema? Definir a mano toda la topología realista es lento y propenso a errores:

  • ¿Cómo reflejas ACLs complejas?
  • ¿Cómo simulas relaciones de confianza multi-bosque?
  • ¿Cómo reproduces un path to DA detectado en un engagement real?

Ahí es donde entra la joya que os traemos hoy: LudusHound.

LudusHound es un parser en Go que toma tu base de datos de BloodHound y la convierte en un bosque AD funcional en Ludus. La idea es esa, exportar exactamente los objetos, ACLs y relaciones del dominio real para desplegarlos en tu lab.

No más “Creo que este GPO era así…”. Copias lo que has pillado con SharpHound tal cual. Solo unos sencillos pasos:

1. Conexión: LudusHound se conecta al Neo4j de BloodHound:

ludushound --bh-server http://127.0.0.1:7474 --bh-user neo4j --bh-pass yourpass

2. Extracción: obtiene nodos (users, computers, groups, domains) y edges (MemberOf, HasSession, AdminTo).

3. Parsing: Genera:

  • JSON con toda la info
  • Plantilla YAML para Ludus
  • Roles Ansible ajustados (ej: DCs, workstations, trusts)

4. Deploy: Con "ludus deploy" montas la infraestructura real en cuestión de minutos.

Veamos un ejemplo muy tonto pero ilustrativo. Imaginaros que nuestra ingesta de Bloodhounf y posterior procesado genera este sencillo yaml:

lab_name: hackplayers-lab

network:
  domain: hackplayers.local
  net: 192.168.56.0/24
  gateway: 192.168.56.1
  dns: 192.168.56.10

nodes:
  - name: DC01
    type: domain_controller
    ip: 192.168.56.10
    ram: 4096
    cpus: 2

  - name: WS-HELP01
    type: workstation
    ip: 192.168.56.20
    ram: 2048
    cpus: 1

  - name: WS-IT01
    type: workstation
    ip: 192.168.56.21
    ram: 2048
    cpus: 1

ous:
  - name: IT
    description: Unidad organizativa para IT
  - name: HelpDesk
    description: Unidad organizativa para Helpdesk

users:
  - name: HelpDeskUser
    password: 'P@ssw0rd123!'
    ou: HelpDesk
    groups:
      - HelpDesk

  - name: ServerAdminUser
    password: 'Adm1nP@ss!'
    ou: IT
    groups:
      - ServerAdmins

groups:
  - name: HelpDesk
    description: Grupo del helpdesk
  - name: ServerAdmins
    description: Admins de servidores
  - name: Domain Admins
    description: Administradores del dominio

acls:
  # HelpDeskUser tiene GenericAll sobre ServerAdmins
  - principal: HelpDeskUser
    target: ServerAdmins
    rights:
      - GenericAll

  # ServerAdmins tiene AddMember sobre Domain Admins
  - principal: ServerAdmins
    target: Domain Admins
    rights:
      - AddMember

scripts:
  post_tasks:
    - name: Crear carpeta compartida en WS-IT01
      script: scripts/create_share.ps1
    - name: Crear archivo de credenciales olvidadas
      script: scripts/drop_plaintext_creds.ps1
El escenario resultante sería este:
  • 1 Dominio: hackplayers.local
  • 1 DC (DC01)
  • 2 Workstations (WS-HELP01 y WS-IT01)
  • 1 usuario helpdesk que tiene GenericAll sobre un grupo de admins de servidores.
  • El grupo ServerAdmins puede añadir miembros a Domain Admins.
  • Path final: HelpDeskUser → ACL → ServerAdmins → AddMember → Domain Admins
Es decir, tendríamos una topología bastante realista con un DC, workstations para Helpdesk e IT y un path to DA reproducible exactamente como lo verías en BloodHound: ACL GenericAll + AddMember.

Además añadiríamos como post-tareas dos scripts para dejar cosas jugosas (shares o ficheros con credenciales).
scripts/drop_plaintext_creds.ps1
# No es OPSEC, es un lab :)
$path = "C:\Users\Public\forgotten_creds.txt"
$content = "svc_backup : P@ssw0rd2024!"
Set-Content -Path $path -Value $content
Y ya estaría. Guardaríamos config.yml y los scripts. Colocamos la ISO de Windows Server en la ruta que definamos en tu Vagrantfile (o usa la default) y ejecutamos el ludus deploy.
En unos 20 minutos tendremos el dominio hackplayers.local, las ACLs aplicadas y los paths para practicar Rubeus, BloodHound, PowerView o Kerberoasting... ;)

"Dame 6 horas para cortar un árbol y pasaré 4 afilando el hacha"
Reflexión de tito Abr4ham L1ncoln en un bosque de AD. 

Happy testing!

Comentarios

Publicar un comentario