asphyxia 0.2.2

A fast and efficient network scanner 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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

use indicatif::{ProgressBar, ProgressStyle};
use ipnetwork::IpNetwork;
use rayon::prelude::*;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
use std::sync::{Arc, Mutex};
use std::time::Duration;

/// Scan a single IP address for availability
///
/// # Arguments
///
/// * `ip` - The IPv4 address to scan
/// * `timeout` - Optional timeout duration (defaults to 1 second)
///
/// # Returns
///
/// * `Option<Ipv4Addr>` - The IP address if it's available, `None` otherwise
///
/// # Examples
///
/// ```
/// use asphyxia::scanner::address::scan_address;
/// use std::net::Ipv4Addr;
/// use std::time::Duration;
///
/// let ip = "192.168.1.1".parse::<Ipv4Addr>().unwrap();
/// if let Some(available_ip) = scan_address(ip, Some(Duration::from_millis(500))) {
///     println!("Host {} is available", available_ip);
/// }
/// ```
pub fn scan_address(ip: Ipv4Addr, timeout: Option<Duration>) -> Option<Ipv4Addr> {
    match TcpStream::connect_timeout(
        &SocketAddr::new(IpAddr::V4(ip), 80),
        timeout.unwrap_or(crate::scanner::port::CONNECT_TIMEOUT),
    ) {
        Ok(_) => Some(ip),
        Err(_) => None,
    }
}

/// Scan an entire subnet for available hosts
///
/// # Arguments
///
/// * `subnet` - The subnet to scan in CIDR notation
///
/// # Returns
///
/// * `Vec<Ipv4Addr>` - A vector of available IP addresses
///
/// # Examples
///
/// ```
/// use asphyxia::scanner::address::scan_subnet;
/// use ipnetwork::IpNetwork;
///
/// let subnet = "192.168.1.0/24".parse::<IpNetwork>().unwrap();
/// let available_hosts = scan_subnet(subnet);
/// println!("Found {} available hosts", available_hosts.len());
/// ```
pub fn scan_subnet(subnet: IpNetwork) -> Vec<Ipv4Addr> {
    let network = subnet.network();
    let broadcast = subnet.broadcast();
    let mut available = Vec::new();

    if let (IpAddr::V4(network), IpAddr::V4(broadcast)) = (network, broadcast) {
        let total_hosts = u32::from(broadcast) - u32::from(network) + 1;
        let pb = ProgressBar::new(total_hosts as u64);
        pb.set_style(
            ProgressStyle::with_template(
                "[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} addresses scanned",
            )
            .unwrap()
            .progress_chars("=> "),
        );

        let available_ips = Arc::new(Mutex::new(Vec::new()));

        (u32::from(network)..=u32::from(broadcast))
            .into_par_iter()
            .for_each(|ip| {
                let ipv4 = Ipv4Addr::from(ip);
                if let Some(available_ip) = scan_address(ipv4, None)
                    && let Ok(mut guard) = available_ips.lock()
                {
                    guard.push(available_ip);
                }
                pb.inc(1);
            });

        pb.finish_with_message("Subnet scan completed");
        let mut result = available_ips.lock().unwrap();
        result.sort();
        available = result.clone();
    }

    available
}

/// Scan a range of IP addresses for available hosts
///
/// # Arguments
///
/// * `start` - The starting IPv4 address
/// * `end` - The ending IPv4 address
///
/// # Returns
///
/// * `Vec<Ipv4Addr>` - A vector of available IP addresses
///
/// # Examples
///
/// ```
/// use asphyxia::scanner::address::scan_ip_range;
/// use std::net::Ipv4Addr;
///
/// let start = "192.168.1.1".parse::<Ipv4Addr>().unwrap();
/// let end = "192.168.1.10".parse::<Ipv4Addr>().unwrap();
/// let available_hosts = scan_ip_range(start, end);
/// println!("Found {} available hosts", available_hosts.len());
/// ```
pub fn scan_ip_range(start: Ipv4Addr, end: Ipv4Addr) -> Vec<Ipv4Addr> {
    let start_num = u32::from(start);
    let end_num = u32::from(end);

    if start_num > end_num {
        return Vec::new();
    }

    let total_hosts = end_num - start_num + 1;
    let pb = ProgressBar::new(total_hosts as u64);
    pb.set_style(
        ProgressStyle::with_template(
            "[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} addresses scanned",
        )
        .unwrap()
        .progress_chars("=> "),
    );

    let available_ips = Arc::new(Mutex::new(Vec::new()));

    (start_num..=end_num).into_par_iter().for_each(|ip| {
        let ipv4 = Ipv4Addr::from(ip);
        if let Some(available_ip) = scan_address(ipv4, None)
            && let Ok(mut guard) = available_ips.lock()
        {
            guard.push(available_ip);
        }
        pb.inc(1);
    });

    pb.finish_with_message("Range scan completed");
    let mut result = available_ips.lock().unwrap();
    result.sort();
    result.clone()
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::Duration;

    // Helper function to check if localhost is available
    fn is_localhost_available() -> bool {
        scan_address(
            "127.0.0.1".parse().unwrap(),
            Some(Duration::from_millis(100)),
        )
        .is_some()
    }

    #[test]
    fn test_scan_address_localhost() {
        // Skip test if localhost is not available
        if !is_localhost_available() {
            println!("Skipping test_scan_address_localhost: localhost is not available");
            return;
        }

        let ip = "127.0.0.1".parse::<Ipv4Addr>().unwrap();
        assert!(scan_address(ip, Some(Duration::from_millis(100))).is_some());
    }

    #[test]
    fn test_scan_address_unavailable() {
        // Test with an address that's very unlikely to be available
        let ip = "192.168.255.255".parse::<Ipv4Addr>().unwrap();
        assert!(scan_address(ip, Some(Duration::from_millis(100))).is_none());
    }

    #[test]
    fn test_scan_subnet() {
        // Skip test if localhost is not available
        if !is_localhost_available() {
            println!("Skipping test_scan_subnet: localhost is not available");
            return;
        }

        // Scan only localhost (127.0.0.1)
        let subnet = "127.0.0.0/24".parse::<IpNetwork>().unwrap();
        let results = scan_subnet(subnet);

        // Verify that results contain localhost and are sorted
        assert!(results.contains(&"127.0.0.1".parse::<Ipv4Addr>().unwrap()));
        assert!(results.windows(2).all(|w| w[0] <= w[1]));
    }

    #[test]
    fn test_scan_ip_range() {
        // Skip test if localhost is not available
        if !is_localhost_available() {
            println!("Skipping test_scan_ip_range: localhost is not available");
            return;
        }

        // Scan only localhost and a few addresses around it
        let start = "127.0.0.1".parse::<Ipv4Addr>().unwrap();
        let end = "127.0.0.3".parse::<Ipv4Addr>().unwrap();
        let results = scan_ip_range(start, end);

        // Verify that results contain localhost and are sorted
        assert!(results.contains(&"127.0.0.1".parse::<Ipv4Addr>().unwrap()));
        assert!(results.windows(2).all(|w| w[0] <= w[1]));
    }

    #[test]
    fn test_scan_empty_range() {
        // Test with an invalid range (start > end)
        let start = "127.0.0.10".parse::<Ipv4Addr>().unwrap();
        let end = "127.0.0.1".parse::<Ipv4Addr>().unwrap();
        let results = scan_ip_range(start, end);
        assert!(results.is_empty());
    }
}