Merge branch 'master' into bee-add-config-file

updated config file to feature nmap top 1k ports

Cargo.lock

@@ -774,6 +774,7 @@ dependencies = [
  "rlimit",
  "shell-words",
  "structopt",
+ "toml",
 ]
 
 [[package]]
@@ -782,6 +783,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"
 
+[[package]]
+name = "serde"
+version = "1.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
+
 [[package]]
 name = "shell-words"
 version = "1.0.0"
@@ -874,6 +881,15 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "toml"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.6.0"

Cargo.toml

@@ -10,8 +10,11 @@ license = "MIT"
 keywords = ["port", "scanning", "nmap"]
 categories = ["command-line-utilities"]
 readme="README.md"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+exclude = [
+    ".github/*",
+    "pictures/*",
+    "rustscan-debbuilder/*",
+]
 
 [dependencies]
 colored = "2.0.0"
@@ -23,11 +26,19 @@ shell-words = "1.0.0"
 log = "0.4.0"
 env_logger = "0.7.1"
 dirs = "3.0.1"
+toml = "0.5.6"
 gcd = "2.0.1"
 rand = "0.7.3"
 colorful = "0.2.1"
 ansi_term = "0.12.1"
+ureq = "1.3.0"
+serde = "1.0.115"
+serde_derive = "1.0.115"
 
 [package.metadata.deb]
 depends = "$auto, nmap"
 section = "rust"
+
+[profile.release]
+lto = true
+panic = 'abort'

README.md

@@ -5,13 +5,13 @@
  <a href="https://github.com/RustScan/RustScan#-usage">Usage Guide</a>
  ⬅️
 <br>
-<img src="pictures/rustscan.png">
+<img src="https://github.com/RustScan/RustScan/blob/master/pictures/rustscan.png?raw=true">
 </p>
 <p align="center">
 <u><b> Turns a 17 minutes Nmap scan into 19 seconds. </b></u><br> Find all open ports <b>fast</b> with RustScan, automatically pipe them into Nmap.
 </p>
 <p align="center">
-<img alt="AUR version" src="https://img.shields.io/aur/version/rustscan-bin">
+<img alt="AUR version" src="https://img.shields.io/aur/version/rustscan">
 <img src="https://img.shields.io/badge/Built%20with-Rust-Purple">
 <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/w/brandonskerritt/rustscan">
 <img alt="GitHub All Releases" src="https://img.shields.io/github/downloads/rustscan/rustscan/total?label=GitHub%20Downloads">
@@ -23,7 +23,7 @@
 
 | <p align="center"><a href="https://hub.docker.com/r/cmnatic/rustscan">🐋 Docker (Recommended) </a></p> | <p align="center"><a href="https://github.com/RustScan/RustScan/releases">👩‍💻 Kali / Debian </p> | <p align="center"><a href="https://aur.archlinux.org/packages/rustscan/">🏗️ Arch </a></p> | <p align="center"><a href="https://crates.io/crates/rustscan">🔧 Cargo (Universal) </a></p> |
 | ---- | ---- | ---- | --- |
-| <p align="center"><img src="pictures/docker.png" /></p> | <p align="center"><img src="pictures/kali.png" /></p> | <p align="center"><img src="pictures/arch.png" /></p> | <p align="center"><img src="pictures/rust.png" /></p>
+| <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/docker.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/kali.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/arch.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/rust.png?raw=true" /></p>
 | `docker pull rustscan/rustscan:alpine` <p>[Usage](https://github.com/RustScan/RustScan#docker-whale) | [Read the install guide](https://github.com/brandonskerritt/RustScan/blob/master/README.md#%EF%B8%8F-debian--kali) | `yay -S rustscan` | `cargo install rustscan`
 
 <hr>
@@ -42,8 +42,8 @@
   </tr>
   <tr>
   <th>Gif</th>
-    <td><img src="pictures/with_rustscan.gif" alt="The guy she tells you not to worry about"></td>
-    <td><img src="pictures/without_rustscan.gif" alt="You"></td>
+    <td><img src="https://github.com/RustScan/RustScan/blob/master/pictures/with_rustscan.gif?raw=true" alt="The guy she tells you not to worry about"></td>
+    <td><img src="https://github.com/RustScan/RustScan/blob/master/pictures/without_rustscan.gif?raw=true" alt="You"></td>
   </tr>
   <tr>
   <th>Time</th>
@@ -79,7 +79,7 @@ RustScans **only** job is to reduce the friction between finding open ports and
 # 🔭 Why RustScan?
 Why spend time running fast scans and manually copying the ports, or waiting for a 20 minute scan to finish when you can just do all 65k ports in less than a minute?
 
-![gif](pictures/8seconds.gif)
+![gif](https://github.com/RustScan/RustScan/blob/master/pictures/8seconds.gif?raw=true)
 
 **RustScan running in 8 seconds and finding all open ports out of 65k.**
 
@@ -213,13 +213,12 @@ rustscan -h
 ```
 
 ```
-rustscan 1.7.1
 Fast Port Scanner built in Rust. WARNING Do not use this program against sensitive infrastructure since the specified
 server may not be able to handle this many socket connections at once. - Discord https://discord.gg/GFrQsGy - GitHub
 https://github.com/RustScan/RustScan
 
 USAGE:
-    rustscan [FLAGS] [OPTIONS] <ips>... [-- <command>...]
+    rustscan [FLAGS] [OPTIONS] <ips-or-hosts>... [-- <command>...]
 
 FLAGS:
     -a, --accessible
@@ -231,6 +230,8 @@ 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.
+    -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:
                                      serial]  [possible values: Serial, Random]
@@ -238,11 +239,11 @@ OPTIONS:
     -u, --ulimit <ulimit>            Automatically ups the ULIMIT with the value you provided
 
 ARGS:
-    <ips>...        A list of comma separated IP addresses to be scanned
-    <command>...    The Nmap arguments to run. To use the argument -A, end RustScan's args with '-- -A'. Example:
-                    'rustscan -T 1500 127.0.0.1 -- -A -sC'. This command adds -Pn -vvv -p $PORTS automatically to
-                    nmap. For things like --script '(safe and vuln)' enclose it in quotations marks \"'(safe and
-                    vuln)'\"")
+    <ips-or-hosts>...    A list of comma separated IP addresses or hosts to be scanned
+    <command>...         The Nmap arguments to run. To use the argument -A, end RustScan's args with '-- -A'.
+                         Example: 'rustscan -T 1500 127.0.0.1 -- -A -sC'. This command adds -Pn -vvv -p $PORTS
+                         automatically to nmap. For things like --script '(safe and vuln)' enclose it in quotations
+                         marks \"'(safe and vuln)'\"")
 ```
 
 The format is `rustscan -b 500 -T 1500 192.168.0.1` to scan 192.168.0.1 with 500 batch size with a timeout of 1500ms. The timeout is how long RustScan waits for a response until it assumes the port is closed.
@@ -339,6 +340,22 @@ To increase accuracy, the easiest way is to increase the timeout. The default is
 
 Decreasing accuracy gives some speed bonus, but my testing found that batch size dramatically changed the speed whereas timeout did, but not so much.
 
+## 🤖 Config File
+
+RustScan uses a Config file to make things easier for you. And to also improve itself.
+The config file is used as the basis of the _adaptive learning_ mechanisms. This means that RustScan _learns_ from your scans and improves itself over time. (Don't worry, no bloated AI framework here 😉)
+
+The config file should be placed in APPDIRS. To find this folder, run RustScan and look out for RustScan saying "couldn't find config at <location>". That location is where your config file should be.
+
+Once you have this location, copy and paste this:
+
+```toml
+
+# The top ports
+[top_ports]
+80, 60, 443
+```
+
 # 🎪 Community
 
 Howdy Space Cow-Person 🤠🌌

docker/ci_test/Dockerfile

@@ -0,0 +1,28 @@
+FROM archlinux:latest
+
+RUN yes | pacman -Syu
+RUN yes | pacman -S fakeroot binutils sudo make gcc gettext awk git
+
+WORKDIR /opt
+RUN git clone https://aur.archlinux.org/yay-git.git
+
+RUN useradd -m tecmint
+RUN passwd -d tecmint
+RUN printf 'tecmint ALL=(ALL) ALL\n' | tee -a /etc/sudoers
+
+WORKDIR /opt/yay-git
+RUN chown -R tecmint /opt/yay-git
+USER tecmint
+RUN makepkg -si --noconfirm
+
+# AUR
+RUN yay -S rustscan --noconfirm
+RUN rustscan 127.0.0.1 -q -b 250 -t 1
+RUN yay -R rustscan --noconfirm
+
+# homebrew
+RUN yes | /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+ENV PATH="/home/linuxbrew/.linuxbrew/bin:${PATH}"
+RUN yes | brew tap brandonskerritt/rustscan
+RUN yes | brew install rustscan
+RUN rustscan 127.0.0.1 -q -b 250 -t 1

docker/rustscan-debbuilder/entrypoint.sh

@@ -5,6 +5,7 @@ git pull --force
 
 #amd64
 cargo deb
+yes | dpkg -i *.deb
 
 #arm64
 rustup target add arm-unknown-linux-gnueabihf

src/main.rs

@@ -13,11 +13,20 @@ use colorful::Colorful;
 use futures::executor::block_on;
 use rlimit::Resource;
 use rlimit::{getrlimit, setrlimit};
+use serde_derive::Deserialize;
 use std::collections::HashMap;
+use std::net::ToSocketAddrs;
 use std::process::Command;
 use std::str::FromStr;
-use std::{net::IpAddr, net::ToSocketAddrs, time::Duration};
+use std::{
+    fs::File,
+    io::{Read, Write},
+    net::IpAddr,
+    path::PathBuf,
+    time::Duration,
+};
 use structopt::{clap::arg_enum, StructOpt};
+use ureq;
 
 extern crate colorful;
 extern crate dirs;
@@ -40,6 +49,35 @@ arg_enum! {
     }
 }
 
+#[derive(Debug)]
+pub struct PortRange {
+    start: u16,
+    end: u16,
+}
+
+fn parse_range(input: &str) -> Result<PortRange, String> {
+    let range = input
+        .split("-")
+        .map(|x| x.parse::<u16>())
+        .collect::<Result<Vec<u16>, std::num::ParseIntError>>();
+
+    if range.is_err() {
+        return Err(String::from(
+            "the range format must be 'start-end'. Example: 1-1000.",
+        ));
+    }
+
+    match range.unwrap().as_slice() {
+        [start, end] => Ok(PortRange {
+            start: *start,
+            end: *end,
+        }),
+        _ => Err(String::from(
+            "the range format must be 'start-end'. Example: 1-1000.",
+        )),
+    }
+}
+
 #[derive(StructOpt, Debug)]
 #[structopt(name = "rustscan", setting = structopt::clap::AppSettings::TrailingVarArg)]
 /// Fast Port Scanner built in Rust.
@@ -52,6 +90,14 @@ struct Opts {
     #[structopt(use_delimiter = true, required = true)]
     ips_or_hosts: Vec<String>,
 
+    /// A list of comma separed ports to be scanned. Example: 80,443,8080.
+    #[structopt(short, long, use_delimiter = true)]
+    ports: Option<Vec<u16>>,
+
+    /// A range of ports with format start-end. Example: 1-1000.
+    #[structopt(short, long, conflicts_with = "ports", parse(try_from_str = parse_range))]
+    range: Option<PortRange>,
+
     ///Quiet mode. Only output the ports. No Nmap. Useful for grep or outputting to a file.
     #[structopt(short, long)]
     quiet: bool,
@@ -60,6 +106,10 @@ struct Opts {
     #[structopt(short, long)]
     accessible: bool,
 
+    ///Config file usage
+    #[structopt(short, long)]
+    config: bool,
+
     /// 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
@@ -90,6 +140,11 @@ struct Opts {
     command: Vec<String>,
 }
 
+#[derive(Deserialize)]
+struct ConfigFile {
+    ip: IpAddr,
+}
+
 #[cfg(not(tarpaulin_include))]
 /// Faster Nmap scanning with Rust
 /// If you're looking for the actual scanning, check out the module Scanner
@@ -97,13 +152,27 @@ fn main() {
     env_logger::init();
 
     info!("Starting up");
-    let opts = Opts::from_args();
+    let mut opts = Opts::from_args();
+
+    if opts.ports.is_none() && opts.range.is_none() {
+        opts.range = Some(PortRange {
+            start: LOWEST_PORT_NUMBER,
+            end: TOP_PORT_NUMBER,
+        });
+    }
+
     info!("Mains() `opts` arguments are {:?}", opts);
 
     if !opts.quiet && !opts.accessible {
         print_opening();
     }
 
+    /*
+    TODO when releasing the new config file feature
+    turn this on.
+    if opts.config {
+        let config = get_config_file();
+    }*/
     let ips: Vec<IpAddr> = parse_ips(&opts);
 
     if ips.is_empty() {
@@ -119,7 +188,7 @@ fn main() {
         batch_size,
         Duration::from_millis(opts.timeout.into()),
         opts.quiet,
-        PortStrategy::pick(LOWEST_PORT_NUMBER, TOP_PORT_NUMBER, opts.scan_order),
+        PortStrategy::pick(opts.range, opts.ports, opts.scan_order),
     );
 
     let scan_result = block_on(scanner.run());
@@ -200,21 +269,65 @@ Faster Nmap scanning with Rust."#;
  --------------------------------------"#;
     println!("{}", info.gradient(Color::Yellow).bold());
     funny_opening!();
+    // println!("{}", loaded_config_file);
+}
 
+fn get_config_file() {
+    let result_get_location = get_location_config();
+    let location = match result_get_location {
+        Ok(path) => path,
+        Err(_) => panic!("Your system does not have appdirs."),
+    };
+    info!("The location of config is {:?}", location);
+
+    detail!(format!("The config file is at {:?}", location));
+
+    load_and_parse_config_file(location);
+}
+
+fn get_location_config() -> Result<std::path::PathBuf, &'static str> {
+    info!("Getting location of config file");
     let config_path = match dirs::config_dir() {
         Some(mut path) => {
             path.push("rustscan");
             path.push("config.toml");
-            path
+            Ok(path)
         }
-        None => panic!("Couldn't find config dir."),
+        None => Err("Your system does not have APPDIRS"),
     };
-
-    detail!(format!(
-        "{} {:?}",
-        "The config file is expected to be at", config_path
-    ));
+    config_path
 }
+
+fn load_and_parse_config_file(config_path: PathBuf) -> ConfigFile {
+    // Gets the file and returns the string of TOML
+    // TODO quiet mode
+
+    let mut file = File::open(&config_path);
+    let mut file: File = match file {
+        Ok(result) => result,
+        Err(_) => download_place_config_file(config_path),
+    };
+    let mut contents = String::new();
+    file.read_to_string(&mut contents).unwrap();
+    let config: ConfigFile = toml::from_str(&contents).unwrap();
+
+    config
+}
+// Downloads config file
+// Places into Appdirs
+
+fn download_place_config_file(config_location: PathBuf) -> std::fs::File {
+    info!("Placing config file");
+    let body = ureq::get("https://raw.githubusercontent.com/RustScan/RustScan/master/config.toml")
+        .call()
+        .into_string()
+        .unwrap();
+
+    let mut file = File::create(config_location).unwrap();
+    file.write(body.as_bytes()).unwrap();
+    file
+}
+
 #[cfg(not(tarpaulin_include))]
 fn build_nmap_arguments<'a>(
     addr: &'a str,
@@ -223,7 +336,6 @@ fn build_nmap_arguments<'a>(
     is_ipv6: bool,
 ) -> Vec<&'a str> {
     let mut arguments: Vec<&str> = user_args.iter().map(AsRef::as_ref).collect();
-    arguments.push("-A");
     arguments.push("-vvv");
 
     if is_ipv6 {
@@ -322,11 +434,14 @@ mod tests {
     fn batch_size_lowered() {
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 50_000,
             timeout: 1_000,
             ulimit: Some(2_000),
             command: Vec::new(),
+            config: false,
             accessible: false,
             scan_order: ScanOrder::Serial,
         };
@@ -339,11 +454,14 @@ mod tests {
     fn batch_size_lowered_average_size() {
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 50_000,
             timeout: 1_000,
             ulimit: Some(2_000),
             command: Vec::new(),
+            config: false,
             accessible: false,
             scan_order: ScanOrder::Serial,
         };
@@ -357,11 +475,14 @@ mod tests {
         // to ULIMIT - 100
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 50_000,
             timeout: 1_000,
             ulimit: Some(2_000),
             command: Vec::new(),
+            config: false,
             accessible: false,
             scan_order: ScanOrder::Serial,
         };
@@ -374,11 +495,14 @@ mod tests {
         // ulimit == batch_size
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 50_000,
             timeout: 1_000,
             ulimit: Some(2_000),
             command: Vec::new(),
+            config: false,
             accessible: false,
             scan_order: ScanOrder::Serial,
         };
@@ -396,11 +520,14 @@ mod tests {
     fn test_high_ulimit_no_quiet_mode() {
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: false,
             batch_size: 10,
             timeout: 1_000,
             ulimit: None,
             command: Vec::new(),
+            config: false,
             accessible: true,
             scan_order: ScanOrder::Serial,
         };
@@ -414,6 +541,8 @@ mod tests {
     fn parse_correct_ips_or_hosts() {
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned(), "google.com".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 10,
             timeout: 1_000,
@@ -421,6 +550,7 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
+            config: false,
         };
         let ips = parse_ips(&opts);
 
@@ -431,6 +561,8 @@ mod tests {
     fn parse_correct_and_incorrect_ips_or_hosts() {
         let opts = Opts {
             ips_or_hosts: vec!["127.0.0.1".to_owned(), "im_wrong".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 10,
             timeout: 1_000,
@@ -438,6 +570,7 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
+            config: false,
         };
         let ips = parse_ips(&opts);
 
@@ -448,6 +581,8 @@ mod tests {
     fn parse_incorrect_ips_or_hosts() {
         let opts = Opts {
             ips_or_hosts: vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()],
+            ports: None,
+            range: None,
             quiet: true,
             batch_size: 10,
             timeout: 1_000,
@@ -455,6 +590,7 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
+            config: false,
         };
         let ips = parse_ips(&opts);
 

src/port_strategy/mod.rs

@@ -1,5 +1,7 @@
 mod range_iterator;
-use super::ScanOrder;
+use super::{PortRange, ScanOrder};
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use range_iterator::RangeIterator;
 
 /// Represents options of port scanning.
@@ -7,20 +9,41 @@ use range_iterator::RangeIterator;
 /// Right now all these options involve ranges, but in the future
 /// it will also contain custom lists of ports.
 pub enum PortStrategy {
+    Manual(Vec<u16>),
     Serial(SerialRange),
     Random(RandomRange),
 }
 
 impl PortStrategy {
-    pub fn pick(start: u16, end: u16, scan_type: ScanOrder) -> Self {
-        match scan_type {
-            ScanOrder::Serial => PortStrategy::Serial(SerialRange { start, end }),
-            ScanOrder::Random => PortStrategy::Random(RandomRange { start, end }),
+    pub fn pick(range: Option<PortRange>, ports: Option<Vec<u16>>, order: ScanOrder) -> Self {
+        match order {
+            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)
+            }
         }
     }
 
     pub fn order(&self) -> Vec<u16> {
         match self {
+            PortStrategy::Manual(ports) => ports.to_vec(),
             PortStrategy::Serial(range) => range.generate(),
             PortStrategy::Random(range) => range.generate(),
         }
@@ -71,18 +94,20 @@ impl RangeOrder for RandomRange {
 #[cfg(test)]
 mod tests {
     use super::PortStrategy;
-    use crate::ScanOrder;
+    use crate::{PortRange, ScanOrder};
 
     #[test]
-    fn serial_strategy() {
-        let strategy = PortStrategy::pick(1, 100, ScanOrder::Serial);
+    fn serial_strategy_with_range() {
+        let range = PortRange { start: 1, end: 100 };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Serial);
         let result = strategy.order();
         let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
     }
     #[test]
-    fn random_strategy() {
-        let strategy = PortStrategy::pick(1, 100, ScanOrder::Random);
+    fn random_strategy_with_range() {
+        let range = PortRange { start: 1, end: 100 };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let mut result = strategy.order();
         let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
         assert_ne!(expected_range, result);
@@ -90,4 +115,22 @@ mod tests {
         result.sort();
         assert_eq!(expected_range, result);
     }
+
+    #[test]
+    fn serial_strategy_with_ports() {
+        let strategy = PortStrategy::pick(None, Some(vec![80, 443]), ScanOrder::Serial);
+        let result = strategy.order();
+        assert_eq!(vec![80, 443], result);
+    }
+
+    #[test]
+    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);
+    }
 }

src/scanner/mod.rs

@@ -139,7 +139,7 @@ impl Scanner {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ScanOrder;
+    use crate::{PortRange, ScanOrder};
     use async_std::task::block_on;
     use std::{net::IpAddr, time::Duration};
 
@@ -147,7 +147,11 @@ mod tests {
     fn scanner_runs() {
         // Makes sure the program still runs and doesn't panic
         let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let strategy = PortStrategy::pick(1, 1_000, ScanOrder::Random);
+        let range = PortRange {
+            start: 1,
+            end: 1_000,
+        };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy);
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
@@ -157,7 +161,11 @@ mod tests {
     fn ipv6_scanner_runs() {
         // Makes sure the program still runs and doesn't panic
         let addrs = vec!["::1".parse::<IpAddr>().unwrap()];
-        let strategy = PortStrategy::pick(1, 1_000, ScanOrder::Random);
+        let range = PortRange {
+            start: 1,
+            end: 1_000,
+        };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy);
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
@@ -166,7 +174,11 @@ mod tests {
     #[test]
     fn quad_zero_scanner_runs() {
         let addrs = vec!["0.0.0.0".parse::<IpAddr>().unwrap()];
-        let strategy = PortStrategy::pick(1, 1_000, ScanOrder::Random);
+        let range = PortRange {
+            start: 1,
+            end: 1_000,
+        };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy);
         block_on(scanner.run());
         assert_eq!(1, 1);
@@ -174,7 +186,11 @@ mod tests {
     #[test]
     fn google_dns_runs() {
         let addrs = vec!["8.8.8.8".parse::<IpAddr>().unwrap()];
-        let strategy = PortStrategy::pick(400, 445, ScanOrder::Random);
+        let range = PortRange {
+            start: 400,
+            end: 445,
+        };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy);
         block_on(scanner.run());
         assert_eq!(1, 1);
@@ -185,7 +201,11 @@ mod tests {
         let addrs = vec!["8.8.8.8".parse::<IpAddr>().unwrap()];
 
         // mac should have this automatically scaled down
-        let strategy = PortStrategy::pick(400, 600, ScanOrder::Random);
+        let range = PortRange {
+            start: 400,
+            end: 600,
+        };
+        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
         let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy);
         block_on(scanner.run());
         assert_eq!(1, 1);