Justine : /* Authentification (cookies, headers */

2023-10-31T10:13:19Z

Authentification (cookies, headers

← Version précédente		Version du 31 octobre 2023 à 10:13
Ligne 95 :		Ligne 95 :
	ffuf -u https://FUZZDOMAIN/FUZZDIR -w ./domains.txt:FUZZDOMAIN,./wordlist.txt:FUZZDIR		ffuf -u https://FUZZDOMAIN/FUZZDIR -w ./domains.txt:FUZZDOMAIN,./wordlist.txt:FUZZDIR

	== Authentification (cookies, headers ==		== Authentification (cookies, headers) ==
	Souvent, on a besoin de bruteforcer derrière une authentification.		Souvent, on a besoin de bruteforcer derrière une authentification.

Justine : /* Fuzz ? = */

2023-10-31T10:12:37Z

Fuzz ? =

← Version précédente		Version du 31 octobre 2023 à 10:12
Ligne 1 :		Ligne 1 :
	= Fuzz ? ==		= Fuzz ? =
	* [https://en.wikipedia.org/wiki/Approximate_string_matching wikipedia]		* [https://en.wikipedia.org/wiki/Approximate_string_matching wikipedia]

Justine : Page créée avec « = Fuzz ? == * [https://en.wikipedia.org/wiki/Approximate_string_matching wikipedia] Le "fuzzy string searching" (ou, de façon plus claire, ''apporximate string searching'') consiste à trouver des strings qui matchent sur un pattern approximatif (plutôt qu'un pattern exact). La difficulté est de réussir à définir ce qui matche dans une substring, et à quel point le match est proche. Le fuzzy searching est largement utilisé de nos jours, par exemple dans... »

2023-01-04T17:16:12Z

Page créée avec « = Fuzz ? == * [https://en.wikipedia.org/wiki/Approximate_string_matching wikipedia] Le "fuzzy string searching" (ou, de façon plus claire, ''apporximate string searching'') consiste à trouver des strings qui matchent sur un pattern approximatif (plutôt qu'un pattern exact). La difficulté est de réussir à définir ce qui matche dans une substring, et à quel point le match est proche. Le fuzzy searching est largement utilisé de nos jours, par exemple dans... »

Nouvelle page

= Fuzz ? ==
* [https://en.wikipedia.org/wiki/Approximate_string_matching wikipedia]

Le "fuzzy string searching" (ou, de façon plus claire, ''apporximate string searching'') consiste à trouver des strings qui matchent sur un pattern approximatif (plutôt qu'un pattern exact). La difficulté est de réussir à définir ce qui matche dans une substring, et à quel point le match est proche. Le fuzzy searching est largement utilisé de nos jours, par exemple dans une barre de recherche. Si je cherche "écuril" sur Wikipedia, il me trouvera la page pour "écureuil" sans que j'ai à lui dire.

= Ffuf ? =
* [https://codingo.io/tools/ffuf/bounty/2020/09/17/everything-you-need-to-know-about-ffuf.html#before-we-start Une très bonne source]
* [https://github.com/ffuf/ffuf Github du projet ffuf]
* [https://github.com/danielmiessler/SecLists Un tas de wordlists]

Ffuf est un outil servant à scanner un site web pour y trouver des pages non répertoriées (interface admin, pages d'informations système, etc) dans le cadre d'une attaque ou d'un pentest. Il le fait via du fuzzy search, donc. Il est particulièrement utilisé pour faire du "bug bounty".

Ffuf est dispo sur Arch dans le AUR.

== Premier Bruteforce ==

On va créer un dossier, et y créer une première wordlist.txt toute simple, juste pour le test:
<nowiki>
test
test1
admin
panel
</nowiki>

On va ensuite utiliser cette wordlist pour bruteforcer un site qui nous appartient ou que l'on a le droit de scanner.
ffuf -u https://attackme.example.org/FUZZ -w ./wordlist.txt

Ici:
* -u : pour passer l'URL que l'on veut scanner. On est pas obligé de prendre la racine du site, d'ailleurs. Le mot "FUZZ" est un mot clef : c'est à cet emplacement que ffuf va faire son fuzzy search
* -w : pour lui passer la wordlist.

Nous avons un retour asserz clair:
<nowiki>

/'___\ /'___\ /'___\
/\ \__/ /\ \__/ __ __ /\ \__/
\ \ ,__\\ \ ,__\/\ \/\ \ \ \ ,__\
\ \ \_/ \ \ \_/\ \ \_\ \ \ \ \_/
\ \_\ \ \_\ \ \____/ \ \_\
\/_/ \/_/ \/___/ \/_/

v1.3.1
________________________________________________

:: Method : GET
:: URL : https://wiki.squi.fr/index.php/FUZZ
:: Wordlist : FUZZ: wordlist.txt
:: Follow redirects : false
:: Calibration : false
:: Timeout : 10
:: Threads : 40
:: Matcher : Response status: 200,204,301,302,307,401,403,405
________________________________________________

test1 [Status: 301, Size: 0, Words: 1, Lines: 1]
admin [Status: 301, Size: 0, Words: 1, Lines: 1]
panel [Status: 301, Size: 0, Words: 1, Lines: 1]
test [Status: 301, Size: 0, Words: 1, Lines: 1]
[Status: 301, Size: 0, Words: 1, Lines: 1]
:: Progress: [5/5] :: Job [1/1] :: 6 req/sec :: Duration: [0:00:06] :: Errors: 0 ::
</nowiki>

Ici, je n'ai aucun match. SI j'en avais, j'aurais une ligne en plus (ou plusieurs) avec le code de retour, la taille de la page, etc.

== Recursion ==
La récursion consiste à chercher des dossiers, et des sous-dossiers. Par exemple, si je trouve https://attackme.example.com/admin, je peux vouloir trouver un https://attackme.example.com/admin/pannel, par exemple.

Pour ça deux arguments:
* -recursion (avec un seul tiret, grrr) : utiliser de la récursion. Par défaut, il cherche une seule couche de récursion.
* -recursion-depth X : remplacer X par un chiffre pour préciser le nombre de couches de récursion. Plus il y'en a, plus c'est long.

== Extensions ==
En plus de chercher des dossiers dans le site, on peut chercher des fichiers. Pour cela, on va donner les extensions cherchées, avec l'argument -e. Par exemple:
ffuf -u https://attackme.example.org/FUZZ -w ./wordlist.txt -e .txt
matcherait sur un https://attackme.example.org/pannel.txt.

== Scanner plusieurs emplacements ==
Dans nos exemples jusque ici, on a utilisé FUZZ pour scanner un seul emplacement de l'URL. Cela dit, on peut faire du fuzzy search avec plusieurs mots-clefs. On est d'ailleurs pas obligés d'utiliser FUZZ:
ffuf -u https://codingo.io/W1 -w ./wordlist.txt:W1
Ici, je cherche avec le mot clef W1, et je donne la wordlist correspondante. Sur le même principe, on peut avoir plusieurs mots-clef:
ffuf -u https://W1/W2 -w ./wordlist.txt:W2,./domains.txt:W1

Pas mal, non ?

L'ordre des wordlists est important. En mode clusterbomb (mode par défaut) il itère sur toute la première wordlist avant de passer à la suivante. Exemple:
ffuf -u https://FUZZDOMAIN/FUZZDIR -w ./wordlist.txt:FUZZDIR,./domains.txt:FUZZDOMAIN
On suppose qu'on a deux wordlist de 1000 éléments.

Ici, il va commencer par FUZZDIR : il va prendre la première wordlist (FUZZDIR) et itérer dessus. Donc:
* Il prend le premier domaine de FUZZDOMAIN, parce qu'il lui en faut bien un.
* Il va faire 1000 requête pour chacun des dossiers de FUZZDIR sur ce domaine
* Il passe au domaine suivant, et re-belotte.

Pas génial : on va se faire rate-limit tout de suite. Il est donc plus intéressant d'inverser les wordlists, pour d'abord tester le premier dossier sur les 1000 adresses, passer au suivant.
ffuf -u https://FUZZDOMAIN/FUZZDIR -w ./domains.txt:FUZZDOMAIN,./wordlist.txt:FUZZDIR

== Authentification (cookies, headers ==
Souvent, on a besoin de bruteforcer derrière une authentification.

C'est assez simple dans le cas d'un cookie ou d'un header; pour ce qui est plus complexe, on peut utiliser burp suite.

=== Par cookie ===
On peut utiliser l'argument -b pour passer des données de cookie (pas seulement d'authent, d'ailleurs).
J'ai pas trouvé d'exemple. Snif

=== Headers ===
Comme avec curl, on peut passer des headers avec -H.
ffuf -w <path-vhosts> -u https://test-url -H "Host: FUZZ"

== Avoir des résultats utilisables dans un script ==
On peut virer le formatage joli de ffuf avec l'argument -s, pour silent. On aura alors juste le résultat (par ex. "admin").

== Rate limit ==
On peut limiter le nombre de requêtes par seconde avec -rate. Par exemple -rate 2

= Conclusion =

Voilà la base. On peut faire bien des choses avec ffuf, cf la doc et surtout la source qui est vraiment complète.

Ffuf : Fuzz Faster U Fool - Historique des versions

Justine : /* Authentification (cookies, headers */

Justine : /* Fuzz ? = */

Justine : /* Authentification (cookies, headers */

Justine : /* Fuzz ? = */