Introduction
Dans ce laboratoire, vous explorerez comment gérer la vitesse de balayage de Gobuster, un outil populaire de brute-force de répertoires et de fichiers, en manipulant son nombre de threads. Comprendre comment ajuster le nombre de threads est crucial pour un balayage efficace et pour minimiser l'impact sur les serveurs cibles. Vous apprendrez à exécuter des balayages avec des nombres de threads par défaut, augmentés et diminués, en observant les implications pratiques de chaque réglage. Cette expérience pratique vous donnera un aperçu de l'optimisation de vos efforts de reconnaissance tout en tenant compte de l'étiquette réseau et de la stabilité de la cible.
Exécuter un balayage avec le nombre de threads par défaut (10)
Dans cette étape, vous allez lancer un balayage Gobuster en utilisant son nombre de threads par défaut, qui est généralement de 10. Cela vous donnera une compréhension de base de ses performances et du format de sortie. Gobuster tentera de découvrir des répertoires et des fichiers sur un serveur web local qui a été configuré pour ce laboratoire.
Ouvrez votre terminal et exécutez la commande suivante :
gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt
gobuster dir: Spécifie que vous souhaitez effectuer un balayage par force brute de répertoires/fichiers.-u http://127.0.0.1:8080: Définit l'URL cible pour le balayage. Dans ce laboratoire, nous ciblons un serveur HTTP local fonctionnant sur le port 8080.-w /tmp/wordlist.txt: Spécifie la liste de mots (wordlist) à utiliser pour le processus de force brute. Ce fichier contient des noms de répertoires et de fichiers courants.
Observez la sortie. Vous verrez Gobuster démarrer le balayage, indiquer le nombre de threads utilisés (par défaut 10), puis lister tous les répertoires ou fichiers découverts. Portez attention à la rapidité avec laquelle les résultats apparaissent.
===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url: http://127.0.0.1:8080
[+] Threads: 10
[+] Wordlist: /tmp/wordlist.txt
[+] Status codes: 200,204,301,302,307,401,403
[+] User Agent: gobuster/X.X.X
[+] Timeout: 10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin (Status: 200)
/login (Status: 200)
/secret (Status: 200)
/index (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================
La sortie montre la configuration utilisée pour le balayage, y compris l'URL, la liste de mots et, surtout, le nombre de threads. Les chemins découverts tels que /admin, /login, /secret et /index sont listés avec leurs codes d'état HTTP respectifs.
Augmenter le nombre de threads à 50 avec le drapeau -t
Dans cette étape, vous allez augmenter le nombre de threads utilisés par Gobuster à 50. Ceci est réalisé à l'aide du drapeau -t, qui vous permet de spécifier le nombre souhaité de threads concurrents. Un nombre de threads plus élevé entraîne généralement un balayage plus rapide, car plus de requêtes sont envoyées simultanément.
Exécutez la commande suivante dans votre terminal :
gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt -t 50
-t 50: Ce nouveau drapeau définit le nombre de threads à 50.
Observez à nouveau la sortie. Vous devriez remarquer que le balayage se termine beaucoup plus rapidement qu'avec les 10 threads par défaut. La sortie initiale confirmera que 50 threads sont utilisés.
===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url: http://127.0.0.1:8080
[+] Threads: 50
[+] Wordlist: /tmp/wordlist.txt
[+] Status codes: 200,204,301,302,307,401,403
[+] User Agent: gobuster/X.X.X
[+] Timeout: 10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin (Status: 200)
/login (Status: 200)
/secret (Status: 200)
/index (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================
Notez la ligne [+] Threads: 50 dans la sortie, confirmant que le nombre de threads que vous avez spécifié est utilisé. Le balayage devrait se terminer presque instantanément en raison de la petite liste de mots et de la cible locale.
Observer l'augmentation de la vitesse de balayage
Dans cette étape, nous allons explicitement comparer les temps de balayage pour confirmer visuellement l'impact de l'augmentation du nombre de threads. Alors que les étapes précédentes ont fourni une observation qualitative, cette étape vise à renforcer le concept.
Bien que les balayages précédents aient été très rapides en raison de la petite liste de mots et du serveur local, vous auriez dû remarquer une différence significative dans le temps nécessaire à l'apparition de la sortie. Lorsque vous avez augmenté les threads de 10 à 50, le balayage s'est terminé presque instantanément.
Pour mieux illustrer la différence de vitesse, imaginez que la liste de mots contienne des milliers ou des millions d'entrées, et que le serveur cible soit distant avec une latence plus élevée. Dans de tels scénarios, la différence entre 10 et 50 threads serait considérablement plus apparente, réduisant potentiellement le temps de balayage de plusieurs heures à quelques minutes.
Le point essentiel à retenir ici est que plus de threads permettent à Gobuster d'envoyer plus de requêtes simultanément, ce qui peut réduire considérablement le temps total de balayage, en particulier pour les grandes listes de mots et les cibles réactives.
Aucune commande spécifique n'est requise pour cette étape, car il s'agit d'une observation basée sur les deux étapes précédentes.
Diminuer le nombre de threads à 5 pour un balayage plus lent
Maintenant, inversons le processus et diminuons le nombre de threads à 5. Cela démontrera comment moins de threads entraînent un balayage plus lent. Bien qu'un balayage plus lent puisse sembler contre-productif, il peut être nécessaire dans certaines situations, par exemple lorsqu'on traite des cibles limitées en débit (rate-limited) ou pour être moins intrusif.
Exécutez la commande suivante dans votre terminal :
gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt -t 5
-t 5: Ceci définit le nombre de threads à 5, soit la moitié de la valeur par défaut.
Observez la sortie. Vous devriez remarquer que le balayage prend légèrement plus de temps à se terminer par rapport aux 10 threads par défaut, et nettement plus de temps que le balayage avec 50 threads.
===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url: http://127.0.0.1:8080
[+] Threads: 5
[+] Wordlist: /tmp/wordlist.txt
[+] Status codes: 200,204,301,302,307,401,403
[+] User Agent: gobuster/X.X.X
[+] Timeout: 10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin (Status: 200)
/login (Status: 200)
/secret (Status: 200)
/index (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================
La ligne [+] Threads: 5 confirme le nombre réduit de threads. Même avec notre petite liste de mots, vous devriez percevoir un léger délai par rapport aux exécutions précédentes. Ceci illustre la relation directe entre le nombre de threads et la durée du balayage.
Comprendre l'impact des threads sur le serveur cible
Dans cette dernière étape, nous allons discuter des implications plus larges de l'ajustement du nombre de threads, en particulier concernant le serveur cible. Bien que l'augmentation des threads puisse accélérer votre balayage, elle augmente également la charge sur le serveur cible.
Nombre de threads élevé (par exemple, 50 ou plus) :
- Avantages : Achèvement plus rapide du balayage.
- Inconvénients :
- Charge serveur accrue : L'envoi de nombreuses requêtes simultanément peut submerger le serveur cible, entraînant potentiellement un déni de service (DoS) ou une dégradation des performances.
- Limitation de débit / Blocage : De nombreux serveurs web et WAF (Web Application Firewalls) implémentent une limitation de débit pour prévenir les attaques par force brute. Un nombre élevé de threads peut rapidement déclencher ces défenses, entraînant le blocage temporaire ou permanent de votre IP.
- Congestion réseau : Peut consommer une bande passante réseau significative, surtout si la cible est distante.
- Suspicion : Des taux de requêtes élevés sont souvent indicatifs d'une activité malveillante et peuvent alerter les équipes de sécurité.
Nombre de threads faible (par exemple, 1-5) :
- Avantages :
- Charge serveur réduite : Moins intrusif et moins susceptible de causer des problèmes de performance sur la cible.
- Éviter la limitation de débit : Des taux de requêtes plus lents sont moins susceptibles de déclencher des mécanismes de limitation de débit, permettant au balayage de se poursuivre plus longtemps sans être détecté.
- Discrétion : Apparaît davantage comme un trafic utilisateur légitime, réduisant les chances de détection.
- Inconvénients :
- Balayage plus lent : Prend beaucoup plus de temps à se terminer, surtout avec de grandes listes de mots.
Choisir le bon nombre de threads : Le nombre optimal de threads dépend de plusieurs facteurs :
- Capacité du serveur cible : Quelle charge le serveur peut-il supporter ?
- Latence réseau : Une latence plus élevée peut nécessiter plus de threads pour maintenir une vitesse décente.
- Politiques de limitation de débit : Existe-t-il des limitations de débit connues ou des WAF en place ?
- Votre objectif : Privilégiez-vous la vitesse ou la discrétion ?
Pour le piratage éthique et les tests d'intrusion, il est crucial d'être conscient de la stabilité de la cible et d'éviter de causer toute perturbation. Commencez toujours par un nombre de threads plus faible et augmentez-le progressivement si la cible peut le supporter et si vos objectifs nécessitent des résultats plus rapides.
Aucune commande spécifique n'est requise pour cette étape, car il s'agit d'une compréhension conceptuelle.
Résumé
Dans ce laboratoire, vous avez appris avec succès à contrôler la vitesse de balayage de Gobuster en ajustant le nombre de threads à l'aide de l'indicateur -t. Vous avez commencé par exécuter un balayage avec les 10 threads par défaut, puis vous l'avez augmenté à 50 pour observer une amélioration significative de la vitesse, et enfin vous l'avez diminué à 5 pour constater un ralentissement du balayage.
Plus important encore, vous avez acquis une compréhension de l'impact critique que le nombre de threads a non seulement sur la durée du balayage, mais aussi sur les performances et les mécanismes de sécurité du serveur cible. Vous savez maintenant que si plus de threads signifient des balayages plus rapides, ils augmentent également la charge du serveur et le risque de détection ou de blocage. Inversement, moins de threads offrent de la discrétion et réduisent l'impact sur le serveur au détriment de la vitesse. Ces connaissances sont essentielles pour mener une reconnaissance responsable et efficace.