Scanner des serveurs web avec Nikto

Introduction

Dans ce laboratoire, vous apprendrez à utiliser Nikto, un scanner de serveur web open-source, pour détecter les vulnérabilités potentielles dans les applications web. Vous allez pratiquer des techniques de scan sur l'application bWAPP, conçue exprès pour être vulnérable, tout en apprenant à interpréter efficacement les résultats des scans.

Le laboratoire couvre l'installation de Nikto, la configuration de la cible, l'exécution du scan et l'analyse des résultats. Grâce à des exercices pratiques, vous acquerrez les compétences essentielles pour effectuer des évaluations de vulnérabilités de serveurs web de base en utilisant cet outil de sécurité très utilisé.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") subgraph Lab Skills nmap/save_output -.-> lab-549948{{"Scanner des serveurs web avec Nikto"}} nmap/target_specification -.-> lab-549948{{"Scanner des serveurs web avec Nikto"}} end

Installer Nikto

Dans cette étape, vous allez installer Nikto, un scanner de serveur web open-source qui permet d'identifier les problèmes de sécurité dans les serveurs web. Nikto vérifie la présence de logiciels de serveur obsolètes, de fichiers/CGI dangereux et d'autres vulnérabilités courantes. Comprendre ces vulnérabilités est essentiel pour sécuriser les applications web.

Avant de commencer, assurons-nous que nous sommes dans le bon répertoire. Le répertoire ~/project est l'endroit où nous effectuerons tout notre travail de laboratoire pour organiser les fichiers :

cd ~/project

Ensuite, nous devons mettre à jour la liste de nos paquets. Cela garantit que nous installerons la dernière version disponible de Nikto avec toutes les mises à jour de sécurité récentes :

sudo apt update

Maintenant, nous sommes prêts à installer Nikto. Le drapeau -y confirme automatiquement l'installation, nous évitant d'avoir à l'approuver manuellement :

sudo apt install -y nikto

Une fois l'installation terminée, vérifions que tout s'est bien passé en vérifiant la version installée. Cela confirme que Nikto est correctement installé et montre la version que nous utiliserons :

nikto -Version

Vous devriez voir une sortie similaire à :

Nikto v2.1.6

Nikto est maintenant installé avec succès sur votre système. Bien que Nikto ait un fichier de configuration à /etc/nikto.conf, nous utiliserons les paramètres par défaut pour ce laboratoire introductif. Ces paramètres par défaut offrent un bon équilibre entre un scan approfondi et une vitesse raisonnable à des fins d'apprentissage.

Choisir un serveur cible

Dans cette étape, vous apprendrez à sélectionner et vérifier un serveur web cible pour le scan de vulnérabilités. Nous utiliserons Nikto pour scanner une application web intentionnellement vulnérable appelée "bWAPP" (Buggy Web Application) qui est configurée en toute sécurité dans notre environnement LabEx. Cette application de pratique est conçue pour les tests de sécurité sans affecter les systèmes réels.

Tout d'abord, naviguons jusqu'au bon répertoire de travail où nous effectuerons nos scans. Cela permet d'organiser nos fichiers de projet :
```
cd ~/project
```
Avant de scanner, nous devons confirmer que notre serveur web cible fonctionne correctement. Nous utiliserons curl avec le drapeau -I pour récupérer uniquement les en-têtes HTTP :
```
curl -I http://localhost:8000
```
Une réponse réussie affichera le code d'état HTTP 200 OK, indiquant que le serveur est actif :
```
HTTP/1.1 200 OK
```
Maintenant, nous allons définir notre URL cible comme variable d'environnement. Cela facilite la référence ultérieure dans nos scans :
```
TARGET="http://localhost:8000"
```
Faisons un test rapide pour voir la réponse du serveur web. Nous utiliserons curl pour récupérer le contenu de la page et afficher seulement les 5 premières lignes :
```
curl $TARGET | head -n 5
```
Cela nous donne un exemple du contenu HTML, confirmant que nous pouvons nous connecter avec succès au serveur.
N'oubliez pas cette URL cible car nous l'utiliserons tout au long du processus de scan. Suivre votre cible est crucial lors de l'exécution d'évaluations de sécurité.

Exécuter un scan de vulnérabilités

Dans cette étape, vous utiliserez Nikto pour effectuer un scan de vulnérabilités sur le serveur cible que nous avons sélectionné à l'étape précédente. Nikto est un scanner de serveur web open-source qui teste plus de 6700 fichiers/programmes potentiellement dangereux, vérifie les versions obsolètes de serveur et identifie les mauvaises configurations courantes des serveurs web.

Avant de commencer le scan, il est important de se trouver dans le bon répertoire où vous avez la permission d'exécuter l'outil et de sauvegarder les résultats. La commande cd change votre répertoire de travail actuel :

Tout d'abord, assurez-vous d'être dans le bon répertoire de travail :
```
cd ~/project
```

Maintenant, nous allons exécuter un scan de base. Le drapeau -h spécifie l'hôte cible (dans ce cas, notre serveur de test local). Nikto vérifiera automatiquement les vulnérabilités courantes telles que :

Fichiers et programmes par défaut
Configurations de serveur non sécurisées
Logiciels de serveur obsolètes
Vulnérabilités potentielles d'injection XSS et SQL

Exécutez un scan de base de Nikto sur notre serveur cible (http://localhost:8000) :
```
nikto -h http://localhost:8000
```

Le scan s'exécutera et affichera les résultats en temps réel. Vous verrez une sortie similaire à :

- Nikto v2.1.6
- Target IP:          127.0.0.1
- Target Hostname:    localhost
- Target Port:        8000
- Start Time:         [timestamp]

Pour un examen plus approfondi, nous pouvons utiliser des options de réglage. Le paramètre -Tuning vous permet de spécifier quels tests exécuter. Ici, x active les tests étendus tandis que 6 vérifie les fichiers courants qui pourraient exposer des informations sensibles.

Pour un scan plus complet, vous pouvez ajouter ces options :
```
nikto -h http://localhost:8000 -Tuning x 6
```
Cela effectue des tests étendus (x) et vérifie les fichiers courants (6).
Le scan peut prendre 1 à 2 minutes pour se terminer. Une fois terminé, vous verrez un résumé des résultats, notamment :
```
+ Server may be vulnerable to XSS
+ Retrieved x-powered-by header: PHP/7.4.3
+ OSVDB-3092: Possible sensitive directory
```

Chaque résultat inclut :

Une description de la vulnérabilité
Le type de vulnérabilité
Des références pertinentes (comme les identifiants OSVDB)
Le composant affecté

Notez que certains résultats peuvent être des faux positifs - nous les analyserons à l'étape suivante. Tous les problèmes signalés ne sont pas des vulnérabilités réelles, c'est pourquoi la vérification manuelle est cruciale dans les tests de sécurité.

Examiner la sortie du scan

Dans cette étape, nous examinerons attentivement les résultats du scan effectué par Nikto pour comprendre quelles vulnérabilités ont été trouvées dans le serveur web cible. En tant que débutant, il est important de savoir que Nikto organise ses résultats de manière structurée pour vous aider à identifier efficacement les problèmes de sécurité.

Tout d'abord, assurez-vous d'être dans le bon répertoire de travail où sont stockés les résultats de votre scan :
```
cd ~/project
```
Cette commande change votre répertoire actuel pour celui où Nikto a enregistré son fichier de sortie.
Découpons les principales sections que vous verrez dans le fichier de sortie de Nikto :
- Informations sur le serveur : Révèle quel logiciel de serveur web est en cours d'exécution (comme Apache ou Nginx) et son numéro de version
- Résultats des vulnérabilités : Montre les problèmes de sécurité spécifiques détectés par Nikto, avec des indicateurs montrant la gravité de chaque problème
- Résumé du scan : Vous donne le total des éléments trouvés lors du scan
Pour trouver rapidement les vulnérabilités les plus importantes, exécutez cette commande :
```
grep -E '\+|OSVDB' ~/project/nikto_scan.txt
```
Cette commande recherche dans les résultats de votre scan et affiche seulement les lignes contenant des marqueurs de vulnérabilité (+) ou des références OSVDB (qui sont des identifiants de base de données de vulnérabilités).
Lors de l'examen des résultats, accordez une attention particulière à :
- Tous les résultats étiquetés comme présentant un risque "ÉLEVÉ" - ce sont les problèmes les plus dangereux
- Les anciennes versions de logiciels de serveur - les programmes obsolètes ont souvent des failles de sécurité connues
- Les répertoires exposés ou les fichiers sensibles - ces éléments ne devraient pas être accessibles publiquement
- Les attaques web courantes telles que le Cross-Site Scripting (XSS) ou l'Injection SQL (SQLi)
Voici à quoi peuvent ressembler des résultats typiques :
```
+ /config.php: PHP config file found
+ OSVDB-3092: /admin/: This might be interesting
```
La première ligne indique que Nikto a trouvé un fichier de configuration qui ne devrait pas être public. La deuxième ligne fait référence à un identifiant de vulnérabilité spécifique de la base de données Open Source Vulnerability Database.
Pour obtenir plus de détails sur une entrée OSVDB spécifique, vous pouvez interroger la base de données de vulnérabilités :
```
curl -s "https://vulners.com/api/v3/search/id/?id=OSVDB-3092" | jq '.data.attributes'
```
Cette commande récupère des informations détaillées sur la vulnérabilité OSVDB - 3092 depuis une base de données en ligne et les formate pour une lecture plus agréable.
Au fur et à mesure que vous parcourez les résultats, notez les problèmes les plus graves que vous trouvez. Nous utiliserons ces notes à l'étape suivante lorsque nous documenterons nos résultats. Concentrez-vous sur la compréhension de ce que signifie chaque vulnérabilité plutôt que d'essayer de tout corriger d'un coup.

Sauvegarder le rapport

Dans cette étape finale, vous allez sauvegarder les résultats du scan Nikto dans un fichier pour la documentation et pour un usage ultérieur. Sauvegarder les rapports est crucial dans les tests de sécurité car cela fournit des preuves des vulnérabilités trouvées et aide à suivre l'évolution de la remédiation.

Tout d'abord, assurez-vous d'être dans le bon répertoire de travail où vous souhaitez stocker vos rapports de scan. La commande cd permet de changer de répertoire :
```
cd ~/project
```
Pour sauvegarder les résultats du scan de l'étape précédente au format texte brut, exécutez cette commande. Le drapeau -output spécifie le nom du fichier dans lequel Nikto écrira ses résultats :
```
nikto -h http://localhost:8000 -output vuln_scan_report.txt
```
Vérifiez que le rapport a été créé avec succès. La commande ls -l liste les fichiers avec des détails, et vous devriez voir votre fichier de rapport avec un contenu (taille non nulle) :
```
ls -l vuln_scan_report.txt
```
Pour une meilleure lisibilité et pour le partager avec les membres de votre équipe, vous pouvez générer un rapport formaté en HTML. L'option -Format html crée un rapport organisé visuellement :
```
nikto -h http://localhost:8000 -Format html -output vuln_scan_report.html
```
Pour vérifier rapidement le contenu de votre rapport texte, utilisez la commande head qui affiche les 20 premières lignes. Cela permet de vérifier que le scan s'est terminé correctement :
```
head -n 20 vuln_scan_report.txt
```
Le rapport contient plusieurs sections importantes que les professionnels de la sécurité analysent :
- Métadonnées du scan (date, cible, etc.) - montre quand et quoi a été scanné
- Toutes les vulnérabilités identifiées - les résultats essentiels qui nécessitent attention
- Recommandations pour la remédiation - solutions suggérées pour chaque problème
- Statistiques du scan et temps de complétion - aide à mesurer les performances du scan
Ces fichiers de rapport sont maintenant sauvegardés dans votre répertoire ~/project. Vous pouvez :
- Les partager avec les développeurs pour corriger les problèmes
- Les comparer avec des scans futurs pour suivre l'évolution
- Les inclure dans la documentation d'audit de sécurité
- Les utiliser comme preuves dans les rapports de conformité

Résumé

Dans ce laboratoire, vous avez appris à installer et configurer Nikto, un puissant scanner de serveur web open-source, pour détecter les vulnérabilités dans les systèmes cibles. L'exercice vous a guidé tout au long de la vérification de l'installation, de la vérification de l'accessibilité du serveur et de la réalisation de scans complets sur une application web vulnérable.

Vous avez acquis une expérience pratique dans l'interprétation des résultats de scan et la génération de rapports, démontrant le rôle essentiel de l'évaluation des vulnérabilités dans le maintien de la sécurité des sites web. Ces connaissances pratiques vous dotent des compétences essentielles pour identifier les risques de sécurité potentiels dans les serveurs web.