ffuf : Tutoriel complet pour débutant en fuzzing web

Vous avez déjà entendu parler de ffuf, mais vous ne savez pas vraiment comment l’utiliser pour découvrir des fichiers, dossiers ou pages cachées sur un site web ? Dans ce tutoriel complet, vous allez apprendre à maîtriser cet outil de fuzzing web étape par étape, même si vous débutez complètement en cybersécurité. Installation, premières commandes, utilisation des wordlists, filtres, découverte de répertoires et tests de paramètres HTTP : tout sera expliqué simplement avec des exemples concrets.

L’objectif n’est pas seulement de lancer des commandes dans un terminal, mais de comprendre ce que fait réellement ffuf et comment l’utiliser intelligemment dans un audit web ou sur vos propres projets. À la fin de ce guide, vous serez capable de réaliser vos premiers scans proprement, d’analyser les résultats et d’éviter les erreurs classiques des débutants.

• Comprendre enfin à quoi sert réellement ffuf et comment repérer rapidement des fichiers, dossiers ou pages invisibles depuis un navigateur classique.
• Apprendre à lancer des scans propres et efficaces avec les bonnes commandes, les bonnes wordlists et des filtres capables d’éviter les faux positifs les plus frustrants.
• Gagner une vraie méthodologie pour tester un site web localement, analyser les réponses HTTP et utiliser ffuf comme un outil sérieux d’audit et de cybersécurité.

Une application web peut contenir des pages d’administration, des fichiers de sauvegarde, des dossiers de test, des paramètres oubliés ou encore des sous-domaines qui ne sont pas directement affichés. C’est précisément là que ffuf entre en scène. Son nom complet est Fuzz Faster U Fool. C’est un outil de fuzzing web en ligne de commande, écrit en Go, très utilisé pour découvrir des répertoires, des fichiers, des hôtes virtuels et des paramètres GET ou POST.

Qu’est-ce que Ffuf ?

ffuf est un programme qui envoie automatiquement de nombreuses requêtes vers une application web en remplaçant un mot-clé par les valeurs contenues dans une liste. Ce mot-clé, c’est FUZZ.

Par exemple, si vous testez cette adresse :

https://exemple.local/FUZZ

ffuf peut remplacer FUZZ par :

admin
login
backup
test
uploads

Il va donc tester :

https://exemple.local/admin
https://exemple.local/login
https://exemple.local/backup
https://exemple.local/test
https://exemple.local/uploads

Ensuite, il observe les réponses du serveur. Une page qui répond en 200, une autre en 403, une autre avec une taille inhabituelle… Tout cela peut donner des indices.

👉 Tout savoir sur : Les codes de statut HTTP

À quoi sert Fuff en cybersécurité ?

ffuf sert principalement à faire de la découverte de contenu web. En français simple, cela signifie : chercher ce qui existe sur un site mais qui n’est pas forcément visible.

Il peut servir à trouver des dossiers oubliés, des fichiers sensibles, des sous-domaines, des paramètres cachés ou des routes d’API. Kali Linux décrit ffuf comme un fuzzer web rapide permettant la découverte de répertoires, d’hôtes virtuels sans enregistrement DNS, ainsi que le fuzzing de paramètres GET et POST.

Dans un audit de sécurité, cela permet de répondre à une question très concrète :

“Qu’est-ce qui est accessible sur cette application et que le développeur n’a peut-être pas prévu de montrer ?”

Pourquoi Fuff est devenu incontournable en pentest

ffuf est apprécié parce qu’il est rapide, flexible et relativement simple à prendre en main. Il fonctionne en ligne de commande, ce qui peut impressionner au début, mais vous allez voir que sa logique reste assez claire.

Il est aussi très pratique parce qu’il ne se limite pas aux URL. Vous pouvez placer FUZZ dans un chemin, un paramètre, un header HTTP ou même dans le corps d’une requête POST. Cela ouvre beaucoup de possibilités pour tester proprement une application.

Différence entre Fuff, Dirb, Gobuster et Feroxbuster

Dirb, Gobuster, Feroxbuster et ffuf appartiennent à la même grande famille : les outils de découverte web. Ils testent des mots issus de wordlists pour voir si des ressources existent.

👉 Découvrez comment créer votre Wordlist ou comment générer automatiquement une wodrlist avec Crunch.

Dirb est ancien et simple. Gobuster est rapide et populaire. Feroxbuster est très efficace pour les recherches récursives. ffuf, lui, brille par sa souplesse : il peut fuzzer presque n’importe quelle partie d’une requête.

Pour un débutant, ffuf est un excellent choix, car il permet de comprendre les bases tout en gardant de vraies possibilités avancées.

Dans quels cas utiliser Fuff ?

Vous pouvez utiliser ffuf dans plusieurs situations pédagogiques ou professionnelles. Par exemple, lorsque vous auditez votre propre site WordPress, une API en développement, un lab de cybersécurité ou une application locale installée sur votre machine.

Imaginons que vous développiez un petit site PHP. Vous avez peut-être créé un dossier /admin, un fichier config.php, un ancien backup.zip, puis vous avez oublié de les supprimer. ffuf peut vous aider à repérer ce type d’oubli avant qu’une personne mal intentionnée ne le fasse à votre place.

Les limites et précautions légales avant de commencer

ffuf n’est pas magique. Il ne devine pas tout seul ce qui existe. Il teste des valeurs à partir d’une wordlist. Si votre liste ne contient pas le bon mot, ffuf peut passer à côté.

Autre point essentiel : ffuf envoie beaucoup de requêtes. Mal configuré, il peut surcharger un serveur. Il faut donc l’utiliser avec respect, prudence et autorisation. Sur un site de production, limitez la vitesse, testez pendant les bons créneaux et prévenez les personnes concernées.

Comprendre le fonctionnement du fuzzing web

Le fuzzing consiste à envoyer automatiquement de nombreuses valeurs à un programme pour observer ses réactions. Dans le cas du web, on envoie plusieurs requêtes HTTP en modifiant une partie de l’adresse ou de la requête.

Imaginez que vous cherchiez une clé dans un trousseau. Vous les essayez une par une jusqu’à trouver celle qui ouvre la porte. Une wordlist, c’est votre trousseau. ffuf, c’est la main très rapide qui teste les clés. Et le serveur web, c’est la porte.

Comment les serveurs web répondent aux requêtes

Quand votre navigateur demande une page, le serveur répond avec un contenu et un code HTTP. Ce code indique globalement ce qui s’est passé.

• Une page existante répond souvent en 200.
• Une page absente répond souvent en 404.
• Une page interdite peut répondre en 403.
• Une redirection utilise souvent 301 ou 302.
• Un 500 signale une erreur côté serveur.

ffuf observe ces réponses et les affiche sous forme de résultats.

Les notions importantes : endpoints, paramètres, headers et statuts HTTP

Un endpoint est une adresse précise d’une application. Par exemple :

/api/users
/admin/login
/dashboard

Un paramètre est une information envoyée dans l’URL ou dans une requête. Exemple :

/search?q=ordinateur

• Ici, q est un paramètre.

Un header HTTP est une information supplémentaire envoyée avec la requête. Par exemple, le navigateur peut envoyer un header User-Agent pour dire quel logiciel il utilise.

Enfin, le statut HTTP est le code de réponse du serveur. C’est souvent le premier indice que vous regarderez dans ffuf.

Attention tout de même : certains sites répondent toujours en 200, même quand la page n’existe pas vraiment. C’est ce qu’on appelle parfois des faux positifs. Et oui, même les serveurs web savent jouer à cache-cache pour mieux se protéger.

Pourquoi certains fichiers restent cachés aux moteurs de recherche

Un fichier peut être accessible sans être indexé par Google. Il suffit qu’aucune page publique ne fasse de lien vers lui, qu’il soit bloqué par un fichier robots.txt, ou qu’il appartienne à une zone technique oubliée.

Par exemple, un fichier comme celui-ci peut exister sans être visible :

https://exemple.local/backup-site.zip

S’il n’y a aucun lien vers ce fichier, un visiteur classique ne le verra jamais. Mais un outil de fuzzing peut le tester si la wordlist contient backup-site.zip.

Installer Fuff sur Windows, Linux et macOS

Télécharger Fuff rapidement : La méthode la plus propre consiste à passer par le dépôt officiel GitHub ou par le gestionnaire de paquets de votre système. Le projet officiel présente ffuf comme un “fast web fuzzer written in Go”, c’est-à-dire un fuzzer web rapide écrit en Go.

Sur Linux, vous pouvez souvent l’installer avec le gestionnaire de paquets. Sur macOS, Homebrew est très pratique. Sur Windows, vous pouvez utiliser un binaire précompilé ou passer par Go.

Installer Fuff sur Linux

Sur Kali Linux ou Linux, l’installation est très simple :

sudo apt update
sudo apt install ffuf

1. La première ligne met à jour la liste des paquets disponibles.
2. La seconde installe ffuf.

Ensuite, vérifiez l’installation :

ffuf -h

Cette commande affiche l’aide. Si vous voyez les options de ffuf, c’est bon signe.

Installer Fuff avec Go sur macOS

Si vous avez Go installé, vous pouvez installer ffuf avec :

go install github.com/ffuf/ffuf/v2@latest

Cette commande demande à Go de télécharger et compiler la dernière version disponible du module ffuf v2.

Ensuite, assurez-vous que le dossier des binaires Go est bien dans votre variable PATH. Sinon, votre terminal risque de répondre quelque chose comme “commande introuvable”, ce qui est toujours un petit moment de solitude.

👉 Pour aller plus loin : Path, Shell et Alias

Vérifier que Fuff fonctionne correctement

Tapez simplement :

ffuf -version

ou :

ffuf -h

Si ffuf répond, il est prêt.

Pour un premier test sans risque, utilisez un environnement local, un lab comme DVWA, Juice Shop, Metasploitable, ou un site de test que vous possédez.

Mettre Fuff à jour facilement

Avec Kali ou Debian :

sudo apt update
sudo apt upgrade ffuf

Avec Go :

go install github.com/ffuf/ffuf/v2@latest

Gardez votre outil à jour, car les options peuvent évoluer et des corrections peuvent être publiées.

Résoudre les problèmes d’installation les plus fréquents

Si ffuf n’est pas reconnu, le problème vient souvent du PATH. Si vous avez installé ffuf avec Go, vérifiez que le dossier ~/go/bin est bien accessible.

Sur Linux ou macOS, vous pouvez tester :

echo $PATH

Si vous ne voyez pas le dossier Go, ajoutez-le dans votre configuration shell.

Prendre en main Fuff pour la première fois

Comprendre la syntaxe de base de Fuff, une commande ffuf minimale ressemble à ceci :

ffuf -w wordlist.txt -u http://site.local/FUZZ

• L’option -w indique la wordlist à utiliser.
• L’option -u indique l’URL à tester.
• Le mot FUZZ indique l’endroit où ffuf doit injecter chaque mot de la liste.

La structure d’une commande simple

Prenons un exemple plus parlant :

ffuf -w /usr/share/seclists/Discovery/Web-Content/common.txt -u http://localhost/FUZZ

Ici, ffuf lit chaque ligne du fichier common.txt. Puis il remplace FUZZ dans l’URL par chaque valeur. Si la wordlist contient admin, ffuf teste http://localhost/admin.

Le rôle du mot-clé FUZZ

FUZZ est le repère principal de ffuf. Sans lui, ffuf ne sait pas où placer les valeurs de la wordlist. Il faut absolument une wordlist et un mot-clé FUZZ placé quelque part dans la requête.

Vous pouvez placer FUZZ dans plusieurs endroits :

# Dans le chemin
ffuf -w mots.txt -u http://site.local/FUZZ

# Dans un paramètre GET
ffuf -w mots.txt -u "http://site.local/search?FUZZ=test"

# Dans une valeur de paramètre
ffuf -w mots.txt -u "http://site.local/page?id=FUZZ"

Voici un exemple de wordlist, simple, que vous pouvez utiliser pour vos petits tests. Copier / coller et enregistrez le dans un fichier avec l’extension .txt :

admin
login
dashboard
panel
config
backup
uploads
images
api
test
dev
staging
old
private
secret
database
db
phpmyadmin
.env
robots.txt

Réaliser son premier scan de répertoires

Pour scanner les dossiers courants d’un site local :

ffuf -w common.txt -u http://localhost/FUZZ

Si ffuf trouve une réponse intéressante, il affiche une ligne avec le mot testé, le code HTTP, la taille de la réponse, le nombre de mots et parfois le nombre de lignes.

Lire et comprendre les résultats affichés

Un résultat peut ressembler à ceci :

admin                   [Status: 200, Size: 1540, Words: 210, Lines: 45]
uploads                 [Status: 301, Size: 178, Words: 6, Lines: 8]
backup.zip              [Status: 200, Size: 120304, Words: 1, Lines: 1]

Ici, admin semble exister. uploads redirige peut-être vers /uploads/. Et backup.zip mérite clairement votre attention si vous auditez votre propre site, car un fichier de sauvegarde public peut contenir des informations sensibles.

Interpréter les tailles, statuts et temps de réponse

Ne regardez pas uniquement le statut HTTP. La taille est souvent très importante. Si toutes les pages inexistantes font 1234octets et qu’un résultat fait 120304 octets, il se passe probablement quelque chose.

Le temps de réponse peut aussi être utile. Une réponse anormalement lente peut indiquer un traitement différent côté serveur.

Exemple concret :

1. Je me place sur mon bureau avec cd desktop car ma wordlist test.txt est sur mon bureau (Apprenez à vous situer dans le terminal)
2. Je lance le scan de mon serveur local qui est sur le port 8888 avec la commande : ffuf -w test.txt -u http://localhost:8888/FUZZ

FFUF a testé automatiquement plusieurs chemins d’URL à partir de la wordlist test.txt.

Par exemple, il a essayé :

/phpmyadmin
/login
/backup
/test

Le but est de voir si ces pages ou dossiers existent sur le serveur.

Voici la signification des résultats :

phpmyadmin [Status: 301]

Cela veut dire que :

• le dossier /phpmyadmin existe probablement ;
• le serveur a répondu avec le code HTTP 301.

Le code 301 signifie :

redirection permanente.

En général, cela veut dire que le serveur redirige vers :

/phpmyadmin/

Les chemins trouvés

FFUF a détecté plusieurs chemins existants :

• phpmyadmin → probablement une interface phpMyAdmin ;
• backup → un dossier de sauvegarde ;
• login → une page de connexion ;
• test → un dossier de test ou de développement.

Pourquoi c’est intéressant ?

Ces dossiers peuvent parfois révéler :

• des interfaces d’administration,
• des fichiers oubliés,
• des sauvegardes sensibles,
• des pages cachées.

• C’est pour cela que ffuf est souvent utilisé en audit de sécurité et en pentest.

Utiliser les wordlists efficacement

Revenons sur un concept primordial : Qu’est-ce qu’une wordlist ? Une wordlist est un fichier texte contenant une valeur par ligne. Pour ffuf, chaque ligne devient une tentative.

admin
login
dashboard
uploads
backup.zip
config.php

Cette liste est simple, mais elle suffit à comprendre le principe.

Où trouver de bonnes wordlists pour Fuff

La collection la plus connue est SecLists. Elle contient des listes pour les répertoires web, les fichiers, les sous-domaines, les paramètres, les noms d’utilisateurs et bien d’autres usages.

Sur Kali ou Linux, SecLists peut être installé avec :

sudo apt install seclists

Les listes sont souvent disponibles dans :

/usr/share/seclists/

Découvrir SecLists et ses principales catégories

Pour ffuf, vous utiliserez souvent :

Discovery/Web-Content/
Discovery/DNS/
Fuzzing/

Discovery/Web-Content contient des listes pour découvrir des fichiers et dossiers. Discovery/DNS sert plutôt aux sous-domaines. Fuzzing contient des listes utiles pour tester des paramètres ou des valeurs spécifiques.

Installer SecLists sur macOS

SecLists est donc une énorme collection de wordlists utilisées en :

• fuzzing,
• brute force,
• OSINT,
• pentest,
• découverte de fichiers et dossiers.

Elle est souvent utilisée avec des outils comme ffuf.

Commençons par vérifier que Git est installé. Dans le terminal, tapez :

git --version

Si un numéro de version apparaît, Git est déjà installé.

Il faut ensuite télécharger SecLists. Placez-vous dans le dossier souhaité, par exemple, le bureau de votre Mac :

cd Desktop

Puis clonez le dépôt :

git clone https://github.com/danielmiessler/SecLists.git

Le téléchargement peut prendre un peu de temps car SecLists contient énormément de fichiers.

Une fois terminé, un dossier SecLists apparaîtra :

Desktop/
└── SecLists/

Entrez dans le dossier :

cd SecLists

Puis affichez son contenu :

ls

Vous verrez plusieurs catégories :

Discovery
Passwords
Fuzzing
Usernames
Web-Shells

Vous pouvez maintenant utiliser une wordlist de SecLists avec ffuf :

ffuf -w ~/Desktop/SecLists/Discovery/Web-Content/common.txt -u http://localhost/FUZZ

Ici :

• common.txt contient des noms de pages et dossiers fréquents ;
• FUZZ sera remplacé automatiquement par chaque mot de la liste.

Choisir la bonne wordlist selon son objectif

Une grosse wordlist n’est pas toujours meilleure. Elle peut ralentir votre scan, générer beaucoup de bruit et fatiguer inutilement le serveur.

Pour débuter, choisissez une liste courte comme common.txt. Ensuite, si vous avez besoin d’aller plus loin, passez sur des listes plus complètes.

Créer sa propre wordlist personnalisée

Une bonne pratique consiste à créer une wordlist adaptée au site testé. Si vous auditez un site e-commerce, vous pouvez inclure :

admin
commande
facture
client
panier
paiement
stock
export

Vous pouvez créer un fichier :

nano ma-wordlist.txt

Puis lancer :

ffuf -w ma-wordlist.txt -u http://localhost/FUZZ

Les erreurs liées aux wordlists

L’erreur classique consiste à lancer une wordlist énorme sans réfléchir. Cela donne l’impression de “faire un gros scan”, mais ce n’est pas forcément intelligent. Un bon test commence souvent petit, proprement, puis s’élargit si nécessaire.

Découvrir des répertoires cachés avec Fuff

Pour scanner un site web pour trouver des dossiers cachés, voici une commande de base :

ffuf -w /usr/share/seclists/Discovery/Web-Content/common.txt -u http://localhost/FUZZ

Chaque mot est testé comme un chemin potentiel.

Identifier les panneaux d’administration oubliés

Pour chercher des interfaces d’administration :

ffuf -w admin-words.txt -u http://localhost/FUZZ

Votre fichier admin-words.txt peut contenir :

admin
administrator
backend
panel
gestion
connexion
login

Si vous trouvez /admin, ne concluez pas immédiatement à une faille. Une page d’administration peut exister normalement. Le risque dépend de son exposition, de son système d’authentification et de sa configuration.

Détecter les sauvegardes et fichiers sensibles

Les fichiers de sauvegarde sont un grand classique :

ffuf -w backups.txt -u http://localhost/FUZZ

Avec une wordlist comme :

backup.zip
site.zip
www.zip
db.sql
database.sql
config.php.bak
.env

Un fichier .env ou .sql accessible publiquement peut contenir des mots de passe. Sur vos propres sites, ce genre de test est très utile avant une mise en ligne.

Repérer les extensions intéressantes (.php, .bak, .zip…)

ffuf permet d’ajouter des extensions avec l’option -e :

ffuf -w common.txt -u http://localhost/FUZZ -e .php,.bak,.zip,.txt

Ici, si la wordlist contient config, ffuf peut tester config.php, config.bak, config.zip et config.txt.

Éviter les faux positifs pendant un scan

Un faux positif est un résultat qui semble intéressant, mais qui ne l’est pas. Par exemple, un site peut répondre 200 pour toutes les URL, même inexistantes.

Pour nettoyer les résultats, vous pouvez filtrer par taille :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

ffuf -w common.txt -u http://localhost/FUZZ -fs 1234

L’option -fs filtre une taille précise. Les options de filtrage comme -fs, -fw, -fl ou -fc font partie des filtres documentés de ffuf.

Rechercher des fichiers spécifiques avec Fuff

Trouver des fichiers de configuration exposés car certains fichiers ne devraient jamais être publics :

ffuf -w sensitive-files.txt -u http://localhost/FUZZ

Exemple de sensitive-files.txt :

.env
config.php
config.php.bak
composer.json
package.json
database.sql
backup.sql

Pour un développeur web, c’est un test très utile. Vous vérifiez que votre serveur ne sert pas des fichiers dangereux.

Scanner plusieurs extensions en une seule commande

Vous pouvez combiner wordlist et extensions :

ffuf -w common.txt -u http://localhost/FUZZ -e .php,.html,.txt,.bak

C’est pratique pour chercher des variantes :

admin.php
admin.html
admin.txt
admin.bak

Détecter des fichiers temporaires ou oubliés

Les fichiers temporaires sont souvent créés pendant le développement :

index.php~
test.old
config.save
backup.tar.gz

Vous pouvez les rechercher avec une wordlist spécialisée :

ffuf -w temp-files.txt -u http://localhost/FUZZ

Utiliser des filtres pour obtenir des résultats propres

Pour n’afficher que les réponses 200 :

ffuf -w common.txt -u http://localhost/FUZZ -mc 200

L’option -mc signifie “match code”.

Elle permet de garder seulement certains codes HTTP. D’après l’aide officielle, ffuf utilise par défaut plusieurs codes comme 200-299, 301, 302, 307, 401, 403, 405 ou 500.

Fuzzer des sous-domaines avec Fuff

Comprendre le fuzzing DNS. Un sous-domaine est une partie placée avant le nom de domaine principal :

admin.exemple.com
api.exemple.com
dev.exemple.com

Le fuzzing de sous-domaines consiste à tester plusieurs noms pour voir lesquels existent.

Rechercher des sous-domaines cachés

Une commande simple peut ressembler à ceci :

ffuf -w subdomains.txt -u http://FUZZ.exemple.com

Ici, FUZZ est placé dans le sous-domaine. ffuf teste donc admin.exemple.com, api.exemple.com, dev.exemple.com, etc.

Utiliser Fuff avec un header Host

Parfois, un serveur héberge plusieurs sites sur la même adresse IP. On parle alors d’hôtes virtuels, ou virtual hosts.

Vous pouvez tester des hôtes virtuels avec le header Host :

ffuf -w subdomains.txt -u http://192.168.1.20/ -H "Host: FUZZ.exemple.local"

L’option -H ajoute un header HTTP. Ici, ffuf remplace FUZZ dans le header Host.

Détecter les environnements de test et préproduction

Les sous-domaines comme ceux-ci sont fréquents :

dev
test
preprod
staging
api
admin

Ils peuvent parfois exposer des versions moins protégées d’un site. Dans un audit autorisé, les identifier permet de corriger les oublis avant qu’ils ne deviennent problématiques.

Les limites du fuzzing de sous-domaines

Le fuzzing de sous-domaines dépend fortement de votre wordlist, de la configuration DNS et des protections en place. Certains domaines utilisent des réponses génériques, ce qui peut produire beaucoup de faux positifs.

Dans ce cas, observez les tailles de réponses et filtrez ce qui revient tout le temps.

Utiliser Fuff pour tester des paramètres HTTP

Les paramètres GET sont visibles dans l’URL, pour Fuzzer des paramètres GET :

http://localhost/search.php?q=test

Vous pouvez chercher des noms de paramètres :

ffuf -w params.txt -u "http://localhost/search.php?FUZZ=test"

Si votre wordlist contient q, search, id, ffuf testera :

?q=test
?search=test
?id=test

Tester des paramètres POST

Les paramètres POST sont envoyés dans le corps de la requête. Exemple :

ffuf -w params.txt -u http://localhost/login.php -X POST -d "FUZZ=test" -H "Content-Type: application/x-www-form-urlencoded"

Ici, -X POST indique la méthode HTTP. -d envoie des données. Le header Content-Type précise le format envoyé.

Découvrir des paramètres cachés dans une application web

Certaines applications acceptent des paramètres non documentés. Pour les découvrir, vous pouvez tester une liste de noms :

ffuf -w params.txt -u "http://localhost/profile.php?FUZZ=1" -fs 1234

Si une réponse change quand un paramètre précis est envoyé, cela peut être intéressant. Attention : “intéressant” ne veut pas forcément dire vulnérable. Cela signifie simplement qu’il faut analyser.

Utiliser Fuff avec des requêtes JSON

Pour une API JSON :

ffuf -w params.txt -u http://localhost/api/user -X POST -H "Content-Type: application/json" -d '{"FUZZ":"test"}'

Cette commande teste différents noms de champs JSON.

Exemple si la wordlist contient role :

{"role":"test"}

Ajouter des cookies et headers personnalisés

Si une page nécessite une session connectée, vous pouvez ajouter un cookie :

ffuf -w common.txt -u http://localhost/admin/FUZZ -H "Cookie: PHPSESSID=votre_session"

Vous pouvez aussi ajouter un user-agent :

ffuf -w common.txt -u http://localhost/FUZZ -H "User-Agent: CreaBlog-Test"

C’est utile pour des tests propres et identifiables.

Exploiter les options avancées de Fuff

Utiliser les filtres de taille et de statut

Les filtres rendent ffuf beaucoup plus lisible. Par exemple :

ffuf -w common.txt -u http://localhost/FUZZ -fc 404

Ici, -fc 404 exclut les réponses en 404.

Autre exemple :

ffuf -w common.txt -u http://localhost/FUZZ -fs 1234

Ici, on exclut toutes les réponses de taille 1234, souvent associées aux pages inexistantes.

Exclure les réponses inutiles

Si vous voyez que presque tous les résultats ont la même taille, filtrez cette taille. Si presque tous les résultats redirigent en 302, filtrez ce code si ce n’est pas utile à votre recherche.

ffuf -w common.txt -u http://localhost/FUZZ -fc 404,302

Cette commande masque les 404 et les 302.

Gérer la vitesse et le nombre de threads

ffuf est rapide, parfois trop rapide pour un serveur fragile. Vous pouvez limiter le nombre de threads :

ffuf -w common.txt -u http://localhost/FUZZ -t 10

-t 10 limite le nombre de traitements parallèles. Pour débuter, c’est plus respectueux.

Vous pouvez aussi limiter le débit :

ffuf -w common.txt -u http://localhost/FUZZ -rate 50

Cela limite le nombre de requêtes par seconde.

Sauvegarder les résultats dans un fichier

Pour garder une trace :

ffuf -w common.txt -u http://localhost/FUZZ -o resultats.json -of json

Ici, -o définit le fichier de sortie et -of le format. C’est pratique pour analyser les résultats après le scan.

Afficher uniquement les résultats pertinents

Pour ne garder que les statuts 200 et 403 :

ffuf -w common.txt -u http://localhost/FUZZ -mc 200,403

Un 403 peut être très intéressant : il signifie souvent que la ressource existe, mais qu’elle est interdite.

Comprendre les options les plus utiles de Fuff

Les options à connaître au début sont :

-w   # indique la wordlist
-u   # indique l’URL à tester
-H   # ajoute un header HTTP
-X   # définit la méthode HTTP
-d   # envoie des données POST
-mc  # conserve certains codes HTTP
-fc  # filtre certains codes HTTP
-fs  # filtre une taille de réponse
-t   # règle le nombre de threads
-o   # sauvegarde les résultats

Gardez cette petite boîte à outils sous la main. Elle couvre déjà une grande partie des usages courants.

Automatiser ses scans avec Fuff

Créer des scripts Bash simples avec Fuff

Pour éviter de retaper toujours la même commande, vous pouvez créer un script :

#!/bin/bash

# URL cible locale
URL="http://localhost"

# Wordlist utilisée
WORDLIST="/usr/share/seclists/Discovery/Web-Content/common.txt"

# Lancement du scan ffuf
ffuf -w "$WORDLIST" -u "$URL/FUZZ" -fc 404 -o resultats.json -of json

Enregistrez ce fichier sous scan.sh, puis rendez-le exécutable (La commande CHMOD pour gérer les permissions):

chmod +x scan.sh

Lancez-le :

./scan.sh

Automatiser plusieurs scans successifs

Vous pouvez scanner plusieurs extensions :

#!/bin/bash

URL="http://localhost"
WORDLIST="common.txt"

for EXT in php txt bak zip
do
  ffuf -w "$WORDLIST" -u "$URL/FUZZ.$EXT" -fc 404 -o "resultats-$EXT.json" -of json
done

Cette boucle teste plusieurs extensions et sauvegarde un fichier de résultat par extension.

Générer des rapports exploitables

Le format JSON est pratique si vous voulez analyser les résultats avec un script. Pour un usage humain, vous pouvez aussi produire un CSV :

ffuf -w common.txt -u http://localhost/FUZZ -o resultats.csv -of csv

Ensuite, vous pouvez ouvrir le fichier dans un tableur pour trier par statut, taille ou URL.

Intégrer Fuff dans une méthodologie OSINT ou pentest

Dans une démarche sérieuse, ffuf n’arrive pas seul. Il s’intègre dans une méthode :

1. Vous commencez par identifier la cible autorisée,
2. vous collectez les informations publiques,
3. vous repérez les technologies utilisées,
4. puis vous lancez des scans ciblés avec ffuf.
5. Ensuite, vous analysez les résultats manuellement.

L’outil aide, mais c’est votre cerveau qui conclut. Et c’est très bien ainsi : aucun terminal ne remplacera votre bon sens.

Utiliser Fuff efficacement

Éviter de surcharger un serveur

Réduisez la vitesse sur les serveurs fragiles :

ffuf -w common.txt -u http://exemple.local/FUZZ -rate 20 -t 5

Cela évite de transformer votre audit en test de charge improvisé. Ce n’est pas le même métier, et le serveur risque de vous le rappeler assez vite.

Respecter le cadre légal et l’autorisation des tests

N’utilisez ffuf que sur des systèmes qui vous appartiennent ou pour lesquels vous avez une autorisation explicite. Un scan non autorisé peut être considéré comme une attaque.

Pour apprendre, privilégiez les environnements locaux : DVWA, Juice Shop, machines de lab, conteneurs Docker ou projets personnels.

Organiser ses résultats proprement

Créez un dossier par audit (gérer vos fichiers et dossiers depuis le terminal):

mkdir audit-local
cd audit-local

Puis sauvegardez vos sorties :

ffuf -w common.txt -u http://localhost/FUZZ -o scan-web.json -of json

Vous vous remercierez plus tard. Rien n’est plus pénible qu’un dossier Téléchargements rempli de fichiers resultats-final-v2-vraiment-final.json.

Choisir les bonnes cibles et les bons timings

Sur un site de production, testez pendant une période calme. Prévenez les équipes concernées. Documentez les commandes utilisées. Plus votre démarche est propre, plus vos résultats seront utiles.

Réduire les faux positifs et gagner du temps

Commencez toujours par observer les réponses normales. Testez une URL qui n’existe pas :

curl -i http://localhost/page-inventee-123

Regardez le code, la taille et le comportement. Ensuite, utilisez ces informations pour filtrer dans ffuf.

Les erreurs des débutants avec Fuff

Utiliser une mauvaise wordlist

Une wordlist trop générale peut produire beaucoup de bruit. Une wordlist trop petite peut manquer des résultats. Adaptez-la au contexte.

Pour un site PHP, cherchez des .php, .bak, .sql. Pour une API, cherchez plutôt des endpoints comme users, login, token, admin, v1.

Oublier les filtres de réponses

Sans filtres, ffuf peut afficher des centaines de lignes inutiles. Prenez l’habitude d’utiliser -fc, -fs ou -mc.

Exemple :

ffuf -w common.txt -u http://localhost/FUZZ -fc 404

Scanner trop rapidement

La vitesse n’est pas toujours votre amie. Un scan trop agressif peut ralentir le serveur, fausser les résultats ou déclencher des protections.

Commencez doucement :

ffuf -w common.txt -u http://localhost/FUZZ -t 5 -rate 20

Mal interpréter les codes HTTP

Un 403 n’est pas forcément une faille. Un 200 n’est pas forcément une page utile. Un 404 peut parfois cacher une logique personnalisée.

Analysez les résultats dans le navigateur ou avec curl :

curl -i http://localhost/admin

Négliger les extensions de fichiers

Si vous cherchez seulement /admin, vous pouvez rater /admin.php. Pensez aux extensions :

ffuf -w common.txt -u http://localhost/FUZZ -e .php,.html,.bak

Ignorer les réponses inhabituelles

Une taille différente, un temps de réponse plus long, un code rare : ce sont parfois les meilleurs indices. Ne lisez pas les résultats comme une simple liste. Observez-les comme un enquêteur.

Cas concret : trouver une interface d’administration cachée

Présentation du mini projet : Imaginons un petit site local de formation, installé sur votre machine. Votre objectif est simple : vérifier si une interface d’administration oubliée est accessible.

Nous allons utiliser une cible fictive :

http://localhost

Dans la vraie vie, remplacez uniquement par votre propre environnement de test.

Préparer l’environnement de test

Créez une petite wordlist :

nano admin-words.txt

Ajoutez :

admin
login
connexion
backend
dashboard
panel
gestion

Cette wordlist est courte, mais adaptée à notre objectif.

Lancer un scan de répertoires

Lancez ffuf :

ffuf -w admin-words.txt -u http://localhost/FUZZ

ffuf teste chaque mot à la place de FUZZ.

Filtrer les résultats inutiles

Si vous constatez que les pages inexistantes répondent toutes avec une taille de 1234, filtrez-les :

ffuf -w admin-words.txt -u http://localhost/FUZZ -fs 1234

Si vous voulez seulement les réponses 200 et 403 :

ffuf -w admin-words.txt -u http://localhost/FUZZ -mc 200,403

Identifier une page sensible intéressante

Supposons que ffuf affiche :

admin                   [Status: 200, Size: 2480, Words: 320, Lines: 72]
dashboard               [Status: 403, Size: 512, Words: 12, Lines: 8]

/admin semble accessible. /dashboard existe peut-être, mais l’accès est interdit. Dans un audit défensif, ces deux informations sont utiles.

Analyser les résultats obtenus

Ouvrez /admin dans votre navigateur ou utilisez :

curl -i http://localhost/admin

Demandez-vous ensuite : cette page doit-elle être publique ? Est-elle protégée ? Peut-on la trouver depuis le menu ? Faut-il ajouter une authentification, une restriction IP ou modifier la configuration serveur ?

Le but n’est pas de “forcer” quoi que ce soit. Le but est d’identifier une exposition et de la corriger.

Ce qu’il faut retenir de ce cas pratique

Avec une wordlist courte et une commande simple, vous avez découvert des routes potentiellement sensibles. C’est exactement la force de ffuf : aller vite, tester proprement et vous donner des indices.

Ensuite, l’analyse humaine prend le relais.

Aller plus loin avec Fuff

Associer Fuff avec Burp Suite

Burp Suite permet d’intercepter des requêtes HTTP. Vous pouvez récupérer une requête complexe, comprendre ses headers, ses cookies et son corps POST, puis reproduire une partie de cette requête avec ffuf.

Dans un apprentissage progressif, Burp aide à voir ce que ffuf envoie. C’est un excellent duo.

Utiliser Fuff avec des proxies

Vous pouvez envoyer le trafic ffuf vers un proxy :

ffuf -w common.txt -u http://localhost/FUZZ -x http://127.0.0.1:8080

Cela permet d’observer les requêtes dans un outil comme Burp Suite. Pratique pour comprendre, déboguer et apprendre.

Intégrer Fuff dans une méthodologie de bug bounty

En bug bounty, ffuf peut aider à découvrir des surfaces oubliées. Mais chaque programme a ses règles. Certains interdisent les scans agressifs. D’autres limitent les domaines autorisés.

Lisez toujours les règles avant de lancer quoi que ce soit. Le bouton “Entrée” est petit, mais ses conséquences peuvent être grandes.

Découvrir des alternatives complémentaires à Fuff

Vous pouvez aussi explorer Gobuster, Feroxbuster, Dirsearch ou Wfuzz. Chaque outil a ses forces. L’important n’est pas de collectionner les commandes, mais de comprendre ce que vous testez.

Ressources utiles pour progresser en fuzzing web

Pour progresser, entraînez-vous sur des labs légaux, relisez l’aide de ffuf avec ffuf -h, testez plusieurs wordlists, comparez les résultats et prenez des notes.

---

FAQ Ffuf

---

ffuf est un outil simple à lancer, mais très riche à maîtriser. Au départ, vous allez surtout remplacer FUZZ dans une URL et observer les codes HTTP. Puis, petit à petit, vous apprendrez à choisir de meilleures wordlists, à filtrer les faux positifs, à tester des paramètres, à analyser les tailles de réponses et à intégrer vos scans dans une vraie démarche d’audit.

Le plus important, ce n’est pas de lancer la commande la plus impressionnante. C’est de comprendre pourquoi vous la lancez, ce que vous cherchez et comment interpréter ce que le serveur vous répond. ffuf est un peu comme une lampe torche dans une cave : il éclaire des zones oubliées, mais c’est à vous de regarder attentivement ce qui s’y trouve.

Alors, installez un petit lab local, créez votre première wordlist, testez quelques commandes et prenez le temps d’observer. C’est comme cela que vous progresserez réellement en cybersécurité web : avec de la pratique, de la curiosité, et un cadre toujours propre et autorisé.