Merge pull request #174 from caass/patch-1

Allow compilation on windows (#171)

.travis.yml

@@ -3,7 +3,7 @@ language: rust
 os:
   - linux
   - osx
-  # - windows
+  - windows
 
 arch:
   - amd64

Cargo.toml

@@ -10,15 +10,17 @@ 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"
 structopt = "0.3.16"
 async-std = "1.6.3"
 futures = "0.3"
-rlimit = "0.4.0"
 shell-words = "1.0.0"
 log = "0.4.0"
 env_logger = "0.7.1"
@@ -28,6 +30,13 @@ rand = "0.7.3"
 colorful = "0.2.1"
 ansi_term = "0.12.1"
 
+[target."cfg(not(windows))".dependencies]
+rlimit = "0.4.0"
+
 [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.**
 
@@ -222,10 +222,9 @@ USAGE:
     rustscan [FLAGS] [OPTIONS] <ips>... [-- <command>...]
 
 FLAGS:
-    -a, --accessible
-    -h, --help          Prints help information
-    -q, --quiet         Quiet mode. Only output the ports. No Nmap. Useful for grep or outputting to a file
-    -V, --version       Prints version information
+    -h, --help       Prints help information
+    -q, --quiet      Quiet mode. Only output the ports. No Nmap. Useful for grep or outputting to a file
+    -V, --version    Prints version information
 
 OPTIONS:
     -b, --batch-size <batch-size>    The batch size for port scanning, it increases or slows the speed of scanning.

src/main.rs

@@ -11,9 +11,13 @@ use port_strategy::PortStrategy;
 use colorful::Color;
 use colorful::Colorful;
 use futures::executor::block_on;
-use rlimit::Resource;
-use rlimit::{getrlimit, setrlimit};
+
+#[cfg(not(target_os = "windows"))]
+use rlimit::{getrlimit, setrlimit, Resource};
+
 use std::collections::HashMap;
+#[cfg(not(target_os = "windows"))]
+use std::convert::TryInto;
 use std::process::Command;
 use std::str::FromStr;
 use std::{net::IpAddr, net::ToSocketAddrs, time::Duration};
@@ -25,9 +29,9 @@ extern crate dirs;
 const LOWEST_PORT_NUMBER: u16 = 1;
 const TOP_PORT_NUMBER: u16 = 65535;
 // Average value for Ubuntu
-const DEFAULT_FILE_DESCRIPTORS_LIMIT: rlimit::rlim = 8000;
+const DEFAULT_FILE_DESCRIPTORS_LIMIT: u32 = 8000;
 // Safest batch size based on experimentation
-const AVERAGE_BATCH_SIZE: rlimit::rlim = 3000;
+const AVERAGE_BATCH_SIZE: u32 = 3000;
 
 #[macro_use]
 extern crate log;
@@ -40,6 +44,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 +85,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,
@@ -73,7 +114,7 @@ struct Opts {
 
     /// Automatically ups the ULIMIT with the value you provided.
     #[structopt(short, long)]
-    ulimit: Option<rlimit::rlim>,
+    ulimit: Option<u32>,
 
     /// The order of scanning to be performed. The "serial" option will
     /// scan ports in ascending order while the "random" option will scan
@@ -97,7 +138,15 @@ 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 {
@@ -111,7 +160,8 @@ fn main() {
         std::process::exit(1);
     }
 
-    let ulimit: rlimit::rlim = adjust_ulimit_size(&opts);
+    let ulimit: u32 = adjust_ulimit_size(&opts);
+
     let batch_size: u16 = infer_batch_size(&opts, ulimit);
 
     let scanner = Scanner::new(
@@ -119,7 +169,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());
@@ -223,7 +273,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 {
@@ -256,9 +305,10 @@ fn parse_ips(opts: &Opts) -> Vec<IpAddr> {
     ips
 }
 
-fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
+#[cfg(not(target_os = "windows"))]
+fn adjust_ulimit_size(opts: &Opts) -> u32 {
     if opts.ulimit.is_some() {
-        let limit: rlimit::rlim = opts.ulimit.unwrap();
+        let limit: rlimit::rlim = opts.ulimit.unwrap().into();
 
         match setrlimit(Resource::NOFILE, limit, limit) {
             Ok(_) => {
@@ -273,14 +323,21 @@ fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
 
     let (rlim, _) = getrlimit(Resource::NOFILE).unwrap();
 
-    rlim
+    rlim.try_into().unwrap()
 }
 
-fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
-    let mut batch_size: rlimit::rlim = opts.batch_size.into();
+// Rlimit does not support Windows
+// set to 1000 if Windows is used
+#[cfg(target_os = "windows")]
+fn adjust_ulimit_size(_opts: &Opts) -> u32 {
+    1000
+}
+
+fn infer_batch_size(opts: &Opts, ulimit: u32) -> u16 {
+    let mut batch_size: u32 = opts.batch_size.into();
 
     // Adjust the batch size when the ulimit value is lower than the desired batch size
-    if ulimit < batch_size {
+    if ulimit < batch_size && !(cfg!(windows)) {
         warning!("File limit is lower than default batch size. Consider upping with --ulimt. May cause harm to sensitive servers",
             opts.quiet
         );
@@ -292,7 +349,11 @@ fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
             // ulimit is smaller than aveage batch size
             // user must have very small ulimit
             // decrease batch size to half of ulimit
-            warning!("Your file limit is very small, which negatively impacts RustScan's speed. Use the Docker image, or up the Ulimit with '--ulimit 5000'. ");
+            if !(cfg!(windows)) {
+                warning!("Your file limit is very small, which negatively impacts RustScan's speed. Use the Docker image, or up the Ulimit with '--ulimit 5000'. ");
+            } else {
+                warning!("Windows is known to be much slower than scanning on Unix systems. Use the Docker image if you need faster speeds.");
+            }
             info!("Halving batch_size because ulimit is smaller than average batch size");
             batch_size = ulimit / 2
         } else if ulimit > DEFAULT_FILE_DESCRIPTORS_LIMIT {
@@ -318,10 +379,13 @@ fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
 mod tests {
     use crate::{adjust_ulimit_size, infer_batch_size, parse_ips, print_opening, Opts, ScanOrder};
 
+    #[cfg(not(target_os = "windows"))]
     #[test]
     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,
@@ -335,10 +399,13 @@ mod tests {
         assert!(batch_size < 50_000);
     }
 
+    #[cfg(not(target_os = "windows"))]
     #[test]
     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,
@@ -351,12 +418,15 @@ mod tests {
 
         assert!(batch_size == 3_000);
     }
+    #[cfg(not(target_os = "windows"))]
     #[test]
     fn batch_size_equals_ulimit_lowered() {
         // because ulimit and batch size are same size, batch size is lowered
         // 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,
@@ -369,11 +439,14 @@ mod tests {
 
         assert!(batch_size == 4_900);
     }
+    #[cfg(not(target_os = "windows"))]
     #[test]
     fn batch_size_adjusted_2000() {
         // 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,
@@ -396,6 +469,8 @@ 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,
@@ -414,6 +489,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,
@@ -431,6 +508,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,
@@ -448,6 +527,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,

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);