New bandwidth limit feature

Author: Saluki

src/args.rs

@@ -109,6 +109,12 @@ pub fn build_args<'a, 'b>() -> App<'a, 'b> {
                 .takes_value(true).value_name("INTERVAL_DURATION")
                 .help("Milliseconds between ARP requests")
         )
+        .arg(
+            Arg::with_name("bandwidth").short("B").long("bandwidth")
+                .takes_value(true).value_name("BITS")
+                .conflicts_with("interval")
+                .help("Limit scan bandwidth (bits/second)")
+        )
         .arg(
             Arg::with_name("oui-file").long("oui-file")
                 .takes_value(true).value_name("FILE_PATH")
@@ -166,6 +172,11 @@ pub enum ProfileType {
     Chaos
 }
 
+pub enum ScanTiming {
+    Interval(u64),
+    Bandwidth(u64)
+}
+
 pub struct ScanOptions {
     pub profile: ProfileType,
     pub interface_name: Option<String>,
@@ -177,7 +188,7 @@ pub struct ScanOptions {
     pub destination_mac: Option<MacAddr>,
     pub vlan_id: Option<u16>,
     pub retry_count: usize,
-    pub interval_ms: u64,
+    pub scan_timing: ScanTiming,
     pub randomize_targets: bool,
     pub output: OutputFormat,
     pub oui_file: String,
@@ -230,6 +241,28 @@ impl ScanOptions {
             }).collect()
         })
     }
+
+    fn compute_interval(matches: &ArgMatches, profile: &ProfileType) -> ScanTiming {
+
+        match (matches.value_of("bandwidth"), matches.value_of("interval")) {
+            (Some(bandwidth_text), None) => {
+                let bits_second: u64 = bandwidth_text.parse().unwrap_or_else(|err| {
+                    eprintln!("Expected positive number, {}", err);
+                    process::exit(1);
+                });
+                ScanTiming::Bandwidth(bits_second)
+            },
+            (None, Some(interval_text)) => parse_to_milliseconds(interval_text).map(ScanTiming::Interval).unwrap_or_else(|err| {
+                eprintln!("Expected correct interval, {}", err);
+                process::exit(1);
+            }),
+            _ => match profile {
+                ProfileType::Stealth => ScanTiming::Interval(REQUEST_MS_INTERVAL * 2),
+                ProfileType::Fast => ScanTiming::Interval(0),
+                _ => ScanTiming::Interval(REQUEST_MS_INTERVAL)
+            }
+        }
+    }
 
     /**
      * Build a new 'ScanOptions' struct that will be used in the whole CLI such
@@ -346,17 +379,7 @@ impl ScanOptions {
             }
         };
 
-        let interval_ms: u64 = match matches.value_of("interval") {
-            Some(interval_text) => parse_to_milliseconds(interval_text).unwrap_or_else(|err| {
-                eprintln!("Expected correct interval, {}", err);
-                process::exit(1);
-            }),
-            None => match profile {
-                ProfileType::Stealth => REQUEST_MS_INTERVAL * 2,
-                ProfileType::Fast => 0,
-                _ => REQUEST_MS_INTERVAL
-            }
-        };
+        let scan_timing: ScanTiming = ScanOptions::compute_interval(matches, &profile);
 
         let output = match matches.value_of("output") {
             Some(output_request) => {
@@ -463,7 +486,7 @@ impl ScanOptions {
             source_mac,
             vlan_id,
             retry_count,
-            interval_ms,
+            scan_timing,
             randomize_targets,
             output,
             oui_file,

src/main.rs

@@ -88,12 +88,14 @@ fn main() {
 
     let network_size = utils::compute_network_size(&ip_networks);
 
+    let estimations = network::compute_scan_estimation(network_size, &scan_options);
+    let interval_ms = estimations.interval_ms;
+
     if scan_options.is_plain_output() {
 
-        let estimations = network::compute_scan_estimation(network_size, &scan_options);
         let formatted_ms = time::format_milliseconds(estimations.duration_ms);
         println!("Estimated scan time {} ({} bytes, {} bytes/s)", formatted_ms, estimations.request_size, estimations.bandwidth);
-        println!("Sending {} ARP requests (waiting at least {}ms, {}ms request interval)", network_size, scan_options.timeout_ms, scan_options.interval_ms);
+        println!("Sending {} ARP requests (waiting at least {}ms, {}ms request interval)", network_size, scan_options.timeout_ms, interval_ms);
     }
 
     let finish_sleep = Arc::new(AtomicBool::new(false));
@@ -130,7 +132,7 @@ fn main() {
 
             if let IpAddr::V4(ipv4_address) = ip_address {
                 network::send_arp_request(&mut tx, selected_interface, source_ip, ipv4_address, Arc::clone(&scan_options));
-                thread::sleep(Duration::from_millis(scan_options.interval_ms));
+                thread::sleep(Duration::from_millis(interval_ms));
             }
         }
     }

src/network.rs

@@ -19,6 +19,7 @@ use rand::prelude::*;
 use crate::args::ScanOptions;
 use crate::vendor::Vendor;
 use crate::utils;
+use crate::args::ScanTiming;
 
 pub const DATALINK_RCV_TIMEOUT: u64 = 500;
 
@@ -34,6 +35,7 @@ const ETHERNET_VLAN_PACKET_SIZE: usize = 46;
  * starts and should give insights about the scan.
  */
 pub struct ScanEstimation {
+    pub interval_ms: u64,
     pub duration_ms: u128,
     pub request_size: u128,
     pub bandwidth: u128
@@ -110,7 +112,6 @@ pub fn compute_network_configuration<'a>(interfaces: &'a [NetworkInterface], sca
  */
 pub fn compute_scan_estimation(host_count: u128, options: &Arc<ScanOptions>) -> ScanEstimation {
 
-    let interval: u128 = options.interval_ms.into();
     let timeout: u128 = options.timeout_ms.into();
     let packet_size: u128 = match options.has_vlan() {
         true => ETHERNET_VLAN_PACKET_SIZE.try_into().expect("Internal number conversion failed for VLAN packet size"),
@@ -120,16 +121,35 @@ pub fn compute_scan_estimation(host_count: u128, options: &Arc<ScanOptions>) ->
 
     // The values below are averages based on an amount of performed network
     // scans. This may of course vary based on network configurations.
-    let avg_arp_request_ms = 3;
+    let avg_arp_request_ms: u128 = 3;
     let avg_resolve_ms = 500;
 
-    let request_phase_ms = (host_count * (avg_arp_request_ms+ interval)) * retry_count;
-    let duration_ms = request_phase_ms + timeout + avg_resolve_ms;
-    let request_size = host_count * packet_size;
+    let request_size: u128 = host_count * packet_size;
+
+    let (interval_ms, bandwidth, request_phase_ms): (u64, u128, u128) = match options.scan_timing {
+        ScanTiming::Bandwidth(bandwidth) => {
+
+            let bandwidth_lg: u128 = bandwidth.into();
+            let request_phase_ms: u128 = (request_size * 1000) as u128 / bandwidth_lg;
+            let interval_ms: u128 = (request_phase_ms/retry_count/host_count) - avg_arp_request_ms;
+            
+            (interval_ms.try_into().unwrap(), bandwidth_lg, request_phase_ms)
+
+        },
+        ScanTiming::Interval(interval) => {
 
-    let bandwidth = (request_size * 1000) / request_phase_ms;
+            let interval_ms_lg: u128 = interval.into();
+            let request_phase_ms: u128 = (host_count * (avg_arp_request_ms + interval_ms_lg)) * retry_count;
+            let bandwidth = (request_size * 1000) / request_phase_ms;
+
+            (interval, bandwidth, request_phase_ms)
+        }
+    };
+    
+    let duration_ms = request_phase_ms + timeout + avg_resolve_ms;
 
     ScanEstimation {
+        interval_ms,
         duration_ms,
         request_size,
         bandwidth

src/utils.rs

@@ -90,7 +90,7 @@ pub fn select_default_interface(interfaces: &[NetworkInterface]) -> Option<Netwo
  * Display scan settings before launching an ARP scan. This includes network
  * details (IP range, interface, ...) and timing informations.
  */
-pub fn display_prescan_details(ip_networks: &Vec<&IpNetwork>, selected_interface: &NetworkInterface, scan_options: Arc<ScanOptions>) -> () {
+pub fn display_prescan_details(ip_networks: &[&IpNetwork], selected_interface: &NetworkInterface, scan_options: Arc<ScanOptions>) {
 
     let mut network_list = ip_networks.iter().take(5).map(|network| network.to_string()).collect::<Vec<String>>().join(", ");
     if ip_networks.len() > 5 {