test PR

.github/dependabot.yml

@@ -1,13 +1,5 @@
 version: 2
 updates:
-- package-ecosystem: "github-actions"
-  directory: "/"
-  schedule:
-    interval: "daily"
-- package-ecosystem: "docker"
-  directory: "/"
-  schedule:
-    interval: "daily"
 - package-ecosystem: cargo
   directory: "/"
   schedule:

.github/workflows/build.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Install stable toolchain
         uses: actions-rs/toolchain@v1
@@ -22,7 +22,7 @@ jobs:
           toolchain: stable
           override: true
 
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
 
       - name: Run cargo check
         uses: actions-rs/cargo@v1
@@ -38,7 +38,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Install stable toolchain
         uses: actions-rs/toolchain@v1
@@ -47,7 +47,7 @@ jobs:
           toolchain: ${{ matrix.rust }}
           override: true
 
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
 
       - name: Run cargo test
         uses: actions-rs/cargo@v1
@@ -59,7 +59,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           submodules: true
 
@@ -71,7 +71,7 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@v1
 
       - name: Run cargo fmt
         uses: actions-rs/cargo@v1

.github/workflows/docker.yml

@@ -3,9 +3,18 @@ name: Publish Docker image
 on:
   push:
     tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
+      - 'v[0-9]+.[0-9]+.[0-9]+'
   release:
     types: [published]
+  pull_request:
+    branches:
+      - master
+    paths:
+      - 'Dockerfile'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'contributing.Dockerfile'
+      - '.github/workflows/docker.yml'
 
 jobs:
   push_to_registry:
@@ -13,24 +22,23 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Log in to Docker Hub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
         with:
-          password: ${{ secrets.DOCKERHUB_USERNAME }}
-          username: ${{ secrets.DOCKERHUB_TOKEN }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          username: ${{ secrets.DOCKER_USERNAME }}
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v4
         with:
           images: rustscan/rustscan
           flavor: latest=true
 
       - name: Build and push Docker image
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v3
         with:
           context: .
           push: ${{ contains(fromJson('["push", "release"]'), github.event_name) }} # Publish to docker registry only on push event or new release.

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Release
 on:
   push:
     tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
+      - 'v[0-9]+.[0-9]+.[0-9]+'
   pull_request:
     branches:
       - master
@@ -59,8 +59,8 @@ jobs:
         #   target: i686-pc-windows-msvc
 
     steps:
-      - name: Set Git config. (windows only)
-        if: contains(matrix.build, 'windows') # Windows is missing some dependencies
+      - name: Strip release binary (linux and macos)
+        if: matrix.build == 'x86_64-windows' # Windows is missing some dependencies
         run: |
           git config --global pack.windowMemory "100m"
           git config --global pack.packSizeLimit "100m"
@@ -68,13 +68,13 @@ jobs:
           git config --global pack.deltaCacheSize "512m"
 
       - name: Install python 3.10 for windows
-        if: contains(matrix.build, 'windows') # Windows is missing some dependencies
-        uses: actions/setup-python@v5
+        if: matrix.build == 'x86_64-windows' # Windows is missing some dependencies
+        uses: actions/setup-python@v4
         with:
           python-version: '3.10'
 
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           submodules: true
 
@@ -100,37 +100,28 @@ jobs:
           command: build
           args: --release --locked --target ${{ matrix.target }}
 
-      - name: Calculate tag name
-        if: contains(matrix.build, 'linux')
-        run: |
-          name=dev
-          if [[ ${GITHUB_REF} =~ refs/tags/[0-9]+.[0-9]+.[0-9]+ ]]; then
-            name=${GITHUB_REF#refs/tags/}
-          fi
-          echo ::set-output name=val::$name
-          echo TAG=$name >> $GITHUB_ENV
-        id: tagname
+      - name: Strip release binary (linux and macos)
+        if: matrix.build == 'x86_64-linux' || matrix.build == 'x86_64-macos'
+        run: strip "target/${{ matrix.target }}/release/$BIN_NAME"
 
-      - name: Build deb package (linux only)
-        if: contains(matrix.build, 'linux')
+      - name: Strip release binary (arm)
+        if: matrix.build == 'aarch64-linux'
         run: |
-          cargo install cargo-deb
-          cargo deb --target ${{ matrix.target }} --deb-version ${TAG}
-
+          docker run --rm -v \
+            "$PWD/target:/target:Z" \
+            rustembedded/cross:${{ matrix.target }} \
+            aarch64-linux-gnu-strip \
+            /target/${{ matrix.target }}/release/$BIN_NAME
       - name: Build archive
         shell: bash
         run: |
           mkdir dist
-          if [[ "${{ matrix.build }}" =~ "windows" ]]; then
+          if [ "${{ matrix.os }}" = "windows-2019" ]; then
             cp "target/${{ matrix.target }}/release/$BIN_NAME.exe" "dist/"
           else
             cp "target/${{ matrix.target }}/release/$BIN_NAME" "dist/"
           fi
-
-          if [[ "${{ matrix.build }}" =~ "linux" ]]; then
-            cp "target/${{ matrix.target }}/debian/rustscan_${TAG}_amd64.deb" "dist/"
-          fi
-      - uses: actions/[email protected]
+      - uses: actions/[email protected]
         with:
           name: bins-${{ matrix.build }}
           path: dist
@@ -142,11 +133,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           submodules: false
 
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v2
         # with:
         #   path: dist
       # - run: ls -al ./dist
@@ -155,8 +146,8 @@ jobs:
       - name: Calculate tag name
         run: |
           name=dev
-          if [[ ${GITHUB_REF} =~ refs/tags/[0-9]+.[0-9]+.[0-9]+ ]]; then
-            name=${GITHUB_REF#refs/tags/}
+          if [[ $GITHUB_REF == refs/tags/v* ]]; then
+            name=${GITHUB_REF:10}
           fi
           echo ::set-output name=val::$name
           echo TAG=$name >> $GITHUB_ENV
@@ -180,18 +171,12 @@ jobs:
               # cp LICENSE README.md tmp/$pkgname
               mv bins-$platform/$BIN_NAME$exe tmp/$pkgname
               chmod +x tmp/$pkgname/$BIN_NAME$exe
-
-              if [[ $platform =~ "linux" ]]; then
-                  mv "bins-$platform/rustscan_${TAG}_amd64.deb" dist/
-              fi
-
               if [ "$exe" = "" ]; then
                   tar cJf dist/$pkgname.tar.xz -C tmp $pkgname
               else
                   (cd tmp && 7z a -r ../dist/$pkgname.zip $pkgname)
               fi
           done
-
       - name: Upload binaries to release
         uses: svenstaro/upload-release-action@v2
         with:
@@ -205,7 +190,7 @@ jobs:
         id: extract-version
         run: |
           printf "::set-output name=%s::%s\n" tag-name "${GITHUB_REF#refs/tags/}"
-      - uses: mislav/bump-homebrew-formula-action@v3
+      - uses: mislav/bump-homebrew-formula-action@v1
         with:
           formula-path: ${{env.PROJECT_NAME}}.rb
           homebrew-tap: ${{ env.BREW_TAP }}

.gitignore

@@ -120,5 +120,3 @@ fabric.properties
 .idea/*
 .idea
 .idea*
-
-settings.json

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustscan"
-version = "2.2.3"
+version = "2.1.1"
 authors = ["Autumn <[email protected]>"]
 edition = "2018"
 description = "Faster Nmap Scanning with Rust"
@@ -17,11 +17,12 @@ exclude = [
 ]
 
 [dependencies]
-colored = "2.1.0"
+colored = "2.0.0"
 structopt = "0.3.20"
 async-std = "1.7.0"
 futures = "0.3"
 rlimit = "0.8.3"
+shell-words = "1.0.0"
 log = "0.4.0"
 env_logger = "0.8.2"
 dirs = "3.0.1"
@@ -34,10 +35,10 @@ serde = "1.0.124"
 serde_derive = "1.0.116"
 cidr-utils = "0.5.1"
 itertools = "0.9.0"
-trust-dns-resolver = { version = "0.23.2", features = ["dns-over-rustls"] }
+trust-dns-resolver = { version = "0.21.1", features = ["dns-over-rustls"] }
 anyhow = "1.0.40"
 subprocess = "0.2.6"
-text_placeholder = { version = "0.5", features = ["struct_context"] }
+text_placeholder = { version = "0.4", features = ["struct_context"] }
 
 [dev-dependencies]
 wait-timeout = "0.2"
@@ -49,9 +50,8 @@ section = "rust"
 [profile.release]
 lto = true
 panic = 'abort'
-strip = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [[bin]]
 name = "rustscan"
-path = "src/main.rs"
+path = "src/main.rs"

Dockerfile

@@ -1,4 +1,3 @@
-# Build Stage
 FROM rust:alpine as builder
 LABEL maintainer="RustScan <https://github.com/RustScan>"
 RUN apk add --no-cache build-base
@@ -9,17 +8,13 @@ COPY Cargo.toml Cargo.lock ./
 COPY src/ src/
 RUN cargo build --release
 
-# Release Stage
-FROM alpine:3.19.1 as release
+FROM alpine:3.17
 LABEL author="Hydragyrum <https://github.com/Hydragyrum>"
 LABEL author="LeoFVO <https://github.com/LeoFVO>"
-
 RUN addgroup -S rustscan && \
     adduser -S -G rustscan rustscan && \
     ulimit -n 100000 && \
-    apk add --no-cache nmap nmap-scripts wget ca-certificates bind-tools
-
+    apk add --no-cache nmap nmap-scripts wget
 USER rustscan
 COPY --from=builder /app/rustscan/target/release/rustscan /usr/local/bin/rustscan
-
 ENTRYPOINT [ "/usr/local/bin/rustscan" ]

rustscan-debbuilder/Dockerfile

@@ -0,0 +1,20 @@
+FROM rust:latest
+
+RUN git clone https://github.com/brandonskerritt/RustScan
+WORKDIR "/RustScan"
+RUN git pull --force
+RUN cargo install cargo-deb
+
+RUN apt update -y && apt upgrade -y
+RUN apt install libc6-dev-i386 -y
+RUN git clone --depth=1 https://github.com/raspberrypi/tools /raspberrypi-tools
+ENV PATH=/raspberrypi-tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/:$PATH
+ENV CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc
+RUN mkdir /root/.cargo
+RUN echo "[target.arm-unknown-linux-gnueabihf]" >> /root/.cargo/config
+RUN echo "strip = { path = \"arm-linux-gnueabihf-strip\" }" >> /root/.cargo/config
+RUN echo "objcopy = { path = \"arm-linux-gnueabihf-objcopy\" }" >> /root/.cargo/config
+
+COPY ./entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]

rustscan-debbuilder/entrypoint.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+cd /RustScan
+git pull --force
+
+#amd64
+cargo deb
+
+#arm64
+rustup target add arm-unknown-linux-gnueabihf
+cargo deb --target=arm-unknown-linux-gnueabihf
+
+#i386
+rustup target add i686-unknown-linux-gnu
+cargo deb --target=i686-unknown-linux-gnu
+
+find target/ -name \*.deb -exec cp {} /debs \;

rustscan-debbuilder/run.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+docker build -t rustscan-builder . || exit
+
+# This creates a volume which binds your currentdirectory/debs to 
+# the location where the deb files get spat out in the container.
+# You don't need to worry about it. Just chmod +x run.sh && ./run.sh and
+# you'll get yer .deb file in a few minutes. It runs faster after you've used it the first time.
+docker run -v "$(pwd)/debs:/debs" rustscan-builder

src/benchmark/mod.rs

@@ -1,20 +1,15 @@
-//! Provides functionality to capture timing information for scans.
-//!
 //! # Usage
-//!
-//! ```rust
+//! ```
 //! // Initiate Benchmark vector
-//! # use rustscan::benchmark::{Benchmark, NamedTimer};
-//! # use log::info;
 //! let mut bm = Benchmark::init();
 //! // Start named timer with name
 //! let mut example_bench = NamedTimer::start("Example Bench");
 //! // Stop named timer
-//! example_bench.end();
+//! example_bench.stop();
 //! // Add named timer to Benchmarks
 //! bm.push(example_bench);
 //! // Print Benchmark Summary
-//! info!("{}", bm.summary());
+//! info!({}, bm.summary());
 //! ```
 use std::time::Instant;
 

src/input.rs

@@ -1,373 +1 @@
-//! Provides a means to read, parse and hold configuration options for scans.
-use serde_derive::Deserialize;
-use std::collections::HashMap;
-use std::fs;
-use std::path::PathBuf;
-use structopt::{clap::arg_enum, StructOpt};
 
-const LOWEST_PORT_NUMBER: u16 = 1;
-const TOP_PORT_NUMBER: u16 = 65535;
-
-arg_enum! {
-    /// Represents the strategy in which the port scanning will run.
-    ///   - Serial will run from start to end, for example 1 to 1_000.
-    ///   - Random will randomize the order in which ports will be scanned.
-    #[derive(Deserialize, Debug, StructOpt, Clone, Copy, PartialEq, Eq)]
-    pub enum ScanOrder {
-        Serial,
-        Random,
-    }
-}
-
-arg_enum! {
-    /// Represents the scripts variant.
-    ///   - none will avoid running any script, only portscan results will be shown.
-    ///   - default will run the default embedded nmap script, that's part of RustScan since the beginning.
-    ///   - custom will read the ScriptConfig file and the available scripts in the predefined folders
-    #[derive(Deserialize, Debug, StructOpt, Clone, PartialEq, Eq, Copy)]
-    pub enum ScriptsRequired {
-        None,
-        Default,
-        Custom,
-    }
-}
-
-/// Represents the range of ports to be scanned.
-#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct PortRange {
-    pub start: u16,
-    pub end: u16,
-}
-
-#[cfg(not(tarpaulin_include))]
-fn parse_range(input: &str) -> Result<PortRange, String> {
-    let range = input
-        .split('-')
-        .map(str::parse)
-        .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, Clone)]
-#[structopt(name = "rustscan", setting = structopt::clap::AppSettings::TrailingVarArg)]
-#[allow(clippy::struct_excessive_bools)]
-/// 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  <http://discord.skerritt.blog>
-/// - GitHub <https://github.com/RustScan/RustScan>
-pub struct Opts {
-    /// A comma-delimited list or newline-delimited file of separated CIDRs, IPs, or hosts to be scanned.
-    #[structopt(short, long, use_delimiter = true)]
-    pub addresses: Vec<String>,
-
-    /// A list of comma separated ports to be scanned. Example: 80,443,8080.
-    #[structopt(short, long, use_delimiter = true)]
-    pub 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))]
-    pub range: Option<PortRange>,
-
-    /// Whether to ignore the configuration file or not.
-    #[structopt(short, long)]
-    pub no_config: bool,
-
-    /// Custom path to config file
-    #[structopt(short, long, parse(from_os_str))]
-    pub config_path: Option<PathBuf>,
-
-    /// Greppable mode. Only output the ports. No Nmap. Useful for grep or outputting to a file.
-    #[structopt(short, long)]
-    pub greppable: bool,
-
-    /// Accessible mode. Turns off features which negatively affect screen readers.
-    #[structopt(long)]
-    pub accessible: 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
-    /// support this.
-    #[structopt(short, long, default_value = "4500")]
-    pub batch_size: u16,
-
-    /// The timeout in milliseconds before a port is assumed to be closed.
-    #[structopt(short, long, default_value = "1500")]
-    pub timeout: u32,
-
-    /// The number of tries before a port is assumed to be closed.
-    /// If set to 0, rustscan will correct it to 1.
-    #[structopt(long, default_value = "1")]
-    pub tries: u8,
-
-    /// Automatically ups the ULIMIT with the value you provided.
-    #[structopt(short, long)]
-    pub ulimit: Option<u64>,
-
-    /// The order of scanning to be performed. The "serial" option will
-    /// scan ports in ascending order while the "random" option will scan
-    /// ports randomly.
-    #[structopt(long, possible_values = &ScanOrder::variants(), case_insensitive = true, default_value = "serial")]
-    pub scan_order: ScanOrder,
-
-    /// Level of scripting required for the run.
-    #[structopt(long, possible_values = &ScriptsRequired::variants(), case_insensitive = true, default_value = "default")]
-    pub scripts: ScriptsRequired,
-
-    /// Use the top 1000 ports.
-    #[structopt(long)]
-    pub top: bool,
-
-    /// The Script arguments to run.
-    /// To use the argument -A, end RustScan's args with '-- -A'.
-    /// Example: 'rustscan -t 1500 -a 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)'\"
-    #[structopt(last = true)]
-    pub command: Vec<String>,
-
-    /// A list of comma separated ports to be excluded from scanning. Example: 80,443,8080.
-    #[structopt(short, long, use_delimiter = true)]
-    pub exclude_ports: Option<Vec<u16>>,
-}
-
-#[cfg(not(tarpaulin_include))]
-impl Opts {
-    pub fn read() -> Self {
-        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,
-            });
-        }
-
-        opts
-    }
-
-    /// Reads the command line arguments into an Opts struct and merge
-    /// values found within the user configuration file.
-    pub fn merge(&mut self, config: &Config) {
-        if !self.no_config {
-            self.merge_required(config);
-            self.merge_optional(config);
-        }
-    }
-
-    fn merge_required(&mut self, config: &Config) {
-        macro_rules! merge_required {
-            ($($field: ident),+) => {
-                $(
-                    if let Some(e) = &config.$field {
-                        self.$field = e.clone();
-                    }
-                )+
-            }
-        }
-
-        merge_required!(
-            addresses, greppable, accessible, batch_size, timeout, tries, scan_order, scripts,
-            command
-        );
-    }
-
-    fn merge_optional(&mut self, config: &Config) {
-        macro_rules! merge_optional {
-            ($($field: ident),+) => {
-                $(
-                    if config.$field.is_some() {
-                        self.$field = config.$field.clone();
-                    }
-                )+
-            }
-        }
-
-        // Only use top ports when the user asks for them
-        if self.top && config.ports.is_some() {
-            let mut ports: Vec<u16> = Vec::with_capacity(config.ports.clone().unwrap().len());
-            for entry in config.ports.clone().unwrap().keys() {
-                ports.push(entry.parse().unwrap());
-            }
-            self.ports = Some(ports);
-        }
-
-        merge_optional!(range, ulimit, exclude_ports);
-    }
-}
-
-impl Default for Opts {
-    fn default() -> Self {
-        Self {
-            addresses: vec![],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 0,
-            timeout: 0,
-            tries: 0,
-            ulimit: None,
-            command: vec![],
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: true,
-            top: false,
-            scripts: ScriptsRequired::Default,
-            config_path: None,
-            exclude_ports: None,
-        }
-    }
-}
-
-/// Struct used to deserialize the options specified within our config file.
-/// These will be further merged with our command line arguments in order to
-/// generate the final Opts struct.
-#[cfg(not(tarpaulin_include))]
-#[derive(Debug, Deserialize)]
-pub struct Config {
-    addresses: Option<Vec<String>>,
-    ports: Option<HashMap<String, u16>>,
-    range: Option<PortRange>,
-    greppable: Option<bool>,
-    accessible: Option<bool>,
-    batch_size: Option<u16>,
-    timeout: Option<u32>,
-    tries: Option<u8>,
-    ulimit: Option<u64>,
-    scan_order: Option<ScanOrder>,
-    command: Option<Vec<String>>,
-    scripts: Option<ScriptsRequired>,
-    exclude_ports: Option<Vec<u16>>,
-}
-
-#[cfg(not(tarpaulin_include))]
-#[allow(clippy::doc_link_with_quotes)]
-impl Config {
-    /// Reads the configuration file with TOML format and parses it into a
-    /// Config struct.
-    ///
-    /// # Format
-    ///
-    /// addresses = ["127.0.0.1", "127.0.0.1"]
-    /// ports = [80, 443, 8080]
-    /// greppable = true
-    /// scan_order: "Serial"
-    /// exclude_ports = [8080, 9090, 80]
-    ///
-    pub fn read(custom_config_path: Option<PathBuf>) -> Self {
-        let mut content = String::new();
-        let config_path = custom_config_path.unwrap_or_else(default_config_path);
-        if config_path.exists() {
-            content = match fs::read_to_string(config_path) {
-                Ok(content) => content,
-                Err(_) => String::new(),
-            }
-        }
-
-        let config: Config = match toml::from_str(&content) {
-            Ok(config) => config,
-            Err(e) => {
-                println!("Found {e} in configuration file.\nAborting scan.\n");
-                std::process::exit(1);
-            }
-        };
-
-        config
-    }
-}
-
-/// Constructs default path to config toml
-pub fn default_config_path() -> PathBuf {
-    let Some(mut config_path) = dirs::home_dir() else {
-        panic!("Could not infer config file path.");
-    };
-    config_path.push(".rustscan.toml");
-    config_path
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Config, Opts, PortRange, ScanOrder, ScriptsRequired};
-    impl Config {
-        fn default() -> Self {
-            Self {
-                addresses: Some(vec!["127.0.0.1".to_owned()]),
-                ports: None,
-                range: None,
-                greppable: Some(true),
-                batch_size: Some(25_000),
-                timeout: Some(1_000),
-                tries: Some(1),
-                ulimit: None,
-                command: Some(vec!["-A".to_owned()]),
-                accessible: Some(true),
-                scan_order: Some(ScanOrder::Random),
-                scripts: None,
-                exclude_ports: None,
-            }
-        }
-    }
-
-    #[test]
-    fn opts_no_merge_when_config_is_ignored() {
-        let mut opts = Opts::default();
-        let config = Config::default();
-
-        opts.merge(&config);
-
-        assert_eq!(opts.addresses, vec![] as Vec<String>);
-        assert!(opts.greppable);
-        assert!(!opts.accessible);
-        assert_eq!(opts.timeout, 0);
-        assert_eq!(opts.command, vec![] as Vec<String>);
-        assert_eq!(opts.scan_order, ScanOrder::Serial);
-    }
-
-    #[test]
-    fn opts_merge_required_arguments() {
-        let mut opts = Opts::default();
-        let config = Config::default();
-
-        opts.merge_required(&config);
-
-        assert_eq!(opts.addresses, config.addresses.unwrap());
-        assert_eq!(opts.greppable, config.greppable.unwrap());
-        assert_eq!(opts.timeout, config.timeout.unwrap());
-        assert_eq!(opts.command, config.command.unwrap());
-        assert_eq!(opts.accessible, config.accessible.unwrap());
-        assert_eq!(opts.scan_order, config.scan_order.unwrap());
-        assert_eq!(opts.scripts, ScriptsRequired::Default);
-    }
-
-    #[test]
-    fn opts_merge_optional_arguments() {
-        let mut opts = Opts::default();
-        let mut config = Config::default();
-        config.range = Some(PortRange {
-            start: 1,
-            end: 1_000,
-        });
-        config.ulimit = Some(1_000);
-
-        opts.merge_optional(&config);
-
-        assert_eq!(opts.range, config.range);
-        assert_eq!(opts.ulimit, config.ulimit);
-    }
-}

src/lib.rs

@@ -1,53 +0,0 @@
-//! This crate exposes the internal functionality of the
-//! [RustScan](https://rustscan.github.io/RustScan) port scanner.
-//!
-//! ## Example: perform a scan against localhost
-//!
-//! The core scanning behaviour is managed by
-//! [`Scanner`](crate::scanner::Scanner) which in turn requires a
-//! [`PortStrategy`](crate::port_strategy::PortStrategy):
-//!
-//! ```rust
-//! use async_std::task::block_on;
-//! use std::{net::IpAddr, time::Duration};
-//!
-//! use rustscan::input::{PortRange, ScanOrder};
-//! use rustscan::port_strategy::PortStrategy;
-//! use rustscan::scanner::Scanner;
-//!
-//! fn main() {
-//!     let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-//!     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),
-//!         1,
-//!         true,
-//!         strategy,
-//!         true,
-//!         vec![9000],
-//!     );
-//!
-//!     let scan_result = block_on(scanner.run());
-//!
-//!     println!("{:?}", scan_result);
-//! }
-//! ```
-#![allow(clippy::needless_doctest_main)]
-
-pub mod tui;
-
-pub mod input;
-
-pub mod scanner;
-
-pub mod port_strategy;
-
-pub mod benchmark;
-
-pub mod scripts;

src/main.rs

@@ -2,12 +2,24 @@
 #![warn(clippy::pedantic)]
 #![allow(clippy::doc_markdown, clippy::if_not_else, clippy::non_ascii_literal)]
 
-use rustscan::benchmark::{Benchmark, NamedTimer};
-use rustscan::input::{self, Config, Opts, ScriptsRequired};
-use rustscan::port_strategy::PortStrategy;
-use rustscan::scanner::Scanner;
-use rustscan::scripts::{init_scripts, Script, ScriptFile};
-use rustscan::{detail, funny_opening, output, warning};
+extern crate shell_words;
+
+mod tui;
+
+mod input;
+use input::{Config, Opts, PortRange, ScanOrder, ScriptsRequired};
+
+mod scanner;
+use scanner::Scanner;
+
+mod port_strategy;
+use port_strategy::PortStrategy;
+
+mod benchmark;
+use benchmark::{Benchmark, NamedTimer};
+
+mod scripts;
+use scripts::{init_scripts, Script, ScriptFile};
 
 use cidr_utils::cidr::IpCidr;
 use colorful::{Color, Colorful};
@@ -86,9 +98,6 @@ fn main() {
     #[cfg(not(unix))]
     let batch_size: u16 = AVERAGE_BATCH_SIZE;
 
-    // Added by wasuaje - 01/26/2024:
-    // exclude_ports  is an exclusion port list
-    //
     let scanner = Scanner::new(
         &ips,
         batch_size,
@@ -97,7 +106,6 @@ fn main() {
         opts.greppable,
         PortStrategy::pick(&opts.range, opts.ports, opts.scan_order),
         opts.accessible,
-        opts.exclude_ports.unwrap_or_default(),
     );
     debug!("Scanner finished building: {:?}", scanner);
 
@@ -276,7 +284,7 @@ fn parse_addresses(input: &Opts) -> Vec<IpAddr> {
     ips
 }
 
-/// Given a string, parse it as a host, IP address, or CIDR.
+/// Given a string, parse it as an host, IP address, or CIDR.
 /// This allows us to pass files as hosts or cidr or IPs easily
 /// Call this every time you have a possible IP_or_host
 fn parse_address(address: &str, resolver: &Resolver) -> Vec<IpAddr> {
@@ -397,8 +405,9 @@ fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
 #[cfg(test)]
 mod tests {
     #[cfg(unix)]
-    use super::{adjust_ulimit_size, infer_batch_size};
-    use super::{parse_addresses, print_opening, Opts};
+    use crate::{adjust_ulimit_size, infer_batch_size};
+
+    use crate::{parse_addresses, print_opening, Opts};
     use std::net::Ipv4Addr;
 
     #[test]

src/port_strategy/mod.rs

@@ -1,6 +1,5 @@
-//! Provides a means to hold configuration options specifically for port scanning.
 mod range_iterator;
-use crate::input::{PortRange, ScanOrder};
+use super::{PortRange, ScanOrder};
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use range_iterator::RangeIterator;
@@ -68,7 +67,7 @@ pub struct SerialRange {
 
 impl RangeOrder for SerialRange {
     fn generate(&self) -> Vec<u16> {
-        (self.start..=self.end).collect()
+        (self.start..self.end).collect()
     }
 }
 
@@ -98,14 +97,14 @@ impl RangeOrder for RandomRange {
 #[cfg(test)]
 mod tests {
     use super::PortStrategy;
-    use crate::input::{PortRange, ScanOrder};
+    use crate::{PortRange, ScanOrder};
 
     #[test]
     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>>();
+        let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
     }
     #[test]
@@ -113,7 +112,7 @@ mod tests {
         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>>();
+        let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
         assert_ne!(expected_range, result);
 
         result.sort_unstable();

src/port_strategy/range_iterator.rs

@@ -15,14 +15,14 @@ pub struct RangeIterator {
 ///
 /// For more information: <https://en.wikipedia.org/wiki/Linear_congruential_generator>
 impl RangeIterator {
-    /// Receives the start and end of a range and normalize
+    /// Receives the the start and end of a range and normalize
     /// these values before selecting a coprime for the end of the range
     /// which will server as the step for the algorithm.
     ///
     /// For example, the range `1000-2500` will be normalized to `0-1500`
     /// before going through the algorithm.
     pub fn new(start: u32, end: u32) -> Self {
-        let normalized_end = end - start + 1;
+        let normalized_end = end - start;
         let step = pick_random_coprime(normalized_end);
 
         // Randomly choose a number within the range to be the first
@@ -103,23 +103,23 @@ mod tests {
     #[test]
     fn range_iterator_iterates_through_the_entire_range() {
         let result = generate_sorted_range(1, 10);
-        let expected_range = (1..=10).into_iter().collect::<Vec<u16>>();
+        let expected_range = (1..10).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
 
         let result = generate_sorted_range(1, 100);
-        let expected_range = (1..=100).into_iter().collect::<Vec<u16>>();
+        let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
 
         let result = generate_sorted_range(1, 1000);
-        let expected_range = (1..=1000).into_iter().collect::<Vec<u16>>();
+        let expected_range = (1..1000).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
 
         let result = generate_sorted_range(1, 65_535);
-        let expected_range = (1..=65_535).into_iter().collect::<Vec<u16>>();
+        let expected_range = (1..65_535).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
 
         let result = generate_sorted_range(1000, 2000);
-        let expected_range = (1000..=2000).into_iter().collect::<Vec<u16>>();
+        let expected_range = (1000..2000).into_iter().collect::<Vec<u16>>();
         assert_eq!(expected_range, result);
     }
 

src/scanner/mod.rs

@@ -1,6 +1,4 @@
-//! Core functionality for actual scanning behaviour.
-use crate::port_strategy::PortStrategy;
-use log::debug;
+use super::PortStrategy;
 
 mod socket_iterator;
 use socket_iterator::SocketIterator;
@@ -23,8 +21,6 @@ use std::{
 /// batch_size is how many ports at a time should be scanned
 /// Timeout is the time RustScan should wait before declaring a port closed. As datatype Duration.
 /// greppable is whether or not RustScan should print things, or wait until the end to print only the ip and open ports.
-/// Added by wasuaje - 01/26/2024:
-///     exclude_ports  is an exclusion port list
 #[cfg(not(tarpaulin_include))]
 #[derive(Debug)]
 pub struct Scanner {
@@ -35,11 +31,8 @@ pub struct Scanner {
     greppable: bool,
     port_strategy: PortStrategy,
     accessible: bool,
-    exclude_ports: Vec<u16>,
 }
 
-// Allowing too many arguments for clippy.
-#[allow(clippy::too_many_arguments)]
 impl Scanner {
     pub fn new(
         ips: &[IpAddr],
@@ -49,7 +42,6 @@ impl Scanner {
         greppable: bool,
         port_strategy: PortStrategy,
         accessible: bool,
-        exclude_ports: Vec<u16>,
     ) -> Self {
         Self {
             batch_size,
@@ -59,27 +51,18 @@ impl Scanner {
             port_strategy,
             ips: ips.iter().map(ToOwned::to_owned).collect(),
             accessible,
-            exclude_ports,
         }
     }
 
     /// Runs scan_range with chunk sizes
     /// If you want to run RustScan normally, this is the entry point used
-    /// Returns all open ports as `Vec<u16>`
-    /// Added by wasuaje - 01/26/2024:
-    ///    Filtering port against exclude port list
+    /// Returns all open ports as Vec<u16>
     pub async fn run(&self) -> Vec<SocketAddr> {
-        let ports: Vec<u16> = self
-            .port_strategy
-            .order()
-            .iter()
-            .filter(|&port| !self.exclude_ports.contains(port))
-            .copied()
-            .collect();
+        let ports: Vec<u16> = self.port_strategy.order();
         let mut socket_iterator: SocketIterator = SocketIterator::new(&self.ips, &ports);
         let mut open_sockets: Vec<SocketAddr> = Vec::new();
         let mut ftrs = FuturesUnordered::new();
-        let mut errors: HashSet<String> = HashSet::new();
+        let mut errors: HashSet<String> = HashSet::with_capacity(self.ips.len() * 1000);
 
         for _ in 0..self.batch_size {
             if let Some(socket) = socket_iterator.next() {
@@ -89,7 +72,7 @@ impl Scanner {
             }
         }
 
-        debug!("Start scanning sockets. \nBatch size {}\nNumber of ip-s {}\nNumber of ports {}\nTargets all together {} ",
+        debug!("Start scanning sockets. \nBatch size {}\nNumber of ip-s {}\nNumber of ports {}\nTargets all together {} ", 
             self.batch_size,
             self.ips.len(),
             &ports.len(),
@@ -117,16 +100,14 @@ impl Scanner {
 
     /// Given a socket, scan it self.tries times.
     /// Turns the address into a SocketAddr
-    /// Deals with the `<result>` type
+    /// Deals with the <result> type
     /// If it experiences error ErrorKind::Other then too many files are open and it Panics!
     /// Else any other error, it returns the error in Result as a string
     /// If no errors occur, it returns the port number in Result to signify the port is open.
     /// This function mainly deals with the logic of Results handling.
     /// # Example
     ///
-    /// ```compile_fail
-    /// scanner.scan_socket(socket)
-    /// ```
+    ///     self.scan_socket(socket)
     ///
     /// Note: `self` must contain `self.ip`.
     async fn scan_socket(&self, socket: SocketAddr) -> io::Result<SocketAddr> {
@@ -172,16 +153,13 @@ impl Scanner {
     /// Performs the connection to the socket with timeout
     /// # Example
     ///
-    /// ```compile_fail
-    /// # use std::net::{IpAddr, Ipv6Addr, SocketAddr};
-    /// let port: u16 = 80;
-    /// // ip is an IpAddr type
-    /// let ip = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
-    /// let socket = SocketAddr::new(ip, port);
-    /// scanner.connect(socket);
-    /// // returns Result which is either Ok(stream) for port is open, or Er for port is closed.
-    /// // Timeout occurs after self.timeout seconds
-    /// ```
+    ///     let port: u16 = 80
+    ///     // ip is an IpAddr type
+    ///     let ip = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
+    ///     let socket = SocketAddr::new(ip, port);
+    ///     self.connect(socket)
+    ///     // returns Result which is either Ok(stream) for port is open, or Er for port is closed.
+    ///     // Timeout occurs after self.timeout seconds
     ///
     async fn connect(&self, socket: SocketAddr) -> io::Result<TcpStream> {
         let stream = io::timeout(
@@ -196,7 +174,7 @@ impl Scanner {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::input::{PortRange, ScanOrder};
+    use crate::{PortRange, ScanOrder};
     use async_std::task::block_on;
     use std::{net::IpAddr, time::Duration};
 
@@ -217,7 +195,6 @@ mod tests {
             true,
             strategy,
             true,
-            vec![9000],
         );
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
@@ -240,7 +217,6 @@ mod tests {
             true,
             strategy,
             true,
-            vec![9000],
         );
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
@@ -262,7 +238,6 @@ mod tests {
             true,
             strategy,
             true,
-            vec![9000],
         );
         block_on(scanner.run());
         assert_eq!(1, 1);
@@ -283,7 +258,6 @@ mod tests {
             true,
             strategy,
             true,
-            vec![9000],
         );
         block_on(scanner.run());
         assert_eq!(1, 1);
@@ -307,7 +281,6 @@ mod tests {
             true,
             strategy,
             true,
-            vec![9000],
         );
         block_on(scanner.run());
         assert_eq!(1, 1);

src/scripts/mod.rs

@@ -1,83 +1,52 @@
-//! Scripting Engine to run scripts based on tags.
-//!
+//! Scripting engine to run scripts based on tags.
 //! This module serves to filter and run the scripts selected by the user.
 //!
 //! A new commandline and configuration file option was added.
 //!
-//! ## `--scripts`
+//! --scripts
 //!
-//! ### `default`
+//!      default
+//!          This is the default behavior, like as it was from the beginning of RustScan.
+//!          The user do not have to chose anything for this. This is the only script embedded in RustScan running as default.
 //!
-//! This is the default behavior, like as it was from the beginning of RustScan.
+//!      none
+//!          The user have to use the --scripts none commandline argument or scripts = "none" in the config file.
+//!          None of the scripts will run, this replaces the removed --no-nmap option.
 //!
-//! The user do not have to chose anything for this. This is the only script
-//! embedded in RustScan running as default.
-//!
-//! ### `none`
-//!
-//! The user have to use the `--scripts none` commandline argument or `scripts =
-//! "none"` in the config file.
-//!
-//! None of the scripts will run, this replaces the removed `--no-nmap` option.
-//!
-//! ### `custom`
-//!
-//! The user have to use the `--scripts custom` commandline argument or
-//! `scripts = "custom"` in the config file.
-//!
-//! RustScan will look for the script configuration file in the user's home
-//! dir: `home_dir/.rustscan_scripts.toml`
-//!
-//! The config file have 3 optional fields: `tag`, `developer` and `port`. Just
-//! the `tag` field will be used forther in the process.
-//!
-//! RustScan will also look for available scripts in the user's home dir:
-//! `home_dir/.rustscan_scripts` and will try to read all the files, and parse
-//! them into a vector of [`ScriptFile`].
-//!
-//! Filtering on tags means the tags found in the `rustscan_scripts.toml` file
-//! will also have to be present in the [`ScriptFile`], otherwise the script
-//! will not be selected.
-//!
-//! All of the `rustscan_script.toml` tags have to be present at minimum in a
-//! [`ScriptFile`] to get selected, but can be also more.
+//!      custom
+//!          The user have to use the --scripts custom commandline argument or scripts = "custom" in the config file.
+//!          Rustscan will look for the script configuration file in the user's home dir: home_dir/.rustscan_scripts.toml
+//!          The config file have 3 optional fields, tag, developer and port. Just the tag field will be used forther in the process.
+//!          RustScan will also look for available scripts in the user's home dir: home_dir/.rustscan_scripts
+//!          and will try to read all the files, and parse them into a vector of ScriptFiles.
+//!          Filtering on tags means the tags found in the rustscan_scripts.toml file will also have to be present in the Scriptfile,
+//!          otherwise the script will not be selected.
+//!          All of the rustscan_script.toml tags have to be present at minimum in a Scriptfile to get selected, but can be also more.
 //!
 //! Config file example:
-//!
-//! - `fixtures/test_rustscan_scripts.toml`
+//! fixtures/test_rustscan_scripts.toml
 //!
 //! Script file examples:
+//! fixtures/test_script.py
+//! fixtures/test_script.pl
+//! fixtures/test_script.sh
+//! fixtures/test_script.txt
 //!
-//! - `fixtures/test_script.py`
-//! - `fixtures/test_script.pl`
-//! - `fixtures/test_script.sh`
-//! - `fixtures/test_script.txt`
+//! call_format in script files can be of 2 variants.
+//! One is where all of the possible tags {{script}} {{ip}} {{port}} are there.
+//!     The {{script}} part will be replaced with the scriptfile full path gathered while parsing available scripts.
+//!     The {{ip}} part will be replaced with the ip we got from the scan.
+//!     The {{port}} part will be reaplced with the ports separated with the ports_separator found in the script file
 //!
-//! `call_format` in script files can be of 2 variants:
+//! And when there is only {{ip}} and {{port}} is in the format, only those will be replaced with the arguments from the scan.
+//! This makes it easy to run a system installed command like nmap, and give any kind of arguments to it.
 //!
-//! One is where all of the possible tags `{{script}}`, `{{ip}}` and `{{port}}`
-//! are there.
-//!
-//! - The `{{script}}` part will be replaced with the scriptfile full path
-//!   gathered while parsing available scripts.
-//! - The `{{ip}}` part will be replaced with the ip we got from the scan.
-//! - The `{{port}}` part will be reaplced with the ports separated with the
-//!   `ports_separator` found in the script file
-//!
-//! And when there is only `{{ip}}` and `{{port}}` is in the format, only those
-//! will be replaced with the arguments from the scan.
-//!
-//! This makes it easy to run a system installed command like `nmap`, and give
-//! any kind of arguments to it.
-//!
-//! If the format is different, the script will be silently discarded and will
-//! not run. With the `Debug` option it's possible to see where it goes wrong.
+//! If the format is different, the script will be silently discarded and will not run. With the Debug option it's possible to see where it goes wrong.
 
 #![allow(clippy::module_name_repetitions)]
 
 use crate::input::ScriptsRequired;
 use anyhow::{anyhow, Result};
-use log::debug;
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::convert::TryInto;
@@ -264,14 +233,16 @@ impl Script {
         }
         debug!("\nScript format to run {}", to_run);
 
-        execute_script(&to_run)
+        let arguments = shell_words::split(&to_run).expect("Failed to parse script arguments");
+
+        execute_script(arguments)
     }
 }
 
 #[cfg(not(tarpaulin_include))]
-fn execute_script(script: &str) -> Result<String> {
-    debug!("\nScript arguments {}", script);
-    let process = Exec::shell(script);
+fn execute_script(mut arguments: Vec<String>) -> Result<String> {
+    debug!("\nScript arguments vec: {:?}", &arguments);
+    let process = Exec::cmd(arguments.remove(0)).args(&arguments);
     match process.capture() {
         Ok(c) => {
             let es = match c.exit_status {

src/tui.rs

@@ -1,7 +1,6 @@
-//! Utilities for terminal output during scanning.
-
 /// Terminal User Interface Module for RustScan
 /// Defines macros to use
+
 #[macro_export]
 macro_rules! warning {
     ($name:expr) => {
@@ -76,23 +75,6 @@ macro_rules! funny_opening {
             "Please contribute more quotes to our GitHub https://github.com/rustscan/rustscan",
             "😵 https://admin.tryhackme.com",
             "0day was here ♥",
-            "I don't always scan ports, but when I do, I prefer RustScan.",
-            "RustScan: Where scanning meets swagging. 😎",
-            "To scan or not to scan? That is the question.",
-            "RustScan: Because guessing isn't hacking.",
-            "Scanning ports like it's my full-time job. Wait, it is.",
-            "Open ports, closed hearts.",
-            "I scanned my computer so many times, it thinks we're dating.",
-            "Port scanning: Making networking exciting since... whenever.",
-            "You miss 100% of the ports you don't scan. - RustScan",
-            "Breaking and entering... into the world of open ports.",
-            "TCP handshake? More like a friendly high-five!",
-            "Scanning ports: The virtual equivalent of knocking on doors.",
-            "RustScan: Making sure 'closed' isn't just a state of mind.",
-            "Port scanning: Because every port has a story to tell.",
-            "I scanned ports so fast, even my computer was surprised.",
-            "RustScan: Where '404 Not Found' meets '200 OK'.",
-            "RustScan: Exploring the digital landscape, one IP at a time.",
         ];
         let random_quote = quotes.choose(&mut rand::thread_rng()).unwrap();