Cette version est uniquement compatible avec BloodHound Legacy 4.x

La version compatible avec BloodHound Community Edition (CE) se trouve ici RustHound-CE.

Sommaire

Limitations
Description
Comment le compiler ?
Comment construire la documentation ?
Utilisation
Démo
Statistiques
Feuille de route
Liens

Limitations

Toutes les fonctionnalités de SharpHound n'ont pas été implémentées. Certaines existent dans RustHound mais pas dans SharpHound ou BloodHound-Python. Veuillez vous référer à la feuille de route pour plus d'informations.

Description

RustHound est un outil collecteur multi-plateforme pour BloodHound écrit en Rust, ce qui le rend compatible avec Linux, Windows et macOS.

Aucune détection par antivirus et cross-compilé.

RustHound génère des fichiers JSON pour les utilisateurs, groupes, ordinateurs, UO, GPO, conteneurs et domaines, pouvant être analysés avec BloodHound.

💡 Si vous pouvez utiliser SharpHound, utilisez-le. Utilisez RustHound comme solution de secours si SharpHound est détecté par l'antivirus ou s'il n'est pas compatible avec votre système d'exploitation.

Comment le compiler ?

Avec Makefile

Vous pouvez utiliser la commande make pour installer RustHound ou pour le compiler pour Linux ou Windows.

make install
rusthound -h

Plus de commandes dans le Makefile :

Default:
usage: make install
usage: make uninstall
usage: make debug
usage: make release

Static:
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

Without cli argument:
usage: make windows_noargs

Dependencies:
usage: make install_windows_deps
usage: make install_linux_musl_deps
usage: make install_macos_deps

Avec Dockerfile

Utilisez RustHound avec Docker pour être sûr d'avoir toutes les dépendances.

docker build --rm -t rusthound .

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

Avec Cargo

Vous devrez installer Rust sur votre système.

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

RustHound prend en charge Kerberos et GSSAPI. Il nécessite donc Clang et ses bibliothèques de développement, ainsi que les bibliothèques de développement Kerberos. Sur Debian et Ubuntu, cela signifie clang-N, libclang-N-dev et libkrb5-dev.

Par exemple :

# 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

Voici comment compiler les versions "release" et "debug" avec la commande cargo.

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

Le résultat se trouve dans le dossier target/release ou target/debug.

Vous trouverez ci-dessous la méthodologie de compilation pour chacun des systèmes d'exploitation à partir de Linux. Si vous avez besoin d'un autre système de compilation, veuillez consulter la liste à ce lien : https://doc.rust-lang.org/nightly/rustc/platform-support.html

Manuellement pour version statique Linux x86_64

# Installer rustup et Cargo pour Linux
curl https://sh.rustup.rs -sSf | sh

# Ajouter les dépendances Linux
rustup install stable-x86_64-unknown-linux-gnu
rustup target add x86_64-unknown-linux-gnu

# Compilation statique pour 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

Le résultat se trouve dans le dossier target/x86_64-unknown-linux-gnu/release.

Manuellement pour version statique Windows depuis Linux

# Installer rustup et Cargo dans Linux
curl https://sh.rustup.rs -sSf | sh

# Ajouter les dépendances Windows
rustup install stable-x86_64-pc-windows-gnu
rustup target add x86_64-pc-windows-gnu

# Compilation statique pour 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

Le résultat se trouve dans le dossier target/x86_64-pc-windows-gnu/release.

Manuellement pour version statique macOS depuis Linux

Documentation géniale : https://wapl.es/rust/2019/02/17/rust-cross-compile-linux-to-macos.html

# Installer rustup et Cargo dans Linux
curl https://sh.rustup.rs -sSf | sh

# Ajouter la chaîne d'outils macOS
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"

# Il faut indiquer à Cargo d'utiliser le bon linker pour la cible x86_64-apple-darwin, donc ajoutez ce qui suit au fichier .cargo/config de votre projet :
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

# Compilation statique pour 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

Le résultat se trouve dans le dossier target/x86_64-apple-darwin/release.

Optimiser la taille du binaire

💡 Pour obtenir une compilation optimisée de RustHound, ajoutez les paramètres de compilation suivants à la fin du fichier Cargo.toml.

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

La taille du binaire sera considérablement réduite. Les commandes de base du compilateur cargo peuvent être utilisées.

make windows

Plus d'informations ici

Comment construire la documentation ?

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

Utilisation

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>  Domain name like: DOMAIN.LOCAL

OPTIONAL VALUES:
  -u, --ldapusername <ldapusername>  LDAP username, like: [email protected]
  -p, --ldappassword <ldappassword>  LDAP password
  -f, --ldapfqdn <ldapfqdn>          Domain Controler FQDN like: DC01.DOMAIN.LOCAL or just DC01
  -i, --ldapip <ldapip>              Domain Controller IP address like: 192.168.1.10
  -P, --ldapport <ldapport>          LDAP port [default: 389]
  -n, --name-server <name-server>    Alternative IP address name server to use for DNS queries
  -o, --output <output>              Output directory where you would like to save JSON files [default: ./]

OPTIONAL FLAGS:
      --ldaps           Force LDAPS using for request like: ldaps://DOMAIN.LOCAL/
      --dns-tcp         Use TCP instead of UDP for DNS queries
      --dc-only         Collects data only from the domain controller. Will not try to retrieve CA security/configuration or check for Web Enrollment
      --old-bloodhound  For ADCS only. Output result as BloodHound data for the original BloodHound version from @BloodHoundAD without PKI support
  -z, --zip             Compress the JSON files into a zip archive

OPTIONAL MODULES:
      --fqdn-resolver  Use fqdn-resolver module to get computers IP address
      --adcs           Use ADCS module to enumerate Certificate Templates, Certificate Authorities and other configurations.
                       (For the custom-built BloodHound version from @ly4k with PKI support)

Démo

Les exemples sont réalisés sur le GOADv2 implémenté par mayfly :

Utilisation simple

# Linux avec username:password
rusthound -d north.sevenkingdoms.local -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z

# Linux avec username:password et ldapip
rusthound -d north.sevenkingdoms.local -i 192.168.56.11 -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z

# Linux avec username:password et ldaps
rusthound -d north.sevenkingdoms.local --ldaps -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z 
# Linux avec username:password et ldaps et port personnalisé
rusthound -d north.sevenkingdoms.local --ldaps -P 3636 -u '[email protected]' -p '_L0ngCl@w_' -o /tmp/demo -z 

# Astuce pour rediriger et concaténer à la fois la sortie standard et la sortie d'erreur vers un fichier > /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 avec session GSSAPI
rusthound.exe -d sevenkingdoms.local --ldapfqdn kingslanding
# Windows simple bind connection username:password (ne pas utiliser de guillemets simples ou doubles avec cmd.exe)
rusthound.exe -d sevenkingdoms.local -u [email protected] -p _L0ngCl@w_ -o output -z

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

Module de résolution FQDN

# Linux avec username:password et module de résolution FQDN
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/demo --fqdn-resolver -z
# Linux avec username:password et ldaps et module de résolution FQDN et requête DNS TCP et serveur de noms personnalisé
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 avec session GSSAPI et module de résolution FQDN
rusthound.exe -d essos.local -f meereen -o output --fqdn-resolver -z
# Windows simple bind connection username:password et module de résolution FQDN et requête DNS TCP et serveur de noms personnalisé (ne pas utiliser de guillemets simples ou doubles avec 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

Collecteur ADCS

Exemple utilisant la version BloodHound de @ly4k.

# Linux avec username:password et module ADCS pour la version BloodHound de @ly4k
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs -z
# Linux avec username:password et module ADCS et option dconly (ne vérifiera pas l'enrôlement web)
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --dc-only -z

# Linux avec username:password et module ADCS utilisant l'argument "--old-bloodhound" pour la version officielle @BloodHoundAd
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --old-bloodhound -z

# Windows avec session GSSAPI et module ADCS
rusthound.exe -d essos.local -f meereen -o output -z --adcs
# Windows avec session GSSAPI et module ADCS et requête DNS TCP et serveur de noms personnalisé
rusthound.exe -d essos.local --ldapfqdn meereen -o output -z --adcs --tcp-dns --name-server 192.168.56.12
# Windows simple bind connection username:password (ne pas utiliser de guillemets simples ou doubles avec cmd.exe)
rusthound.exe -d essos.local -u [email protected] -p BurnThemAll! -o output -z --adcs --dc-only

Vous pouvez trouver les requêtes personnalisées utilisées dans la démo dans le dossier resource.

Utilisez la commande suivante pour les installer :

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

🚀 Statistiques

Afin d'effectuer des statistiques sur un contrôleur de domaine avec plus d'objets LDAP, exécutez le BadBlood sur le contrôleur de domaine ESSOS.local de GOAD. Le contrôleur de domaine devrait maintenant compter environ 3500 objets. Vous trouverez ci-dessous le temps moyen nécessaire pour exécuter les outils suivants :

🚥 Feuille de route

Authentification

Sorties

Modules

Récupérer le mot de passe LAPS si votre utilisateur peut les lire automatique
Résoudre les FQDN des ordinateurs trouvés en adresse IP --fqdn-resolver
Récupérer les certificats pour l'exploitation ESC avec Certipy --adcs
Module d'attaque Kerberos (ASREPROASTING et KERBEROASTING) --attack-kerberos
Récupérer les données des domaines de confiance --follow-trust (Actuellement en cours de développement, version bêta de ce module disponible)

BloodHound v4.2

Fonctionnalités d'analyse
- Utilisateurs et ordinateurs
  - HasSIDHistory
- Utilisateurs
  - Propriétés : sfupassword
DCERPC (dépendances)
- Ordinateurs
  - Sessions
- UO & Domaines
  - Administrateurs locaux
  - Utilisateurs du Bureau à distance
  - Utilisateurs DCOM

Liens

Article de 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
Documentation BloodHound : https://bloodhound.readthedocs.io/en/latest/index.html
GOAD : https://github.com/Orange-Cyberdefense/GOAD
Version 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

Populaires