Esta versión solo es compatible con BloodHound Legacy 4.x

Versión compatible con BloodHound Community Edition (CE) se puede encontrar aquí RustHound-CE.

Resumen

Limitación
Descripción
Cómo compilarlo?
Cómo construir la documentación?
Uso
Demo
Estadísticas
Hoja de ruta
Enlaces

Limitaciones

No todas las funciones de SharpHound han sido implementadas. Algunas existen en RustHound y no en SharpHound o BloodHound-Python. Consulte la hoja de ruta para más información.

Descripción

RustHound es una herramienta recolectora multiplataforma de BloodHound escrita en Rust, lo que la hace compatible con Linux, Windows y macOS.

Sin detección de AV y compilación cruzada.

RustHound genera archivos JSON de usuarios, grupos, equipos, UOs, GPOs, contenedores y dominios que pueden analizarse con BloodHound.

💡 Si puedes usar SharpHound, úsalo. Usa RustHound como solución de respaldo si SharpHound es detectado por el AV o no es compatible con tu sistema operativo.

Cómo compilarlo?

Usando Makefile

Puedes usar el comando make para instalar RustHound o compilarlo para Linux o Windows.

make install
rusthound -h

Más comandos en el Makefile:

Por defecto:
usage: make install
usage: make uninstall
usage: make debug
usage: make release

Estático:
usage: make windows
usage: make windows_x64
usage: make windows_x86
usage: make linux_aarch64
usage: make linux_x86_64
usage: make linux_musl
usage: make macos
usage: make arm_musl
usage: make armv7

Sin argumento cli:
usage: make windows_noargs

Dependencias:
usage: make install_windows_deps
usage: make install_linux_musl_deps
usage: make install_macos_deps

Usando Dockerfile

Usa RustHound con Docker para asegurarte de tener todas las dependencias.

docker build --rm -t rusthound .

# Then
docker run --rm -v ./:/usr/src/rusthound rusthound windows
docker run --rm -v ./:/usr/src/rusthound rusthound linux_musl
docker run --rm -v ./:/usr/src/rusthound rusthound macos

Usando Cargo

Necesitarás instalar Rust en tu sistema.

https://www.rust-lang.org/fr/tools/install

RustHound soporta Kerberos y GSSAPI. Por lo tanto, requiere Clang y sus bibliotecas de desarrollo, así como las bibliotecas de desarrollo de Kerberos. En Debian y Ubuntu, esto significa clang-N, libclang-N-dev y libkrb5-dev.

Por ejemplo:

# Debian/Ubuntu
sudo apt-get -y update && sudo apt-get -y install gcc clang libclang-dev libgssapi-krb5-2 libkrb5-dev libsasl2-modules-gssapi-mit musl-tools gcc-mingw-w64-x86-64

Aquí está cómo compilar las versiones "release" y "debug" usando el comando cargo.

git clone https://github.com/OPENCYBER-FR/RustHound
cd RustHound
cargo build --release
# or debug version
cargo b

El resultado se puede encontrar en la carpeta target/release o target/debug.

A continuación puedes encontrar la metodología de compilación para cada uno de los SO desde Linux. Si necesitas otro sistema de compilación, consulta la lista en este enlace: https://doc.rust-lang.org/nightly/rustc/platform-support.html

Manualmente para la versión estática de Linux x86_64

# Install rustup and Cargo for Linux
curl https://sh.rustup.rs -sSf | sh

# Add Linux deps
rustup install stable-x86_64-unknown-linux-gnu
rustup target add x86_64-unknown-linux-gnu

# Static compilation for Linux
git clone https://github.com/OPENCYBER-FR/RustHound
cd RustHound
CFLAGS="-lrt";LDFLAGS="-lrt";RUSTFLAGS='-C target-feature=+crt-static';cargo build --release --target x86_64-unknown-linux-gnu

El resultado se puede encontrar en la carpeta target/x86_64-unknown-linux-gnu/release.

Manualmente para la versión estática de Windows desde Linux

# Install rustup and Cargo in Linux
curl https://sh.rustup.rs -sSf | sh

# Add Windows deps
rustup install stable-x86_64-pc-windows-gnu
rustup target add x86_64-pc-windows-gnu

# Static compilation for Windows
git clone https://github.com/OPENCYBER-FR/RustHound
cd RustHound
RUSTFLAGS="-C target-feature=+crt-static" cargo build --release --target x86_64-pc-windows-gnu

El resultado se puede encontrar en la carpeta target/x86_64-pc-windows-gnu/release.

Manualmente para la versión estática de macOS desde Linux

Documentación increíble: https://wapl.es/rust/2019/02/17/rust-cross-compile-linux-to-macos.html

# Install rustup and Cargo in Linux
curl https://sh.rustup.rs -sSf | sh

# Add macOS tool chain
sudo git clone https://github.com/tpoechtrager/osxcross /usr/local/bin/osxcross
sudo wget -P /usr/local/bin/osxcross/ -nc https://s3.dockerproject.org/darwin/v2/MacOSX10.10.sdk.tar.xz && sudo mv /usr/local/bin/osxcross/MacOSX10.10.sdk.tar.xz /usr/local/bin/osxcross/tarballs/
sudo UNATTENDED=yes OSX_VERSION_MIN=10.7 /usr/local/bin/osxcross/build.sh
sudo chmod 775 /usr/local/bin/osxcross/ -R
export PATH="/usr/local/bin/osxcross/target/bin:$PATH"

# Cargo needs to be told to use the correct linker for the x86_64-apple-darwin target, so add the following to your project’s .cargo/config file:
grep 'target.x86_64-apple-darwin' ~/.cargo/config || echo "[target.x86_64-apple-darwin]" >> ~/.cargo/config
grep 'linker = "x86_64-apple-darwin14-clang"' ~/.cargo/config || echo 'linker = "x86_64-apple-darwin14-clang"' >> ~/.cargo/config
grep 'ar = "x86_64-apple-darwin14-clang"' ~/.cargo/config || echo 'ar = "x86_64-apple-darwin14-clang"' >> ~/.cargo/config

# Static compilation for macOS
git clone https://github.com/OPENCYBER-FR/RustHound
cd RustHound
RUSTFLAGS="-C target-feature=+crt-static" cargo build --release --target x86_64-apple-darwin --features nogssapi

El resultado se puede encontrar en la carpeta target/x86_64-apple-darwin/release.

Optimizar el tamaño del binario

💡 Para obtener una compilación optimizada de RustHound, añade los siguientes parámetros de compilación al final del archivo Cargo.toml.

[profile.release]
opt-level = "z"
lto = true
strip = true
codegen-units = 1
panic = "abort"

El tamaño del binario se minimizará considerablemente. Se pueden usar los comandos básicos del compilador de cargo.

make windows

Más información aquí

Cómo construir la documentación?

git clone https://github.com/OPENCYBER-FR/RustHound
cd RustHound
cargo doc --open --no-deps

Uso

Usage: rusthound [OPTIONS] --domain <domain>

Options:
  -v...          Set the level of verbosity
  -h, --help     Print help information
  -V, --version  Print version information

REQUIRED VALUES:
  -d, --domain <domain>  Nombre de dominio como: DOMAIN.LOCAL

OPTIONAL VALUES:
  -u, --ldapusername <ldapusername>  Nombre de usuario LDAP, como: [email protected]
  -p, --ldappassword <ldappassword>  Contraseña LDAP
  -f, --ldapfqdn <ldapfqdn>          FQDN del Controlador de Dominio como: DC01.DOMAIN.LOCAL o solo DC01
  -i, --ldapip <ldapip>              Dirección IP del Controlador de Dominio como: 192.168.1.10
  -P, --ldapport <ldapport>          Puerto LDAP [por defecto: 389]
  -n, --name-server <name-server>    Dirección IP alternativa del servidor de nombres para consultas DNS
  -o, --output <output>              Directorio de salida donde guardar los archivos JSON [por defecto: ./]

OPTIONAL FLAGS:
      --ldaps           Forzar el uso de LDAPS para la solicitud como: ldaps://DOMAIN.LOCAL/
      --dns-tcp         Usar TCP en lugar de UDP para consultas DNS
      --dc-only         Recopila datos solo del controlador de dominio. No intentará recuperar la seguridad/configuración de CA ni verificar la inscripción web
      --old-bloodhound  Solo para ADCS. Genera el resultado como datos de BloodHound para la versión original de BloodHound de @BloodHoundAD sin soporte PKI
  -z, --zip             Comprimir los archivos JSON en un archivo zip

OPTIONAL MODULES:
      --fqdn-resolver  Usar el módulo fqdn-resolver para obtener direcciones IP de equipos
      --adcs           Usar el módulo ADCS para enumerar Plantillas de Certificados, Autoridades de Certificación y otras configuraciones.
                       (Para la versión personalizada de BloodHound de @ly4k con soporte PKI)

Demo

Los ejemplos se realizan en GOADv2 implementado por mayfly:

Uso simple

# Linux con nombre de usuario:contraseña
rusthound -d north.sevenkingdoms.local -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z

# Linux con nombre de usuario:contraseña y ldapip
rusthound -d north.sevenkingdoms.local -i 192.168.56.11 -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z

# Linux con nombre de usuario:contraseña y ldaps
rusthound -d north.sevenkingdoms.local --ldaps -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z 
# Linux con nombre de usuario:contraseña y ldaps y puerto personalizado
rusthound -d north.sevenkingdoms.local --ldaps -P 3636 -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z 

# Consejo para redirigir y añadir tanto la salida estándar como la de error a un archivo > /tmp/rh_output 2>&1
rusthound -d north.sevenkingdoms.local --ldaps -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo --fqdn-resolver > /tmp/rh_output 2>&1

# Windows con sesión GSSAPI
rusthound.exe -d sevenkingdoms.local --ldapfqdn kingslanding
# Windows conexión simple bind usuario:contraseña (no uses comillas simples o dobles con cmd.exe)
rusthound.exe -d sevenkingdoms.local -u [email protected] -p _L0ngCl@w_ -o output -z

# Autenticación Kerberos (Linux)
export KRB5CCNAME="/tmp/jeor.mormont.ccache"
rusthound -d sevenkingdoms.local -f kingslanding -k -z
# Autenticación Kerberos (Windows)
rusthound.exe -d sevenkingdoms.local -f kingslanding -k -z

Módulo FQDN resolver

# Linux con nombre de usuario:contraseña y módulo FQDN resolver
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/demo --fqdn-resolver -z
# Linux con nombre de usuario:contraseña y ldaps y módulo FQDN resolver y petición DNS TCP y servidor de nombres personalizado
rusthound -d essos.local --ldaps -u '[email protected]' -p 'BurnThemAll!' -o /tmp/demo --fqdn-resolver --tcp-dns --name-server 192.168.56.12 -z

# Windows con sesión GSSAPI y módulo FQDN resolver
rusthound.exe -d essos.local -f meereen -o output --fqdn-resolver -z
# Windows conexión simple bind usuario:contraseña y módulo FQDN resolver y petición DNS TCP y servidor de nombres personalizado (no uses comillas simples o dobles con cmd.exe)
rusthound.exe -d essos.local -u [email protected] -p BurnThemAll! -o output -z --fqdn-resolver --tcp-dns --name-server 192.168.56.12

Módulo ADCS collector

Ejemplo usando la versión de BloodHound de @ly4k.

# Linux con nombre de usuario:contraseña y módulo ADCS para la versión de BloodHound de @ly4k
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs -z
# Linux con nombre de usuario:contraseña y módulo ADCS y flag dconly (no comprobará webenrollment)
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --dc-only -z

# Linux con nombre de usuario:contraseña y módulo ADCS usando argumento "--old-bloodhound" para la versión oficial de @BloodHoundAd
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --old-bloodhound -z

# Windows con sesión GSSAPI y módulo ADCS
rusthound.exe -d essos.local -f meereen -o output -z --adcs
# Windows con sesión GSSAPI y módulo ADCS y petición DNS TCP y servidor de nombres personalizado
rusthound.exe -d essos.local --ldapfqdn meereen -o output -z --adcs --tcp-dns --name-server 192.168.56.12
# Windows conexión simple bind usuario:contraseña (no uses comillas simples o dobles con cmd.exe)
rusthound.exe -d essos.local -u [email protected] -p BurnThemAll! -o output -z --adcs --dc-only

Puedes encontrar las consultas personalizadas usadas en la demo en la carpeta de recursos.

Usa el siguiente comando para instalarlo:

cp resources/customqueries.json ~/.config/bloodhound/customqueries.json

🚀 Estadísticas

Para hacer estadísticas en un DC con más objetos LDAP, ejecuta BadBlood en el controlador de dominio ESSOS.local desde GOAD. El DC debería tener ahora alrededor de 3500 objetos. A continuación se muestra el tiempo promedio que toma ejecutar las siguientes herramientas:

🚥 Hoja de ruta

Autenticación

Salidas

Módulos

Recuperar contraseñas LAPS si tu usuario puede leerlas automático
Resolver FQDN de equipos encontrados a dirección IP --fqdn-resolver
Recuperar certificados para explotación ESC con Certipy --adcs
Módulo de ataque Kerberos (ASREPROASTING y KERBEROASTING) --attack-kerberos
Recuperar datos de dominios de confianza --follow-trust (Actualmente trabajando en ello, tengo versión beta de este módulo)

BloodHound v4.2

Funciones de análisis
- Usuarios y Equipos
  - HasSIDHistory
- Usuarios
  - Properties : sfupassword
DCERPC (dependencias)
- Equipos
  - Sessions
- UOs y Dominios
  - LocalAdmins
  - RemoteDesktopUsers
  - DcomUsers
  - PSRemoteUsers

🔗 Enlaces

Artículo del blog: https://www.opencyber.com/rusthound-data-collector-for-bloodhound-written-in-rust/
BloodHound.py: https://github.com/fox-it/BloodHound.py
SharpHound: https://github.com/BloodHoundAD/SharpHound
BloodHound: https://github.com/BloodHoundAD/BloodHound
Documentación de BloodHound: https://bloodhound.readthedocs.io/en/latest/index.html
GOAD: https://github.com/Orange-Cyberdefense/GOAD
Versión de BloodHound de ly4k: https://github.com/ly4k/BloodHound
Certipy: https://github.com/ly4k/Certipy

SharpHound.exe	Windows	~3500	~51.605s	Measure-Command { sharphound.exe -d essos.local --ldapusername 'khal.drogo' --ldappassword 'horse' --domaincontroller '192.168.56.12' -c All }
BloodHound.py	Linux	~3500	~9.657s	time python3 bloodhound.py -u khal.drogo -p horse -d essos.local -ns 192.168.56.12 --zip -c all
RustHound.exe	Windows	~3500	~5.315s	Measure-Command { rusthound.exe -d essos.local -u [email protected] -p horse -z }
RustHound	Linux	~3500	~3.166s	time rusthound -d essos.local -u [email protected] -p horse -z

RustHound

Más Populares