ffuf Maskottchen

ffuf - Fuzz Faster U Fool

Ein schneller Web-Fuzzer, geschrieben in Go.

Installation

Lade eine vorkompilierte Binärdatei von der Releases-Seite herunter, entpacke sie und führe sie aus!

oder
Wenn du Windows mit Scoop verwendest, kann ffuf mit folgendem Befehl installiert werden: scoop install ffuf

oder
Wenn du Windows mit Winget verwendest, kann ffuf mit folgendem Befehl installiert werden: winget install ffuf.ffuf

oder
Wenn du macOS mit homebrew verwendest, kann ffuf mit folgendem Befehl installiert werden: brew install ffuf

oder
Wenn du einen aktuellen Go-Compiler installiert hast: go install github.com/ffuf/ffuf/v2@latest (derselbe Befehl funktioniert auch zum Aktualisieren)

oder
git clone https://github.com/ffuf/ffuf ; cd ffuf ; go get ; go build

Ffuf benötigt Go 1.20 oder höher.
Ein Go-Build aus einem Checkout zeigt git-<date>-<commit> anstelle des Tags. Ein lokaler Build ist keine offizielle Release-Version, selbst wenn du auf einem Tag sitzt, und die eingebetteten Build-Informationen von Go liefern uns den Commit, aber nicht den Tag-Namen – daher zeigen wir den genauen Commit an, aus dem er erstellt wurde. Die maßgeblichen versionierten Binärdateien sind die auf der Releases-Seite.

Beispielverwendung

Die folgenden Verwendungsbeispiele zeigen nur die einfachsten Aufgaben, die du mit ffuf erledigen kannst.

Ausführlichere Dokumentation, die viele Funktionen mit zahlreichen Beispielen behandelt, ist im ffuf-Wiki unter https://github.com/ffuf/ffuf/wiki verfügbar.

Für eine umfangreichere Dokumentation mit realen Anwendungsbeispielen und Tipps solltest du dir unbedingt den großartigen Leitfaden ansehen: „Everything you need to know about FFUF" von Michael Skelton (@codingo).

Du kannst deine ffuf-Scans auch gegen einen Live-Host mit verschiedenen Lektionen und Anwendungsfällen üben, entweder lokal mit dem Docker-Container https://github.com/adamtlangley/ffufme oder gegen die gehostete Live-Version unter http://ffuf.me, erstellt von Adam Langley @adamtlangley.

Typische Verzeichnisermittlung

Indem du das FUZZ-Schlüsselwort am Ende der URL (-u) verwendest:

ffuf -w /path/to/wordlist -u https://target/FUZZ

Vhost-Ermittlung (ohne DNS-Einträge)

Angenommen, die Standardantwortgröße des virtuellen Hosts beträgt 4242 Bytes, können wir alle Antworten dieser Größe (-fs 4242) herausfiltern, während wir den Host-Header fuzzen:

ffuf -w /path/to/vhost/wordlist -u https://target -H "Host: FUZZ" -fs 4242

GET-Parameter-Fuzzing

Das Fuzzing von GET-Parameternamen ist der Verzeichnisermittlung sehr ähnlich und funktioniert, indem das FUZZ-Schlüsselwort als Teil der URL definiert wird. Dabei wird ebenfalls eine Antwortgröße von 4242 Bytes für einen ungültigen GET-Parameternamen angenommen.

ffuf -w /path/to/paramnames.txt -u https://target/script.php?FUZZ=test_value -fs 4242

Wenn der Parametername bekannt ist, können die Werte auf dieselbe Weise gefuzzt werden. Dieses Beispiel geht von einem falschen Parameterwert aus, der den HTTP-Antwortcode 401 zurückgibt.

ffuf -w /path/to/values.txt -u https://target/script.php?valid_name=FUZZ -fc 401

POST-Daten-Fuzzing

Dies ist eine sehr einfache Operation, wiederum mit dem FUZZ-Schlüsselwort. Dieses Beispiel fuzzt nur einen Teil der POST-Anfrage. Wir filtern erneut die 401-Antworten heraus.

ffuf -w /path/to/postdata.txt -X POST -d "username=admin\&password=FUZZ" -u https://target/login.php -fc 401

Maximale Ausführungszeit

Wenn du nicht möchtest, dass ffuf unbegrenzt läuft, kannst du -maxtime verwenden. Dies stoppt den gesamten Prozess nach einer bestimmten Zeit (in Sekunden).

ffuf -w /path/to/wordlist -u https://target/FUZZ -maxtime 60

Wenn du mit Rekursion arbeitest, kannst du die Maximalzeit pro Job mit -maxtime-job steuern. Dadurch wird der aktuelle Job nach einer bestimmten Zeit (in Sekunden) gestoppt und mit dem nächsten fortgefahren. Neue Jobs werden erstellt, wenn die Rekursionsfunktion ein Unterverzeichnis erkennt.

ffuf -w /path/to/wordlist -u https://target/FUZZ -maxtime-job 60 -recursion -recursion-depth 2

Es ist auch möglich, beide Flags zu kombinieren, um sowohl die maximale Ausführungszeit pro Job als auch die Gesamtausführungszeit zu begrenzen. Wenn du keine Rekursion verwendest, verhalten sich beide Flags gleich.

Verwendung eines externen Mutators zur Erzeugung von Testfällen

Für dieses Beispiel fuzzen wir JSON-Daten, die per POST gesendet werden. Radamsa wird als Mutator verwendet.

Wenn --input-cmd verwendet wird, zeigt ffuf Übereinstimmungen als ihre Position an. Dieser Positionswert steht dem Aufgerufenen als Umgebungsvariable $FFUF_NUM zur Verfügung. Wir verwenden diesen Positionswert als Seed für den Mutator. Die Dateien example1.txt und example2.txt enthalten gültige JSON-Payloads. Wir matchen alle Antworten, filtern aber den Antwortcode 400 - Bad request heraus:

ffuf --input-cmd 'radamsa --seed $FFUF_NUM example1.txt example2.txt' -H "Content-Type: application/json" -X POST -u https://ffuf.io.fi/FUZZ -mc all -fc 400

Es ist natürlich nicht sehr effizient, den Mutator für jede Payload aufzurufen. Daher können wir die Payloads auch vorab generieren, wiederum mit Radamsa als Beispiel:

# Generate 1000 example payloads
radamsa -n 1000 -o %n.txt example1.txt example2.txt

# This results into files 1.txt ... 1000.txt
# Now we can just read the payload data in a loop from file for ffuf

ffuf --input-cmd 'cat $FFUF_NUM.txt' -H "Content-Type: application/json" -X POST -u https://ffuf.io.fi/ -mc all -fc 400

Konfigurationsdateien

Wenn ffuf ausgeführt wird, prüft es zuerst, ob eine Standardkonfigurationsdatei existiert. Der Standardpfad für eine ffufrc-Datei ist $XDG_CONFIG_HOME/ffuf/ffufrc. Du kannst eine oder mehrere Optionen in dieser Datei konfigurieren, und sie werden bei jedem nachfolgenden ffuf-Job angewendet. Ein Beispiel für eine ffufrc-Datei findest du hier.

Eine detailliertere Beschreibung der Speicherorte von Konfigurationsdateien findest du im Wiki: https://github.com/ffuf/ffuf/wiki/Configuration

Die über die Befehlszeile angegebenen Konfigurationsoptionen überschreiben die aus der Standarddatei ffufrc geladenen. Hinweis: Dies gilt nicht für CLI-Flags, die mehr als einmal angegeben werden können. Ein solches Beispiel ist das -H-Flag (Header). In diesem Fall werden die über die Befehlszeile angegebenen -H-Werte stattdessen an die aus der Konfigurationsdatei angehängt.

Wenn du außerdem für verschiedene Anwendungsfälle eine Reihe von Konfigurationsdateien verwenden möchtest, kannst du dies tun, indem du den Pfad der Konfigurationsdatei über das Befehlszeilenflag -config angibst, das den Dateipfad zur Konfigurationsdatei als Parameter entgegennimmt.

Verwendung

Um den Testfall für ffuf zu definieren, verwende das Schlüsselwort FUZZ an beliebiger Stelle in der URL (-u), in den Headern (-H) oder in den POST-Daten (-d).

Fuzz Faster U Fool - v2.1.0

HTTP OPTIONS:
  -H                  Header `"Name: Value"`, separated by colon. Multiple -H flags are accepted.
  -X                  HTTP method to use
  -b                  Cookie data `"NAME1=VALUE1; NAME2=VALUE2"` for copy as curl functionality.
  -cc                 Client cert for authentication. Client key needs to be defined as well for this to work
  -ck                 Client key for authentication. Client certificate needs to be defined as well for this to work
  -d                  POST data
  -http2              Use HTTP2 protocol (default: false)
  -ignore-body        Do not fetch the response content. (default: false)
  -r                  Follow redirects (default: false)
  -raw                Do not encode URI (default: false)
  -recursion          Scan recursively. Only FUZZ keyword is supported, and URL (-u) has to end in it. (default: false)
  -recursion-depth    Maximum recursion depth. (default: 0)
  -recursion-strategy Recursion strategy: "default" for a redirect based, and "greedy" to recurse on all matches (default: default)
  -replay-proxy       Replay matched requests using this proxy.
  -sni                Target TLS SNI, does not support FUZZ keyword
  -timeout            HTTP request timeout in seconds. (default: 10)
  -u                  Target URL
  -x                  Proxy URL (SOCKS5 or HTTP). For example: http://127.0.0.1:8080 or socks5://127.0.0.1:8080

GENERAL OPTIONS:
  -V                  Show version information. (default: false)
  -ac                 Automatically calibrate filtering options (default: false)
  -acc                Custom auto-calibration string. Can be used multiple times. Implies -ac
  -ach                Per host autocalibration (default: false)
  -ack                Autocalibration keyword (default: FUZZ)
  -acs                Custom auto-calibration strategies. Can be used multiple times. Implies -ac
  -c                  Colorize output. (default: false)
  -config             Load configuration from a file
  -json               JSON output, printing newline-delimited JSON records (default: false)
  -maxtime            Maximum running time in seconds for entire process. (default: 0)
  -maxtime-job        Maximum running time in seconds per job. (default: 0)
  -noninteractive     Disable the interactive console functionality (default: false)
  -p                  Seconds of `delay` between requests, or a range of random delay. For example "0.1" or "0.1-2.0"
  -rate               Rate of requests per second (default: 0)
  -s                  Do not print additional information (silent mode) (default: false)
  -sa                 Stop on all error cases. Implies -sf and -se. (default: false)
  -scraperfile        Custom scraper file path
  -scrapers           Active scraper groups (default: all)
  -se                 Stop on spurious errors (default: false)
  -search             Search for a FFUFHASH payload from ffuf history
  -sf                 Stop when > 95% of responses return 403 Forbidden (default: false)
  -t                  Number of concurrent threads. (default: 40)
  -v                  Verbose output, printing full URL and redirect location (if any) with the results. (default: false)

MATCHER OPTIONS:
  -mc                 Match HTTP status codes, or "all" for everything. (default: 200-299,301,302,307,401,403,405,500)
  -ml                 Match amount of lines in response
  -mmode              Matcher set operator. Either of: and, or (default: or)
  -mr                 Match regexp
  -ms                 Match HTTP response size
  -mt                 Match how many milliseconds to the first response byte, either greater or less than. EG: >100 or <100
  -mw                 Match amount of words in response

FILTER OPTIONS:
  -fc                 Filter HTTP status codes from response. Comma separated list of codes and ranges
  -fl                 Filter by amount of lines in response. Comma separated list of line counts and ranges
  -fmode              Filter set operator. Either of: and, or (default: or)
  -fr                 Filter regexp
  -fs                 Filter HTTP response size. Comma separated list of sizes and ranges
  -ft                 Filter by number of milliseconds to the first response byte, either greater or less than. EG: >100 or <100
  -fw                 Filter by amount of words in response. Comma separated list of word counts and ranges

INPUT OPTIONS:
  -D                  DirSearch wordlist compatibility mode. Used in conjunction with -e flag. (default: false)
  -e                  Comma separated list of extensions. Extends FUZZ keyword.
  -enc                Encoders for keywords, eg. 'FUZZ:urlencode b64encode'
  -ic                 Ignore wordlist comments (default: false)
  -input-cmd          Command producing the input. --input-num is required when using this input method. Overrides -w.
  -input-num          Number of inputs to test. Used in conjunction with --input-cmd. (default: 100)
  -input-shell        Shell to be used for running command
  -mode               Multi-wordlist operation mode. Available modes: clusterbomb, pitchfork, sniper (default: clusterbomb)
  -request            File containing the raw http request
  -request-proto      Protocol to use along with raw request (default: https)
  -w                  Wordlist file path and (optional) keyword separated by colon. eg. '/path/to/wordlist:KEYWORD'

OUTPUT OPTIONS:
  -debug-log          Write all of the internal logging to the specified file.
  -o                  Write output to file
  -od                 Directory path to store matched results to.
  -of                 Output file format. Available formats: json, ejson, html, md, csv, ecsv (or, 'all' for all formats) (default: json)
  -or                 Don't create the output file if we don't have results (default: false)

EXAMPLE USAGE:
  Fuzz file paths from wordlist.txt, match all responses but filter out those with content-size 42.
  Colored, verbose output.
    ffuf -w wordlist.txt -u https://example.org/FUZZ -mc all -fs 42 -c -v

  Fuzz Host-header, match HTTP 200 responses.
    ffuf -w hosts.txt -u https://example.org/ -H "Host: FUZZ" -mc 200

  Fuzz POST JSON data. Match all responses not containing text "error".
    ffuf -w entries.txt -u https://example.org/ -X POST -H "Content-Type: application/json" \
      -d '{"name": "FUZZ", "anotherkey": "anothervalue"}' -fr "error"

  Fuzz multiple locations. Match only responses reflecting the value of "VAL" keyword. Colored.
    ffuf -w params.txt:PARAM -w values.txt:VAL -u https://example.org/?PARAM=VAL -mr "VAL" -c

  More information and examples: https://github.com/ffuf/ffuf

Interaktiver Modus

Durch Drücken von ENTER während der ffuf-Ausführung wird der Prozess angehalten und der Benutzer landet in einem shell-ähnlichen interaktiven Modus:

entering interactive mode
type "help" for a list of commands, or ENTER to resume.
> help

available commands:
 afc  [value]             - append to status code filter 
 fc   [value]             - (re)configure status code filter 
 afl  [value]             - append to line count filter 
 fl   [value]             - (re)configure line count filter 
 afw  [value]             - append to word count filter 
 fw   [value]             - (re)configure word count filter 
 afs  [value]             - append to size filter 
 fs   [value]             - (re)configure size filter 
 aft  [value]             - append to time filter 
 ft   [value]             - (re)configure time filter 
 rate [value]             - adjust rate of requests per second (active: 0)
 queueshow                - show job queue
 queuedel [number]        - delete a job in the queue
 queueskip                - advance to the next queued job
 restart                  - restart and resume the current ffuf job
 resume                   - resume current ffuf job (or: ENTER) 
 show                     - show results for the current job
 savejson [filename]      - save current matches to a file
 help                     - you are looking at it
>

In diesem Modus können Filter neu konfiguriert, die Warteschlange verwaltet und der aktuelle Zustand auf der Festplatte gespeichert werden.

Beim (Neu-)Konfigurieren der Filter werden diese im Nachhinein angewendet, und alle False-Positive-Treffer aus dem Speicher, die durch die neu hinzugefügten Filter herausgefiltert worden wären, werden gelöscht.

Der neue Stand der Treffer kann mit dem Befehl show ausgegeben werden, der alle Treffer so ausgibt, als wären sie von ffuf gefunden worden.

Da „negative“ Treffer nicht im Speicher abgelegt werden, können gelockerte Filter die verlorenen Treffer leider nicht zurückbringen. Für ein solches Szenario kannst du den Befehl restart verwenden, der den Zustand zurücksetzt und den aktuellen Job von Anfang an startet.

Mitwirken

Fehlerberichte, Funktionsanfragen und Pull-Requests sind willkommen. Siehe CONTRIBUTING.md für den Einstieg und den Abschnitt „Contributing“ im Wiki für die Architektur- und Testdokumentation.

Lizenz

ffuf wird unter der MIT-Lizenz veröffentlicht. Siehe LICENSE.

ffuf v2.2.1

Kategorien