rusthound-ce 2.4.7

Active Directory data collector for Bloodhound Community Edition written in rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

pub mod banner;
pub mod modules;

use env_logger::Builder;
use log::{error, info, trace};

use rusthound_ce::{
    args, ldap, objects,
    DiskStorage, DiskStorageReader,
    utils,
};

use std::error::Error;
use colored::Colorize;

#[cfg(feature = "noargs")]
use args::auto_args;
#[cfg(not(feature = "noargs"))]
use args::{extract_args, Options};

use banner::{print_banner, print_end_banner};
use ldap::ldap_search;
use modules::run_modules;

const CACHE_DIR: &str = ".rusthound-cache";
const CACHE_FILE: &str = "ldap.bin";

/// Main of RustHound
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Banner
    print_banner();

    // Get args
    #[cfg(not(feature = "noargs"))]
    let common_args: Options = extract_args();
    #[cfg(feature = "noargs")]
    let common_args = auto_args();

    // Build logger
    Builder::new()
        .filter(Some("rusthound"), common_args.verbose)
        .filter_level(log::LevelFilter::Error)
        .init();

    // Get verbose level
    info!("Verbosity level: {:?}", common_args.verbose);
    info!("Collection method: {:?}", common_args.collection_method);

    let mut results = match common_args.resume {
        true => {
            let ldap_cache_path = std::path::PathBuf::from(CACHE_DIR)
                .join(&common_args.domain)
                .join(CACHE_FILE);
            info!("Resuming from cache: {}", format!("{}",ldap_cache_path.display()).bold());
            let cache = DiskStorageReader::from_path(ldap_cache_path)?;
            rusthound_ce::prepare_results_from_source(cache, &common_args, None).await?
        }
        false => {
            if common_args.cache {
                // store ldap results in cache
                let ldap_cache_path = std::path::PathBuf::from(CACHE_DIR)
                    .join(&common_args.domain)
                    .join(CACHE_FILE);
                std::fs::create_dir_all(
                    ldap_cache_path
                        .parent()
                        .expect("Unable to get parent directory for cache path"), // shouldn't happen
                )?;
                info!("Using cache for LDAP search: {}", format!("{}",ldap_cache_path.display()).bold());

                let mut cache_writer = DiskStorage::new_with_capacity(
                    ldap_cache_path,
                    common_args.cache_buffer_size,
                )?;

                let total_cached = ldap_search(
                    common_args.ldaps,
                    common_args.ip.as_deref(),
                    common_args.port,
                    &common_args.domain,
                    &common_args.ldapfqdn,
                    common_args.username.as_deref(),
                    common_args.password.as_deref(),
                    common_args.kerberos,
                    &common_args.ldap_filter,
                    &mut cache_writer,
                )
                .await?;

                rusthound_ce::prepare_results_from_source(
                    cache_writer.into_reader()?,
                    &common_args,
                    Some(total_cached),
                )
                .await?
            } else {
                // store ldap results in memory
                let mut ldap_results = Vec::new();
                let total = rusthound_ce::ldap::ldap_search(
                    common_args.ldaps,
                    common_args.ip.as_deref(),
                    common_args.port,
                    &common_args.domain,
                    &common_args.ldapfqdn,
                    common_args.username.as_deref(),
                    common_args.password.as_deref(),
                    common_args.kerberos,
                    &common_args.ldap_filter,
                    &mut ldap_results,
                )
                .await?;
                rusthound_ce::prepare_results_from_source(ldap_results, &common_args, Some(total))
                    .await?
            }
        }
    };

    // Running modules
    run_modules(
        &common_args,
        &mut results.mappings.fqdn_ip,
        &mut results.computers,
    )
    .await?;

    // Add all in json files
    match rusthound_ce::make_result(&common_args, results) {
        Ok(_) => trace!("Making json/zip files finished!"),
        Err(err) => error!("Error. Reason: {err}"),
    }

    // End banner
    print_end_banner();
    Ok(())
}