Merge pull request #157 from epi052/dependabot/add-v2-config-file

Create Dependabot config file

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 21
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "feroxbuster"
-version = "1.9.1"
+version = "1.10.0"
 authors = ["Ben 'epi' Risher <epibar052@gmail.com>"]
 license = "MIT"
 edition = "2018"
@@ -16,7 +16,9 @@ build = "build.rs"
 maintenance = { status = "actively-developed" }
 
 [build-dependencies]
-clap = "2"
+clap = "2.33"
+regex = "1"
+lazy_static = "1.4"
 
 [dependencies]
 futures = { version = "0.3"}
@@ -25,7 +27,7 @@ tokio-util = {version = "0.3", features = ["codec"]}
 log = "0.4"
 env_logger = "0.8"
 reqwest = { version = "0.10", features = ["socks"] }
-clap = "2"
+clap = "2.33"
 lazy_static = "1.4"
 toml = "0.5"
 serde = { version = "1.0", features = ["derive"] }

README.md

@@ -85,8 +85,10 @@ This attack is also known as Predictable Resource Location, File Enumeration, Di
     - [Filter Response by Status Code  (new in `v1.3.0`)](#filter-response-by-status-code--new-in-v130)
     - [Pause an Active Scan (new in `v1.4.0`)](#pause-an-active-scan-new-in-v140)
     - [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)
+    - [Filter Response by Word Count & Line Count  (new in `v1.6.0`)](#filter-response-by-word-count--line-count--new-in-v160)
     - [Filter Response Using a Regular Expression (new in `v1.8.0`)](#filter-response-using-a-regular-expression-new-in-v180)
     - [Stop and Resume Scans (save scan's state to disk) (new in `v1.9.0`)](#stop-and-resume-scans---resume-from-file-new-in-v190)
+    - [Enforce a Time Limit on Your Scan (new in `v1.10.0`)](#enforce-a-time-limit-on-your-scan-new-in-v1100)
 - [Comparison w/ Similar Tools](#-comparison-w-similar-tools)
 - [Common Problems/Issues (FAQ)](#-common-problemsissues-faq)
     - [No file descriptors available](#no-file-descriptors-available)
@@ -351,6 +353,7 @@ A pre-made configuration file with examples of all available settings can be fou
 # filter_line_count = [35, 36]
 # queries = [["name","value"], ["rick", "astley"]]
 # save_state = false
+# time_limit = 10m
 
 # headers can be specified on multiple lines or as an inline table
 #
@@ -403,8 +406,8 @@ OPTIONS:
     -o, --output <FILE>                     Output file to write results to (use w/ --json for JSON entries)
     -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)
-    -R, --replay-codes <REPLAY_CODE>...     Status Codes to send through a Replay Proxy when found (default: --status
-                                            -codes value)
+    -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
         --resume-from <STATE_FILE>          State file from which to resume a partially complete scan (ex. --resume-from
@@ -413,6 +416,7 @@ OPTIONS:
     -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)
+        --time-limit <TIME_SPEC>            Limit total run time of all scans (ex: --time-limit 10m)
     -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, --user-agent <USER_AGENT>           Sets the User-Agent (default: feroxbuster/VERSION)
@@ -541,6 +545,22 @@ Of note: this means that for every response that matches your replay criteria, y
 
 ![replay-proxy-demo](img/replay-proxy-demo.gif)
 
+### Filter Response by Word Count & Line Count  (new in `v1.6.0`)
+
+In addition to filtering on the size of a response, version 1.6.0 added the ability to filter out responses based on the number of lines and/or words contained within the response body.  This change drove a change to the information displayed to the user as well. This section will detail the new information and how to make use of it with the new filters provided.
+
+Example output:
+```
+200        10l        212w       38437c https://example-site.com/index.html
+```
+
+There are five columns of output above:
+- column 1: status code - can be filtered with `-C|--filter-status`
+- column 2: number of lines - can be filtered with `-N|--filter-lines`
+- column 3: number of words - can be filtered with `-W|--filter-words`
+- column 4: number of bytes (overall size) - can be filtered with `-S|--filter-size`
+- column 5: url to discovered resource
+
 ### Filter Response Using a Regular Expression (new in `v1.8.0`) 
 
 Version 1.3.0 included an overhaul to the filtering system which will allow for a wide array of filters to be added 
@@ -615,6 +635,20 @@ In order to prevent state file creation when `Ctrl+C` is pressed, you can simply
 save_state = false
 ```
 
+### Enforce a Time Limit on Your Scan (new in `v1.10.0`)
+
+Version 1.10.0 adds the ability to set a maximum runtime, or time limit, on your scan.  The usage is pretty simple: a number followed directly by a single character representing seconds, minutes, hours, or days.  `feroxbuster` refers to this combination as a time_spec.  
+
+Examples of possible time_specs:
+- `30s` - 30 seconds
+- `20m` - 20 minutes
+- `1h`  - 1 hour
+- `1d`  - 1 day (why??)
+
+A valid time_spec can be passed to `--time-limit` in order to force a shutdown after the given time has elapsed.
+
+![time-limit](img/time-limit.gif)
+
 ## 🧐 Comparison w/ Similar Tools
 
 There are quite a few similar tools for forced browsing/content discovery.  Burp Suite Pro, Dirb, Dirbuster, etc... 
@@ -633,24 +667,32 @@ a few of the use-cases in which feroxbuster may be a better fit:
 - You want **recursion** along with some other thing mentioned above (ffuf also does recursion)
 - You want a **configuration file** option for overriding built-in default values for your scans
 
-|                                                                  | feroxbuster | gobuster | ffuf |
-|------------------------------------------------------------------|---|---|---|
-| fast                                                             | ✔ | ✔ | ✔ |
-| easy to use                                                      | ✔ | ✔ |   |
-| filter out responses by status code (new in `v1.3.0`)            | ✔ | ✔ | ✔ |
-| allows recursion                                                 | ✔ |   | ✔ |
-| can specify query parameters                                     | ✔ |   | ✔ |
-| SOCKS proxy support                                              | ✔ |   |   |
-| extracts links from response body to increase scan coverage      | ✔ |   |   |
-| multiple target scan (via stdin or multiple -u)                  | ✔ |   | ✔ |
-| configuration file for default value override                    | ✔ |   | ✔ |
-| can accept urls via STDIN as part of a pipeline                  | ✔ |   | ✔ |
-| can accept wordlists via STDIN                                   |   | ✔ | ✔ |
-| filter based on response size, wordcount, and linecount          | ✔ |   | ✔ |
-| auto-filter wildcard responses                                   | ✔ |   | ✔ |
-| performs other scans (vhost, dns, etc)                           |   | ✔ | ✔ |
-| time delay / rate limiting                                       |   | ✔ | ✔ |
-| **huge** number of other options                                 |   |   | ✔ |
+|                                                          | feroxbuster | gobuster | ffuf |
+|------------------------------------------------------------------------------|---|---|---|
+| fast                                                                         | ✔ | ✔ | ✔ |
+| easy to use                                                                  | ✔ | ✔ |   |
+| allows recursion                                                             | ✔ |   | ✔ |
+| can specify query parameters                                                 | ✔ |   | ✔ |
+| SOCKS proxy support                                                          | ✔ |   |   |
+| multiple target scan (via stdin or multiple -u)                              | ✔ |   | ✔ |
+| configuration file for default value override                                | ✔ |   | ✔ |
+| can accept urls via STDIN as part of a pipeline                              | ✔ |   | ✔ |
+| can accept wordlists via STDIN                                               |   | ✔ | ✔ |
+| filter based on response size, wordcount, and linecount                      | ✔ |   | ✔ |
+| auto-filter wildcard responses                                               | ✔ |   | ✔ |
+| performs other scans (vhost, dns, etc)                                       |   | ✔ | ✔ |
+| time delay / rate limiting                                                   |   | ✔ | ✔ |
+| extracts links from response body to increase scan coverage (`v1.1.0`)       | ✔ |   |   |
+| limit number of concurrent recursive scans (`v1.2.0`)                        | ✔ |   |   |
+| filter out responses by status code (`v1.3.0`)                               | ✔ | ✔ | ✔ |
+| interactive pause and resume of active scan (`v1.4.0`)                       | ✔ |   |   |
+| replay only matched requests to a proxy (`v1.5.0`)                           | ✔ |   | ✔ |
+| filter out responses by line & word count (`v1.6.0`)                         | ✔ |   | ✔ |
+| json output (ffuf supports other formats as well) (`v1.7.0`)                 | ✔ |   | ✔ |
+| filter out responses by regular expression (`v1.8.0`)                        | ✔ |   | ✔ |
+| save scan's state to disk (can pick up where it left off) (`v1.9.0`)         | ✔ |   |   |
+| maximum run time limit (`v1.10.0`)                                           | ✔ |   | ✔ |
+| **huge** number of other options                                             |   |   | ✔ |
 
 Of note, there's another written-in-rust content discovery tool, [rustbuster](https://github.com/phra/rustbuster). I 
 came across rustbuster when I was naming my tool (😢). I don't have any experience using it, but it appears to 
@@ -736,4 +778,8 @@ sudo sysctl net.ipv4.tcp_tw_reuse=1
 ![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.
+consider using `-q` to suppress the progress bars.
+
+### What do each of the numbers beside the URL mean?
+
+Please refer to [this section](#filter-response-by-word-count--line-count--new-in-v160) where each number's meaning and how to use it to filter responses is discussed.

ferox-config.toml.example

@@ -37,6 +37,7 @@
 # filter_line_count = [35, 36]
 # queries = [["name","value"], ["rick", "astley"]]
 # save_state = false
+# time_limit = "10m"
 
 # headers can be specified on multiple lines or as an inline table
 #

shell_completions/_feroxbuster

@@ -1,53 +1,63 @@
 #compdef feroxbuster
 
+autoload -U is-at-least
+
 _feroxbuster() {
     typeset -A opt_args
+    typeset -a _arguments_options
     local ret=1
 
+    if is-at-least 5.2; then
+        _arguments_options=(-s -S -C)
+    else
+        _arguments_options=(-s -C)
+    fi
+
     local context curcontext="$curcontext" state line
-    _arguments -s -S -C \
+    _arguments "${_arguments_options[@]}" \
 '-w+[Path to the wordlist]' \
-'--wordlist+[Path to the wordlist]' \
+'--wordlist=[Path to the wordlist]' \
 '*-u+[The target URL(s) (required, unless --stdin used)]' \
-'*--url+[The target URL(s) (required, unless --stdin used)]' \
+'*--url=[The target URL(s) (required, unless --stdin used)]' \
 '-t+[Number of concurrent threads (default: 50)]' \
-'--threads+[Number of concurrent threads (default: 50)]' \
+'--threads=[Number of concurrent threads (default: 50)]' \
 '-d+[Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)]' \
-'--depth+[Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)]' \
+'--depth=[Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)]' \
 '-T+[Number of seconds before a request times out (default: 7)]' \
-'--timeout+[Number of seconds before a request times out (default: 7)]' \
+'--timeout=[Number of seconds before a request times out (default: 7)]' \
 '-p+[Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)]' \
-'--proxy+[Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)]' \
+'--proxy=[Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)]' \
 '-P+[Send only unfiltered requests through a Replay Proxy, instead of all requests]' \
-'--replay-proxy+[Send only unfiltered requests through a Replay Proxy, instead of all requests]' \
+'--replay-proxy=[Send only unfiltered requests through a Replay Proxy, instead of all requests]' \
 '*-R+[Status Codes to send through a Replay Proxy when found (default: --status-codes value)]' \
-'*--replay-codes+[Status Codes to send through a Replay Proxy when found (default: --status-codes value)]' \
+'*--replay-codes=[Status Codes to send through a Replay Proxy when found (default: --status-codes value)]' \
 '*-s+[Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)]' \
-'*--status-codes+[Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)]' \
+'*--status-codes=[Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)]' \
 '-o+[Output file to write results to (use w/ --json for JSON entries)]' \
-'--output+[Output file to write results to (use w/ --json for JSON entries)]' \
-'(-u --url)--resume-from+[State file from which to resume a partially complete scan (ex. --resume-from ferox-1606586780.state)]' \
-'--debug-log+[Output file to write log entries (use w/ --json for JSON entries)]' \
+'--output=[Output file to write results to (use w/ --json for JSON entries)]' \
+'(-u --url)--resume-from=[State file from which to resume a partially complete scan (ex. --resume-from ferox-1606586780.state)]' \
+'--debug-log=[Output file to write log entries (use w/ --json for JSON entries)]' \
 '-a+[Sets the User-Agent (default: feroxbuster/VERSION)]' \
-'--user-agent+[Sets the User-Agent (default: feroxbuster/VERSION)]' \
+'--user-agent=[Sets the User-Agent (default: feroxbuster/VERSION)]' \
 '*-x+[File extension(s) to search for (ex: -x php -x pdf js)]' \
-'*--extensions+[File extension(s) to search for (ex: -x php -x pdf js)]' \
+'*--extensions=[File extension(s) to search for (ex: -x php -x pdf js)]' \
 '*-H+[Specify HTTP headers (ex: -H Header:val '\''stuff: things'\'')]' \
-'*--headers+[Specify HTTP headers (ex: -H Header:val '\''stuff: things'\'')]' \
+'*--headers=[Specify HTTP headers (ex: -H Header:val '\''stuff: things'\'')]' \
 '*-Q+[Specify URL query parameters (ex: -Q token=stuff -Q secret=key)]' \
-'*--query+[Specify URL query parameters (ex: -Q token=stuff -Q secret=key)]' \
+'*--query=[Specify URL query parameters (ex: -Q token=stuff -Q secret=key)]' \
 '*-S+[Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)]' \
-'*--filter-size+[Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)]' \
+'*--filter-size=[Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)]' \
 '*-X+[Filter out messages via regular expression matching on the response'\''s body (ex: -X '\''^ignore me$'\'')]' \
-'*--filter-regex+[Filter out messages via regular expression matching on the response'\''s body (ex: -X '\''^ignore me$'\'')]' \
+'*--filter-regex=[Filter out messages via regular expression matching on the response'\''s body (ex: -X '\''^ignore me$'\'')]' \
 '*-W+[Filter out messages of a particular word count (ex: -W 312 -W 91,82)]' \
-'*--filter-words+[Filter out messages of a particular word count (ex: -W 312 -W 91,82)]' \
+'*--filter-words=[Filter out messages of a particular word count (ex: -W 312 -W 91,82)]' \
 '*-N+[Filter out messages of a particular line count (ex: -N 20 -N 31,30)]' \
-'*--filter-lines+[Filter out messages of a particular line count (ex: -N 20 -N 31,30)]' \
+'*--filter-lines=[Filter out messages of a particular line count (ex: -N 20 -N 31,30)]' \
 '*-C+[Filter out status codes (deny list) (ex: -C 200 -C 401)]' \
-'*--filter-status+[Filter out status codes (deny list) (ex: -C 200 -C 401)]' \
+'*--filter-status=[Filter out status codes (deny list) (ex: -C 200 -C 401)]' \
 '-L+[Limit total number of concurrent scans (default: 0, i.e. no limit)]' \
-'--scan-limit+[Limit total number of concurrent scans (default: 0, i.e. no limit)]' \
+'--scan-limit=[Limit total number of concurrent scans (default: 0, i.e. no limit)]' \
+'--time-limit=[Limit total run time of all scans (ex: --time-limit 10m)]' \
 '*-v[Increase verbosity level (use -vv or more for greater effect. \[CAUTION\] 4 -v'\''s is probably too much)]' \
 '*--verbosity[Increase verbosity level (use -vv or more for greater effect. \[CAUTION\] 4 -v'\''s is probably too much)]' \
 '-q[Only print URLs; Don'\''t print status codes, response size, running config, etc...]' \
@@ -74,13 +84,6 @@ _feroxbuster() {
     
 }
 
-(( $+functions[_feroxbuster_commands] )) ||
-_feroxbuster_commands() {
-    local commands; commands=(
-        
-    )
-    _describe -t commands 'feroxbuster commands' commands "$@"
-}
 (( $+functions[_feroxbuster_commands] )) ||
 _feroxbuster_commands() {
     local commands; commands=(

shell_completions/_feroxbuster.ps1

@@ -1,38 +1,94 @@
 
-@('feroxbuster', './feroxbuster') | %{
-    Register-ArgumentCompleter -Native -CommandName $_ -ScriptBlock {
-        param($wordToComplete, $commandAst, $cursorPosition)
+using namespace System.Management.Automation
+using namespace System.Management.Automation.Language
 
-        $command = '_feroxbuster'
-        $commandAst.CommandElements |
-            Select-Object -Skip 1 |
-            %{
-                switch ($_.ToString()) {
-
-                    'feroxbuster' {
-                        $command += '_feroxbuster'
-                        break
-                    }
-
-                    default { 
-                        break
-                    }
-                }
-            }
-
-        $completions = @()
-
-        switch ($command) {
-
-            '_feroxbuster' {
-                $completions = @('-v', '-q', '-D', '-r', '-k', '-n', '-f', '-e', '-h', '-V', '-w', '-u', '-t', '-d', '-T', '-p', '-P', '-R', '-s', '-o', '-a', '-x', '-H', '-Q', '-S', '-X', '-W', '-N', '-C', '-L', '--verbosity', '--quiet', '--json', '--dont-filter', '--redirects', '--insecure', '--no-recursion', '--add-slash', '--stdin', '--extract-links', '--help', '--version', '--wordlist', '--url', '--threads', '--depth', '--timeout', '--proxy', '--replay-proxy', '--replay-codes', '--status-codes', '--output', '--resume-from', '--debug-log', '--user-agent', '--extensions', '--headers', '--query', '--filter-size', '--filter-regex', '--filter-words', '--filter-lines', '--filter-status', '--scan-limit')
-            }
+Register-ArgumentCompleter -Native -CommandName 'feroxbuster' -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
 
+    $commandElements = $commandAst.CommandElements
+    $command = @(
+        'feroxbuster'
+        for ($i = 1; $i -lt $commandElements.Count; $i++) {
+            $element = $commandElements[$i]
+            if ($element -isnot [StringConstantExpressionAst] -or
+                $element.StringConstantType -ne [StringConstantType]::BareWord -or
+                $element.Value.StartsWith('-')) {
+                break
         }
+        $element.Value
+    }) -join ';'
 
-        $completions |
-            ?{ $_ -like "$wordToComplete*" } |
-            Sort-Object |
-            %{ New-Object System.Management.Automation.CompletionResult $_, $_, 'ParameterValue', $_ }
-    }
+    $completions = @(switch ($command) {
+        'feroxbuster' {
+            [CompletionResult]::new('-w', 'w', [CompletionResultType]::ParameterName, 'Path to the wordlist')
+            [CompletionResult]::new('--wordlist', 'wordlist', [CompletionResultType]::ParameterName, 'Path to the wordlist')
+            [CompletionResult]::new('-u', 'u', [CompletionResultType]::ParameterName, 'The target URL(s) (required, unless --stdin used)')
+            [CompletionResult]::new('--url', 'url', [CompletionResultType]::ParameterName, 'The target URL(s) (required, unless --stdin used)')
+            [CompletionResult]::new('-t', 't', [CompletionResultType]::ParameterName, 'Number of concurrent threads (default: 50)')
+            [CompletionResult]::new('--threads', 'threads', [CompletionResultType]::ParameterName, 'Number of concurrent threads (default: 50)')
+            [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)')
+            [CompletionResult]::new('--depth', 'depth', [CompletionResultType]::ParameterName, 'Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)')
+            [CompletionResult]::new('-T', 'T', [CompletionResultType]::ParameterName, 'Number of seconds before a request times out (default: 7)')
+            [CompletionResult]::new('--timeout', 'timeout', [CompletionResultType]::ParameterName, 'Number of seconds before a request times out (default: 7)')
+            [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)')
+            [CompletionResult]::new('--proxy', 'proxy', [CompletionResultType]::ParameterName, 'Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)')
+            [CompletionResult]::new('-P', 'P', [CompletionResultType]::ParameterName, 'Send only unfiltered requests through a Replay Proxy, instead of all requests')
+            [CompletionResult]::new('--replay-proxy', 'replay-proxy', [CompletionResultType]::ParameterName, 'Send only unfiltered requests through a Replay Proxy, instead of all requests')
+            [CompletionResult]::new('-R', 'R', [CompletionResultType]::ParameterName, 'Status Codes to send through a Replay Proxy when found (default: --status-codes value)')
+            [CompletionResult]::new('--replay-codes', 'replay-codes', [CompletionResultType]::ParameterName, 'Status Codes to send through a Replay Proxy when found (default: --status-codes value)')
+            [CompletionResult]::new('-s', 's', [CompletionResultType]::ParameterName, 'Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)')
+            [CompletionResult]::new('--status-codes', 'status-codes', [CompletionResultType]::ParameterName, 'Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)')
+            [CompletionResult]::new('-o', 'o', [CompletionResultType]::ParameterName, 'Output file to write results to (use w/ --json for JSON entries)')
+            [CompletionResult]::new('--output', 'output', [CompletionResultType]::ParameterName, 'Output file to write results to (use w/ --json for JSON entries)')
+            [CompletionResult]::new('--resume-from', 'resume-from', [CompletionResultType]::ParameterName, 'State file from which to resume a partially complete scan (ex. --resume-from ferox-1606586780.state)')
+            [CompletionResult]::new('--debug-log', 'debug-log', [CompletionResultType]::ParameterName, 'Output file to write log entries (use w/ --json for JSON entries)')
+            [CompletionResult]::new('-a', 'a', [CompletionResultType]::ParameterName, 'Sets the User-Agent (default: feroxbuster/VERSION)')
+            [CompletionResult]::new('--user-agent', 'user-agent', [CompletionResultType]::ParameterName, 'Sets the User-Agent (default: feroxbuster/VERSION)')
+            [CompletionResult]::new('-x', 'x', [CompletionResultType]::ParameterName, 'File extension(s) to search for (ex: -x php -x pdf js)')
+            [CompletionResult]::new('--extensions', 'extensions', [CompletionResultType]::ParameterName, 'File extension(s) to search for (ex: -x php -x pdf js)')
+            [CompletionResult]::new('-H', 'H', [CompletionResultType]::ParameterName, 'Specify HTTP headers (ex: -H Header:val ''stuff: things'')')
+            [CompletionResult]::new('--headers', 'headers', [CompletionResultType]::ParameterName, 'Specify HTTP headers (ex: -H Header:val ''stuff: things'')')
+            [CompletionResult]::new('-Q', 'Q', [CompletionResultType]::ParameterName, 'Specify URL query parameters (ex: -Q token=stuff -Q secret=key)')
+            [CompletionResult]::new('--query', 'query', [CompletionResultType]::ParameterName, 'Specify URL query parameters (ex: -Q token=stuff -Q secret=key)')
+            [CompletionResult]::new('-S', 'S', [CompletionResultType]::ParameterName, 'Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)')
+            [CompletionResult]::new('--filter-size', 'filter-size', [CompletionResultType]::ParameterName, 'Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)')
+            [CompletionResult]::new('-X', 'X', [CompletionResultType]::ParameterName, 'Filter out messages via regular expression matching on the response''s body (ex: -X ''^ignore me$'')')
+            [CompletionResult]::new('--filter-regex', 'filter-regex', [CompletionResultType]::ParameterName, 'Filter out messages via regular expression matching on the response''s body (ex: -X ''^ignore me$'')')
+            [CompletionResult]::new('-W', 'W', [CompletionResultType]::ParameterName, 'Filter out messages of a particular word count (ex: -W 312 -W 91,82)')
+            [CompletionResult]::new('--filter-words', 'filter-words', [CompletionResultType]::ParameterName, 'Filter out messages of a particular word count (ex: -W 312 -W 91,82)')
+            [CompletionResult]::new('-N', 'N', [CompletionResultType]::ParameterName, 'Filter out messages of a particular line count (ex: -N 20 -N 31,30)')
+            [CompletionResult]::new('--filter-lines', 'filter-lines', [CompletionResultType]::ParameterName, 'Filter out messages of a particular line count (ex: -N 20 -N 31,30)')
+            [CompletionResult]::new('-C', 'C', [CompletionResultType]::ParameterName, 'Filter out status codes (deny list) (ex: -C 200 -C 401)')
+            [CompletionResult]::new('--filter-status', 'filter-status', [CompletionResultType]::ParameterName, 'Filter out status codes (deny list) (ex: -C 200 -C 401)')
+            [CompletionResult]::new('-L', 'L', [CompletionResultType]::ParameterName, 'Limit total number of concurrent scans (default: 0, i.e. no limit)')
+            [CompletionResult]::new('--scan-limit', 'scan-limit', [CompletionResultType]::ParameterName, 'Limit total number of concurrent scans (default: 0, i.e. no limit)')
+            [CompletionResult]::new('--time-limit', 'time-limit', [CompletionResultType]::ParameterName, 'Limit total run time of all scans (ex: --time-limit 10m)')
+            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'Increase verbosity level (use -vv or more for greater effect. [CAUTION] 4 -v''s is probably too much)')
+            [CompletionResult]::new('--verbosity', 'verbosity', [CompletionResultType]::ParameterName, 'Increase verbosity level (use -vv or more for greater effect. [CAUTION] 4 -v''s is probably too much)')
+            [CompletionResult]::new('-q', 'q', [CompletionResultType]::ParameterName, 'Only print URLs; Don''t print status codes, response size, running config, etc...')
+            [CompletionResult]::new('--quiet', 'quiet', [CompletionResultType]::ParameterName, 'Only print URLs; Don''t print status codes, response size, running config, etc...')
+            [CompletionResult]::new('--json', 'json', [CompletionResultType]::ParameterName, 'Emit JSON logs to --output and --debug-log instead of normal text')
+            [CompletionResult]::new('-D', 'D', [CompletionResultType]::ParameterName, 'Don''t auto-filter wildcard responses')
+            [CompletionResult]::new('--dont-filter', 'dont-filter', [CompletionResultType]::ParameterName, 'Don''t auto-filter wildcard responses')
+            [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Follow redirects')
+            [CompletionResult]::new('--redirects', 'redirects', [CompletionResultType]::ParameterName, 'Follow redirects')
+            [CompletionResult]::new('-k', 'k', [CompletionResultType]::ParameterName, 'Disables TLS certificate validation')
+            [CompletionResult]::new('--insecure', 'insecure', [CompletionResultType]::ParameterName, 'Disables TLS certificate validation')
+            [CompletionResult]::new('-n', 'n', [CompletionResultType]::ParameterName, 'Do not scan recursively')
+            [CompletionResult]::new('--no-recursion', 'no-recursion', [CompletionResultType]::ParameterName, 'Do not scan recursively')
+            [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'Append / to each request')
+            [CompletionResult]::new('--add-slash', 'add-slash', [CompletionResultType]::ParameterName, 'Append / to each request')
+            [CompletionResult]::new('--stdin', 'stdin', [CompletionResultType]::ParameterName, 'Read url(s) from STDIN')
+            [CompletionResult]::new('-e', 'e', [CompletionResultType]::ParameterName, 'Extract links from response body (html, javascript, etc...); make new requests based on findings (default: false)')
+            [CompletionResult]::new('--extract-links', 'extract-links', [CompletionResultType]::ParameterName, 'Extract links from response body (html, javascript, etc...); make new requests based on findings (default: false)')
+            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
+            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
+            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
+            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
+            break
+        }
+    })
+
+    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
+        Sort-Object -Property ListItemText
 }

shell_completions/feroxbuster.bash

@@ -13,9 +13,6 @@ _feroxbuster() {
                 cmd="feroxbuster"
                 ;;
             
-            feroxbuster)
-                cmd+="__feroxbuster"
-                ;;
             *)
                 ;;
         esac
@@ -23,186 +20,190 @@ _feroxbuster() {
 
     case "${cmd}" in
         feroxbuster)
-            opts=" -v -q -D -r -k -n -f -e -h -V -w -u -t -d -T -p -P -R -s -o -a -x -H -Q -S -X -W -N -C -L  --verbosity --quiet --json --dont-filter --redirects --insecure --no-recursion --add-slash --stdin --extract-links --help --version --wordlist --url --threads --depth --timeout --proxy --replay-proxy --replay-codes --status-codes --output --resume-from --debug-log --user-agent --extensions --headers --query --filter-size --filter-regex --filter-words --filter-lines --filter-status --scan-limit  "
+            opts=" -v -q -D -r -k -n -f -e -h -V -w -u -t -d -T -p -P -R -s -o -a -x -H -Q -S -X -W -N -C -L  --verbosity --quiet --json --dont-filter --redirects --insecure --no-recursion --add-slash --stdin --extract-links --help --version --wordlist --url --threads --depth --timeout --proxy --replay-proxy --replay-codes --status-codes --output --resume-from --debug-log --user-agent --extensions --headers --query --filter-size --filter-regex --filter-words --filter-lines --filter-status --scan-limit --time-limit  "
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
             fi
             case "${prev}" in
                 
                 --wordlist)
-                    COMPREPLY=("<FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -w)
-                    COMPREPLY=("<FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --url)
-                    COMPREPLY=("<URL>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -u)
-                    COMPREPLY=("<URL>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --threads)
-                    COMPREPLY=("<THREADS>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -t)
-                    COMPREPLY=("<THREADS>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --depth)
-                    COMPREPLY=("<RECURSION_DEPTH>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -d)
-                    COMPREPLY=("<RECURSION_DEPTH>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --timeout)
-                    COMPREPLY=("<SECONDS>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -T)
-                    COMPREPLY=("<SECONDS>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --proxy)
-                    COMPREPLY=("<PROXY>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -p)
-                    COMPREPLY=("<PROXY>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --replay-proxy)
-                    COMPREPLY=("<REPLAY_PROXY>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -P)
-                    COMPREPLY=("<REPLAY_PROXY>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --replay-codes)
-                    COMPREPLY=("<REPLAY_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -R)
-                    COMPREPLY=("<REPLAY_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --status-codes)
-                    COMPREPLY=("<STATUS_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -s)
-                    COMPREPLY=("<STATUS_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --output)
-                    COMPREPLY=("<FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -o)
-                    COMPREPLY=("<FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --resume-from)
-                    COMPREPLY=("<STATE_FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --debug-log)
-                    COMPREPLY=("<FILE>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --user-agent)
-                    COMPREPLY=("<USER_AGENT>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -a)
-                    COMPREPLY=("<USER_AGENT>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --extensions)
-                    COMPREPLY=("<FILE_EXTENSION>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -x)
-                    COMPREPLY=("<FILE_EXTENSION>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --headers)
-                    COMPREPLY=("<HEADER>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -H)
-                    COMPREPLY=("<HEADER>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --query)
-                    COMPREPLY=("<QUERY>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -Q)
-                    COMPREPLY=("<QUERY>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --filter-size)
-                    COMPREPLY=("<SIZE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -S)
-                    COMPREPLY=("<SIZE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --filter-regex)
-                    COMPREPLY=("<REGEX>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -X)
-                    COMPREPLY=("<REGEX>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --filter-words)
-                    COMPREPLY=("<WORDS>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -W)
-                    COMPREPLY=("<WORDS>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --filter-lines)
-                    COMPREPLY=("<LINES>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -N)
-                    COMPREPLY=("<LINES>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --filter-status)
-                    COMPREPLY=("<STATUS_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -C)
-                    COMPREPLY=("<STATUS_CODE>...")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 --scan-limit)
-                    COMPREPLY=("<SCAN_LIMIT>")
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                     -L)
-                    COMPREPLY=("<SCAN_LIMIT>")
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --time-limit)
+                    COMPREPLY=($(compgen -f "${cur}"))
                     return 0
                     ;;
                 *)
                     COMPREPLY=()
                     ;;
             esac
-            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
             return 0
             ;;
         

shell_completions/feroxbuster.fish

@@ -1,47 +1,35 @@
-function __fish_using_command
-    set cmd (commandline -opc)
-    if [ (count $cmd) -eq (count $argv) ]
-        for i in (seq (count $argv))
-            if [ $cmd[$i] != $argv[$i] ]
-                return 1
-            end
-        end
-        return 0
-    end
-    return 1
-end
-
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s w -l wordlist -d 'Path to the wordlist'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s u -l url -d 'The target URL(s) (required, unless --stdin used)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s t -l threads -d 'Number of concurrent threads (default: 50)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s d -l depth -d 'Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s T -l timeout -d 'Number of seconds before a request times out (default: 7)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s p -l proxy -d 'Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s P -l replay-proxy -d 'Send only unfiltered requests through a Replay Proxy, instead of all requests'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s R -l replay-codes -d 'Status Codes to send through a Replay Proxy when found (default: --status-codes value)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s s -l status-codes -d 'Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s o -l output -d 'Output file to write results to (use w/ --json for JSON entries)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -l resume-from -d 'State file from which to resume a partially complete scan (ex. --resume-from ferox-1606586780.state)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -l debug-log -d 'Output file to write log entries (use w/ --json for JSON entries)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s a -l user-agent -d 'Sets the User-Agent (default: feroxbuster/VERSION)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s x -l extensions -d 'File extension(s) to search for (ex: -x php -x pdf js)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s H -l headers -d 'Specify HTTP headers (ex: -H Header:val \'stuff: things\')'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s Q -l query -d 'Specify URL query parameters (ex: -Q token=stuff -Q secret=key)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s S -l filter-size -d 'Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s X -l filter-regex -d 'Filter out messages via regular expression matching on the response\'s body (ex: -X \'^ignore me$\')'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s W -l filter-words -d 'Filter out messages of a particular word count (ex: -W 312 -W 91,82)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s N -l filter-lines -d 'Filter out messages of a particular line count (ex: -N 20 -N 31,30)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s C -l filter-status -d 'Filter out status codes (deny list) (ex: -C 200 -C 401)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s L -l scan-limit -d 'Limit total number of concurrent scans (default: 0, i.e. no limit)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s v -l verbosity -d 'Increase verbosity level (use -vv or more for greater effect. [CAUTION] 4 -v\'s is probably too much)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s q -l quiet -d 'Only print URLs; Don\'t print status codes, response size, running config, etc...'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -l json -d 'Emit JSON logs to --output and --debug-log instead of normal text'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s D -l dont-filter -d 'Don\'t auto-filter wildcard responses'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s r -l redirects -d 'Follow redirects'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s k -l insecure -d 'Disables TLS certificate validation'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s n -l no-recursion -d 'Do not scan recursively'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s f -l add-slash -d 'Append / to each request'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -l stdin -d 'Read url(s) from STDIN'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s e -l extract-links -d 'Extract links from response body (html, javascript, etc...); make new requests based on findings (default: false)'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s h -l help -d 'Prints help information'
-complete -c feroxbuster -n "__fish_using_command feroxbuster" -s V -l version -d 'Prints version information'
+complete -c feroxbuster -n "__fish_use_subcommand" -s w -l wordlist -d 'Path to the wordlist'
+complete -c feroxbuster -n "__fish_use_subcommand" -s u -l url -d 'The target URL(s) (required, unless --stdin used)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s t -l threads -d 'Number of concurrent threads (default: 50)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s d -l depth -d 'Maximum recursion depth, a depth of 0 is infinite recursion (default: 4)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s T -l timeout -d 'Number of seconds before a request times out (default: 7)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s p -l proxy -d 'Proxy to use for requests (ex: http(s)://host:port, socks5://host:port)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s P -l replay-proxy -d 'Send only unfiltered requests through a Replay Proxy, instead of all requests'
+complete -c feroxbuster -n "__fish_use_subcommand" -s R -l replay-codes -d 'Status Codes to send through a Replay Proxy when found (default: --status-codes value)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s s -l status-codes -d 'Status Codes to include (allow list) (default: 200 204 301 302 307 308 401 403 405)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s o -l output -d 'Output file to write results to (use w/ --json for JSON entries)'
+complete -c feroxbuster -n "__fish_use_subcommand" -l resume-from -d 'State file from which to resume a partially complete scan (ex. --resume-from ferox-1606586780.state)'
+complete -c feroxbuster -n "__fish_use_subcommand" -l debug-log -d 'Output file to write log entries (use w/ --json for JSON entries)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s a -l user-agent -d 'Sets the User-Agent (default: feroxbuster/VERSION)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s x -l extensions -d 'File extension(s) to search for (ex: -x php -x pdf js)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s H -l headers -d 'Specify HTTP headers (ex: -H Header:val \'stuff: things\')'
+complete -c feroxbuster -n "__fish_use_subcommand" -s Q -l query -d 'Specify URL query parameters (ex: -Q token=stuff -Q secret=key)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s S -l filter-size -d 'Filter out messages of a particular size (ex: -S 5120 -S 4927,1970)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s X -l filter-regex -d 'Filter out messages via regular expression matching on the response\'s body (ex: -X \'^ignore me$\')'
+complete -c feroxbuster -n "__fish_use_subcommand" -s W -l filter-words -d 'Filter out messages of a particular word count (ex: -W 312 -W 91,82)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s N -l filter-lines -d 'Filter out messages of a particular line count (ex: -N 20 -N 31,30)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s C -l filter-status -d 'Filter out status codes (deny list) (ex: -C 200 -C 401)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s L -l scan-limit -d 'Limit total number of concurrent scans (default: 0, i.e. no limit)'
+complete -c feroxbuster -n "__fish_use_subcommand" -l time-limit -d 'Limit total run time of all scans (ex: --time-limit 10m)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s v -l verbosity -d 'Increase verbosity level (use -vv or more for greater effect. [CAUTION] 4 -v\'s is probably too much)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s q -l quiet -d 'Only print URLs; Don\'t print status codes, response size, running config, etc...'
+complete -c feroxbuster -n "__fish_use_subcommand" -l json -d 'Emit JSON logs to --output and --debug-log instead of normal text'
+complete -c feroxbuster -n "__fish_use_subcommand" -s D -l dont-filter -d 'Don\'t auto-filter wildcard responses'
+complete -c feroxbuster -n "__fish_use_subcommand" -s r -l redirects -d 'Follow redirects'
+complete -c feroxbuster -n "__fish_use_subcommand" -s k -l insecure -d 'Disables TLS certificate validation'
+complete -c feroxbuster -n "__fish_use_subcommand" -s n -l no-recursion -d 'Do not scan recursively'
+complete -c feroxbuster -n "__fish_use_subcommand" -s f -l add-slash -d 'Append / to each request'
+complete -c feroxbuster -n "__fish_use_subcommand" -l stdin -d 'Read url(s) from STDIN'
+complete -c feroxbuster -n "__fish_use_subcommand" -s e -l extract-links -d 'Extract links from response body (html, javascript, etc...); make new requests based on findings (default: false)'
+complete -c feroxbuster -n "__fish_use_subcommand" -s h -l help -d 'Prints help information'
+complete -c feroxbuster -n "__fish_use_subcommand" -s V -l version -d 'Prints version information'

src/banner.rs

@@ -495,6 +495,15 @@ by Ben "epi" Risher {}                  ver: {}"#,
         .unwrap_or_default(); // 🦥
     }
 
+    if !CONFIGURATION.time_limit.is_empty() {
+        writeln!(
+            &mut writer,
+            "{}",
+            format_banner_entry!("\u{1f556}", "Time Limit", config.time_limit)
+        )
+        .unwrap_or_default(); // 🕖
+    }
+
     if matches!(status, UpdateStatus::OutOfDate) {
         writeln!(
             &mut writer,

src/config.rs

@@ -228,6 +228,11 @@ pub struct Configuration {
     /// Not configurable from CLI; can only be set from a config file
     #[serde(default = "save_state")]
     pub save_state: bool,
+
+    /// The maximum runtime for a scan, expressed as N[smdh] where N can be parsed into a
+    /// non-negative integer and the next character is either s, m, h, or d (case insensitive)
+    #[serde(default)]
+    pub time_limit: String,
 }
 
 // functions timeout, threads, status_codes, user_agent, wordlist, save_state, and depth are used to provide
@@ -314,6 +319,7 @@ impl Default for Configuration {
             output: String::new(),
             debug_log: String::new(),
             target_url: String::new(),
+            time_limit: String::new(),
             replay_proxy: String::new(),
             queries: Vec::new(),
             extensions: Vec::new(),
@@ -365,6 +371,7 @@ impl Configuration {
     /// - **dont_filter**: `false` (auto filter wildcard responses)
     /// - **depth**: `4` (maximum recursion depth)
     /// - **scan_limit**: `0` (no limit on concurrent scans imposed)
+    /// - **time_limit**: `None` (no limit on length of scan imposed)
     /// - **replay_proxy**: `None` (no limit on concurrent scans imposed)
     /// - **replay_codes**: [`DEFAULT_RESPONSE_CODES`](constant.DEFAULT_RESPONSE_CODES.html)
     ///
@@ -388,7 +395,9 @@ impl Configuration {
     pub fn new() -> Self {
         // when compiling for test, we want to eliminate the runtime dependency of the parser
         if cfg!(test) {
-            return Configuration::default();
+            let mut test_config = Configuration::default();
+            test_config.save_state = false; // don't clutter up junk when testing
+            return test_config;
         }
 
         let args = parser::initialize().get_matches();
@@ -499,6 +508,7 @@ impl Configuration {
         update_config_if_present!(&mut config.wordlist, args, "wordlist", String);
         update_config_if_present!(&mut config.output, args, "output", String);
         update_config_if_present!(&mut config.debug_log, args, "debug_log", String);
+        update_config_if_present!(&mut config.time_limit, args, "time_limit", String);
 
         if let Some(arg) = args.values_of("status_codes") {
             config.status_codes = arg
@@ -730,6 +740,7 @@ impl Configuration {
         //  - resumed
         //  - config
         update_if_not_default!(&mut conf.target_url, new.target_url, "");
+        update_if_not_default!(&mut conf.time_limit, new.time_limit, "");
         update_if_not_default!(&mut conf.proxy, new.proxy, "");
         update_if_not_default!(&mut conf.verbosity, new.verbosity, 0);
         update_if_not_default!(&mut conf.quiet, new.quiet, false);
@@ -864,6 +875,7 @@ mod tests {
             quiet = true
             verbosity = 1
             scan_limit = 6
+            time_limit = "10m"
             output = "/some/otherpath"
             debug_log = "/yet/anotherpath"
             redirects = true
@@ -898,6 +910,7 @@ mod tests {
         assert_eq!(config.wordlist, wordlist());
         assert_eq!(config.proxy, String::new());
         assert_eq!(config.target_url, String::new());
+        assert_eq!(config.time_limit, String::new());
         assert_eq!(config.debug_log, String::new());
         assert_eq!(config.config, String::new());
         assert_eq!(config.replay_proxy, String::new());
@@ -1125,6 +1138,13 @@ mod tests {
         assert_eq!(config.save_state, false);
     }
 
+    #[test]
+    /// parse the test config and see that the value parsed is correct
+    fn config_reads_time_limit() {
+        let config = setup_config_test();
+        assert_eq!(config.time_limit, "10m");
+    }
+
     #[test]
     /// parse the test config and see that the values parsed are correct
     fn config_reads_headers() {

src/main.rs

@@ -220,6 +220,14 @@ async fn wrapped_main() {
         PROGRESS_BAR.join().unwrap();
     });
 
+    if !CONFIGURATION.time_limit.is_empty() {
+        // --time-limit value not an empty string, need to kick off the thread that enforces
+        // the limit
+        tokio::spawn(async move {
+            scan_manager::start_max_time_thread(&CONFIGURATION.time_limit).await
+        });
+    }
+
     // can't trace main until after logger is initialized and the above task is started
     log::trace!("enter: main");
 

src/parser.rs

@@ -1,4 +1,18 @@
 use clap::{App, Arg, ArgGroup};
+use lazy_static::lazy_static;
+use regex::Regex;
+
+lazy_static! {
+    /// Regex used to validate values passed to --time-limit
+    ///
+    /// Examples of expected values that will this regex will match:
+    /// - 30s
+    /// - 20m
+    /// - 1h
+    /// - 1d
+    pub static ref TIMESPEC_REGEX: Regex =
+        Regex::new(r"^(?i)(?P<n>\d+)(?P<m>[smdh])$").expect("Could not compile regex");
+}
 
 /// Create and return an instance of [clap::App](https://docs.rs/clap/latest/clap/struct.App.html), i.e. the Command Line Interface's configuration
 pub fn initialize() -> App<'static, 'static> {
@@ -302,6 +316,14 @@ pub fn initialize() -> App<'static, 'static> {
                 .takes_value(true)
                 .help("Limit total number of concurrent scans (default: 0, i.e. no limit)")
         )
+        .arg(
+            Arg::with_name("time_limit")
+                .long("time-limit")
+                .value_name("TIME_SPEC")
+                .takes_value(true)
+                .validator(valid_time_spec)
+                .help("Limit total run time of all scans (ex: --time-limit 10m)")
+        )
         .group(ArgGroup::with_name("output_files")
             .args(&["debug_log", "output"])
             .multiple(true)
@@ -343,6 +365,20 @@ EXAMPLES:
     "#)
 }
 
+/// Validate that a string is formatted as a number followed by s, m, h, or d (10d, 30s, etc...)
+fn valid_time_spec(time_spec: String) -> Result<(), String> {
+    match TIMESPEC_REGEX.is_match(&time_spec) {
+        true => Ok(()),
+        false => {
+            let msg = format!(
+                "Expected a non-negative, whole number followed by s, m, h, or d (case insensitive); received {}",
+                time_spec
+            );
+            Err(msg)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -353,4 +389,37 @@ mod tests {
         let app = initialize();
         assert_eq!(app.get_name(), "feroxbuster");
     }
+
+    #[test]
+    /// sanity checks that valid_time_spec correctly checks and rejects a given string
+    ///
+    /// instead of having a bunch of single tests here, they're all quick and are mostly checking
+    /// that i didn't hose up the regex.  Going to consolidate them into a single test
+    fn validate_valid_time_spec_validation() {
+        let float_rejected = "1.4m";
+        assert!(valid_time_spec(float_rejected.into()).is_err());
+
+        let negative_rejected = "-1m";
+        assert!(valid_time_spec(negative_rejected.into()).is_err());
+
+        let only_number_rejected = "1";
+        assert!(valid_time_spec(only_number_rejected.into()).is_err());
+
+        let only_measurement_rejected = "m";
+        assert!(valid_time_spec(only_measurement_rejected.into()).is_err());
+
+        for accepted_measurement in &["s", "m", "h", "d", "S", "M", "H", "D"] {
+            // all upper/lowercase should be good
+            assert!(valid_time_spec(format!("1{}", *accepted_measurement)).is_ok());
+        }
+
+        let leading_space_rejected = " 14m";
+        assert!(valid_time_spec(leading_space_rejected.into()).is_err());
+
+        let trailing_space_rejected = "14m ";
+        assert!(valid_time_spec(trailing_space_rejected.into()).is_err());
+
+        let space_between_rejected = "1 4m";
+        assert!(valid_time_spec(space_between_rejected.into()).is_err());
+    }
 }

src/reporter.rs

@@ -94,7 +94,7 @@ async fn spawn_terminal_reporter(
         save_output
     );
 
-    while let Some(resp) = resp_chan.recv().await {
+    while let Some(mut resp) = resp_chan.recv().await {
         log::trace!("received {} on reporting channel", resp.url());
 
         let contains_sentry = CONFIGURATION.status_codes.contains(&resp.status().as_u16());
@@ -134,6 +134,11 @@ async fn spawn_terminal_reporter(
             // add response to RESPONSES for serialization in case of ctrl+c
             // placed all by its lonesome like this so that RESPONSES can take ownership
             // of the FeroxResponse
+
+            // before ownership is transferred, there's no real reason to keep the body anymore
+            // so we can free that piece of data, reducing memory usage
+            resp.text = String::new();
+
             RESPONSES.insert(resp);
         }
     }

src/scan_manager.rs

@@ -3,6 +3,7 @@ use crate::reporter::safe_file_write;
 use crate::utils::open_file;
 use crate::{
     config::{CONFIGURATION, PROGRESS_PRINTER},
+    parser::TIMESPEC_REGEX,
     progress,
     scanner::{NUMBER_OF_REQUESTS, RESPONSES, SCANNED_URLS},
     FeroxResponse, FeroxSerialize, SLEEP_DURATION,
@@ -589,51 +590,102 @@ impl FeroxSerialize for FeroxState {
     }
 }
 
+/// Given a string representing some number of seconds, minutes, hours, or days, convert
+/// that representation to seconds and then wait for those seconds to elapse.  Once that period
+/// of time has elapsed, kill all currently running scans and dump a state file to disk that can
+/// be used to resume any unfinished scan.
+pub async fn start_max_time_thread(time_spec: &str) {
+    log::trace!("enter: start_max_time_thread({})", time_spec);
+
+    // as this function has already made it through the parser, which calls is_match on
+    // the value passed to --time-limit using TIMESPEC_REGEX; we can safely assume that
+    // the capture groups are populated; can expect something like 10m, 30s, 1h, etc...
+    let captures = TIMESPEC_REGEX.captures(&time_spec).unwrap();
+    let length_match = captures.get(1).unwrap();
+    let measurement_match = captures.get(2).unwrap();
+
+    if let Ok(length) = length_match.as_str().parse::<u64>() {
+        let length_in_secs = match measurement_match.as_str().to_ascii_lowercase().as_str() {
+            "s" => length,
+            "m" => length * 60,           // minutes
+            "h" => length * 60 * 60,      // hours
+            "d" => length * 60 * 60 * 24, // days
+            _ => length,
+        };
+
+        log::debug!(
+            "max time limit as string: {} and as seconds: {}",
+            time_spec,
+            length_in_secs
+        );
+
+        time::delay_for(time::Duration::new(length_in_secs, 0)).await;
+
+        log::trace!("exit: start_max_time_thread");
+
+        #[cfg(test)]
+        panic!();
+        #[cfg(not(test))]
+        sigint_handler();
+    }
+
+    log::error!(
+        "Could not parse the value provided ({}), can't enforce time limit",
+        length_match.as_str()
+    );
+}
+
+/// Writes the current state of the program to disk (if save_state is true) and then exits
+fn sigint_handler() {
+    log::trace!("enter: sigint_handler");
+
+    let ts = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    let slug = if !CONFIGURATION.target_url.is_empty() {
+        // target url populated
+        CONFIGURATION
+            .target_url
+            .replace("://", "_")
+            .replace("/", "_")
+            .replace(".", "_")
+    } else {
+        // stdin used
+        "stdin".to_string()
+    };
+
+    let filename = format!("ferox-{}-{}.state", slug, ts);
+    let warning = format!(
+        "🚨 Caught {} 🚨 saving scan state to {} ...",
+        style("ctrl+c").yellow(),
+        filename
+    );
+
+    PROGRESS_PRINTER.println(warning);
+
+    let state = FeroxState {
+        config: &CONFIGURATION,
+        scans: &SCANNED_URLS,
+        responses: &RESPONSES,
+    };
+
+    let state_file = open_file(&filename);
+
+    if let Some(buffered_file) = state_file {
+        safe_file_write(&state, buffered_file, true);
+    }
+
+    log::trace!("exit: sigint_handler (end of program)");
+    std::process::exit(1);
+}
+
 /// Initialize the ctrl+c handler that saves scan state to disk
 pub fn initialize() {
     log::trace!("enter: initialize");
 
-    let result = ctrlc::set_handler(move || {
-        let ts = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs();
-
-        let slug = if !CONFIGURATION.target_url.is_empty() {
-            // target url populated
-            CONFIGURATION
-                .target_url
-                .replace("://", "_")
-                .replace("/", "_")
-                .replace(".", "_")
-        } else {
-            // stdin used
-            "stdin".to_string()
-        };
-
-        let filename = format!("ferox-{}-{}.state", slug, ts);
-        let warning = format!(
-            "🚨 Caught {} 🚨 saving scan state to {} ...",
-            style("ctrl+c").yellow(),
-            filename
-        );
-
-        PROGRESS_PRINTER.println(warning);
-
-        let state = FeroxState {
-            config: &CONFIGURATION,
-            scans: &SCANNED_URLS,
-            responses: &RESPONSES,
-        };
-
-        let state_file = open_file(&filename);
-
-        if let Some(buffered_file) = state_file {
-            safe_file_write(&state, buffered_file, true);
-        }
-
-        std::process::exit(1);
-    });
+    let result = ctrlc::set_handler(sigint_handler);
 
     if result.is_err() {
         log::error!("Could not set Ctrl+c handler");
@@ -983,10 +1035,36 @@ mod tests {
 
         let json_state = ferox_state.as_json();
         let expected = format!(
-            r#"{{"scans":[{{"id":"{}","url":"https://spiritanimal.com","scan_type":"Directory","complete":false}}],"config":{{"type":"configuration","wordlist":"/usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt","config":"","proxy":"","replay_proxy":"","target_url":"","status_codes":[200,204,301,302,307,308,401,403,405],"replay_codes":[200,204,301,302,307,308,401,403,405],"filter_status":[],"threads":50,"timeout":7,"verbosity":0,"quiet":false,"json":false,"output":"","debug_log":"","user_agent":"feroxbuster/{}","redirects":false,"insecure":false,"extensions":[],"headers":{{}},"queries":[],"no_recursion":false,"extract_links":false,"add_slash":false,"stdin":false,"depth":4,"scan_limit":0,"filter_size":[],"filter_line_count":[],"filter_word_count":[],"filter_regex":[],"dont_filter":false,"resumed":false,"save_state":true}},"responses":[{{"type":"response","url":"https://nerdcore.com/css","path":"/css","wildcard":true,"status":301,"content_length":173,"line_count":10,"word_count":16,"headers":{{"server":"nginx/1.16.1"}}}}]}}"#,
+            r#"{{"scans":[{{"id":"{}","url":"https://spiritanimal.com","scan_type":"Directory","complete":false}}],"config":{{"type":"configuration","wordlist":"/usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt","config":"","proxy":"","replay_proxy":"","target_url":"","status_codes":[200,204,301,302,307,308,401,403,405],"replay_codes":[200,204,301,302,307,308,401,403,405],"filter_status":[],"threads":50,"timeout":7,"verbosity":0,"quiet":false,"json":false,"output":"","debug_log":"","user_agent":"feroxbuster/{}","redirects":false,"insecure":false,"extensions":[],"headers":{{}},"queries":[],"no_recursion":false,"extract_links":false,"add_slash":false,"stdin":false,"depth":4,"scan_limit":0,"filter_size":[],"filter_line_count":[],"filter_word_count":[],"filter_regex":[],"dont_filter":false,"resumed":false,"save_state":false,"time_limit":""}},"responses":[{{"type":"response","url":"https://nerdcore.com/css","path":"/css","wildcard":true,"status":301,"content_length":173,"line_count":10,"word_count":16,"headers":{{"server":"nginx/1.16.1"}}}}]}}"#,
             saved_id, VERSION
         );
 
         assert!(predicates::str::similar(expected).eval(&json_state));
     }
+
+    #[should_panic]
+    #[tokio::test(core_threads = 1)]
+    /// call start_max_time_thread with a valid timespec, expect a panic, but only after a certain
+    /// number of seconds
+    async fn start_max_time_thread_panics_after_delay() {
+        let now = time::Instant::now();
+        let delay = time::Duration::new(3, 0);
+
+        start_max_time_thread("3s").await;
+
+        assert!(now.elapsed() > delay);
+    }
+
+    #[tokio::test(core_threads = 1)]
+    /// call start_max_time_thread with a timespec that's too large to be parsed correctly, expect
+    /// immediate return and no panic, as the sigint handler is never called
+    async fn start_max_time_thread_returns_immediately_with_too_large_input() {
+        let now = time::Instant::now();
+        let delay = time::Duration::new(1, 0);
+
+        // pub const MAX: usize = usize::MAX; // 18_446_744_073_709_551_615usize
+        start_max_time_thread("18446744073709551616m").await; // can't fit in dest u64
+
+        assert!(now.elapsed() < delay); // assuming function call will take less than 1second
+    }
 }

tests/test_banner.rs

@@ -783,3 +783,30 @@ fn banner_prints_filter_regex() {
                 .and(predicate::str::contains("─┴─")),
         );
 }
+
+#[test]
+/// test allows non-existent wordlist to trigger the banner printing to stderr
+/// expect to see all mandatory prints + time limit
+fn banner_prints_time_limit() {
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg("http://localhost")
+        .arg("--time-limit")
+        .arg("10m")
+        .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("Time Limit"))
+                .and(predicate::str::contains("│ 10m"))
+                .and(predicate::str::contains("─┴─")),
+        );
+}

tests/test_scan_manager.rs

@@ -3,6 +3,9 @@ use assert_cmd::Command;
 use httpmock::Method::GET;
 use httpmock::{Mock, MockServer};
 use predicates::prelude::*;
+use std::fs::{read_to_string, write};
+use std::path::Path;
+use std::time;
 use utils::{setup_tmp_directory, teardown_tmp_directory};
 
 #[test]
@@ -91,3 +94,42 @@ fn resume_scan_works() {
     assert_eq!(also_already_scanned.times_called(), 0);
     assert_eq!(not_scanned_yet.times_called(), 1);
 }
+
+#[test]
+/// kick off scan with a time limit;  
+fn time_limit_enforced_when_specified() {
+    let srv = MockServer::start();
+    let (tmp_dir, file) =
+        setup_tmp_directory(&["css".to_string(), "stuff".to_string()], "wordlist").unwrap();
+
+    // ensure the command will run long enough by adding crap to the wordlist
+    let more_words = read_to_string(Path::new("tests/extra-words")).unwrap();
+    write(&file, more_words).unwrap();
+
+    assert!(file.metadata().unwrap().len() > 100); // sanity check on wordlist size
+
+    let now = time::Instant::now();
+    let lower_bound = time::Duration::new(5, 0);
+    let upper_bound = time::Duration::new(6, 0);
+
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg(srv.url("/"))
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("--time-limit")
+        .arg("5s")
+        .assert()
+        .failure();
+
+    // expected run time is somewhere in the 30 seconds ballpark (real    0m37.376s)
+    // so if the cmd returns in a significantly shorter amount of time, the test will have
+    // succeeded
+
+    // --time-limit is 5 seconds, so elapsed should be in a window that is greater than 5
+    // but significantly less than 30ish
+    assert!(now.elapsed() > lower_bound && now.elapsed() < upper_bound);
+
+    teardown_tmp_directory(tmp_dir);
+}