Aller au contenu principal

Etapes d'un pentest Web

Comprendre les étapes clés pour tester la sécurité d'une application Web

Notions théoriques​

Un pentest Web (ou test d’intrusion Web) est une méthode utilisée pour évaluer la sécurité d’une application Web en simulant des attaques réelles.

astuce

Le but est d’identifier des failles exploitables avant qu’un attaquant ne les découvre.

Un pentest Web suit une méthodologie structurée qui comprend plusieurs étapes :

1. Reconnaissance passive​

Cette étape consiste à collecter des informations sans interagir directement avec la cible.
Outils utilisés :

  • whois
  • shodan
  • netcraft
  • Google Dorking

Objectifs :

  • Identifier les technologies utilisées (CMS, serveur web, etc.)
  • Trouver des sous-domaines, adresses IP, emails, etc.

2. Reconnaissance active​

Interaction directe avec la cible pour obtenir plus d’informations techniques.
Outils :

  • nmap
  • whatweb
  • nikto

Objectifs :

  • Scanner les ports ouverts
  • Détecter les services web
  • Identifier les versions des logiciels

3. Cartographie de l’application​

Analyser l’architecture de l’application Web :

  • Nombre de pages
  • Paramètres GET/POST
  • Points d’entrée utilisateur
  • Authentification, sessions, cookies

Outils :

  • Burp Suite (Spider)
  • OWASP ZAP
  • Fiddler

4. Recherche de vulnérabilités​

Tester les points d’entrée pour détecter des failles :

  • Injection SQL
  • Cross-Site Scripting (XSS)
  • Mauvaise gestion des sessions
  • Contrôle d’accès insuffisant

Méthodes :

  • Tests manuels avec Burp Suite
  • Scanners automatisés (Nikto, OWASP ZAP)

5. Exploitation​

Après avoir identifié une faille, tenter de l’exploiter pour confirmer son existence :

  • Extraire des données via une injection SQL
  • Exécuter du JavaScript malveillant avec XSS
  • Accéder à un compte sans autorisation

6. Rédaction du rapport​

Documenter toutes les étapes :

  • Vulnérabilités trouvées
  • Méthodes utilisées
  • Preuves d’exploitation
  • Recommandations de correction

Exemple pratique​

Il est possible de réaliser un pentest Web sur une application vulnérable en local.
Le projet DVWA (Damn Vulnerable Web Application) est conçu pour s’entraîner à l’audit de sécurité Web.

Étapes à suivre :​

  1. Télécharger et installer DVWA avec Docker :
git clone https://github.com/digininja/DVWA.git
cd DVWA
docker-compose up -d

  1. Accéder à l’application via le navigateur à l’adresse :
    http://localhost:8080

  2. Se connecter avec les identifiants par défaut :

    • Nom d’utilisateur : admin
    • Mot de passe : password

  3. Lancer Burp Suite et configurer son navigateur pour intercepter le trafic HTTP.

  4. Explorer l’application avec Burp Suite pour :

    • Identifier les formulaires
    • Repérer les paramètres GET/POST
    • Intercepter les requêtes

  5. Tester les vulnérabilités dans les modules proposés (XSS, SQLi, CSRF, etc.).

Test de mémorisation/compréhension​


Quel outil permet de collecter des informations sans interagir directement avec la cible ?


Quel est l’objectif principal de la reconnaissance passive ?


Quel outil est utilisé pour capturer et modifier les requêtes HTTP ?


Quel type de vulnérabilité permet d’exécuter du code JavaScript dans le navigateur de la victime ?


Quel outil permet de cartographier automatiquement une application Web ?


Quel est le rôle du fichier robots.txt ?


Quel outil est utilisé pour scanner les ports et services d’un serveur ?


Quel outil open-source permet de détecter automatiquement des failles dans une application Web ?


Qu’est-ce que l’exploitation dans un pentest ?


Pourquoi rédiger un rapport après un pentest ?


TP pour réfléchir et résoudre des problèmes​

L’objectif est de mettre en pratique les étapes d’un pentest Web en analysant une application vulnérable différente de DVWA.

remarque

Ce TP utilise l’application bWAPP (buggy Web Application), un projet open-source conçu pour s’entraîner à l’audit de sécurité Web.

Étape 1 — Récupérer et lancer l’application bWAPP​

Cloner le dépôt bWAPP et exécuter le conteneur Docker :

git clone https://github.com/raesene/bwapp.git
cd bwapp/docker
docker-compose up -d

Accéder à l’application via le navigateur à l’adresse :
http://localhost:8080/install.php

Suivre les instructions pour l’installation de la base de données.
Puis se connecter à l’application à l’adresse suivante :
http://localhost:8080/login.php

Identifiants par défaut :

  • Nom d’utilisateur : bee
  • Mot de passe : bug
info

L’application bWAPP est accessible via Docker et propose une interface Web contenant plusieurs modules vulnérables.
Lors de la première connexion, il faut initialiser la base de données via la page install.php.
Une fois connecté avec les identifiants bee / bug, il est possible de choisir un niveau de sécurité (low, medium, high) et un type de vulnérabilité à tester.

Étape 2 — Intercepter le trafic HTTP avec Burp Suite​

Configurer le navigateur pour utiliser un proxy local (127.0.0.1:8080) et lancer Burp Suite.

Dans l’onglet Proxy > Intercept, activer l’interception et naviguer dans l’application bWAPP.
Repérer les requêtes HTTP contenant des paramètres, des cookies, ou des formulaires.

info

Dans Burp Suite :

  • Aller dans Proxy > Options pour vérifier que le proxy écoute sur 127.0.0.1:8080.
  • Dans le navigateur, configurer le proxy HTTP manuellement.
  • Naviguer sur bWAPP pour intercepter les requêtes HTTP.
  • Observer les paramètres envoyés dans les requêtes POST ou GET.
  • Identifier des points d’entrée exploitables (ex : champs de formulaire, URL avec paramètres).

Étape 3 — Choisir un module vulnérable et analyser son comportement​

Dans le menu de bWAPP, sélectionner le module "SQL Injection (GET/Search)".
Effectuer une recherche avec un mot-clé classique (par exemple : test) puis observer la requête interceptée dans Burp Suite.

Analyser la requête GET et identifier le paramètre injectable.

info

Lorsqu’on sélectionne le module "SQL Injection (GET/Search)", une URL de ce type apparaît :
http://localhost:8080/sqli_1.php?title=test

Dans Burp Suite, on peut voir :

GET /sqli_1.php?title=test HTTP/1.1
Host: localhost:8080
Cookie: PHPSESSID=xyz

Le paramètre title est potentiellement vulnérable à une injection SQL.
Il est possible de tester avec des payloads simples comme ' OR '1'='1 pour vérifier le comportement de l’application.

Étape 4 — Tester l’injection SQL​

Dans le champ de recherche, entrer des payloads SQL classiques comme :

  • ' OR '1'='1
  • ' UNION SELECT null, version()--

Observer la réponse de l’application dans le navigateur et dans Burp Suite.

info

En testant avec ' OR '1'='1, l’application retourne tous les résultats, ce qui confirme que la requête SQL est vulnérable.

Avec ' UNION SELECT null, version()--, l’application peut afficher la version du serveur SQL si la requête est bien construite.

Cela prouve que l’injection SQL est exploitable.
Il est possible d’utiliser des outils comme sqlmap pour automatiser cette étape, mais ici le test est manuel.

Étape 5 — Modifier la requête dans Burp Suite pour affiner l’exploitation​

Dans Burp Suite, envoyer la requête interceptée vers l’onglet Repeater.
Modifier les paramètres pour tester différents types d’injections :

  • Extraire la base de données en cours (database())
  • Lister les tables (information_schema.tables)
  • Lire des données sensibles
info

Dans l’onglet Repeater, envoyer une requête comme :

GET /sqli_1.php?title=' UNION SELECT null, database()-- HTTP/1.1
Host: localhost:8080

La réponse contient le nom de la base de données, souvent bWAPP.

Puis tester :

GET /sqli_1.php?title=' UNION SELECT null, table_name FROM information_schema.tables-- HTTP/1.1

Cela peut permettre de découvrir des tables comme users, blog, etc.

Enfin :

GET /sqli_1.php?title=' UNION SELECT null, login FROM users-- HTTP/1.1

Permet de récupérer des identifiants stockés dans la base.

Étape 6 — Rédiger un mini rapport d’audit​

Créer un fichier pentest_rapport.docx contenant :

  • La description de l’application testée
  • Les étapes suivies
  • Les vulnérabilités identifiées
  • Les preuves (captures d’écran, requêtes)
  • Les recommandations de correction
info

Extrait possible du rapport :

# Rapport d’audit — Application bWAPP

## Application testée
- Nom : bWAPP
- URL : http://localhost:8080/
- Type : Application Web vulnérable pour tests

## Vulnérabilité détectée
- Type : Injection SQL (GET)
- Module : sqli_1.php
- Paramètre vulnérable : title

## Preuve
Requête :
GET /sqli_1.php?title=' OR '1'='1

Résultat :
Affichage de tous les résultats sans filtrage.

## Recommandations
- Utiliser des requêtes préparées (PDO, mysqli)
- Filtrer et échapper les entrées utilisateur
- Activer un WAF (Web Application Firewall)