Reduce binary size from 2.4MB to 1.9MB

By default, Cargo instructs compilation units to be compiled and optimized
in isolation. LTO instructs the linker to optimize at the link stage.
This can, for example, remove dead code and often times reduces binary size.

By default, when Rust code encounters a situation when it must call panic!(),
it unwinds the stack and produces a helpful backtrace. The unwinding code,
however, does require extra binary size. rustc can be instructed to abort
immediately rather than unwind, which removes the need for this extra unwinding code.

For more information see: https://github.com/johnthagen/min-sized-rust

Cargo.toml

@@ -16,8 +16,6 @@ exclude = [
     "rustscan-debbuilder/*",
 ]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 colored = "2.0.0"
 structopt = "0.3.16"
@@ -36,3 +34,7 @@ ansi_term = "0.12.1"
 [package.metadata.deb]
 depends = "$auto, nmap"
 section = "rust"
+
+[profile.release]
+lto = true
+panic = 'abort'

README.md

@@ -230,8 +230,7 @@ OPTIONS:
     -b, --batch-size <batch-size>    The batch size for port scanning, it increases or slows the speed of scanning.
                                      Depends on the open file limit of your OS.  If you do 65535 it will do every port
                                      at the same time. Although, your OS may not support this [default: 4500]
-    -p, --ports <ports>...           A list of comma separed ports to be scanned. Example: 80,443,8080. These ports will
-                                     be scanned sequentially
+    -p, --ports <ports>...           A list of comma separed ports to be scanned. Example: 80,443,8080.
     -r, --range <range>              A range of ports with format start-end. Example: 1-1000
         --scan-order <scan-order>    The order of scanning to be performed. The "serial" option will scan ports in
                                      ascending order while the "random" option will scan ports randomly [default:

src/main.rs

@@ -82,7 +82,6 @@ struct Opts {
     ips_or_hosts: Vec<String>,
 
     /// A list of comma separed ports to be scanned. Example: 80,443,8080.
-    /// These ports will be scanned sequentially.
     #[structopt(short, long, use_delimiter = true)]
     ports: Option<Vec<u16>>,
 

src/port_strategy/mod.rs

@@ -1,5 +1,7 @@
 mod range_iterator;
 use super::{PortRange, ScanOrder};
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use range_iterator::RangeIterator;
 
 /// Represents options of port scanning.
@@ -15,26 +17,27 @@ pub enum PortStrategy {
 impl PortStrategy {
     pub fn pick(range: Option<PortRange>, ports: Option<Vec<u16>>, order: ScanOrder) -> Self {
         match order {
-            ScanOrder::Serial => match ports.is_none() {
-                true => {
-                    let range = range.as_ref().unwrap();
-                    PortStrategy::Serial(SerialRange {
-                        start: range.start,
-                        end: range.end,
-                    })
-                }
-                false => PortStrategy::Manual(ports.unwrap()),
-            },
-            ScanOrder::Random => match ports.is_none() {
-                true => {
-                    let range = range.as_ref().unwrap();
-                    PortStrategy::Random(RandomRange {
-                        start: range.start,
-                        end: range.end,
-                    })
-                }
-                false => PortStrategy::Manual(ports.unwrap()),
-            },
+            ScanOrder::Serial if ports.is_none() => {
+                let range = range.as_ref().unwrap();
+                PortStrategy::Serial(SerialRange {
+                    start: range.start,
+                    end: range.end,
+                })
+            }
+            ScanOrder::Random if ports.is_none() => {
+                let range = range.as_ref().unwrap();
+                PortStrategy::Random(RandomRange {
+                    start: range.start,
+                    end: range.end,
+                })
+            }
+            ScanOrder::Serial => PortStrategy::Manual(ports.unwrap()),
+            ScanOrder::Random => {
+                let mut rng = thread_rng();
+                let mut ports = ports.unwrap();
+                ports.shuffle(&mut rng);
+                PortStrategy::Manual(ports)
+            }
         }
     }
 
@@ -121,9 +124,13 @@ mod tests {
     }
 
     #[test]
-    fn random_strategy_with_ports_does_not_randomize_ports() {
-        let strategy = PortStrategy::pick(None, Some(vec![80, 443]), ScanOrder::Random);
-        let result = strategy.order();
-        assert_eq!(vec![80, 443], result);
+    fn random_strategy_with_ports() {
+        let strategy = PortStrategy::pick(None, Some((1..10).collect()), ScanOrder::Random);
+        let mut result = strategy.order();
+        let expected_range = (1..10).into_iter().collect::<Vec<u16>>();
+        assert_ne!(expected_range, result);
+
+        result.sort();
+        assert_eq!(expected_range, result);
     }
 }