subscan 1.3.0

A subdomain enumeration tool leveraging diverse techniques, designed for advanced pentesting operations
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

use std::time::Duration;

use hickory_resolver::config::ResolverConfig as HickoryResolverConfig;

use crate::{
    cli::commands::{
        brute::BruteCommandArgs, module::run::ModuleRunSubCommandArgs, scan::ScanCommandArgs,
    },
    constants::{DEFAULT_RESOLVER_CONCURRENCY, DEFAULT_RESOLVER_TIMEOUT},
    utilities::net,
};

/// IP address resolver component configurations
#[derive(Clone, Debug)]
pub struct ResolverConfig {
    pub inner: HickoryResolverConfig,
    pub concurrency: u64,
    pub disabled: bool,
    pub timeout: Duration,
}

impl Default for ResolverConfig {
    fn default() -> Self {
        Self {
            inner: net::read_system_ns_conf().unwrap_or(HickoryResolverConfig::cloudflare()),
            timeout: DEFAULT_RESOLVER_TIMEOUT,
            concurrency: DEFAULT_RESOLVER_CONCURRENCY,
            disabled: false,
        }
    }
}

impl From<ModuleRunSubCommandArgs> for ResolverConfig {
    /// Create [`ResolverConfig`] object from [`ModuleRunSubCommandArgs`]
    ///
    /// # Examples
    ///
    /// ```
    /// use subscan::cli::commands::module::run::ModuleRunSubCommandArgs;
    /// use subscan::types::config::resolver::ResolverConfig;
    ///
    /// let args = ModuleRunSubCommandArgs {
    ///     resolver_concurrency: 100,
    ///     ..Default::default()
    /// };
    ///
    /// let config: ResolverConfig = args.clone().into();
    ///
    /// assert_eq!(config.concurrency, args.resolver_concurrency);
    /// ```
    fn from(args: ModuleRunSubCommandArgs) -> Self {
        Self {
            inner: args.resolver_list.map_or(
                net::read_system_ns_conf().unwrap_or(HickoryResolverConfig::cloudflare()),
                net::read_resolver_list_file,
            ),
            timeout: Duration::from_millis(args.resolver_timeout),
            concurrency: args.resolver_concurrency,
            disabled: args.resolver_disabled,
        }
    }
}

impl From<BruteCommandArgs> for ResolverConfig {
    /// Create [`ResolverConfig`] object from [`BruteCommandArgs`]
    ///
    /// # Examples
    ///
    /// ```
    /// use subscan::cli::commands::brute::BruteCommandArgs;
    /// use subscan::types::config::resolver::ResolverConfig;
    ///
    /// let args = BruteCommandArgs {
    ///     resolver_concurrency: 100,
    ///     ..Default::default()
    /// };
    ///
    /// let config: ResolverConfig = args.clone().into();
    ///
    /// assert_eq!(config.concurrency, args.resolver_concurrency);
    /// ```
    fn from(args: BruteCommandArgs) -> Self {
        Self {
            inner: args.resolver_list.map_or(
                net::read_system_ns_conf().unwrap_or(HickoryResolverConfig::cloudflare()),
                net::read_resolver_list_file,
            ),
            timeout: Duration::from_millis(args.resolver_timeout),
            concurrency: args.resolver_concurrency,
            disabled: false,
        }
    }
}

impl From<ScanCommandArgs> for ResolverConfig {
    /// Create [`ResolverConfig`] object from [`ScanCommandArgs`]
    ///
    /// # Examples
    ///
    /// ```
    /// use subscan::cli::commands::scan::ScanCommandArgs;
    /// use subscan::types::config::resolver::ResolverConfig;
    ///
    /// let args = ScanCommandArgs {
    ///     resolver_concurrency: 100,
    ///     ..Default::default()
    /// };
    ///
    /// let config: ResolverConfig = args.clone().into();
    ///
    /// assert_eq!(config.concurrency, args.resolver_concurrency);
    /// ```
    fn from(args: ScanCommandArgs) -> Self {
        Self {
            inner: args.resolver_list.map_or(
                net::read_system_ns_conf().unwrap_or(HickoryResolverConfig::cloudflare()),
                net::read_resolver_list_file,
            ),
            timeout: Duration::from_millis(args.resolver_timeout),
            concurrency: args.resolver_concurrency,
            disabled: args.resolver_disabled,
        }
    }
}