Merge pull request #120 from epi052/fix-directory-extraction-bug

Fix directory extraction bug
fixed bug found by flangyver
2026-05-22 20:31:13 -03:00 · 2020-11-11 07:13:35 -06:00 · 2020-11-11 06:59:50 -06:00 · 2020-11-11 06:59:09 -06:00 · 2020-11-07 16:11:39 -06:00 · 2020-11-07 15:29:05 -06:00
28 changed files with 1501 additions and 461 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "feroxbuster"
-version = "1.1.1"
+version = "1.5.3"
 authors = ["Ben 'epi' Risher <epibar052@gmail.com>"]
 license = "MIT"
 edition = "2018"
@@ -19,7 +19,7 @@ futures = { version = "0.3"}
 tokio = { version = "0.2", features = ["full"] }
 tokio-util = {version = "0.3", features = ["codec"]}
 log = "0.4"
-env_logger = "0.7"
+env_logger = "0.8"
 reqwest = { version = "0.10", features = ["socks"] }
 clap = "2"
 lazy_static = "1.4"
@@ -32,6 +32,8 @@ console = "0.12"
 openssl = { version = "0.10", features = ["vendored"] }
 dirs = "3.0"
 regex = "1"
+crossterm = "0.18"
+rlimit = "0.5"

 [dev-dependencies]
 tempfile = "3.1"
--- a/README.md
+++ b/README.md
@@ -71,6 +71,7 @@ This attack is also known as Predictable Resource Location, File Enumeration, Di
    - [ferox-config.toml](#ferox-configtoml)
    - [Command Line Parsing](#command-line-parsing)
 - [Example Usage](#-example-usage)
+    - [Pause and Resume Scans (new in `v1.4.0`)](#pause-and-resume-scans-new-in-v140)
    - [Multiple Values](#multiple-values)
    - [Extract Links from Response Body (new in `v1.1.0`)](#extract-links-from-response-body-new-in-v110)
    - [Include Headers](#include-headers)
@@ -79,9 +80,13 @@ This attack is also known as Predictable Resource Location, File Enumeration, Di
    - [Proxy traffic through Burp](#proxy-traffic-through-burp)
    - [Proxy traffic through a SOCKS proxy](#proxy-traffic-through-a-socks-proxy)
    - [Pass auth token via query parameter](#pass-auth-token-via-query-parameter)
+    - [Limit Total Number of Concurrent Scans (new in `v1.2.0`)](#limit-total-number-of-concurrent-scans-new-in-v120)
+    - [Filter Response by Status Code  (new in `v1.3.0`)](#filter-response-by-status-code--new-in-v130)
+    - [Replay Responses to a Proxy based on Status Code (new in `v1.5.0`)](#replay-responses-to-a-proxy-based-on-status-code-new-in-v150)
 - [Comparison w/ Similar Tools](#-comparison-w-similar-tools)
 - [Common Problems/Issues (FAQ)](#-common-problemsissues-faq)
    - [No file descriptors available](#no-file-descriptors-available)
+    - [Progress bars print one line at a time](#progress-bars-print-one-line-at-a-time)

 ## 💿 Installation

@@ -89,28 +94,9 @@ This attack is also known as Predictable Resource Location, File Enumeration, Di

 Releases for multiple architectures can be found in the [Releases](https://github.com/epi052/feroxbuster/releases) section.  The latest release for each of the following systems can be downloaded and executed as shown below.

-#### Linux x86
+#### Linux (32 and 64-bit) & MacOS
 ```
-curl -sLO https://github.com/epi052/feroxbuster/releases/latest/download/x86-linux-feroxbuster.zip
-unzip x86-linux-feroxbuster.zip
-chmod +x ./feroxbuster
-./feroxbuster -V
-```
-#### Linux x86_64
-
-```
-curl -sLO https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-linux-feroxbuster.zip
-unzip x86_64-linux-feroxbuster.zip
-chmod +x ./feroxbuster
-./feroxbuster -V
-```
-
-#### MacOS x86_64
-```
-curl -sLO https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-macos-feroxbuster.zip
-unzip x86_64-macos-feroxbuster.zip
-chmod +x ./feroxbuster
-./feroxbuster -V
+curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
 ```

 #### Windows x86
@@ -237,8 +223,9 @@ Configuration begins with with the following built-in default values baked into
 - wordlist: `/usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt`
 - threads: `50`
 - verbosity: `0` (no logging enabled)
- statuscodes: `200 204 301 302 307 308 401 403 405`
- useragent: `feroxbuster/VERSION`
+- scan_limit: `0` (no limit imposed on concurrent scans)
+- status_codes: `200 204 301 302 307 308 401 403 405`
+- user_agent: `feroxbuster/VERSION`
 - recursion depth: `4`
 - auto-filter wildcards - `true`
 - output: `stdout`
@@ -288,24 +275,28 @@ A pre-made configuration file with examples of all available settings can be fou
 # Any setting used here can be overridden by the corresponding command line option/argument
 #
 # wordlist = "/wordlists/jhaddix/all.txt"
-# statuscodes = [200, 500]
+# status_codes = [200, 500]
+# filter_status = [301]
+# replay_codes = [301]
 # threads = 1
 # timeout = 5
 # proxy = "http://127.0.0.1:8080"
+# replay_proxy = "http://127.0.0.1:8081"
 # verbosity = 1
+# scan_limit = 6
 # quiet = true
 # output = "/targets/ellingson_mineral_company/gibson.txt"
-# useragent = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
+# user_agent = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
 # redirects = true
 # insecure = true
 # extensions = ["php", "html"]
-# norecursion = true
-# addslash = true
+# no_recursion = true
+# add_slash = true
 # stdin = true
-# dontfilter = true
+# dont_filter = true
 # extract_links = true
 # depth = 1
-# sizefilters = [5174]
+# filter_size = [5174]
 # queries = [["name","value"], ["rick", "astley"]]

 # headers can be specified on multiple lines or as an inline table
@@ -330,13 +321,13 @@ USAGE:
    feroxbuster [FLAGS] [OPTIONS] --url <URL>...

 FLAGS:
-    -f, --addslash         Append / to each request
-    -D, --dontfilter       Don't auto-filter wildcard responses
+    -f, --add-slash        Append / to each request
+    -D, --dont-filter      Don't auto-filter wildcard responses
    -e, --extract-links    Extract links from response body (html, javascript, etc...); make new requests based on
                           findings (default: false)
    -h, --help             Prints help information
    -k, --insecure         Disables TLS certificate validation
-    -n, --norecursion      Do not scan recursively
+    -n, --no-recursion     Do not scan recursively
    -q, --quiet            Only print URLs; Don't print status codes, response size, running config, etc...
    -r, --redirects        Follow redirects
        --stdin            Read url(s) from STDIN
@@ -346,21 +337,34 @@ FLAGS:
 OPTIONS:
    -d, --depth <RECURSION_DEPTH>           Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)
    -x, --extensions <FILE_EXTENSION>...    File extension(s) to search for (ex: -x php -x pdf js)
+    -S, --filter-size <SIZE>...             Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)
+    -C, --filter-status <STATUS_CODE>...    Filter out status codes (deny list) (ex: -C 200 -C 401)
    -H, --headers <HEADER>...               Specify HTTP headers (ex: -H Header:val 'stuff: things')
    -o, --output <FILE>                     Output file to write results to (default: stdout)
    -p, --proxy <PROXY>                     Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)
    -Q, --query <QUERY>...                  Specify URL query parameters (ex: -Q token=stuff -Q secret=key)
-    -S, --sizefilter <SIZE>...              Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)
-    -s, --statuscodes <STATUS_CODE>...      Status Codes of interest (default: 200 204 301 302 307 308 401 403 405)
+    -R, --replay-codes <REPLAY_CODE>...     Status Codes to send through a Replay Proxy when found (default: --status
+                                            -codes value)
+    -P, --replay-proxy <REPLAY_PROXY>       Send only unfiltered requests through a Replay Proxy, instead of all
+                                            requests
+    -L, --scan-limit <SCAN_LIMIT>           Limit total number of concurrent scans (default: 0, i.e. no limit)
+    -s, --status-codes <STATUS_CODE>...     Status Codes to include (allow list) (default: 200 204 301 302 307 308 401
+                                            403 405)
    -t, --threads <THREADS>                 Number of concurrent threads (default: 50)
    -T, --timeout <SECONDS>                 Number of seconds before a request times out (default: 7)
    -u, --url <URL>...                      The target URL(s) (required, unless --stdin used)
-    -a, --useragent <USER_AGENT>            Sets the User-Agent (default: feroxbuster/VERSION)
+    -a, --user-agent <USER_AGENT>           Sets the User-Agent (default: feroxbuster/VERSION)
    -w, --wordlist <FILE>                   Path to the wordlist
 ```

 ## 🧰 Example Usage

+### Pause and Resume Scans (new in `v1.4.0`)
+
+Scans can be paused and resumed by pressing the ENTER key (shown below)
+
+![pause-resume-demo](img/pause-resume-demo.gif)
+
 ### Multiple Values

 Options that take multiple values are very flexible.  Consider the following ways of specifying extensions:
@@ -399,10 +403,21 @@ Example request/response with `--extract-links` enabled:
 ./feroxbuster -u http://127.1 --extract-links
 ```

+Here's a comparison of a wordlist-only scan vs `--extract-links` using [Feline](https://www.hackthebox.eu/home/machines/profile/274) from Hack the Box:
+
+Wordlist only
+
+![normal-scan-cmp-extract](img/normal-scan-cmp-extract.gif)
+
+With `--extract-links`
+
+![extract-scan-cmp-normal](img/extract-scan-cmp-normal.gif)
+
+
 ### IPv6, non-recursive scan with INFO-level logging enabled

 ```
-./feroxbuster -u http://[::1] --norecursion -vv
+./feroxbuster -u http://[::1] --no-recursion -vv
 ```

 ### Read urls from STDIN; pipe only resulting urls out to another tool
@@ -423,12 +438,47 @@ cat targets | ./feroxbuster --stdin --quiet -s 200 301 302 --redirects -x js | f
 ./feroxbuster -u http://127.1 --proxy socks5://127.0.0.1:9050
 ```

-### Pass auth token via query parameter
+### Pass auth token via query parameter 

 ```
 ./feroxbuster -u http://127.1 --query token=0123456789ABCDEF
 ```

+### Limit Total Number of Concurrent Scans (new in `v1.2.0`)
+
+Limit the number of scans permitted to run at any given time.  Recursion will still identify new directories, but newly
+discovered directories can only begin scanning when the total number of active scans drops below the value passed to 
+`--scan-limit`.
+
+```
+./feroxbuster -u http://127.1 --scan-limit 2
+```
+
+![limit-demo](img/limit-demo.gif)
+
+### Filter Response by Status Code  (new in `v1.3.0`)
+
+Version 1.3.0 included an overhaul to the filtering system which will allow for a wide array of filters to be added 
+with minimal effort. The first such filter is a Status Code Filter. As responses come back from the scanned server,
+each one is checked against a list of known filters and either displayed or not according to which filters are set.
+
+```
+./feroxbuster -u http://127.1 --filter-status 301
+```
+
+### Replay Responses to a Proxy based on Status Code (new in `v1.5.0`)
+
+The `--replay-proxy` and `--replay-codes` options were added as a way to only send a select few responses to a proxy.  This is in stark contrast to `--proxy` which proxies EVERY request.  
+
+Imagine you only care about proxying responses that have either the status code `200` or `302` (or you just don't want to clutter up your Burp history).  These two options will allow you to fine-tune what gets proxied and what doesn't.  
+
+```
+./feroxbuster -u http://127.1 --replay-proxy http://localhost:8080 --replay-codes 200 302 --insecure
+```
+
+Of note: this means that for every response that matches your replay criteria, you'll end up sending the request that generated that response a second time.  Depending on the target and your engagement terms (if any), it may not make sense from a traffic generated perspective.
+
+![replay-proxy-demo](img/replay-proxy-demo.gif)

 ## 🧐 Comparison w/ Similar Tools

@@ -452,7 +502,7 @@ a few of the use-cases in which feroxbuster may be a better fit:
 |------------------------------------------------------------------|---|---|---|
 | fast                                                             | ✔ | ✔ | ✔ |
 | easy to use                                                      | ✔ | ✔ |   |
-| blacklist status codes (in addition to whitelist)                |   | ✔ | ✔ |
+| filter out responses by status code (new in `v1.3.0`)            | ✔ | ✔ | ✔ |
 | allows recursion                                                 | ✔ |   | ✔ |
 | can specify query parameters                                     | ✔ |   | ✔ |
 | SOCKS proxy support                                              | ✔ |   |   |
@@ -543,3 +593,12 @@ This allows fast cycling of sockets in time_wait state and re-using them. Make s
 ```
 sudo sysctl net.ipv4.tcp_tw_reuse=1 
 ```
+
+### Progress bars print one line at a time
+
+`feroxbuster` needs a terminal width of at least the size of what's being printed in order to do progress bar printing correctly.  If your width is too small, you may see output like what's shown below.
+
+![small-term](img/small-term.png)
+
+If you can, simply make the terminal wider and rerun.  If you're unable to make your terminal wider
+consider using `-q` to suppress the progress bars.
--- a/ferox-config.toml.example
+++ b/ferox-config.toml.example
@@ -8,24 +8,28 @@
 # Any setting used here can be overridden by the corresponding command line option/argument
 #
 # wordlist = "/wordlists/seclists/Discovery/Web-Content/raft-medium-directories.txt"
-# statuscodes = [200, 500]
+# status_codes = [200, 500]
+# filter_status = [301]
 # threads = 1
 # timeout = 5
 # proxy = "http://127.0.0.1:8080"
+# replay_proxy = "http://127.0.0.1:8081"
+# replay_codes = [200, 302]
 # verbosity = 1
+# scan_limit = 6
 # quiet = true
 # output = "/targets/ellingson_mineral_company/gibson.txt"
-# useragent = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
+# user_agent = "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
 # redirects = true
 # insecure = true
 # extensions = ["php", "html"]
-# norecursion = true
-# addslash = true
+# no_recursion = true
+# add_slash = true
 # stdin = true
-# dontfilter = true
+# dont_filter = true
 # extract_links = true
 # depth = 1
-# sizefilters = [5174]
+# filter_size = [5174]
 # queries = [["name","value"], ["rick", "astley"]]

 # headers can be specified on multiple lines or as an inline table
--- a/img/extract-scan-cmp-normal.gif
+++ b/img/extract-scan-cmp-normal.gif
--- a/img/limit-demo.gif
+++ b/img/limit-demo.gif
--- a/img/normal-scan-cmp-extract.gif
+++ b/img/normal-scan-cmp-extract.gif
--- a/img/pause-resume-demo.gif
+++ b/img/pause-resume-demo.gif
--- a/img/replay-proxy-demo.gif
+++ b/img/replay-proxy-demo.gif
--- a/img/small-term.png
+++ b/img/small-term.png
--- a/install-nix.sh
+++ b/install-nix.sh
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+BASE_URL=https://github.com/epi052/feroxbuster/releases/latest/download
+
+MAC_ZIP=x86_64-macos-feroxbuster.zip
+MAC_URL="${BASE_URL}/${MAC_ZIP}"
+
+LIN32_ZIP=x86-linux-feroxbuster.zip
+LIN32_URL="${BASE_URL}/${LIN32_ZIP}"
+
+LIN64_ZIP=x86_64-linux-feroxbuster.zip
+LIN64_URL="${BASE_URL}/${LIN64_ZIP}"
+
+EMOJI_URL=https://gist.github.com/epi052/8196b550ea51d0907ad4b93751b1b57d/raw/6112c9f32ae07922983fdc549c54fd3fb9a38e4c/NotoColorEmoji.ttf
+
+echo "[+] Installing feroxbuster!"
+
+if [[ "$(uname)" == "Darwin" ]]; then
+    echo "[=] Found MacOS, downloading from ${MAC_URL}"
+
+    curl -sLO "${MAC_URL}"
+    unzip -o "${MAC_ZIP}" > /dev/null
+    rm "${MAC_ZIP}"
+elif [[ "$(expr substr $(uname -s) 1 5)" == "Linux" ]]; then
+    if [[ $(getconf LONG_BIT) == 32 ]]; then
+        echo "[=] Found 32-bit Linux, downloading from ${LIN32_URL}"
+
+        curl -sLO "${LIN32_URL}"
+        unzip -o "${LIN32_ZIP}" > /dev/null
+        rm "${LIN32_ZIP}"
+    else
+        echo "[=] Found 64-bit Linux, downloading from ${LIN64_URL}"
+
+        curl -sLO "${LIN64_URL}"
+        unzip -o "${LIN64_ZIP}" > /dev/null
+        rm "${LIN64_ZIP}"
+    fi
+
+    echo "[=] Installing Noto Emoji Font"
+    mkdir -p ~/.fonts
+    pushd ~/.fonts 2>&1 >/dev/null
+
+    curl -sLO "${EMOJI_URL}"
+
+    fc-cache -f -v >/dev/null
+
+    popd 2>&1 >/dev/null
+    echo "[+] Noto Emoji Font installed"
+fi
+
+chmod +x ./feroxbuster
+
+echo "[+] Installed feroxbuster version $(./feroxbuster -V)"
+
+
+
--- a/src/banner.rs
+++ b/src/banner.rs
@@ -1,5 +1,6 @@
 use crate::config::{Configuration, CONFIGURATION};
 use crate::utils::{make_request, status_colorizer};
+use console::style;
 use reqwest::{Client, Url};
 use serde_json::Value;
 use std::io::Write;
@@ -144,6 +145,7 @@ by Ben "epi" Risher {}                  ver: {}"#,
    let status = needs_update(&CONFIGURATION.client, UPDATE_URL, version).await;

    let top = "───────────────────────────┬──────────────────────";
+    let addl_section = "──────────────────────────────────────────────────";
    let bottom = "───────────────────────────┴──────────────────────";

    writeln!(&mut writer, "{}", artwork).unwrap_or_default();
@@ -161,7 +163,7 @@ by Ben "epi" Risher {}                  ver: {}"#,

    let mut codes = vec![];

-    for code in &config.statuscodes {
+    for code in &config.status_codes {
        codes.push(status_colorizer(&code.to_string()))
    }

@@ -190,6 +192,27 @@ by Ben "epi" Risher {}                  ver: {}"#,
    )
    .unwrap_or_default(); // 🆗

+    if !config.filter_status.is_empty() {
+        // exception here for optional print due to me wanting the allows and denys to be printed
+        // one after the other
+        let mut code_filters = vec![];
+
+        for code in &config.filter_status {
+            code_filters.push(status_colorizer(&code.to_string()))
+        }
+
+        writeln!(
+            &mut writer,
+            "{}",
+            format_banner_entry!(
+                "\u{1f5d1}",
+                "Status Code Filters",
+                format!("[{}]", code_filters.join(", "))
+            )
+        )
+        .unwrap_or_default(); // 🗑
+    }
+
    writeln!(
        &mut writer,
        "{}",
@@ -200,7 +223,7 @@ by Ben "epi" Risher {}                  ver: {}"#,
    writeln!(
        &mut writer,
        "{}",
-        format_banner_entry!("\u{1F9a1}", "User-Agent", config.useragent)
+        format_banner_entry!("\u{1F9a1}", "User-Agent", config.user_agent)
    )
    .unwrap_or_default(); // 🦡

@@ -223,6 +246,35 @@ by Ben "epi" Risher {}                  ver: {}"#,
        .unwrap_or_default(); // 💎
    }

+    if !config.replay_proxy.is_empty() {
+        // i include replay codes logic here because in config.rs, replay codes are set to the
+        // value in status codes, meaning it's never empty
+
+        let mut replay_codes = vec![];
+
+        writeln!(
+            &mut writer,
+            "{}",
+            format_banner_entry!("\u{1f3a5}", "Replay Proxy", config.replay_proxy)
+        )
+        .unwrap_or_default(); // 🎥
+
+        for code in &config.replay_codes {
+            replay_codes.push(status_colorizer(&code.to_string()))
+        }
+
+        writeln!(
+            &mut writer,
+            "{}",
+            format_banner_entry!(
+                "\u{1f4fc}",
+                "Replay Proxy Codes",
+                format!("[{}]", replay_codes.join(", "))
+            )
+        )
+        .unwrap_or_default(); // 📼
+    }
+
    if !config.headers.is_empty() {
        for (name, value) in &config.headers {
            writeln!(
@@ -234,8 +286,8 @@ by Ben "epi" Risher {}                  ver: {}"#,
        }
    }

-    if !config.sizefilters.is_empty() {
-        for filter in &config.sizefilters {
+    if !config.filter_size.is_empty() {
+        for filter in &config.filter_size {
            writeln!(
                &mut writer,
                "{}",
@@ -309,11 +361,11 @@ by Ben "epi" Risher {}                  ver: {}"#,
        .unwrap_or_default(); // 📍
    }

-    if config.dontfilter {
+    if config.dont_filter {
        writeln!(
            &mut writer,
            "{}",
-            format_banner_entry!("\u{1f92a}", "Filter Wildcards", !config.dontfilter)
+            format_banner_entry!("\u{1f92a}", "Filter Wildcards", !config.dont_filter)
        )
        .unwrap_or_default(); // 🤪
    }
@@ -355,16 +407,16 @@ by Ben "epi" Risher {}                  ver: {}"#,
        _ => {}
    }

-    if config.addslash {
+    if config.add_slash {
        writeln!(
            &mut writer,
            "{}",
-            format_banner_entry!("\u{1fa93}", "Add Slash", config.addslash)
+            format_banner_entry!("\u{1fa93}", "Add Slash", config.add_slash)
        )
        .unwrap_or_default(); // 🪓
    }

-    if !config.norecursion {
+    if !config.no_recursion {
        if config.depth == 0 {
            writeln!(
                &mut writer,
@@ -384,11 +436,20 @@ by Ben "epi" Risher {}                  ver: {}"#,
        writeln!(
            &mut writer,
            "{}",
-            format_banner_entry!("\u{1f6ab}", "Do Not Recurse", config.norecursion)
+            format_banner_entry!("\u{1f6ab}", "Do Not Recurse", config.no_recursion)
        )
        .unwrap_or_default(); // 🚫
    }

+    if CONFIGURATION.scan_limit > 0 {
+        writeln!(
+            &mut writer,
+            "{}",
+            format_banner_entry!("\u{1f9a5}", "Concurrent Scan Limit", config.scan_limit)
+        )
+        .unwrap_or_default(); // 🦥
+    }
+
    if matches!(status, UpdateStatus::OutOfDate) {
        writeln!(
            &mut writer,
@@ -403,6 +464,16 @@ by Ben "epi" Risher {}                  ver: {}"#,
    }

    writeln!(&mut writer, "{}", bottom).unwrap_or_default();
+    // ⏯
+    writeln!(
+        &mut writer,
+        " \u{23ef}   Press [{}] to {}|{} your scan",
+        style("ENTER").yellow(),
+        style("pause").red(),
+        style("resume").green()
+    )
+    .unwrap_or_default();
+    writeln!(&mut writer, "{}", addl_section).unwrap_or_default();
 }

 #[cfg(test)]
@@ -427,7 +498,7 @@ mod tests {
    /// test to hit no execution of statuscode for loop in banner
    async fn banner_intialize_without_status_codes() {
        let mut config = Configuration::default();
-        config.statuscodes = vec![];
+        config.status_codes = vec![];
        initialize(
            &[String::from("http://localhost")],
            &config,
--- a/src/client.rs
+++ b/src/client.rs
@@ -10,7 +10,7 @@ use std::time::Duration;
 /// Create and return an instance of [reqwest::Client](https://docs.rs/reqwest/latest/reqwest/struct.Client.html)
 pub fn initialize(
    timeout: u64,
-    useragent: &str,
+    user_agent: &str,
    redirects: bool,
    insecure: bool,
    headers: &HashMap<String, String>,
@@ -27,7 +27,7 @@ pub fn initialize(

    let client = Client::builder()
        .timeout(Duration::new(timeout, 0))
-        .user_agent(useragent)
+        .user_agent(user_agent)
        .danger_accept_invalid_certs(insecure)
        .default_headers(header_map)
        .redirect(policy);
@@ -62,11 +62,6 @@ pub fn initialize(
    match client.build() {
        Ok(client) => client,
        Err(e) => {
-            eprintln!(
-                "{} {} Could not create a Client with the given configuration, exiting.",
-                status_colorizer("ERROR"),
-                module_colorizer("Client::build")
-            );
            eprintln!(
                "{} {} {}",
                status_colorizer("ERROR"),
--- a/src/config.rs
+++ b/src/config.rs
@@ -10,6 +10,7 @@ use std::collections::HashMap;
 use std::env::{current_dir, current_exe};
 use std::fs::read_to_string;
 use std::path::PathBuf;
+#[cfg(not(test))]
 use std::process::exit;

 lazy_static! {
@@ -23,6 +24,21 @@ lazy_static! {
    pub static ref PROGRESS_PRINTER: ProgressBar = progress::add_bar("", 0, true);
 }

+/// simple helper to clean up some code reuse below; panics under test / exits in prod
+fn report_and_exit(err: &str) -> ! {
+    eprintln!(
+        "{} {}: {}",
+        status_colorizer("ERROR"),
+        module_colorizer("Configuration::new"),
+        err
+    );
+
+    #[cfg(test)]
+    panic!();
+    #[cfg(not(test))]
+    exit(1);
+}
+
 /// Represents the final, global configuration of the program.
 ///
 /// This struct is the combination of the following:
@@ -47,18 +63,34 @@ pub struct Configuration {
    #[serde(default)]
    pub proxy: String,

+    /// Replay Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)
+    #[serde(default)]
+    pub replay_proxy: String,
+
    /// The target URL
    #[serde(default)]
    pub target_url: String,

-    /// Status Codes of interest (default: 200 204 301 302 307 308 401 403 405)
-    #[serde(default = "statuscodes")]
-    pub statuscodes: Vec<u16>,
+    /// Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)
+    #[serde(default = "status_codes")]
+    pub status_codes: Vec<u16>,
+
+    /// Status Codes to replay to the Replay Proxy (default: whatever is passed to --status-code)
+    #[serde(default)]
+    pub replay_codes: Vec<u16>,
+
+    /// Status Codes to filter out (deny list)
+    #[serde(default)]
+    pub filter_status: Vec<u16>,

    /// Instance of [reqwest::Client](https://docs.rs/reqwest/latest/reqwest/struct.Client.html)
    #[serde(skip)]
    pub client: Client,

+    /// Instance of [reqwest::Client](https://docs.rs/reqwest/latest/reqwest/struct.Client.html)
+    #[serde(skip)]
+    pub replay_client: Option<Client>,
+
    /// Number of concurrent threads (default: 50)
    #[serde(default = "threads")]
    pub threads: usize,
@@ -80,8 +112,8 @@ pub struct Configuration {
    pub output: String,

    /// Sets the User-Agent (default: feroxbuster/VERSION)
-    #[serde(default = "useragent")]
-    pub useragent: String,
+    #[serde(default = "user_agent")]
+    pub user_agent: String,

    /// Follow redirects
    #[serde(default)]
@@ -105,7 +137,7 @@ pub struct Configuration {

    /// Do not scan recursively
    #[serde(default)]
-    pub norecursion: bool,
+    pub no_recursion: bool,

    /// Extract links from html/javscript
    #[serde(default)]
@@ -113,7 +145,7 @@ pub struct Configuration {

    /// Append / to each request
    #[serde(default)]
-    pub addslash: bool,
+    pub add_slash: bool,

    /// Read url(s) from STDIN
    #[serde(default)]
@@ -123,16 +155,20 @@ pub struct Configuration {
    #[serde(default = "depth")]
    pub depth: usize,

+    /// Number of concurrent scans permitted; a limit of 0 means no limit is imposed
+    #[serde(default)]
+    pub scan_limit: usize,
+
    /// Filter out messages of a particular size
    #[serde(default)]
-    pub sizefilters: Vec<u64>,
+    pub filter_size: Vec<u64>,

    /// Don't auto-filter wildcard responses
    #[serde(default)]
-    pub dontfilter: bool,
+    pub dont_filter: bool,
 }

-// functions timeout, threads, statuscodes, useragent, wordlist, and depth are used to provide
+// functions timeout, threads, status_codes, user_agent, wordlist, and depth are used to provide
 // defaults in the event that a ferox-config.toml is found but one or more of the values below
 // aren't listed in the config.  This way, we get the correct defaults upon Deserialization

@@ -147,7 +183,7 @@ fn threads() -> usize {
 }

 /// default status codes
-fn statuscodes() -> Vec<u16> {
+fn status_codes() -> Vec<u16> {
    DEFAULT_STATUS_CODES
        .iter()
        .map(|code| code.as_u16())
@@ -159,8 +195,8 @@ fn wordlist() -> String {
    String::from(DEFAULT_WORDLIST)
 }

-/// default useragent
-fn useragent() -> String {
+/// default user-agent
+fn user_agent() -> String {
    format!("feroxbuster/{}", VERSION)
 }

@@ -173,34 +209,42 @@ impl Default for Configuration {
    /// Builds the default Configuration for feroxbuster
    fn default() -> Self {
        let timeout = timeout();
-        let useragent = useragent();
-        let client = client::initialize(timeout, &useragent, false, false, &HashMap::new(), None);
+        let user_agent = user_agent();
+        let client = client::initialize(timeout, &user_agent, false, false, &HashMap::new(), None);
+        let replay_client = None;
+        let status_codes = status_codes();
+        let replay_codes = status_codes.clone();

        Configuration {
            client,
            timeout,
-            useragent,
-            dontfilter: false,
+            user_agent,
+            replay_codes,
+            status_codes,
+            replay_client,
+            dont_filter: false,
            quiet: false,
            stdin: false,
            verbosity: 0,
-            addslash: false,
+            scan_limit: 0,
+            add_slash: false,
            insecure: false,
            redirects: false,
-            norecursion: false,
+            no_recursion: false,
            extract_links: false,
            proxy: String::new(),
            config: String::new(),
            output: String::new(),
            target_url: String::new(),
+            replay_proxy: String::new(),
            queries: Vec::new(),
            extensions: Vec::new(),
-            sizefilters: Vec::new(),
+            filter_size: Vec::new(),
+            filter_status: Vec::new(),
            headers: HashMap::new(),
-            threads: threads(),
            depth: depth(),
+            threads: threads(),
            wordlist: wordlist(),
-            statuscodes: statuscodes(),
        }
    }
 }
@@ -218,20 +262,24 @@ impl Configuration {
    /// - **timeout**: `7` seconds
    /// - **verbosity**: `0` (no logging enabled)
    /// - **proxy**: `None`
-    /// - **statuscodes**: [`DEFAULT_RESPONSE_CODES`](constant.DEFAULT_RESPONSE_CODES.html)
+    /// - **status_codes**: [`DEFAULT_RESPONSE_CODES`](constant.DEFAULT_RESPONSE_CODES.html)
+    /// - **filter_status**: `None`
    /// - **output**: `None` (print to stdout)
    /// - **quiet**: `false`
-    /// - **useragent**: `feroxer/VERSION`
+    /// - **user_agent**: `feroxer/VERSION`
    /// - **insecure**: `false` (don't be insecure, i.e. don't allow invalid certs)
    /// - **extensions**: `None`
-    /// - **sizefilters**: `None`
+    /// - **filter_size**: `None`
    /// - **headers**: `None`
    /// - **queries**: `None`
-    /// - **norecursion**: `false` (recursively scan enumerated sub-directories)
-    /// - **addslash**: `false`
+    /// - **no_recursion**: `false` (recursively scan enumerated sub-directories)
+    /// - **add_slash**: `false`
    /// - **stdin**: `false`
-    /// - **dontfilter**: `false` (auto filter wildcard responses)
+    /// - **dont_filter**: `false` (auto filter wildcard responses)
    /// - **depth**: `4` (maximum recursion depth)
+    /// - **scan_limit**: `0` (no limit on concurrent scans imposed)
+    /// - **replay_proxy**: `None` (no limit on concurrent scans imposed)
+    /// - **replay_codes**: [`DEFAULT_RESPONSE_CODES`](constant.DEFAULT_RESPONSE_CODES.html)
    ///
    /// After which, any values defined in a
    /// [ferox-config.toml](constant.DEFAULT_CONFIG_NAME.html) config file will override the
@@ -316,6 +364,12 @@ impl Configuration {
            config.depth = depth;
        }

+        if args.value_of("scan_limit").is_some() {
+            let scan_limit =
+                value_t!(args.value_of("scan_limit"), usize).unwrap_or_else(|e| e.exit());
+            config.scan_limit = scan_limit;
+        }
+
        if args.value_of("wordlist").is_some() {
            config.wordlist = String::from(args.value_of("wordlist").unwrap());
        }
@@ -324,21 +378,41 @@ impl Configuration {
            config.output = String::from(args.value_of("output").unwrap());
        }

-        if args.values_of("statuscodes").is_some() {
-            config.statuscodes = args
-                .values_of("statuscodes")
+        if args.values_of("status_codes").is_some() {
+            config.status_codes = args
+                .values_of("status_codes")
                .unwrap() // already known good
                .map(|code| {
                    StatusCode::from_bytes(code.as_bytes())
-                        .unwrap_or_else(|e| {
-                            eprintln!(
-                                "{} {}: {}",
-                                status_colorizer("ERROR"),
-                                module_colorizer("Configuration::new"),
-                                e
-                            );
-                            exit(1)
-                        })
+                        .unwrap_or_else(|e| report_and_exit(&e.to_string()))
+                        .as_u16()
+                })
+                .collect();
+        }
+
+        if args.values_of("replay_codes").is_some() {
+            // replay codes passed in by the user
+            config.replay_codes = args
+                .values_of("replay_codes")
+                .unwrap() // already known good
+                .map(|code| {
+                    StatusCode::from_bytes(code.as_bytes())
+                        .unwrap_or_else(|e| report_and_exit(&e.to_string()))
+                        .as_u16()
+                })
+                .collect();
+        } else {
+            // not passed in by the user, use whatever value is held in status_codes
+            config.replay_codes = config.status_codes.clone();
+        }
+
+        if args.values_of("filter_status").is_some() {
+            config.filter_status = args
+                .values_of("filter_status")
+                .unwrap() // already known good
+                .map(|code| {
+                    StatusCode::from_bytes(code.as_bytes())
+                        .unwrap_or_else(|e| report_and_exit(&e.to_string()))
                        .as_u16()
                })
                .collect();
@@ -352,20 +426,13 @@ impl Configuration {
                .collect();
        }

-        if args.values_of("sizefilters").is_some() {
-            config.sizefilters = args
-                .values_of("sizefilters")
+        if args.values_of("filter_size").is_some() {
+            config.filter_size = args
+                .values_of("filter_size")
                .unwrap() // already known good
                .map(|size| {
-                    size.parse::<u64>().unwrap_or_else(|e| {
-                        eprintln!(
-                            "{} {}: {}",
-                            status_colorizer("ERROR"),
-                            module_colorizer("Configuration::new"),
-                            e
-                        );
-                        exit(1)
-                    })
+                    size.parse::<u64>()
+                        .unwrap_or_else(|e| report_and_exit(&e.to_string()))
                })
                .collect();
        }
@@ -378,8 +445,8 @@ impl Configuration {
            config.quiet = args.is_present("quiet");
        }

-        if args.is_present("dontfilter") {
-            config.dontfilter = args.is_present("dontfilter");
+        if args.is_present("dont_filter") {
+            config.dont_filter = args.is_present("dont_filter");
        }

        if args.occurrences_of("verbosity") > 0 {
@@ -388,12 +455,12 @@ impl Configuration {
            config.verbosity = args.occurrences_of("verbosity") as u8;
        }

-        if args.is_present("norecursion") {
-            config.norecursion = args.is_present("norecursion");
+        if args.is_present("no_recursion") {
+            config.no_recursion = args.is_present("no_recursion");
        }

-        if args.is_present("addslash") {
-            config.addslash = args.is_present("addslash");
+        if args.is_present("add_slash") {
+            config.add_slash = args.is_present("add_slash");
        }

        if args.is_present("extract_links") {
@@ -413,8 +480,12 @@ impl Configuration {
            config.proxy = String::from(args.value_of("proxy").unwrap());
        }

-        if args.value_of("useragent").is_some() {
-            config.useragent = String::from(args.value_of("useragent").unwrap());
+        if args.value_of("replay_proxy").is_some() {
+            config.replay_proxy = String::from(args.value_of("replay_proxy").unwrap());
+        }
+
+        if args.value_of("user_agent").is_some() {
+            config.user_agent = String::from(args.value_of("user_agent").unwrap());
        }

        if args.value_of("timeout").is_some() {
@@ -462,7 +533,7 @@ impl Configuration {
        // the client and store it in the config struct
        if !config.proxy.is_empty()
            || config.timeout != timeout()
-            || config.useragent != useragent()
+            || config.user_agent != user_agent()
            || config.redirects
            || config.insecure
            || !config.headers.is_empty()
@@ -470,7 +541,7 @@ impl Configuration {
            if config.proxy.is_empty() {
                config.client = client::initialize(
                    config.timeout,
-                    &config.useragent,
+                    &config.user_agent,
                    config.redirects,
                    config.insecure,
                    &config.headers,
@@ -479,7 +550,7 @@ impl Configuration {
            } else {
                config.client = client::initialize(
                    config.timeout,
-                    &config.useragent,
+                    &config.user_agent,
                    config.redirects,
                    config.insecure,
                    &config.headers,
@@ -488,6 +559,18 @@ impl Configuration {
            }
        }

+        if !config.replay_proxy.is_empty() {
+            // only set replay_client when replay_proxy is set
+            config.replay_client = Some(client::initialize(
+                config.timeout,
+                &config.user_agent,
+                config.redirects,
+                config.insecure,
+                &config.headers,
+                Some(&config.replay_proxy),
+            ));
+        }
+
        config
    }

@@ -515,25 +598,29 @@ impl Configuration {
    fn merge_config(settings: &mut Self, settings_to_merge: Self) {
        settings.threads = settings_to_merge.threads;
        settings.wordlist = settings_to_merge.wordlist;
-        settings.statuscodes = settings_to_merge.statuscodes;
+        settings.status_codes = settings_to_merge.status_codes;
        settings.proxy = settings_to_merge.proxy;
        settings.timeout = settings_to_merge.timeout;
        settings.verbosity = settings_to_merge.verbosity;
        settings.quiet = settings_to_merge.quiet;
        settings.output = settings_to_merge.output;
-        settings.useragent = settings_to_merge.useragent;
+        settings.user_agent = settings_to_merge.user_agent;
        settings.redirects = settings_to_merge.redirects;
        settings.insecure = settings_to_merge.insecure;
        settings.extract_links = settings_to_merge.extract_links;
        settings.extensions = settings_to_merge.extensions;
        settings.headers = settings_to_merge.headers;
        settings.queries = settings_to_merge.queries;
-        settings.norecursion = settings_to_merge.norecursion;
-        settings.addslash = settings_to_merge.addslash;
+        settings.no_recursion = settings_to_merge.no_recursion;
+        settings.add_slash = settings_to_merge.add_slash;
        settings.stdin = settings_to_merge.stdin;
        settings.depth = settings_to_merge.depth;
-        settings.sizefilters = settings_to_merge.sizefilters;
-        settings.dontfilter = settings_to_merge.dontfilter;
+        settings.filter_size = settings_to_merge.filter_size;
+        settings.filter_status = settings_to_merge.filter_status;
+        settings.dont_filter = settings_to_merge.dont_filter;
+        settings.scan_limit = settings_to_merge.scan_limit;
+        settings.replay_proxy = settings_to_merge.replay_proxy;
+        settings.replay_codes = settings_to_merge.replay_codes;
    }

    /// If present, read in `DEFAULT_CONFIG_NAME` and deserialize the specified values
@@ -569,25 +656,29 @@ mod tests {
    fn setup_config_test() -> Configuration {
        let data = r#"
            wordlist = "/some/path"
-            statuscodes = [201, 301, 401]
+            status_codes = [201, 301, 401]
+            replay_codes = [201, 301]
            threads = 40
            timeout = 5
            proxy = "http://127.0.0.1:8080"
+            replay_proxy = "http://127.0.0.1:8081"
            quiet = true
            verbosity = 1
+            scan_limit = 6
            output = "/some/otherpath"
            redirects = true
            insecure = true
            extensions = ["html", "php", "js"]
            headers = {stuff = "things", mostuff = "mothings"}
            queries = [["name","value"], ["rick", "astley"]]
-            norecursion = true
-            addslash = true
+            no_recursion = true
+            add_slash = true
            stdin = true
-            dontfilter = true
+            dont_filter = true
            extract_links = true
            depth = 1
-            sizefilters = [4120]
+            filter_size = [4120]
+            filter_status = [201]
        "#;
        let tmp_dir = TempDir::new().unwrap();
        let file = tmp_dir.path().join(DEFAULT_CONFIG_NAME);
@@ -603,22 +694,27 @@ mod tests {
        assert_eq!(config.proxy, String::new());
        assert_eq!(config.target_url, String::new());
        assert_eq!(config.config, String::new());
-        assert_eq!(config.statuscodes, statuscodes());
+        assert_eq!(config.replay_proxy, String::new());
+        assert_eq!(config.status_codes, status_codes());
+        assert_eq!(config.replay_codes, config.status_codes);
+        assert!(config.replay_client.is_none());
        assert_eq!(config.threads, threads());
        assert_eq!(config.depth, depth());
        assert_eq!(config.timeout, timeout());
        assert_eq!(config.verbosity, 0);
+        assert_eq!(config.scan_limit, 0);
        assert_eq!(config.quiet, false);
-        assert_eq!(config.dontfilter, false);
-        assert_eq!(config.norecursion, false);
+        assert_eq!(config.dont_filter, false);
+        assert_eq!(config.no_recursion, false);
        assert_eq!(config.stdin, false);
-        assert_eq!(config.addslash, false);
+        assert_eq!(config.add_slash, false);
        assert_eq!(config.redirects, false);
        assert_eq!(config.extract_links, false);
        assert_eq!(config.insecure, false);
        assert_eq!(config.queries, Vec::new());
        assert_eq!(config.extensions, Vec::<String>::new());
-        assert_eq!(config.sizefilters, Vec::<u64>::new());
+        assert_eq!(config.filter_size, Vec::<u64>::new());
+        assert_eq!(config.filter_status, Vec::<u16>::new());
        assert_eq!(config.headers, HashMap::new());
    }

@@ -631,9 +727,16 @@ mod tests {

    #[test]
    /// parse the test config and see that the value parsed is correct
-    fn config_reads_statuscodes() {
+    fn config_reads_status_codes() {
        let config = setup_config_test();
-        assert_eq!(config.statuscodes, vec![201, 301, 401]);
+        assert_eq!(config.status_codes, vec![201, 301, 401]);
+    }
+
+    #[test]
+    /// parse the test config and see that the value parsed is correct
+    fn config_reads_replay_codes() {
+        let config = setup_config_test();
+        assert_eq!(config.replay_codes, vec![201, 301]);
    }

    #[test]
@@ -650,6 +753,13 @@ mod tests {
        assert_eq!(config.depth, 1);
    }

+    #[test]
+    /// parse the test config and see that the value parsed is correct
+    fn config_reads_scan_limit() {
+        let config = setup_config_test();
+        assert_eq!(config.scan_limit, 6);
+    }
+
    #[test]
    /// parse the test config and see that the value parsed is correct
    fn config_reads_timeout() {
@@ -664,6 +774,13 @@ mod tests {
        assert_eq!(config.proxy, "http://127.0.0.1:8080");
    }

+    #[test]
+    /// parse the test config and see that the value parsed is correct
+    fn config_reads_replay_proxy() {
+        let config = setup_config_test();
+        assert_eq!(config.replay_proxy, "http://127.0.0.1:8081");
+    }
+
    #[test]
    /// parse the test config and see that the value parsed is correct
    fn config_reads_quiet() {
@@ -701,9 +818,9 @@ mod tests {

    #[test]
    /// parse the test config and see that the value parsed is correct
-    fn config_reads_norecursion() {
+    fn config_reads_no_recursion() {
        let config = setup_config_test();
-        assert_eq!(config.norecursion, true);
+        assert_eq!(config.no_recursion, true);
    }

    #[test]
@@ -715,16 +832,16 @@ mod tests {

    #[test]
    /// parse the test config and see that the value parsed is correct
-    fn config_reads_dontfilter() {
+    fn config_reads_dont_filter() {
        let config = setup_config_test();
-        assert_eq!(config.dontfilter, true);
+        assert_eq!(config.dont_filter, true);
    }

    #[test]
    /// parse the test config and see that the value parsed is correct
-    fn config_reads_addslash() {
+    fn config_reads_add_slash() {
        let config = setup_config_test();
-        assert_eq!(config.addslash, true);
+        assert_eq!(config.add_slash, true);
    }

    #[test]
@@ -743,9 +860,16 @@ mod tests {

    #[test]
    /// parse the test config and see that the value parsed is correct
-    fn config_reads_sizefilters() {
+    fn config_reads_filter_size() {
        let config = setup_config_test();
-        assert_eq!(config.sizefilters, vec![4120]);
+        assert_eq!(config.filter_size, vec![4120]);
+    }
+
+    #[test]
+    /// parse the test config and see that the value parsed is correct
+    fn config_reads_filter_status() {
+        let config = setup_config_test();
+        assert_eq!(config.filter_status, vec![201]);
    }

    #[test]
@@ -767,4 +891,11 @@ mod tests {
        queries.push(("rick".to_string(), "astley".to_string()));
        assert_eq!(config.queries, queries);
    }
+
+    #[test]
+    #[should_panic]
+    /// test that an error message is printed and panic is called when report_and_exit is called
+    fn config_report_and_exit_works() {
+        report_and_exit("some message");
+    }
 }
--- a/src/filters.rs
+++ b/src/filters.rs
@@ -0,0 +1,142 @@
+use crate::config::CONFIGURATION;
+use crate::utils::get_url_path_length;
+use crate::FeroxResponse;
+use std::any::Any;
+use std::fmt::Debug;
+
+// references:
+//   https://dev.to/magnusstrale/rust-trait-objects-in-a-vector-non-trivial-4co5
+//   https://stackoverflow.com/questions/25339603/how-to-test-for-equality-between-trait-objects
+
+/// FeroxFilter trait; represents different types of possible filters that can be applied to
+/// responses
+pub trait FeroxFilter: Debug + Send + Sync {
+    /// Determine whether or not this particular filter should be applied or not
+    fn should_filter_response(&self, response: &FeroxResponse) -> bool;
+
+    /// delegates to the FeroxFilter-implementing type which gives us the actual type of self
+    fn box_eq(&self, other: &dyn Any) -> bool;
+
+    /// gives us `other` as Any in box_eq
+    fn as_any(&self) -> &dyn Any;
+}
+
+/// implementation of PartialEq, necessary long-form due to "trait cannot be made into an object"
+/// error when attempting to derive PartialEq on the trait itself
+impl PartialEq for Box<dyn FeroxFilter> {
+    /// Perform a comparison of two implementors of the FeroxFilter trait
+    fn eq(&self, other: &Box<dyn FeroxFilter>) -> bool {
+        self.box_eq(other.as_any())
+    }
+}
+
+/// Data holder for two pieces of data needed when auto-filtering out wildcard responses
+///
+/// `dynamic` is the size of the response that will later be combined with the length
+/// of the path of the url requested and used to determine interesting pages from custom
+/// 404s where the requested url is reflected back in the response
+///
+/// `size` is size of the response that should be included with filters passed via runtime
+/// configuration and any static wildcard lengths.
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct WildcardFilter {
+    /// size of the response that will later be combined with the length of the path of the url
+    /// requested
+    pub dynamic: u64,
+
+    /// size of the response that should be included with filters passed via runtime configuration
+    pub size: u64,
+}
+
+/// implementation of FeroxFilter for WildcardFilter
+impl FeroxFilter for WildcardFilter {
+    /// Examine size, dynamic, and content_len to determine whether or not the response received
+    /// is a wildcard response and therefore should be filtered out
+    fn should_filter_response(&self, response: &FeroxResponse) -> bool {
+        log::trace!("enter: should_filter_response({:?} {:?})", self, response);
+
+        // quick return if dont_filter is set
+        if CONFIGURATION.dont_filter {
+            // --dont-filter applies specifically to wildcard filters, it is not a 100% catch all
+            // for not filtering anything.  As such, it should live in the implementation of
+            // a wildcard filter
+            return false;
+        }
+
+        if self.size > 0 && self.size == response.content_length() {
+            // static wildcard size found during testing
+            // size isn't default, size equals response length, and auto-filter is on
+            log::debug!("static wildcard: filtered out {}", response.url());
+            log::trace!("exit: should_filter_response -> true");
+            return true;
+        }
+
+        if self.dynamic > 0 {
+            // dynamic wildcard offset found during testing
+
+            // I'm about to manually split this url path instead of using reqwest::Url's
+            // builtin parsing. The reason is that they call .split() on the url path
+            // except that I don't want an empty string taking up the last index in the
+            // event that the url ends with a forward slash.  It's ugly enough to be split
+            // into its own function for readability.
+            let url_len = get_url_path_length(&response.url());
+
+            if url_len + self.dynamic == response.content_length() {
+                log::debug!("dynamic wildcard: filtered out {}", response.url());
+                log::trace!("exit: should_filter_response -> true");
+                return true;
+            }
+        }
+        log::trace!("exit: should_filter_response -> false");
+        false
+    }
+
+    /// Compare one WildcardFilter to another
+    fn box_eq(&self, other: &dyn Any) -> bool {
+        other.downcast_ref::<Self>().map_or(false, |a| self == a)
+    }
+
+    /// Return self as Any for dynamic dispatch purposes
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+/// Simple implementor of FeroxFilter; used to filter out status codes specified using
+/// -C|--filter-status
+#[derive(Default, Debug, PartialEq)]
+pub struct StatusCodeFilter {
+    /// Status code that should not be displayed to the user
+    pub filter_code: u16,
+}
+
+/// implementation of FeroxFilter for StatusCodeFilter
+impl FeroxFilter for StatusCodeFilter {
+    /// Check `filter_code` against what was passed in via -C|--filter-status
+    fn should_filter_response(&self, response: &FeroxResponse) -> bool {
+        log::trace!("enter: should_filter_response({:?} {:?})", self, response);
+
+        if response.status().as_u16() == self.filter_code {
+            log::debug!(
+                "filtered out {} based on --filter-status of {}",
+                response.url(),
+                self.filter_code
+            );
+            log::trace!("exit: should_filter_response -> true");
+            return true;
+        }
+
+        log::trace!("exit: should_filter_response -> false");
+        false
+    }
+
+    /// Compare one StatusCodeFilter to another
+    fn box_eq(&self, other: &dyn Any) -> bool {
+        other.downcast_ref::<Self>().map_or(false, |a| self == a)
+    }
+
+    /// Return self as Any for dynamic dispatch purposes
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
--- a/src/heuristics.rs
+++ b/src/heuristics.rs
@@ -1,36 +1,21 @@
-use crate::config::{CONFIGURATION, PROGRESS_PRINTER};
-use crate::scanner::should_filter_response;
-use crate::utils::{
-    ferox_print, format_url, get_url_path_length, make_request, module_colorizer, status_colorizer,
+use crate::{
+    config::{CONFIGURATION, PROGRESS_PRINTER},
+    filters::WildcardFilter,
+    scanner::should_filter_response,
+    utils::{
+        ferox_print, format_url, get_url_path_length, make_request, module_colorizer,
+        status_colorizer,
+    },
+    FeroxResponse,
 };
 use console::style;
 use indicatif::ProgressBar;
-use reqwest::Response;
-use std::process;
 use tokio::sync::mpsc::UnboundedSender;
 use uuid::Uuid;

 /// length of a standard UUID, used when determining wildcard responses
 const UUID_LENGTH: u64 = 32;

-/// Data holder for two pieces of data needed when auto-filtering out wildcard responses
-///
-/// `dynamic` is the size of the response that will later be combined with the length
-/// of the path of the url requested and used to determine interesting pages from custom
-/// 404s where the requested url is reflected back in the response
-///
-/// `size` is size of the response that should be included with filters passed via runtime
-/// configuration and any static wildcard lengths.
-#[derive(Default, Debug, PartialEq, Copy, Clone)]
-pub struct WildcardFilter {
-    /// size of the response that will later be combined with the length of the path of the url
-    /// requested
-    pub dynamic: u64,
-
-    /// size of the response that should be included with filters passed via runtime configuration
-    pub size: u64,
-}
-
 /// Simple helper to return a uuid, formatted as lowercase without hyphens
 ///
 /// `length` determines the number of uuids to string together. Each uuid
@@ -66,8 +51,8 @@ pub async fn wildcard_test(
        tx_file
    );

-    if CONFIGURATION.dontfilter {
-        // early return, dontfilter scans don't need tested
+    if CONFIGURATION.dont_filter {
+        // early return, dont_filter scans don't need tested
        log::trace!("exit: wildcard_test -> None");
        return None;
    }
@@ -75,13 +60,13 @@ pub async fn wildcard_test(
    let clone_req_one = tx_file.clone();
    let clone_req_two = tx_file.clone();

-    if let Some(resp_one) = make_wildcard_request(&target_url, 1, clone_req_one).await {
+    if let Some(ferox_response) = make_wildcard_request(&target_url, 1, clone_req_one).await {
        bar.inc(1);

        // found a wildcard response
        let mut wildcard = WildcardFilter::default();

-        let wc_length = resp_one.content_length().unwrap_or(0);
+        let wc_length = ferox_response.content_length();

        if wc_length == 0 {
            log::trace!("exit: wildcard_test -> Some({:?})", wildcard);
@@ -93,25 +78,23 @@ pub async fn wildcard_test(
        if let Some(resp_two) = make_wildcard_request(&target_url, 3, clone_req_two).await {
            bar.inc(1);

-            let wc2_length = resp_two.content_length().unwrap_or(0);
+            let wc2_length = resp_two.content_length();

            if wc2_length == wc_length + (UUID_LENGTH * 2) {
                // second length is what we'd expect to see if the requested url is
                // reflected in the response along with some static content; aka custom 404
-                let url_len = get_url_path_length(&resp_one.url());
+                let url_len = get_url_path_length(&ferox_response.url());

                wildcard.dynamic = wc_length - url_len;

-                if !CONFIGURATION.quiet
-                    && !should_filter_response(&wildcard.dynamic, &resp_one.url())
-                {
+                if !CONFIGURATION.quiet {
                    let msg = format!(
                            "{} {:>10} Wildcard response is dynamic; {} ({} + url length) responses; toggle this behavior by using {}\n",
                            status_colorizer("WLD"),
                            wildcard.dynamic,
                            style("auto-filtering").yellow(),
                            style(wc_length - url_len).cyan(),
-                            style("--dontfilter").yellow()
+                            style("--dont-filter").yellow()
                        );

                    ferox_print(&msg, &PROGRESS_PRINTER);
@@ -125,15 +108,14 @@ pub async fn wildcard_test(
            } else if wc_length == wc2_length {
                wildcard.size = wc_length;

-                if !CONFIGURATION.quiet && !should_filter_response(&wildcard.size, &resp_one.url())
-                {
+                if !CONFIGURATION.quiet {
                    let msg = format!(
                        "{} {:>10} Wildcard response is static; {} {} responses; toggle this behavior by using {}\n",
                        status_colorizer("WLD"),
                        wc_length,
                        style("auto-filtering").yellow(),
                        style(wc_length).cyan(),
-                        style("--dontfilter").yellow()
+                        style("--dont-filter").yellow()
                    );

                    ferox_print(&msg, &PROGRESS_PRINTER);
@@ -167,7 +149,7 @@ async fn make_wildcard_request(
    target_url: &str,
    length: usize,
    tx_file: UnboundedSender<String>,
-) -> Option<Response> {
+) -> Option<FeroxResponse> {
    log::trace!(
        "enter: make_wildcard_request({}, {}, {:?})",
        target_url,
@@ -180,7 +162,7 @@ async fn make_wildcard_request(
    let nonexistent = match format_url(
        target_url,
        &unique_str,
-        CONFIGURATION.addslash,
+        CONFIGURATION.add_slash,
        &CONFIGURATION.queries,
        None,
    ) {
@@ -197,20 +179,21 @@ async fn make_wildcard_request(
    match make_request(&CONFIGURATION.client, &nonexistent.to_owned()).await {
        Ok(response) => {
            if CONFIGURATION
-                .statuscodes
+                .status_codes
                .contains(&response.status().as_u16())
            {
                // found a wildcard response
-                let url_len = get_url_path_length(&response.url());
-                let content_len = response.content_length().unwrap_or(0);
+                let ferox_response = FeroxResponse::from(response, false).await;
+                let url_len = get_url_path_length(&ferox_response.url());
+                let content_len = ferox_response.content_length();

-                if !CONFIGURATION.quiet && !should_filter_response(&content_len, &response.url()) {
+                if !CONFIGURATION.quiet && !should_filter_response(&ferox_response) {
                    let msg = format!(
                        "{} {:>10} Got {} for {} (url length: {})\n",
                        wildcard,
                        content_len,
-                        status_colorizer(&response.status().as_str()),
-                        response.url(),
+                        status_colorizer(&ferox_response.status().as_str()),
+                        ferox_response.url(),
                        url_len
                    );

@@ -223,18 +206,16 @@ async fn make_wildcard_request(
                    );
                }

-                if response.status().is_redirection() {
+                if ferox_response.status().is_redirection() {
                    // show where it goes, if possible
-                    if let Some(next_loc) = response.headers().get("Location") {
+                    if let Some(next_loc) = ferox_response.headers().get("Location") {
                        let next_loc_str = next_loc.to_str().unwrap_or("Unknown");
-                        if !CONFIGURATION.quiet
-                            && !should_filter_response(&content_len, &response.url())
-                        {
+                        if !CONFIGURATION.quiet && !should_filter_response(&ferox_response) {
                            let msg = format!(
                                "{} {:>10} {} redirects to => {}\n",
                                wildcard,
                                content_len,
-                                response.url(),
+                                ferox_response.url(),
                                next_loc_str
                            );

@@ -248,8 +229,8 @@ async fn make_wildcard_request(
                        }
                    }
                }
-                log::trace!("exit: make_wildcard_request -> {:?}", response);
-                return Some(response);
+                log::trace!("exit: make_wildcard_request -> {:?}", ferox_response);
+                return Some(ferox_response);
            }
        }
        Err(e) => {
@@ -276,7 +257,7 @@ pub async fn connectivity_test(target_urls: &[String]) -> Vec<String> {
        let request = match format_url(
            target_url,
            "",
-            CONFIGURATION.addslash,
+            CONFIGURATION.add_slash,
            &CONFIGURATION.queries,
            None,
        ) {
@@ -305,14 +286,6 @@ pub async fn connectivity_test(target_urls: &[String]) -> Vec<String> {

    if good_urls.is_empty() {
        log::error!("Could not connect to any target provided, exiting.");
-        log::trace!("exit: connectivity_test");
-        eprintln!(
-            "{} {} Could not connect to any target provided",
-            status_colorizer("ERROR"),
-            module_colorizer("heuristics::connectivity_test"),
-        );
-
-        process::exit(1);
    }

    log::trace!("exit: connectivity_test -> {:?}", good_urls);
@@ -334,8 +307,7 @@ fn try_send_message_to_file(msg: &str, tx_file: UnboundedSender<String>, save_ou
            }
            Err(e) => {
                log::error!(
-                    "{} {} {}",
-                    status_colorizer("ERROR"),
+                    "{} {}",
                    module_colorizer("heuristics::try_send_message_to_file"),
                    e
                );
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,6 +2,7 @@ pub mod banner;
 pub mod client;
 pub mod config;
 pub mod extractor;
+pub mod filters;
 pub mod heuristics;
 pub mod logger;
 pub mod parser;
@@ -10,13 +11,30 @@ pub mod reporter;
 pub mod scanner;
 pub mod utils;

-use reqwest::header::HeaderMap;
-use reqwest::{Response, StatusCode, Url};
+use reqwest::{
+    header::HeaderMap,
+    {Response, StatusCode, Url},
+};
+use std::{error, fmt};
 use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};

 /// Generic Result type to ease error handling in async contexts
-pub type FeroxResult<T> =
-    std::result::Result<T, Box<dyn std::error::Error + Send + Sync + 'static>>;
+pub type FeroxResult<T> = std::result::Result<T, Box<dyn error::Error + Send + Sync + 'static>>;
+
+/// Simple Error implementation to allow for custom error returns
+#[derive(Debug, Default)]
+pub struct FeroxError {
+    /// fancy string that can be printed via Display
+    pub message: String,
+}
+
+impl error::Error for FeroxError {}
+
+impl fmt::Display for FeroxError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", &self.message)
+    }
+}

 /// Generic mpsc::unbounded_channel type to tidy up some code
 pub type FeroxChannel<T> = (UnboundedSender<T>, UnboundedReceiver<T>);
@@ -24,6 +42,9 @@ pub type FeroxChannel<T> = (UnboundedSender<T>, UnboundedReceiver<T>);
 /// Version pulled from Cargo.toml at compile time
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

+/// Maximum number of file descriptors that can be opened during a scan
+pub const DEFAULT_OPEN_FILE_LIMIT: usize = 8192;
+
 /// Default wordlist to use when `-w|--wordlist` isn't specified and not `wordlist` isn't set
 /// in a [ferox-config.toml](constant.DEFAULT_CONFIG_NAME.html) config file.
 ///
@@ -32,6 +53,9 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const DEFAULT_WORDLIST: &str =
    "/usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt";

+/// Number of milliseconds to wait between polls of `PAUSE_SCAN` when user pauses a scan
+pub static SLEEP_DURATION: u64 = 500;
+
 /// Default list of status codes to report
 ///
 /// * 200 Ok
@@ -61,7 +85,7 @@ pub const DEFAULT_STATUS_CODES: [StatusCode; 9] = [
 pub const DEFAULT_CONFIG_NAME: &str = "ferox-config.toml";

 /// A `FeroxResponse`, derived from a `Response` to a submitted `Request`
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FeroxResponse {
    /// The final `Url` of this `FeroxResponse`
    url: Url,
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,61 @@
-use feroxbuster::config::{CONFIGURATION, PROGRESS_PRINTER};
-use feroxbuster::scanner::scan_url;
-use feroxbuster::utils::{ferox_print, get_current_depth, module_colorizer, status_colorizer};
-use feroxbuster::{banner, heuristics, logger, reporter, FeroxResponse, FeroxResult, VERSION};
+use crossterm::event::{self, Event, KeyCode};
+use feroxbuster::{
+    banner,
+    config::{CONFIGURATION, PROGRESS_BAR, PROGRESS_PRINTER},
+    heuristics, logger, reporter,
+    scanner::{scan_url, PAUSE_SCAN},
+    utils::{ferox_print, get_current_depth, module_colorizer, status_colorizer},
+    FeroxError, FeroxResponse, FeroxResult, SLEEP_DURATION, VERSION,
+};
+#[cfg(not(target_os = "windows"))]
+use feroxbuster::{utils::set_open_file_limit, DEFAULT_OPEN_FILE_LIMIT};
 use futures::StreamExt;
-use std::collections::HashSet;
-use std::fs::File;
-use std::io::{stderr, BufRead, BufReader};
-use std::process;
-use std::sync::Arc;
-use tokio::io;
-use tokio::sync::mpsc::UnboundedSender;
+use std::{
+    collections::HashSet,
+    fs::File,
+    io::{stderr, BufRead, BufReader},
+    process,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+use tokio::{io, sync::mpsc::UnboundedSender, task::JoinHandle};
 use tokio_util::codec::{FramedRead, LinesCodec};

+/// Atomic boolean flag, used to determine whether or not the terminal input handler should exit
+pub static SCAN_COMPLETE: AtomicBool = AtomicBool::new(false);
+
+/// Handles specific key events triggered by the user over stdin
+fn terminal_input_handler() {
+    log::trace!("enter: terminal_input_handler");
+
+    loop {
+        if event::poll(Duration::from_millis(SLEEP_DURATION)).unwrap_or(false) {
+            // It's guaranteed that the `read()` won't block when the `poll()`
+            // function returns `true`
+
+            if let Ok(key_pressed) = event::read() {
+                if key_pressed == Event::Key(KeyCode::Enter.into()) {
+                    // if the user presses Enter, toggle the value stored in PAUSE_SCAN
+                    // ignore any other keys
+                    let current = PAUSE_SCAN.load(Ordering::Acquire);
+
+                    PAUSE_SCAN.store(!current, Ordering::Release);
+                }
+            }
+        } else {
+            // Timeout expired and no `Event` is available; use the timeout to check SCAN_COMPLETE
+            if SCAN_COMPLETE.load(Ordering::Relaxed) {
+                // scan has been marked complete by main, time to exit the loop
+                break;
+            }
+        }
+    }
+    log::trace!("exit: terminal_input_handler");
+}
+
 /// Create a HashSet of Strings from the given wordlist then stores it inside an Arc
 fn get_unique_words_from_wordlist(path: &str) -> FeroxResult<Arc<HashSet<String>>> {
    log::trace!("enter: get_unique_words_from_wordlist({})", path);
@@ -19,12 +63,6 @@ fn get_unique_words_from_wordlist(path: &str) -> FeroxResult<Arc<HashSet<String>
    let file = match File::open(&path) {
        Ok(f) => f,
        Err(e) => {
-            eprintln!(
-                "{} {} {}",
-                status_colorizer("ERROR"),
-                module_colorizer("main::get_unique_words_from_wordlist"),
-                e
-            );
            log::error!("Could not open wordlist: {}", e);
            log::trace!("exit: get_unique_words_from_wordlist -> {}", e);

@@ -69,13 +107,9 @@ async fn scan(
            .await??;

    if words.len() == 0 {
-        eprintln!(
-            "{} {} Did not find any words in {}",
-            status_colorizer("ERROR"),
-            module_colorizer("main::scan"),
-            CONFIGURATION.wordlist
-        );
-        process::exit(1);
+        let mut err = FeroxError::default();
+        err.message = format!("Did not find any words in {}", CONFIGURATION.wordlist);
+        return Err(Box::new(err));
    }

    let mut tasks = vec![];
@@ -100,6 +134,7 @@ async fn scan(
    Ok(())
 }

+/// Get targets from either commandline or stdin, pass them back to the caller as a Result<Vec>
 async fn get_targets() -> FeroxResult<Vec<String>> {
    log::trace!("enter: get_targets");

@@ -123,15 +158,31 @@ async fn get_targets() -> FeroxResult<Vec<String>> {
    Ok(targets)
 }

-#[tokio::main]
-async fn main() {
-    // setup logging based on the number of -v's used
-    logger::initialize(CONFIGURATION.verbosity);
+/// async main called from real main, broken out in this way to allow for some synchronous code
+/// to be executed before bringing the tokio runtime online
+async fn wrapped_main() {
+    // join can only be called once, otherwise it causes the thread to panic
+    tokio::task::spawn_blocking(move || {
+        // ok, lazy_static! uses (unsurprisingly in retrospect) a lazy loading model where the
+        // thing obtained through deref isn't actually created until it's used. This created a
+        // problem when initializing the logger as it relied on PROGRESS_PRINTER which may or may
+        // not have been created by the time it was needed for logging (really only occurred in
+        // heuristics / banner / main). In order to initialize logging properly, we need to ensure
+        // PROGRESS_PRINTER and PROGRESS_BAR have been used at least once.  This call satisfies
+        // that constraint
+        PROGRESS_PRINTER.println("");
+        PROGRESS_BAR.join().unwrap();
+    });

-    // can't trace main until after logger is initialized
+    // can't trace main until after logger is initialized and the above task is started
    log::trace!("enter: main");
    log::debug!("{:#?}", *CONFIGURATION);

+    // spawn a thread that listens for keyboard input on stdin, when a user presses enter
+    // the input handler will toggle PAUSE_SCAN, which in turn is used to pause and resume
+    // scans that are already running
+    tokio::task::spawn_blocking(terminal_input_handler);
+
    let save_output = !CONFIGURATION.output.is_empty(); // was -o used?

    let (tx_term, tx_file, term_handle, file_handle) =
@@ -142,17 +193,9 @@ async fn main() {
        Ok(t) => t,
        Err(e) => {
            // should only happen in the event that there was an error reading from stdin
-            log::error!("{}", e);
-            ferox_print(
-                &format!(
-                    "{} {} {}",
-                    status_colorizer("ERROR"),
-                    module_colorizer("main::get_targets"),
-                    e
-                ),
-                &PROGRESS_PRINTER,
-            );
-            process::exit(1);
+            log::error!("{} {}", module_colorizer("main::get_targets"), e);
+            clean_up(tx_term, term_handle, tx_file, file_handle, save_output).await;
+            return;
        }
    };

@@ -165,15 +208,49 @@ async fn main() {
    // discard non-responsive targets
    let live_targets = heuristics::connectivity_test(&targets).await;

+    if live_targets.is_empty() {
+        clean_up(tx_term, term_handle, tx_file, file_handle, save_output).await;
+        return;
+    }
+
    // kick off a scan against any targets determined to be responsive
    match scan(live_targets, tx_term.clone(), tx_file.clone()).await {
        Ok(_) => {
            log::info!("All scans complete!");
        }
-        Err(e) => log::error!("An error occurred: {}", e),
+        Err(e) => {
+            ferox_print(
+                &format!("{} while scanning: {}", status_colorizer("Error"), e),
+                &PROGRESS_PRINTER,
+            );
+            clean_up(tx_term, term_handle, tx_file, file_handle, save_output).await;
+            process::exit(1);
+        }
    };

-    // manually drop tx in order for the rx task's while loops to eval to false
+    clean_up(tx_term, term_handle, tx_file, file_handle, save_output).await;
+
+    log::trace!("exit: main");
+}
+
+/// Single cleanup function that handles all the necessary drops/finishes etc required to gracefully
+/// shutdown the program
+async fn clean_up(
+    tx_term: UnboundedSender<FeroxResponse>,
+    term_handle: JoinHandle<()>,
+    tx_file: UnboundedSender<String>,
+    file_handle: Option<JoinHandle<()>>,
+    save_output: bool,
+) {
+    log::trace!(
+        "enter: clean_up({:?}, {:?}, {:?}, {:?}, {}",
+        tx_term,
+        term_handle,
+        tx_file,
+        file_handle,
+        save_output
+    );
+
    drop(tx_term);
    log::trace!("dropped terminal output handler's transmitter");

@@ -205,9 +282,26 @@ async fn main() {
        log::trace!("done awaiting file output handler's receiver");
    }

-    log::trace!("exit: main");
+    // mark all scans complete so the terminal input handler will exit cleanly
+    SCAN_COMPLETE.store(true, Ordering::Relaxed);

    // clean-up function for the MultiProgress bar; must be called last in order to still see
-    // the final trace message above
+    // the final trace messages above
    PROGRESS_PRINTER.finish();
+
+    log::trace!("exit: clean_up");
+}
+
+fn main() {
+    // setup logging based on the number of -v's used
+    logger::initialize(CONFIGURATION.verbosity);
+
+    // this function uses rlimit, which is not supported on windows
+    #[cfg(not(target_os = "windows"))]
+    set_open_file_limit(DEFAULT_OPEN_FILE_LIMIT);
+
+    if let Ok(mut runtime) = tokio::runtime::Runtime::new() {
+        let future = wrapped_main();
+        runtime.block_on(future);
+    }
 }
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -68,15 +68,38 @@ pub fn initialize() -> App<'static, 'static> {
                ),
        )
        .arg(
-            Arg::with_name("statuscodes")
+            Arg::with_name("replay_proxy")
+                .short("P")
+                .long("replay-proxy")
+                .takes_value(true)
+                .value_name("REPLAY_PROXY")
+                .help(
+                    "Send only unfiltered requests through a Replay Proxy, instead of all requests",
+                ),
+        )
+        .arg(
+            Arg::with_name("replay_codes")
+                .short("R")
+                .long("replay-codes")
+                .value_name("REPLAY_CODE")
+                .takes_value(true)
+                .multiple(true)
+                .use_delimiter(true)
+                .requires("replay_proxy")
+                .help(
+                    "Status Codes to send through a Replay Proxy when found (default: --status-codes value)",
+                ),
+        )
+        .arg(
+            Arg::with_name("status_codes")
                .short("s")
-                .long("statuscodes")
+                .long("status-codes")
                .value_name("STATUS_CODE")
                .takes_value(true)
                .multiple(true)
                .use_delimiter(true)
                .help(
-                    "Status Codes of interest (default: 200 204 301 302 307 308 401 403 405)",
+                    "Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)",
                ),
        )
        .arg(
@@ -87,9 +110,9 @@ pub fn initialize() -> App<'static, 'static> {
                .help("Only print URLs; Don't print status codes, response size, running config, etc...")
        )
        .arg(
-            Arg::with_name("dontfilter")
+            Arg::with_name("dont_filter")
                .short("D")
-                .long("dontfilter")
+                .long("dont-filter")
                .takes_value(false)
                .help("Don't auto-filter wildcard responses")
        )
@@ -102,9 +125,9 @@ pub fn initialize() -> App<'static, 'static> {
                .takes_value(true),
        )
        .arg(
-            Arg::with_name("useragent")
+            Arg::with_name("user_agent")
                .short("a")
-                .long("useragent")
+                .long("user-agent")
                .value_name("USER_AGENT")
                .takes_value(true)
                .help(
@@ -162,16 +185,16 @@ pub fn initialize() -> App<'static, 'static> {
                ),
        )
        .arg(
-            Arg::with_name("norecursion")
+            Arg::with_name("no_recursion")
                .short("n")
-                .long("norecursion")
+                .long("no-recursion")
                .takes_value(false)
                .help("Do not scan recursively")
        )
        .arg(
-            Arg::with_name("addslash")
+            Arg::with_name("add_slash")
                .short("f")
-                .long("addslash")
+                .long("add-slash")
                .takes_value(false)
                .conflicts_with("extensions")
                .help("Append / to each request")
@@ -184,9 +207,9 @@ pub fn initialize() -> App<'static, 'static> {
                .conflicts_with("url")
        )
        .arg(
-            Arg::with_name("sizefilters")
+            Arg::with_name("filter_size")
                .short("S")
-                .long("sizefilter")
+                .long("filter-size")
                .value_name("SIZE")
                .takes_value(true)
                .multiple(true)
@@ -195,6 +218,18 @@ pub fn initialize() -> App<'static, 'static> {
                    "Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)",
                ),
        )
+        .arg(
+            Arg::with_name("filter_status")
+                .short("C")
+                .long("filter-status")
+                .value_name("STATUS_CODE")
+                .takes_value(true)
+                .multiple(true)
+                .use_delimiter(true)
+                .help(
+                    "Filter out status codes (deny list) (ex: -C 200 -C 401)",
+                ),
+        )
        .arg(
            Arg::with_name("extract_links")
                .short("e")
@@ -202,7 +237,14 @@ pub fn initialize() -> App<'static, 'static> {
                .takes_value(false)
                .help("Extract links from response body (html, javascript, etc...); make new requests based on findings (default: false)")
        )
-
+        .arg(
+            Arg::with_name("scan_limit")
+                .short("L")
+                .long("scan-limit")
+                .value_name("SCAN_LIMIT")
+                .takes_value(true)
+                .help("Limit total number of concurrent scans (default: 0, i.e. no limit)")
+        )
        .after_help(r#"NOTE:
    Options that take multiple values are very flexible.  Consider the following ways of specifying
    extensions:
@@ -218,7 +260,7 @@ EXAMPLES:
        ./feroxbuster -u http://127.1 -H Accept:application/json "Authorization: Bearer {token}"

    IPv6, non-recursive scan with INFO-level logging enabled:
-        ./feroxbuster -u http://[::1] --norecursion -vv
+        ./feroxbuster -u http://[::1] --no-recursion -vv

    Read urls from STDIN; pipe only resulting urls out to another tool
        cat targets | ./feroxbuster --stdin --quiet -s 200 301 302 --redirects -x js | fff -s 200 -o js-files
--- a/src/reporter.rs
+++ b/src/reporter.rs
@@ -1,5 +1,5 @@
 use crate::config::{CONFIGURATION, PROGRESS_PRINTER};
-use crate::utils::{ferox_print, status_colorizer};
+use crate::utils::{ferox_print, make_request, status_colorizer};
 use crate::{FeroxChannel, FeroxResponse};
 use console::strip_ansi_codes;
 use std::io::Write;
@@ -92,9 +92,9 @@ async fn spawn_terminal_reporter(
    );

    while let Some(resp) = resp_chan.recv().await {
-        log::debug!("received {} on reporting channel", resp.url());
+        log::trace!("received {} on reporting channel", resp.url());

-        if CONFIGURATION.statuscodes.contains(&resp.status().as_u16()) {
+        if CONFIGURATION.status_codes.contains(&resp.status().as_u16()) {
            let report = if CONFIGURATION.quiet {
                // -q used, just need the url
                format!("{}\n", resp.url())
@@ -126,7 +126,20 @@ async fn spawn_terminal_reporter(
                }
            }
        }
-        log::debug!("report complete: {}", resp.url());
+        log::trace!("report complete: {}", resp.url());
+
+        if CONFIGURATION.replay_client.is_some()
+            && CONFIGURATION.replay_codes.contains(&resp.status().as_u16())
+        {
+            // replay proxy specified/client created and this response's status code is one that
+            // should be replayed
+            match make_request(CONFIGURATION.replay_client.as_ref().unwrap(), &resp.url()).await {
+                Ok(_) => {}
+                Err(e) => {
+                    log::error!("{}", e);
+                }
+            }
+        }
    }
    log::trace!("exit: spawn_terminal_reporter");
 }
--- a/src/scanner.rs
+++ b/src/scanner.rs
@@ -1,29 +1,120 @@
-use crate::config::{CONFIGURATION, PROGRESS_BAR};
-use crate::extractor::get_links;
-use crate::heuristics::WildcardFilter;
-use crate::utils::{format_url, get_current_depth, get_url_path_length, make_request};
-use crate::{heuristics, progress, FeroxChannel, FeroxResponse};
-use futures::future::{BoxFuture, FutureExt};
-use futures::{stream, StreamExt};
+use crate::{
+    config::CONFIGURATION,
+    extractor::get_links,
+    filters::{FeroxFilter, StatusCodeFilter, WildcardFilter},
+    heuristics, progress,
+    utils::{format_url, get_current_depth, make_request},
+    FeroxChannel, FeroxResponse, SLEEP_DURATION,
+};
+use console::style;
+use futures::{
+    future::{BoxFuture, FutureExt},
+    stream, StreamExt,
+};
+use indicatif::{ProgressBar, ProgressStyle};
 use lazy_static::lazy_static;
 use reqwest::Url;
-use std::collections::HashSet;
-use std::convert::TryInto;
-use std::ops::Deref;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, RwLock};
-use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
-use tokio::task::JoinHandle;
+use std::{
+    collections::HashSet,
+    convert::TryInto,
+    io::{stderr, Write},
+    ops::Deref,
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::{Arc, RwLock},
+};
+use tokio::{
+    sync::{
+        mpsc::{self, UnboundedReceiver, UnboundedSender},
+        Semaphore,
+    },
+    task::JoinHandle,
+    time,
+};

 /// Single atomic number that gets incremented once, used to track first scan vs. all others
 static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);

+/// Atomic boolean flag, used to determine whether or not a scan should pause or resume
+pub static PAUSE_SCAN: AtomicBool = AtomicBool::new(false);
+
 lazy_static! {
    /// Set of urls that have been sent to [scan_url](fn.scan_url.html), used for deduplication
    static ref SCANNED_URLS: RwLock<HashSet<String>> = RwLock::new(HashSet::new());

-    /// Vector of WildcardFilters that have been ID'd through heuristics
-    static ref WILDCARD_FILTERS: Arc<RwLock<Vec<Arc<WildcardFilter>>>> = Arc::new(RwLock::new(Vec::<Arc<WildcardFilter>>::new()));
+    /// A clock spinner protected with a RwLock to allow for a single thread to use at a time
+    static ref SINGLE_SPINNER: RwLock<ProgressBar> = RwLock::new(get_single_spinner());
+
+    /// Vector of implementors of the FeroxFilter trait
+    static ref FILTERS: Arc<RwLock<Vec<Box<dyn FeroxFilter>>>> = Arc::new(RwLock::new(Vec::<Box<dyn FeroxFilter>>::new()));
+
+    /// Bounded semaphore used as a barrier to limit concurrent scans
+    static ref SCAN_LIMITER: Semaphore = Semaphore::new(CONFIGURATION.scan_limit);
+}
+
+/// Return a clock spinner, used when scans are paused
+fn get_single_spinner() -> ProgressBar {
+    log::trace!("enter: get_single_spinner");
+
+    let spinner = ProgressBar::new_spinner().with_style(
+        ProgressStyle::default_spinner()
+            .tick_strings(&[
+                "🕛", "🕐", "🕑", "🕒", "🕓", "🕔", "🕕", "🕖", "🕗", "🕘", "🕙", "🕚",
+            ])
+            .template(&format!(
+                "\t-= All Scans {{spinner}} {} =-",
+                style("Paused").red()
+            )),
+    );
+
+    log::trace!("exit: get_single_spinner -> {:?}", spinner);
+    spinner
+}
+
+/// Forced the calling thread into a busy loop
+///
+/// Every `SLEEP_DURATION` milliseconds, the function examines the result stored in `PAUSE_SCAN`
+///
+/// When the value stored in `PAUSE_SCAN` becomes `false`, the function returns, exiting the busy
+/// loop
+async fn pause_scan() {
+    log::trace!("enter: pause_scan");
+    // function uses tokio::time, not std
+
+    // local testing showed a pretty slow increase (less than linear) in CPU usage as # of
+    // concurrent scans rose when SLEEP_DURATION was set to 500, using that as the default for now
+    let mut interval = time::interval(time::Duration::from_millis(SLEEP_DURATION));
+
+    // ignore any error returned
+    let _ = stderr().flush();
+
+    if SINGLE_SPINNER.read().unwrap().is_finished() {
+        // in order to not leave draw artifacts laying around in the terminal, we call
+        // finish_and_clear on the progress bar when resuming scans. For this reason, we need to
+        // check if the spinner is finished, and repopulate the RwLock with a new spinner if
+        // necessary
+        if let Ok(mut guard) = SINGLE_SPINNER.write() {
+            *guard = get_single_spinner();
+        }
+    }
+
+    if let Ok(spinner) = SINGLE_SPINNER.write() {
+        spinner.enable_steady_tick(120);
+    }
+
+    loop {
+        // first tick happens immediately, all others wait the specified duration
+        interval.tick().await;
+
+        if !PAUSE_SCAN.load(Ordering::Acquire) {
+            // PAUSE_SCAN is false, so we can exit the busy loop
+            if let Ok(spinner) = SINGLE_SPINNER.write() {
+                spinner.finish_and_clear();
+            }
+            let _ = stderr().flush();
+            log::trace!("exit: pause_scan");
+            return;
+        }
+    }
 }

 /// Adds the given url to `SCANNED_URLS`
@@ -39,17 +130,9 @@ fn add_url_to_list_of_scanned_urls(resp: &str, scanned_urls: &RwLock<HashSet<Str
    match scanned_urls.write() {
        // check new url against what's already been scanned
        Ok(mut urls) => {
-            let normalized_url = if resp.ends_with('/') {
-                // append a / to the list of 'seen' urls, this is to prevent the case where
-                // 3xx and 2xx duplicate eachother
-                resp.to_string()
-            } else {
-                format!("{}/", resp)
-            };
-
            // If the set did not contain resp, true is returned.
            // If the set did contain resp, false is returned.
-            let response = urls.insert(normalized_url);
+            let response = urls.insert(resp.to_string());

            log::trace!("exit: add_url_to_list_of_scanned_urls -> {}", response);
            response
@@ -63,37 +146,37 @@ fn add_url_to_list_of_scanned_urls(resp: &str, scanned_urls: &RwLock<HashSet<Str
    }
 }

-/// Adds the given WildcardFilter to `WILDCARD_FILTERS`
+/// Adds the given FeroxFilter to the given list of FeroxFilter implementors
 ///
-/// If `WILDCARD_FILTERS` did not already contain the filter, return true; otherwise return false
-fn add_filter_to_list_of_wildcard_filters(
-    filter: Arc<WildcardFilter>,
-    wildcard_filters: Arc<RwLock<Vec<Arc<WildcardFilter>>>>,
+/// If the given list did not already contain the filter, return true; otherwise return false
+fn add_filter_to_list_of_ferox_filters(
+    filter: Box<dyn FeroxFilter>,
+    ferox_filters: Arc<RwLock<Vec<Box<dyn FeroxFilter>>>>,
 ) -> bool {
    log::trace!(
-        "enter: add_filter_to_list_of_wildcard_filters({:?}, {:?})",
+        "enter: add_filter_to_list_of_ferox_filters({:?}, {:?})",
        filter,
-        wildcard_filters
+        ferox_filters
    );

-    match wildcard_filters.write() {
+    match ferox_filters.write() {
        Ok(mut filters) => {
            // If the set did not contain the assigned filter, true is returned.
            // If the set did contain the assigned filter, false is returned.
            if filters.contains(&filter) {
-                log::trace!("exit: add_filter_to_list_of_wildcard_filters -> false");
+                log::trace!("exit: add_filter_to_list_of_ferox_filters -> false");
                return false;
            }

            filters.push(filter);

-            log::trace!("exit: add_filter_to_list_of_wildcard_filters -> true");
+            log::trace!("exit: add_filter_to_list_of_ferox_filters -> true");
            true
        }
        Err(e) => {
            // poisoned lock
            log::error!("Set of wildcard filters poisoned: {}", e);
-            log::trace!("exit: add_filter_to_list_of_wildcard_filters -> false");
+            log::trace!("exit: add_filter_to_list_of_ferox_filters -> false");
            false
        }
    }
@@ -120,6 +203,7 @@ fn spawn_recursion_handler(

    let boxed_future = async move {
        let mut scans = vec![];
+
        while let Some(resp) = recursion_channel.recv().await {
            let unknown = add_url_to_list_of_scanned_urls(&resp, &SCANNED_URLS);

@@ -173,7 +257,7 @@ fn create_urls(target_url: &str, word: &str, extensions: &[String]) -> Vec<Url>
    if let Ok(url) = format_url(
        &target_url,
        &word,
-        CONFIGURATION.addslash,
+        CONFIGURATION.add_slash,
        &CONFIGURATION.queries,
        None,
    ) {
@@ -184,7 +268,7 @@ fn create_urls(target_url: &str, word: &str, extensions: &[String]) -> Vec<Url>
        if let Ok(url) = format_url(
            &target_url,
            &word,
-            CONFIGURATION.addslash,
+            CONFIGURATION.add_slash,
            &CONFIGURATION.queries,
            Some(ext),
        ) {
@@ -237,6 +321,7 @@ fn response_is_directory(response: &FeroxResponse) -> bool {
        }
    } else if response.status().is_success() {
        // status code is 2xx, need to check if it ends in /
+
        if response.url().as_str().ends_with('/') {
            log::debug!("{} is directory suitable for recursion", response.url());
            log::trace!("exit: is_directory -> true");
@@ -332,43 +417,24 @@ async fn try_recursion(

 /// Simple helper to stay DRY; determines whether or not a given `FeroxResponse` should be reported
 /// to the user or not.
-pub fn should_filter_response(content_len: &u64, url: &Url) -> bool {
-    if CONFIGURATION.sizefilters.contains(content_len) {
-        // filtered value from --sizefilters, move on to the next url
-        log::debug!("size filter: filtered out {}", url);
+pub fn should_filter_response(response: &FeroxResponse) -> bool {
+    if CONFIGURATION
+        .filter_size
+        .contains(&response.content_length())
+    {
+        // filtered value from --filter-size, size filters and wildcards are two separate filters
+        // and are applied independently
+        log::debug!("size filter: filtered out {}", response.url());
        return true;
    }

-    match WILDCARD_FILTERS.read() {
+    match FILTERS.read() {
        Ok(filters) => {
            for filter in filters.iter() {
-                if CONFIGURATION.dontfilter {
-                    // quick return if dontfilter is set
-                    return false;
-                }
-
-                if filter.size > 0 && filter.size == *content_len {
-                    // static wildcard size found during testing
-                    // size isn't default, size equals response length, and auto-filter is on
-                    log::debug!("static wildcard: filtered out {}", url);
+                // wildcard.should_filter goes here
+                if filter.should_filter_response(&response) {
                    return true;
                }
-
-                if filter.dynamic > 0 {
-                    // dynamic wildcard offset found during testing
-
-                    // I'm about to manually split this url path instead of using reqwest::Url's
-                    // builtin parsing. The reason is that they call .split() on the url path
-                    // except that I don't want an empty string taking up the last index in the
-                    // event that the url ends with a forward slash.  It's ugly enough to be split
-                    // into its own function for readability.
-                    let url_len = get_url_path_length(&url);
-
-                    if url_len + filter.dynamic == *content_len {
-                        log::debug!("dynamic wildcard: filtered out {}", url);
-                        return true;
-                    }
-                }
            }
        }
        Err(e) => {
@@ -407,16 +473,14 @@ async fn make_requests(
            let ferox_response = FeroxResponse::from(response, CONFIGURATION.extract_links).await;

            // do recursion if appropriate
-            if !CONFIGURATION.norecursion {
+            if !CONFIGURATION.no_recursion {
                try_recursion(&ferox_response, base_depth, dir_chan.clone()).await;
            }

            // purposefully doing recursion before filtering. the thought process is that
            // even though this particular url is filtered, subsequent urls may not

-            let content_len = &ferox_response.content_length();
-
-            if should_filter_response(content_len, &ferox_response.url()) {
+            if should_filter_response(&ferox_response) {
                continue;
            }

@@ -435,7 +499,7 @@ async fn make_requests(
                    let new_url = match format_url(
                        &new_link,
                        &"",
-                        CONFIGURATION.addslash,
+                        CONFIGURATION.add_slash,
                        &CONFIGURATION.queries,
                        None,
                    ) {
@@ -453,8 +517,7 @@ async fn make_requests(
                        FeroxResponse::from(new_response, CONFIGURATION.extract_links).await;

                    // filter if necessary
-                    let new_content_len = &new_ferox_response.content_length();
-                    if should_filter_response(new_content_len, &new_ferox_response.url()) {
+                    if should_filter_response(&new_ferox_response) {
                        continue;
                    }

@@ -471,7 +534,7 @@ async fn make_requests(
                        continue;
                    }

-                    if !CONFIGURATION.norecursion {
+                    if !CONFIGURATION.no_recursion {
                        log::debug!(
                            "Recursive extraction: {} ({})",
                            new_ferox_response.url(),
@@ -548,15 +611,26 @@ pub async fn scan_url(
    progress_bar.reset_elapsed();

    if CALL_COUNT.load(Ordering::Relaxed) == 0 {
-        // join can only be called once, otherwise it causes the thread to panic
-        tokio::task::spawn_blocking(move || PROGRESS_BAR.join().unwrap());
        CALL_COUNT.fetch_add(1, Ordering::Relaxed);

-        // this protection around join also allows us to add the first scanned url to SCANNED_URLS
+        // this protection allows us to add the first scanned url to SCANNED_URLS
        // from within the scan_url function instead of the recursion handler
        add_url_to_list_of_scanned_urls(&target_url, &SCANNED_URLS);
+
+        if CONFIGURATION.scan_limit == 0 {
+            // scan_limit == 0 means no limit should be imposed... however, scoping the Semaphore
+            // permit is tricky, so as a workaround, we'll add a ridiculous number of permits to
+            // the semaphore (1,152,921,504,606,846,975 to be exact) and call that 'unlimited'
+            SCAN_LIMITER.add_permits(usize::MAX >> 4);
+        }
    }

+    // When acquire is called and the semaphore has remaining permits, the function immediately
+    // returns a permit. However, if no remaining permits are available, acquire (asynchronously)
+    // waits until an outstanding permit is dropped. At this point, the freed permit is assigned
+    // to the caller.
+    let permit = SCAN_LIMITER.acquire().await;
+
    // Arc clones to be passed around to the various scans
    let wildcard_bar = progress_bar.clone();
    let heuristics_file_clone = tx_file.clone();
@@ -576,13 +650,23 @@ pub async fn scan_url(
        .await
    });

+    // add any wildcard filters to `FILTERS`
    let filter =
        match heuristics::wildcard_test(&target_url, wildcard_bar, heuristics_file_clone).await {
-            Some(f) => Arc::new(f),
-            None => Arc::new(WildcardFilter::default()),
+            Some(f) => Box::new(f),
+            None => Box::new(WildcardFilter::default()),
        };

-    add_filter_to_list_of_wildcard_filters(filter.clone(), WILDCARD_FILTERS.clone());
+    add_filter_to_list_of_ferox_filters(filter, FILTERS.clone());
+
+    // add any status code filters to `FILTERS`
+    for code_filter in &CONFIGURATION.filter_status {
+        let filter = StatusCodeFilter {
+            filter_code: *code_filter,
+        };
+        let boxed_filter = Box::new(filter);
+        add_filter_to_list_of_ferox_filters(boxed_filter, FILTERS.clone());
+    }

    // producer tasks (mp of mpsc); responsible for making requests
    let producers = stream::iter(looping_words.deref().to_owned())
@@ -592,7 +676,15 @@ pub async fn scan_url(
            let pb = progress_bar.clone(); // progress bar is an Arc around internal state
            let tgt = target_url.to_string(); // done to satisfy 'static lifetime below
            (
-                tokio::spawn(async move { make_requests(&tgt, &word, base_depth, txd, txr).await }),
+                tokio::spawn(async move {
+                    if PAUSE_SCAN.load(Ordering::Acquire) {
+                        // for every word in the wordlist, check to see if PAUSE_SCAN is set to true
+                        // when true; enter a busy loop that only exits by setting PAUSE_SCAN back
+                        // to false
+                        pause_scan().await;
+                    }
+                    make_requests(&tgt, &word, base_depth, txd, txr).await
+                }),
                pb,
            )
        })
@@ -612,6 +704,9 @@ pub async fn scan_url(
    producers.await;
    log::trace!("done awaiting scan producers");

+    // drop the current permit so the semaphore will allow another scan to proceed
+    drop(permit);
+
    progress_bar.finish();

    // manually drop tx in order for the rx task's while loops to eval to false
@@ -752,7 +847,7 @@ mod tests {
        assert_eq!(
            urls.write()
                .unwrap()
-                .insert("http://unknown_url/".to_string()),
+                .insert("http://unknown_url".to_string()),
            true
        );

@@ -760,28 +855,31 @@ mod tests {
    }

    #[test]
-    /// add a wildcard filter with the `size` attribute set to WILDCARD_FILTERS and ensure that
-    /// should_filter_response correctly returns true
-    fn should_filter_response_filters_wildcard_size() {
-        let mut filter = WildcardFilter::default();
-        let url = Url::parse("http://localhost").unwrap();
-        filter.size = 18;
-        let filter = Arc::new(filter);
-        add_filter_to_list_of_wildcard_filters(filter, WILDCARD_FILTERS.clone());
-        let result = should_filter_response(&18, &url);
-        assert!(result);
+    /// test that get_single_spinner returns the correct spinner
+    fn scanner_get_single_spinner_returns_spinner() {
+        let spinner = get_single_spinner();
+        assert!(!spinner.is_finished());
    }

-    #[test]
-    /// add a wildcard filter with the `dynamic` attribute set to WILDCARD_FILTERS and ensure that
-    /// should_filter_response correctly returns true
-    fn should_filter_response_filters_wildcard_dynamic() {
-        let mut filter = WildcardFilter::default();
-        let url = Url::parse("http://localhost/some-path").unwrap();
-        filter.dynamic = 9;
-        let filter = Arc::new(filter);
-        add_filter_to_list_of_wildcard_filters(filter, WILDCARD_FILTERS.clone());
-        let result = should_filter_response(&18, &url);
-        assert!(result);
+    #[tokio::test(core_threads = 1)]
+    /// tests that pause_scan pauses execution and releases execution when PAUSE_SCAN is toggled
+    /// the spinner used during the test has had .finish_and_clear called on it, meaning that
+    /// a new one will be created, taking the if branch within the function
+    async fn scanner_pause_scan_with_finished_spinner() {
+        let now = time::Instant::now();
+
+        PAUSE_SCAN.store(true, Ordering::Relaxed);
+        SINGLE_SPINNER.write().unwrap().finish_and_clear();
+
+        let expected = time::Duration::from_secs(2);
+
+        tokio::spawn(async move {
+            time::delay_for(expected).await;
+            PAUSE_SCAN.store(false, Ordering::Relaxed);
+        });
+
+        pause_scan().await;
+
+        assert!(now.elapsed() > expected);
    }
 }
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,8 +1,10 @@
-use crate::FeroxResult;
+use crate::{FeroxError, FeroxResult};
 use console::{strip_ansi_codes, style, user_attended};
 use indicatif::ProgressBar;
 use reqwest::Url;
 use reqwest::{Client, Response};
+#[cfg(not(target_os = "windows"))]
+use rlimit::{getrlimit, setrlimit, Resource, Rlim};
 use std::convert::TryInto;

 /// Helper function that determines the current depth of a given url
@@ -140,7 +142,7 @@ pub fn ferox_print(msg: &str, bar: &ProgressBar) {
 pub fn format_url(
    url: &str,
    word: &str,
-    addslash: bool,
+    add_slash: bool,
    queries: &[(String, String)],
    extension: Option<&str>,
 ) -> FeroxResult<Url> {
@@ -148,11 +150,32 @@ pub fn format_url(
        "enter: format_url({}, {}, {}, {:?} {:?})",
        url,
        word,
-        addslash,
+        add_slash,
        queries,
        extension
    );

+    if Url::parse(&word).is_ok() {
+        // when a full url is passed in as a word to be joined to a base url using
+        // reqwest::Url::join, the result is that the word (url) completely overwrites the base
+        // url, potentially resulting in requests to places that aren't actually the target
+        // specified.
+        //
+        // in order to resolve the issue, we check if the word from the wordlist is a parsable URL
+        // and if so, don't do any further processing
+        let message = format!(
+            "word ({}) from the wordlist is actually a URL, skipping...",
+            word
+        );
+        log::warn!("{}", message);
+
+        let mut err = FeroxError::default();
+        err.message = message;
+
+        log::trace!("exit: format_url -> {}", err);
+        return Err(Box::new(err));
+    }
+
    // from reqwest::Url::join
    //   Note: a trailing slash is significant. Without it, the last path component
    //   is considered to be a “file” name to be removed to get at the “directory”
@@ -175,7 +198,7 @@ pub fn format_url(
    // extensions and slashes are mutually exclusive cases
    let word = if extension.is_some() {
        format!("{}.{}", word, extension.unwrap())
-    } else if addslash && !word.ends_with('/') {
+    } else if add_slash && !word.ends_with('/') {
        // -f used, and word doesn't already end with a /
        format!("{}/", word)
    } else {
@@ -238,10 +261,89 @@ pub async fn make_request(client: &Client, url: &Url) -> FeroxResult<Response> {
    }
 }

+/// Attempts to set the soft limit for the RLIMIT_NOFILE resource
+///
+/// RLIMIT_NOFILE is the maximum number of file descriptors that can be opened by this process
+///
+/// The soft limit is the value that the kernel enforces for the corresponding resource.
+/// The hard limit acts as a ceiling for the soft limit: an unprivileged process may set only its
+/// soft limit to a value in the range from 0 up to the hard limit, and (irreversibly) lower its
+/// hard limit.
+///
+/// A child process created via fork(2) inherits its parent's resource limits. Resource limits are
+/// per-process attributes that are shared by all of the threads in a process.
+///
+/// Based on the above information, no attempt is made to restore the limit to its pre-scan value
+/// as the adjustment made here is only valid for the scan itself (and any child processes, of which
+/// there are none).
+#[cfg(not(target_os = "windows"))]
+pub fn set_open_file_limit(limit: usize) -> bool {
+    log::trace!("enter: set_open_file_limit");
+
+    if let Ok((soft, hard)) = getrlimit(Resource::NOFILE) {
+        if hard.as_usize() > limit {
+            // our default open file limit is less than the current hard limit, this means we can
+            // set the soft limit to our default
+            let new_soft_limit = Rlim::from_usize(limit);
+
+            if setrlimit(Resource::NOFILE, new_soft_limit, hard).is_ok() {
+                log::debug!("set open file descriptor limit to {}", limit);
+
+                log::trace!("exit: set_open_file_limit -> {}", true);
+                return true;
+            }
+        } else if soft != hard {
+            // hard limit is lower than our default, the next best option is to set the soft limit as
+            // high as the hard limit will allow
+            if setrlimit(Resource::NOFILE, hard, hard).is_ok() {
+                log::debug!("set open file descriptor limit to {}", limit);
+
+                log::trace!("exit: set_open_file_limit -> {}", true);
+                return true;
+            }
+        }
+    }
+
+    // failed to set a new limit, as limit adjustments are a 'nice to have', we'll just log
+    // and move along
+    log::warn!("could not set open file descriptor limit to {}", limit);
+
+    log::trace!("exit: set_open_file_limit -> {}", false);
+    false
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;

+    #[test]
+    /// set_open_file_limit with a low requested limit succeeds
+    fn utils_set_open_file_limit_with_low_requested_limit() {
+        let (_, hard) = getrlimit(Resource::NOFILE).unwrap();
+        let lower_limit = hard.as_usize() - 1;
+        assert!(set_open_file_limit(lower_limit));
+    }
+
+    #[test]
+    /// set_open_file_limit with a high requested limit succeeds
+    fn utils_set_open_file_limit_with_high_requested_limit() {
+        let (_, hard) = getrlimit(Resource::NOFILE).unwrap();
+        let higher_limit = hard.as_usize() + 1;
+        // calculate a new soft to ensure soft != hard and hit that logic branch
+        let new_soft = Rlim::from_usize(hard.as_usize() - 1);
+        setrlimit(Resource::NOFILE, new_soft, hard).unwrap();
+        assert!(set_open_file_limit(higher_limit));
+    }
+
+    #[test]
+    /// set_open_file_limit should fail when hard == soft
+    fn utils_set_open_file_limit_with_fails_when_both_limits_are_equal() {
+        let (_, hard) = getrlimit(Resource::NOFILE).unwrap();
+        // calculate a new soft to ensure soft == hard and hit the failure logic branch
+        setrlimit(Resource::NOFILE, hard, hard).unwrap();
+        assert!(!set_open_file_limit(hard.as_usize())); // returns false
+    }
+
    #[test]
    /// base url returns 1
    fn get_current_depth_base_url_returns_1() {
@@ -352,6 +454,19 @@ mod tests {
        );
    }

+    #[test]
+    /// word that is a fully formed url, should return an error
+    fn format_url_word_that_is_a_url() {
+        let url = format_url(
+            "http://localhost",
+            "http://schmocalhost",
+            false,
+            &Vec::new(),
+            None,
+        );
+        assert!(url.is_err());
+    }
+
    #[test]
    /// status colorizer uses red for 500s
    fn status_colorizer_uses_red_for_500s() {
--- a/tests/test_banner.rs
+++ b/tests/test_banner.rs
@@ -23,7 +23,7 @@ fn banner_prints_proxy() -> Result<(), Box<dyn std::error::Error>> {
        .pipe_stdin(file)
        .unwrap()
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -43,6 +43,46 @@ fn banner_prints_proxy() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

+#[test]
+/// test allows non-existent wordlist to trigger the banner printing to stderr
+/// expect to see all mandatory prints + replay proxy
+fn banner_prints_replay_proxy() -> Result<(), Box<dyn std::error::Error>> {
+    let urls = vec![
+        String::from("http://localhost"),
+        String::from("http://schmocalhost"),
+    ];
+    let (tmp_dir, file) = setup_tmp_directory(&urls, "wordlist")?;
+
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--stdin")
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("--replay-proxy")
+        .arg("http://127.0.0.1:8081")
+        .pipe_stdin(file)
+        .unwrap()
+        .assert()
+        .success()
+        .stderr(
+            predicate::str::contains("─┬─")
+                .and(predicate::str::contains("Target Url"))
+                .and(predicate::str::contains("http://localhost"))
+                .and(predicate::str::contains("http://schmocalhost"))
+                .and(predicate::str::contains("Threads"))
+                .and(predicate::str::contains("Wordlist"))
+                .and(predicate::str::contains("Status Codes"))
+                .and(predicate::str::contains("Timeout (secs)"))
+                .and(predicate::str::contains("User-Agent"))
+                .and(predicate::str::contains("Replay Proxy"))
+                .and(predicate::str::contains("http://127.0.0.1:8081"))
+                .and(predicate::str::contains("─┴─")),
+        );
+
+    teardown_tmp_directory(tmp_dir);
+    Ok(())
+}
+
 #[test]
 /// test allows non-existent wordlist to trigger the banner printing to stderr
 /// expect to see all mandatory prints + multiple headers
@@ -56,7 +96,7 @@ fn banner_prints_headers() -> Result<(), Box<dyn std::error::Error>> {
        .arg("-H")
        .arg("mostuff:mothings")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -77,17 +117,17 @@ fn banner_prints_headers() -> Result<(), Box<dyn std::error::Error>> {
 #[test]
 /// test allows non-existent wordlist to trigger the banner printing to stderr
 /// expect to see all mandatory prints + multiple size filters
-fn banner_prints_size_filters() -> Result<(), Box<dyn std::error::Error>> {
+fn banner_prints_filter_sizes() -> Result<(), Box<dyn std::error::Error>> {
    Command::cargo_bin("feroxbuster")
        .unwrap()
        .arg("--url")
        .arg("http://localhost")
        .arg("-S")
        .arg("789456123")
-        .arg("--sizefilter")
+        .arg("--filter-size")
        .arg("44444444")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -118,7 +158,7 @@ fn banner_prints_queries() -> Result<(), Box<dyn std::error::Error>> {
        .arg("--query")
        .arg("stuff=things")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -147,7 +187,7 @@ fn banner_prints_status_codes() -> Result<(), Box<dyn std::error::Error>> {
        .arg("-s")
        .arg("201,301,401")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -163,6 +203,37 @@ fn banner_prints_status_codes() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

+#[test]
+/// test allows non-existent wordlist to trigger the banner printing to stderr
+/// expect to see all mandatory prints + replay codes
+fn banner_prints_replay_codes() -> Result<(), Box<dyn std::error::Error>> {
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg("http://localhost")
+        .arg("--replay-codes")
+        .arg("200,302")
+        .arg("--replay-proxy")
+        .arg("http://localhost:8081")
+        .assert()
+        .success()
+        .stderr(
+            predicate::str::contains("─┬─")
+                .and(predicate::str::contains("Target Url"))
+                .and(predicate::str::contains("http://localhost"))
+                .and(predicate::str::contains("Threads"))
+                .and(predicate::str::contains("Wordlist"))
+                .and(predicate::str::contains("Timeout (secs)"))
+                .and(predicate::str::contains("User-Agent"))
+                .and(predicate::str::contains("Replay Proxy"))
+                .and(predicate::str::contains("http://localhost:8081"))
+                .and(predicate::str::contains("Replay Proxy Codes"))
+                .and(predicate::str::contains("[200, 302]"))
+                .and(predicate::str::contains("─┴─")),
+        );
+    Ok(())
+}
+
 #[test]
 /// test allows non-existent wordlist to trigger the banner printing to stderr
 /// expect to see all mandatory prints + output file
@@ -174,7 +245,7 @@ fn banner_prints_output_file() -> Result<(), Box<dyn std::error::Error>> {
        .arg("--output")
        .arg("/super/cool/path")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -201,7 +272,7 @@ fn banner_prints_insecure() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-k")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -228,7 +299,7 @@ fn banner_prints_redirects() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-r")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -258,7 +329,7 @@ fn banner_prints_extensions() -> Result<(), Box<dyn std::error::Error>> {
        .arg("--extensions")
        .arg("pdf")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -277,15 +348,15 @@ fn banner_prints_extensions() -> Result<(), Box<dyn std::error::Error>> {

 #[test]
 /// test allows non-existent wordlist to trigger the banner printing to stderr
-/// expect to see all mandatory prints + dontfilter
-fn banner_prints_dontfilter() -> Result<(), Box<dyn std::error::Error>> {
+/// expect to see all mandatory prints + dont_filter
+fn banner_prints_dont_filter() -> Result<(), Box<dyn std::error::Error>> {
    Command::cargo_bin("feroxbuster")
        .unwrap()
        .arg("--url")
        .arg("http://localhost")
-        .arg("--dontfilter")
+        .arg("--dont-filter")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -312,7 +383,7 @@ fn banner_prints_verbosity_one() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-v")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -339,7 +410,7 @@ fn banner_prints_verbosity_two() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-vv")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -366,7 +437,7 @@ fn banner_prints_verbosity_three() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-vvv")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -393,7 +464,7 @@ fn banner_prints_verbosity_four() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-vvvv")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -420,7 +491,7 @@ fn banner_prints_add_slash() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-f")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -448,7 +519,7 @@ fn banner_prints_infinite_depth() -> Result<(), Box<dyn std::error::Error>> {
        .arg("--depth")
        .arg("0")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -476,7 +547,7 @@ fn banner_prints_recursion_depth() -> Result<(), Box<dyn std::error::Error>> {
        .arg("--depth")
        .arg("343214")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -503,7 +574,7 @@ fn banner_prints_no_recursion() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-n")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -522,7 +593,7 @@ fn banner_prints_no_recursion() -> Result<(), Box<dyn std::error::Error>> {

 #[test]
 /// test allows non-existent wordlist to trigger the banner printing to stderr
-/// expect to see only the error of could not connect
+/// expect to see nothing
 fn banner_doesnt_print() -> Result<(), Box<dyn std::error::Error>> {
    Command::cargo_bin("feroxbuster")
        .unwrap()
@@ -530,10 +601,8 @@ fn banner_doesnt_print() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-q")
        .assert()
-        .failure()
-        .stderr(predicate::str::contains(
-            "ERROR heuristics::connectivity_test Could not connect to any target provided",
-        ));
+        .success()
+        .stderr(predicate::str::is_empty());
    Ok(())
 }

@@ -547,7 +616,7 @@ fn banner_prints_extract_links() -> Result<(), Box<dyn std::error::Error>> {
        .arg("http://localhost")
        .arg("-e")
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("─┬─")
                .and(predicate::str::contains("Target Url"))
@@ -563,3 +632,59 @@ fn banner_prints_extract_links() -> Result<(), Box<dyn std::error::Error>> {
        );
    Ok(())
 }
+
+#[test]
+/// test allows non-existent wordlist to trigger the banner printing to stderr
+/// expect to see all mandatory prints + scan-limit
+fn banner_prints_scan_limit() -> Result<(), Box<dyn std::error::Error>> {
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg("http://localhost")
+        .arg("-L")
+        .arg("4")
+        .assert()
+        .success()
+        .stderr(
+            predicate::str::contains("─┬─")
+                .and(predicate::str::contains("Target Url"))
+                .and(predicate::str::contains("http://localhost"))
+                .and(predicate::str::contains("Threads"))
+                .and(predicate::str::contains("Wordlist"))
+                .and(predicate::str::contains("Status Codes"))
+                .and(predicate::str::contains("Timeout (secs)"))
+                .and(predicate::str::contains("User-Agent"))
+                .and(predicate::str::contains("Concurrent Scan Limit"))
+                .and(predicate::str::contains("│ 4"))
+                .and(predicate::str::contains("─┴─")),
+        );
+    Ok(())
+}
+
+#[test]
+/// test allows non-existent wordlist to trigger the banner printing to stderr
+/// expect to see all mandatory prints + filter-status
+fn banner_prints_filter_status() -> Result<(), Box<dyn std::error::Error>> {
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg("http://localhost")
+        .arg("-C")
+        .arg("200")
+        .assert()
+        .success()
+        .stderr(
+            predicate::str::contains("─┬─")
+                .and(predicate::str::contains("Target Url"))
+                .and(predicate::str::contains("http://localhost"))
+                .and(predicate::str::contains("Threads"))
+                .and(predicate::str::contains("Wordlist"))
+                .and(predicate::str::contains("Status Codes"))
+                .and(predicate::str::contains("Timeout (secs)"))
+                .and(predicate::str::contains("User-Agent"))
+                .and(predicate::str::contains("Status Code Filters"))
+                .and(predicate::str::contains("│ [200]"))
+                .and(predicate::str::contains("─┴─")),
+        );
+    Ok(())
+}
--- a/tests/test_config.rs
+++ b/tests/test_config.rs
@@ -18,7 +18,7 @@ fn read_in_config_file_for_settings() -> Result<(), Box<dyn std::error::Error>>
        .arg(file.as_os_str())
        .arg("-vvvv")
        .assert()
-        .failure()
+        .success()
        .stderr(predicate::str::contains("│ 37"));

    teardown_tmp_directory(tmp_dir);
--- a/tests/test_extractor.rs
+++ b/tests/test_extractor.rs
@@ -181,7 +181,7 @@ fn extractor_finds_same_relative_url_twice() -> Result<(), Box<dyn std::error::E
 }

 #[test]
-/// send a request to a page that contains an absolute link that leads to a page with a sizefilter
+/// send a request to a page that contains an absolute link that leads to a page with a filter_size
 /// that should filter it out, expect not to see the second response reported
 fn extractor_finds_filtered_content() -> Result<(), Box<dyn std::error::Error>> {
    let srv = MockServer::start();
@@ -209,7 +209,7 @@ fn extractor_finds_filtered_content() -> Result<(), Box<dyn std::error::Error>>
        .arg("--wordlist")
        .arg(file.as_os_str())
        .arg("--extract-links")
-        .arg("--sizefilter")
+        .arg("--filter-size")
        .arg("18")
        .unwrap();

--- a/tests/test_filters.rs
+++ b/tests/test_filters.rs
@@ -0,0 +1,57 @@
+mod utils;
+use assert_cmd::prelude::*;
+use httpmock::Method::GET;
+use httpmock::{Mock, MockServer};
+use predicates::prelude::*;
+use std::process::Command;
+use utils::{setup_tmp_directory, teardown_tmp_directory};
+
+#[test]
+/// create a FeroxResponse that should elicit a true from
+/// StatusCodeFilter::should_filter_response
+fn filters_status_code_should_filter_response() {
+    let srv = MockServer::start();
+    let (tmp_dir, file) =
+        setup_tmp_directory(&["LICENSE".to_string(), "file.js".to_string()], "wordlist").unwrap();
+
+    let mock = Mock::new()
+        .expect_method(GET)
+        .expect_path("/LICENSE")
+        .return_status(302)
+        .return_body("this is a test")
+        .create_on(&srv);
+
+    let mock_two = Mock::new()
+        .expect_method(GET)
+        .expect_path("/file.js")
+        .return_status(200)
+        .return_body("this is also a test of some import")
+        .create_on(&srv);
+
+    let cmd = Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg(srv.url("/"))
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("-vvvv")
+        .arg("--filter-status")
+        .arg("302")
+        .unwrap();
+
+    cmd.assert().success().stdout(
+        predicate::str::contains("/LICENSE")
+            .not()
+            .and(predicate::str::contains("302"))
+            .not()
+            .and(predicate::str::contains("14"))
+            .not()
+            .and(predicate::str::contains("/file.js"))
+            .and(predicate::str::contains("200"))
+            .and(predicate::str::contains("34")),
+    );
+
+    assert_eq!(mock.times_called(), 1);
+    assert_eq!(mock_two.times_called(), 1);
+    teardown_tmp_directory(tmp_dir);
+}
--- a/tests/test_heuristics.rs
+++ b/tests/test_heuristics.rs
@@ -19,11 +19,9 @@ fn test_single_target_cannot_connect() -> Result<(), Box<dyn std::error::Error>>
        .arg("--wordlist")
        .arg(file.as_os_str())
        .assert()
-        .failure()
-        .stderr(
-            predicate::str::contains("Could not connect to any target provided")
-                .and(predicate::str::contains("ERROR"))
-                .and(predicate::str::contains("heuristics::connectivity_test")),
+        .success()
+        .stdout(
+            predicate::str::contains("Could not connect to http://fjdksafjkdsajfkdsajkfdsajkfsdjkdsfdsafdsafdsajkr3l2ajfdskafdsjk, skipping...", )
        );

    teardown_tmp_directory(tmp_dir);
@@ -47,11 +45,9 @@ fn test_two_targets_cannot_connect() -> Result<(), Box<dyn std::error::Error>> {
        .pipe_stdin(file)
        .unwrap()
        .assert()
-        .failure()
-        .stderr(
-            predicate::str::contains("Could not connect to any target provided")
-                .and(predicate::str::contains("ERROR"))
-                .and(predicate::str::contains("heuristics::connectivity_test")),
+        .success()
+        .stdout(
+            predicate::str::contains("Could not connect to http://fjdksafjkdsajfkdsajkfdsajkfsdjkdsfdsafdsafdsajkr3l2ajfdskafdsjk, skipping...", )
        );

    teardown_tmp_directory(tmp_dir);
@@ -115,7 +111,7 @@ fn test_static_wildcard_request_found() -> Result<(), Box<dyn std::error::Error>
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .unwrap();

    teardown_tmp_directory(tmp_dir);
@@ -158,7 +154,7 @@ fn test_dynamic_wildcard_request_found() -> Result<(), Box<dyn std::error::Error
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .arg("--output")
        .arg(outfile.as_os_str())
        .unwrap();
@@ -198,8 +194,8 @@ fn test_dynamic_wildcard_request_found() -> Result<(), Box<dyn std::error::Error
 }

 #[test]
-/// uses dontfilter, so the normal wildcard test should never happen
-fn heuristics_static_wildcard_request_with_dontfilter() -> Result<(), Box<dyn std::error::Error>> {
+/// uses dont_filter, so the normal wildcard test should never happen
+fn heuristics_static_wildcard_request_with_dont_filter() -> Result<(), Box<dyn std::error::Error>> {
    let srv = MockServer::start();
    let (tmp_dir, file) = setup_tmp_directory(&["LICENSE".to_string()], "wordlist")?;

@@ -216,7 +212,7 @@ fn heuristics_static_wildcard_request_with_dontfilter() -> Result<(), Box<dyn st
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--dontfilter")
+        .arg("--dont-filter")
        .unwrap();

    teardown_tmp_directory(tmp_dir);
@@ -251,7 +247,7 @@ fn heuristics_wildcard_test_with_two_static_wildcards() -> Result<(), Box<dyn st
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .unwrap();

    teardown_tmp_directory(tmp_dir);
@@ -299,7 +295,7 @@ fn heuristics_wildcard_test_with_two_static_wildcards_with_quiet_enabled(
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .arg("-q")
        .unwrap();

@@ -340,7 +336,7 @@ fn heuristics_wildcard_test_with_two_static_wildcards_and_output_to_file(
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .arg("--output")
        .arg(outfile.as_os_str())
        .unwrap();
@@ -406,7 +402,7 @@ fn heuristics_wildcard_test_with_redirect_as_response_code(
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("--addslash")
+        .arg("--add-slash")
        .arg("--output")
        .arg(outfile.as_os_str())
        .unwrap();
--- a/tests/test_main.rs
+++ b/tests/test_main.rs
@@ -25,10 +25,8 @@ fn main_use_root_owned_file_as_wordlist() -> Result<(), Box<dyn std::error::Erro
        .arg("/etc/shadow")
        .arg("-vvvv")
        .assert()
-        .success()
-        .stderr(predicate::str::contains(
-            "ERROR main::get_unique_words_from_wordlist Permission denied (os error 13)",
-        ));
+        .failure()
+        .stdout(predicate::str::contains("Permission denied (os error 13)"));

    // connectivity test hits it once
    assert_eq!(mock.times_called(), 1);
@@ -57,9 +55,7 @@ fn main_use_empty_wordlist() -> Result<(), Box<dyn std::error::Error>> {
        .arg("-vvvv")
        .assert()
        .failure()
-        .stderr(predicate::str::contains(
-            "ERROR main::scan Did not find any words in",
-        ));
+        .stdout(predicate::str::contains("Did not find any words in"));

    assert_eq!(mock.times_called(), 1);

@@ -83,11 +79,9 @@ fn main_use_empty_stdin_targets() -> Result<(), Box<dyn std::error::Error>> {
        .pipe_stdin(file)
        .unwrap()
        .assert()
-        .failure()
+        .success()
        .stderr(
            predicate::str::contains("Could not connect to any target provided")
-                .and(predicate::str::contains("ERROR"))
-                .and(predicate::str::contains("heuristics::connectivity_test"))
                .and(predicate::str::contains("Target Url"))
                .not(), // no target url found
        );
--- a/tests/test_scanner.rs
+++ b/tests/test_scanner.rs
@@ -327,7 +327,8 @@ fn scanner_single_request_quiet_scan() -> Result<(), Box<dyn std::error::Error>>
 }

 #[test]
-/// send single valid request, get back a 301 without a Location header, expect false
+/// send single valid request, get back a 301 without a Location header
+/// expect response_is_directory to return false when called
 fn scanner_single_request_returns_301_without_location_header(
 ) -> Result<(), Box<dyn std::error::Error>> {
    let srv = MockServer::start();
@@ -336,6 +337,7 @@ fn scanner_single_request_returns_301_without_location_header(
    let mock = Mock::new()
        .expect_method(GET)
        .expect_path("/LICENSE")
+        .return_body("this is a test")
        .return_status(301)
        .create_on(&srv);

@@ -345,17 +347,16 @@ fn scanner_single_request_returns_301_without_location_header(
        .arg(srv.url("/"))
        .arg("--wordlist")
        .arg(file.as_os_str())
-        .arg("-T")
+        .arg("--timeout")
        .arg("5")
-        .arg("-a")
+        .arg("--user-agent")
        .arg("some-user-agent-string")
        .unwrap();

    cmd.assert().success().stdout(
        predicate::str::contains(srv.url("/LICENSE"))
            .and(predicate::str::contains("301"))
-            .and(predicate::str::contains("14"))
-            .not(),
+            .and(predicate::str::contains("14")),
    );

    assert_eq!(mock.times_called(), 1);
@@ -401,7 +402,7 @@ fn scanner_single_request_scan_with_filtered_result() -> Result<(), Box<dyn std:
            .and(predicate::str::contains("20"))
            .and(predicate::str::contains("ignored"))
            .not()
-            .and(predicate::str::contains("14"))
+            .and(predicate::str::contains(" 14 "))
            .not(),
    );

@@ -410,3 +411,52 @@ fn scanner_single_request_scan_with_filtered_result() -> Result<(), Box<dyn std:
    teardown_tmp_directory(tmp_dir);
    Ok(())
 }
+
+#[test]
+/// send a single valid request, expect a 200 response that then gets routed to the replay
+/// proxy
+fn scanner_single_request_replayed_to_proxy() -> Result<(), Box<dyn std::error::Error>> {
+    let srv = MockServer::start();
+    let proxy = MockServer::start();
+    let (tmp_dir, file) = setup_tmp_directory(&["LICENSE".to_string()], "wordlist")?;
+
+    let mock = Mock::new()
+        .expect_method(GET)
+        .expect_path("/LICENSE")
+        .return_status(200)
+        .return_body("this is a test")
+        .create_on(&srv);
+
+    let mock_two = Mock::new()
+        .expect_method(GET)
+        .expect_path("/LICENSE")
+        .return_status(200)
+        .return_body("this is a test")
+        .create_on(&proxy);
+
+    let cmd = Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg(srv.url("/"))
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("--replay-proxy")
+        .arg(format!("http://{}", proxy.address().to_string()))
+        .arg("--replay-codes")
+        .arg("200")
+        .unwrap();
+
+    cmd.assert()
+        .success()
+        .stdout(
+            predicate::str::contains("/LICENSE")
+                .and(predicate::str::contains("200"))
+                .and(predicate::str::contains("14")),
+        )
+        .stderr(predicate::str::contains("Replay Proxy Codes"));
+
+    assert_eq!(mock.times_called(), 1);
+    assert_eq!(mock_two.times_called(), 1);
+    teardown_tmp_directory(tmp_dir);
+    Ok(())
+}
Author	SHA1	Message	Date
epi	20938dd544	Merge pull request #120 from epi052/fix-directory-extraction-bug Fix directory extraction bug	2020-11-11 07:13:35 -06:00
epi	d63d7dc078	fixed bug found by flangyver	2020-11-11 06:59:50 -06:00
epi	5e7be449d0	fixed bug found by flangyver	2020-11-11 06:59:09 -06:00
epi	c8775e3c8c	excluded rlimit usage from windows build	2020-11-07 16:11:39 -06:00
epi	427efdef3b	excluded rlimit usage from windows build	2020-11-07 15:29:05 -06:00
epi	45815ff796	Merge pull request #118 from epi052/85-automatically-adjust-nofile-limit added auto-adjustment of open file limit	2020-11-07 15:17:07 -06:00
epi	0dbc3bee23	added auto-adjustment of open file limit	2020-11-07 15:05:07 -06:00
epi	9e143d9f19	bumped version to 1.5.1	2020-11-07 11:35:06 -06:00
epi	bd2bd2035c	Merge pull request #117 from epi052/114-fix-extract-links-reporting Fix handling of urls found in wordlists	2020-11-07 11:33:59 -06:00
epi	6e71f4e039	fixed issue with 2 urls being joined	2020-11-07 11:24:49 -06:00
epi	f5229a1ddd	fixed issue with 2 urls being joined	2020-11-07 11:24:11 -06:00
epi	d4eae2af8b	Merge pull request #110 from epi052/FEATURE-105-add-replay-proxy added replay-proxy option	2020-11-07 05:48:24 -06:00
epi	ae3b837e81	updated emoji comment in banner	2020-11-06 05:49:23 -06:00
epi	20fbb2f68d	removed cruft	2020-11-06 05:44:51 -06:00
epi	2ddcf4249f	nitpickery in the banner	2020-11-06 05:41:33 -06:00
epi	c975a7b82f	updated readme with gif	2020-11-06 05:14:42 -06:00
epi	43c1eb58ad	updated readme with replay proxy info	2020-11-05 20:53:21 -06:00
epi	2b94205f2a	Merge pull request #116 from epi052/FEATURE-105-add-replay-proxy--implement-feature implemented replay proxy	2020-11-05 20:08:04 -06:00
epi	15942e7a06	implemented replay proxy	2020-11-05 19:59:39 -06:00
epi	39f82816d8	Merge pull request #113 from epi052/FEATURE-105-add-replay-proxy--update-banner added replay options to banner and parser	2020-11-05 06:33:01 -06:00
epi	d39a2ab0f7	added comma to help	2020-11-05 06:31:08 -06:00
epi	095edc0804	combined replay logic in banner	2020-11-05 06:29:10 -06:00
epi	7d70126eea	combined replay logic in banner	2020-11-05 06:28:33 -06:00
epi	b09e8d078a	added replay options to banner and parser	2020-11-05 06:05:33 -06:00
epi	47d4221ada	Merge pull request #111 from epi052/FEATURE-105-add-replay-proxy--update-config added replay_[codes,proxy,client] to config.rs; added examples to fer…	2020-11-04 14:49:00 -06:00
epi	4578630b13	broke out reused code into helper function	2020-11-04 12:56:59 -06:00
epi	c4f018a757	added replay_[codes,proxy,client] to config.rs; added examples to ferox-config.toml.example	2020-11-04 07:36:20 -06:00
epi	49462df2fa	bumped version to 1.5.0	2020-11-04 07:01:24 -06:00
epi	0898914d19	Merge pull request #109 from epi052/106-notify-users-of-bad-certs logging initialized early enough to display all intended log messages	2020-11-03 12:54:28 -06:00
epi	d97d2714ce	fixed comments from review	2020-11-03 12:46:21 -06:00
epi	c1bbd10f51	fixed failing test	2020-11-03 11:26:30 -06:00
epi	cda1628aa6	logging initialized early enough to display all intended log messages	2020-11-03 10:44:55 -06:00
epi	9e08766c07	Merge pull request #104 from epi052/FEATURE-add-pause-resume-functionality add pause\|resume feature	2020-11-01 19:07:19 -06:00
epi	b1e4c3fd6f	changed banner color from crossterm to console	2020-11-01 19:04:18 -06:00
epi	08abb044e3	cargo fmt on scanner.rs	2020-11-01 19:00:19 -06:00
epi	bc4893970d	updated README with pause\|resume	2020-11-01 18:56:07 -06:00
epi	fae6f96f3a	updated tests	2020-11-01 14:48:30 -06:00
epi	a627841058	added tests for pause_scan	2020-11-01 10:10:27 -06:00
epi	b5c640cc4f	added tests for pause_scan	2020-11-01 10:09:40 -06:00
epi	5285f22dae	added test for get_single_spinner	2020-11-01 09:52:18 -06:00
epi	96a4fb1139	added message about how to pause to banner	2020-11-01 09:47:09 -06:00
epi	95aca72670	added default to terminal input polling	2020-11-01 07:45:18 -06:00
epi	39f8f38204	implemented pause\|resume functionality	2020-11-01 07:35:16 -06:00
epi	db5509cb52	bumped version to 1.4.0	2020-10-31 09:11:43 -05:00
epi	231752194f	Merge pull request #100 from epi052/FEATURE-response-code-blacklist Feature response code blacklist	2020-10-31 06:59:11 -05:00
epi	f64f02135e	moved dont_filter from scanner to WildcardFilter	2020-10-31 06:54:19 -05:00
epi	db5e1e2e2d	gif was out of place	2020-10-30 07:18:48 -05:00
epi	f649da359f	updated readme to reflect 1.3.0 changes	2020-10-30 07:17:10 -05:00
epi	6e981e6d3a	added whitespace around response size; server port number can clash with size	2020-10-30 05:58:17 -05:00
epi	12b46a44e1	Merge pull request #102 from epi052/FEATURE-response-code-blacklist--implement-blacklist implemented deny list	2020-10-30 05:46:32 -05:00
epi	e35f86876d	fixed oddly failing tests /shrug	2020-10-30 05:26:16 -05:00
epi	6fe5ae0d0c	added integration test for status code filter	2020-10-30 05:19:38 -05:00
epi	dc89f3b5aa	implemented deny list	2020-10-29 20:58:44 -05:00
epi	5918554754	Merge pull request #101 from epi052/FEATURE-response-code-blacklist--add-option-to-parser added --filter-status option	2020-10-29 20:35:08 -05:00
epi	39241594ae	added status code filter option to banner and config	2020-10-29 20:22:39 -05:00
epi	665564bbfe	refactored long option names	2020-10-29 16:17:50 -05:00
epi	ffed3820a5	Merge pull request #99 from epi052/FEATURE-response-code-blacklist--filter-trait Added new filter system to allow for extending with different filter types	2020-10-29 06:34:13 -05:00
epi	254f502ed3	removed lint from scanner	2020-10-29 06:33:21 -05:00
epi	d3ddefa0b7	removed lint and dead code from scanner	2020-10-29 06:13:25 -05:00
epi	acf16c92cd	removed lint from heuristics	2020-10-29 06:11:07 -05:00
epi	2d67336b86	new filter system appears to work	2020-10-29 06:05:25 -05:00
epi	9db0dc505b	updated emoji font to 13.1 after building from github source	2020-10-25 11:35:00 -05:00
epi	702cc8f18e	updated README	2020-10-25 10:57:27 -05:00
epi	737d347121	added terminal width FAQ to README	2020-10-25 10:44:21 -05:00
epi	a4b7a8a8e6	updated nix install script	2020-10-25 07:58:51 -05:00
epi	afacb13787	install script for nix now adds emoji font	2020-10-25 07:38:48 -05:00
epi	610379c6a9	renamed install script, updated README	2020-10-25 07:18:52 -05:00
epi	1bb132f157	added install script	2020-10-25 07:15:07 -05:00
epi	c9601d4fe9	updated README	2020-10-25 06:42:10 -05:00
epi	fae404ff9a	fixed link in README	2020-10-25 06:40:11 -05:00
epi	ab5ff1b2e0	updated README with some gifs	2020-10-25 06:38:22 -05:00
epi	045719b25a	Merge pull request #96 from epi052/FEATURE-limit-number-of-scans Added ability to limit number of scans	2020-10-25 05:29:24 -05:00
epi	154d8ae408	updated README	2020-10-24 21:10:49 -05:00
epi	8bebc7b81d	Merge pull request #97 from epi052/FEATURE-limit-number-of-scans--implement-scan-limiter implemented scan limiting	2020-10-24 20:54:39 -05:00
epi	204b90e1fa	implemented scan limiter	2020-10-24 20:44:27 -05:00
epi	6ceba1170f	reverted last change	2020-10-24 18:45:19 -05:00
epi	6f7e4564e7	changed scan_limit type to atomic	2020-10-24 16:42:14 -05:00
epi	e8041df0cd	Merge pull request #95 from epi052/FEATURE-limit-number-of-scans--add-cli-option added --scan-limit option	2020-10-24 16:09:46 -05:00
epi	1c364b0a21	added --scan-limit option	2020-10-24 15:59:53 -05:00
epi	6caa6b864c	bumped version to 1.1.2	2020-10-24 12:56:19 -05:00