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

use colored::Colorize;
use derive_more::{Display, From};
use serde::Serialize;

use crate::error::{ModuleErrorKind, SubscanError};

/// Subscan module states
#[derive(Clone, Debug, Default, Display, Eq, From, Ord, PartialEq, PartialOrd)]
pub enum SubscanModuleStatus {
    #[default]
    #[display("STARTED")]
    Started,
    #[display("FINISHED")]
    Finished,
    #[from]
    #[display("SKIPPED")]
    Skipped(SkipReason),
    #[from(ModuleErrorKind, &str)]
    #[display("FAILED")]
    Failed(ModuleErrorKind),
}

impl From<SubscanError> for SubscanModuleStatus {
    fn from(err: SubscanError) -> Self {
        err.status()
    }
}

impl Serialize for SubscanModuleStatus {
    /// Serialize object to string for JSON outputs
    ///
    /// # Examples
    ///
    /// ```
    /// use subscan::types::result::status::SubscanModuleStatus;
    /// use serde_json::json;
    ///
    /// let json = json!({
    ///     "status": SubscanModuleStatus::Finished,
    /// });
    ///
    /// assert_eq!(serde_json::to_string(&json).unwrap(), "{\"status\":\"FINISHED\"}");
    /// ```
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl SubscanModuleStatus {
    /// Return status with a reason text
    ///
    /// # Examples
    ///
    /// ```
    /// use subscan::types::result::status::{
    ///     SubscanModuleStatus::{
    ///         Started,
    ///         Finished,
    ///         Failed,
    ///         Skipped
    ///     },
    ///     SkipReason::AuthenticationNotProvided,
    /// };
    /// use subscan::error::ModuleErrorKind::Custom;
    ///
    /// assert_eq!(Started.with_reason(), "[STARTED]");
    /// assert_eq!(Finished.with_reason(), "[FINISHED]");
    ///
    /// assert_eq!(
    ///     Failed(Custom("foo".into())).with_reason(),
    ///     "[foo FAILED]"
    /// );
    /// assert_eq!(
    ///     Skipped(AuthenticationNotProvided.into()).with_reason(),
    ///     "[auth not provided SKIPPED]"
    /// );
    /// ```
    pub fn with_reason(&self) -> String {
        match self {
            SubscanModuleStatus::Started => format!("[{self}]"),
            SubscanModuleStatus::Finished => format!("[{self}]"),
            SubscanModuleStatus::Failed(err) => format!("[{err} {self}]"),
            SubscanModuleStatus::Skipped(reason) => format!("[{reason} {self}]"),
        }
    }

    pub fn log(&self, module: &str) {
        match self {
            SubscanModuleStatus::Started | SubscanModuleStatus::Finished => {
                log::debug!("{:.<25}{:.>35}", module.white(), self.with_reason().white())
            }
            SubscanModuleStatus::Skipped(_) => {
                log::warn!(
                    "{:.<25}{:.>35}",
                    module.yellow(),
                    self.with_reason().yellow()
                )
            }
            SubscanModuleStatus::Failed(err) => {
                log::error!("{:.<25}{:.>35}", module.red(), err.with_msg().red())
            }
        }
    }
}

/// Module skip reasons
#[derive(Clone, Debug, Display, Eq, Ord, PartialEq, PartialOrd, Serialize)]
pub enum SkipReason {
    /// Indicates that if authentication requires by module but API key, HTTP credentials
    /// or other any authentication method not provided
    #[display("auth not provided")]
    AuthenticationNotProvided,
    /// Indicates that the module skipped by user
    #[display("skipped by user")]
    SkippedByUser,
}