Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/nh-red-team/rusthound
RicognizioneRaccolta InformazioniPenetration TestingRed Teaming
GitHubnh-red-team/rusthound

RustHound

Ingestore di dati di Active Directory per BloodHound Legacy scritto in Rust. 🦀

Vedi Repository
1.2k10721 anno faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Questa versione è compatibile solo con BloodHound Legacy 4.x

La versione compatibile con BloodHound Community Edition (CE) è disponibile qui RustHound-CE.


Crates.io GitHub Twitter Follow Twitter Follow
Linux supported Windows supported macOS supported

Sommario

  • Limitazione

  • Descrizione

  • Come compilarlo?

    • Usando Makefile
    • Usando Dockerfile
    • Usando Cargo
    • Manualmente per versione statica Linux x86_64
    • Manualmente per versione statica Windows da Linux
    • Manualmente per versione statica macOS da Linux
    • Ottimizzare la dimensione del binario
  • Come costruire la documentazione?

  • Uso

  • Demo

    • Uso semplice
    • Modulo risolutore FQDN
    • Modulo collettore ADCS
  • Statistiche

  • Roadmap

  • Link

Limitazioni

Non tutte le funzionalità di SharpHound sono state implementate. Alcune esistono in RustHound e non in SharpHound o BloodHound-Python. Fare riferimento alla roadmap per maggiori informazioni.

Descrizione

RustHound è uno strumento di raccolta BloodHound cross-platform scritto in Rust, che lo rende compatibile con Linux, Windows e macOS.

Nessuna rilevazione AV e cross-compilato.

RustHound genera file JSON di utenti, gruppi, computer, OU, GPO, contenitori e domini che possono essere analizzati con BloodHound.

💡 Se puoi usare SharpHound, usalo. Usa RustHound come soluzione di backup se SharpHound viene rilevato dall'AV o se non è compatibile con il tuo sistema operativo.

Come compilarlo?

Usando Makefile

Puoi usare il comando make per installare RustHound o per compilarlo per Linux o Windows.

root@kitploit:~
make install
rusthound -h

Ulteriori comandi nel Makefile:

root@kitploit:~
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

Usando Dockerfile

Usa RustHound con Docker per assicurarti di avere tutte le dipendenze.

root@kitploit:~
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

Dovrai installare Rust sul tuo sistema.

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

RustHound supporta Kerberos e GSSAPI. Pertanto, richiede Clang e le sue librerie di sviluppo, così come le librerie di sviluppo di Kerberos. Su Debian e Ubuntu, questo significa clang-N, libclang-N-dev e libkrb5-dev.

Ad esempio:

root@kitploit:~
# 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

Ecco come compilare le versioni "release" e "debug" usando il comando cargo.

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

Il risultato si trova nella cartella target/release o target/debug.

Di seguito puoi trovare la metodologia di compilazione per ciascun sistema operativo da Linux. Se hai bisogno di un altro sistema di compilazione, consulta l'elenco in questo link: https://doc.rust-lang.org/nightly/rustc/platform-support.html

Manualmente per versione statica Linux x86_64

root@kitploit:~
# 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

Il risultato si trova nella cartella target/x86_64-unknown-linux-gnu/release.

Manualmente per versione statica Windows da Linux

root@kitploit:~
# 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

Il risultato si trova nella cartella target/x86_64-pc-windows-gnu/release.

Manualmente per versione statica macOS da Linux

Documentazione fantastica: https://wapl.es/rust/2019/02/17/rust-cross-compile-linux-to-macos.html

root@kitploit:~
# 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

Il risultato si trova nella cartella target/x86_64-apple-darwin/release.

Ottimizzare la dimensione del binario

💡 Per ottenere una compilazione ottimizzata di RustHound aggiungi i seguenti parametri di compilazione alla fine del file Cargo.toml.

root@kitploit:~
[profile.release]
opt-level = "z"
lto = true
strip = true
codegen-units = 1
panic = "abort"

La dimensione del binario sarà notevolmente ridotta. Si possono usare i comandi di base del compilatore cargo.

root@kitploit:~
make windows

Maggiori informazioni qui

Come costruire la documentazione?

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

Uso

root@kitploit:~
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)

Demo

Gli esempi sono realizzati su GOADv2 implementato da mayfly:

Uso semplice

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

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

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

# Tips to redirect and append both standard output and standard error to a file > /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 with GSSAPI session
rusthound.exe -d sevenkingdoms.local --ldapfqdn kingslanding
# Windows simple bind connection username:password (do not use single or double quotes with cmd.exe)
rusthound.exe -d sevenkingdoms.local -u [email protected] -p _L0ngCl@w_ -o output -z

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

Modulo risolutore FQDN

root@kitploit:~
# Linux with username:password and FQDN resolver module
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/demo --fqdn-resolver -z
# Linux with username:password and ldaps and FQDN resolver module and TCP DNS request and custom name server
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 with GSSAPI session and FQDN resolver module
rusthound.exe -d essos.local -f meereen -o output --fqdn-resolver -z
# Windows simple bind connection username:password and FQDN resolver module and TCP DNS request and custom name server (do not use single or double quotes with 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 

Modulo collettore ADCS

Esempio usando @ly4k BloodHound version.

root@kitploit:~
# Linux with username:password and ADCS module for @ly4k BloodHound version
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs -z
# Linux with username:password and ADCS module and dconly flag (will don't check webenrollment)
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --dc-only -z

# Linux with username:password and ADCS module using "--old-bloodhound" argument for official @BloodHoundAd version
rusthound -d essos.local -u '[email protected]' -p 'BurnThemAll!' -o /tmp/adcs --adcs --old-bloodhound -z

# Windows with GSSAPI session and ADCS module
rusthound.exe -d essos.local -f meereen -o output -z --adcs
# Windows with GSSAPI session and ADCS module and TCP DNS request and custom name server
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 (do not use single or double quotes with cmd.exe)
rusthound.exe -d essos.local -u [email protected] -p BurnThemAll! -o output -z --adcs --dc-only

Puoi trovare le query personalizzate utilizzate nella demo nella cartella resource.

Usa il seguente comando per installarle:

root@kitploit:~
cp resources/customqueries.json ~/.config/bloodhound/customqueries.json

🚀 Statistiche

Per fare statistiche su un DC con più oggetti LDAP, esegui BadBlood sul controller di dominio ESSOS.local da GOAD. Il DC dovrebbe ora avere circa 3500 oggetti. Di seguito è riportato il tempo medio per eseguire i seguenti strumenti:

🚥 Roadmap

Autenticazione

  • LDAP (389)
  • LDAPS (636)
  • BIND
  • NTLM
  • Kerberos
  • Richiedi password

Output

  • users.json
  • groups.json
  • computers.json
  • ous.json
  • gpos.json
  • containers.json
  • domains.json
  • cas.json
  • templates.json
  • argomento e funzione per zippare i file JSON --zip

Moduli

  • Recupera password LAPS se il tuo utente può leggerle automatico
  • Risolve i computer FQDN trovati in indirizzi IP --fqdn-resolver
  • Recupera certificati per sfruttamento ESC con Certipy --adcs
  • Modulo attacco Kerberos (ASREPROASTING e KERBEROASTING) --attack-kerberos
  • Recupera dati da domini trusted --follow-trust (Attualmente in lavorazione, ho una versione beta di questo modulo)

BloodHound v4.2

  • Funzionalità di parsing

    • Utenti & Computer
      • HasSIDHistory
    • Utenti
      • Properties : sfupassword
  • DCERPC (dipendenze)

    • Computer
      • Sessions
    • OU & Domini
      • LocalAdmins
      • RemoteDesktopUsers
      • DcomUsers
      • PSRemoteUsers

🔗 Link

  • Post 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
  • Documentazione BloodHound: https://bloodhound.readthedocs.io/en/latest/index.html
  • GOAD: https://github.com/Orange-Cyberdefense/GOAD
  • ly4k BloodHound version: https://github.com/ly4k/BloodHound
  • Certipy: https://github.com/ly4k/Certipy
Scarica lo strumento
ToolEnvironmentObjectsTimeCommand
SharpHound.exeWindows ~3500~51.605sMeasure-Command { sharphound.exe -d essos.local --ldapusername 'khal.drogo' --ldappassword 'horse' --domaincontroller '192.168.56.12' -c All }
BloodHound.pyLinux ~3500~9.657stime python3 bloodhound.py -u khal.drogo -p horse -d essos.local -ns 192.168.56.12 --zip -c all
RustHound.exeWindows ~3500~5.315sMeasure-Command { rusthound.exe -d essos.local -u [email protected] -p horse -z }
RustHoundLinux ~3500~3.166stime rusthound -d essos.local -u [email protected] -p horse -z
  • CA
    • User Specified SAN
    • Request Disposition