B3.5 - Outils et Méthodologies

OWASP, Burp Suite et Tests de Sécurité - BTS SIO

🎯 Objectifs du cours

À l'issue de ce cours, vous serez capable de : - Utiliser les ressources et outils OWASP pour la sécurité web - Maîtriser Burp Suite pour les tests de sécurité - Mettre en place une méthodologie de tests de pénétration - Analyser et documenter les vulnérabilités découvertes

---

🛡️ OWASP (Open Web Application Security Project)

OWASP

Organisation internationale à but non lucratif dédiée à l'amélioration de la sécurité des applications web. Elle fournit des ressources, outils et standards gratuits pour la communauté de la sécurité informatique.

Ressources principales OWASP

🔟

OWASP Top 10

Liste des 10 vulnérabilités web les plus critiques, mise à jour tous les 3-4 ans. Guide de référence pour les développeurs et testeurs.

📋

ASVS

Application Security Verification Standard - Standard de vérification de la sécurité des applications avec différents niveaux de maturité.

🧪

Testing Guide

Guide complet de tests de sécurité des applications web avec méthodologies et techniques détaillées.

🔧

ZAP

Zed Attack Proxy - Scanner de vulnérabilités web gratuit et open source, alternative à Burp Suite.

OWASP Top 10 - 2021

Rang	Vulnérabilité	Impact	Outils de détection
A01	Broken Access Control	Accès non autorisé aux données	Burp Suite, ZAP, tests manuels
A02	Cryptographic Failures	Exposition de données sensibles	SSLyze, testssl.sh, Nmap
A03	Injection	Exécution de code malveillant	SQLMap, Burp Suite, ZAP
A04	Insecure Design	Failles architecturales	Revue de code, threat modeling
A05	Security Misconfiguration	Exposition de services	Nessus, OpenVAS, Nikto
A06	Vulnerable Components	Exploitation de CVE connues	OWASP Dependency Check
A07	Authentication Failures	Usurpation d'identité	Hydra, Burp Intruder
A08	Software Integrity Failures	Code malveillant	Analyse statique, SCA
A09	Logging Failures	Détection d'incidents limitée	Audit manuel, SIEM
A10	Server-Side Request Forgery	Accès aux ressources internes	Burp Suite, tests manuels

Installation et utilisation d'OWASP ZAP

Installation et configuration d'OWASP ZAP

# Installation sur macOS avec Homebrew
brew install --cask owasp-zap

# Installation sur Ubuntu/Debian
sudo apt update
sudo apt install zaproxy

# Installation via Docker
docker run -u zap -p 8080:8080 -p 8090:8090 \
  -v $(pwd):/zap/wrk/:rw \
  -t owasp/zap2docker-stable zap-webswing.sh

# Lancement en mode daemon (API)
zap.sh -daemon -host 0.0.0.0 -port 8080 -config api.addrs.addr.name=.* \
  -config api.addrs.addr.regex=true

# Script Python pour automatiser ZAP
import time
from zapv2 import ZAPv2

# Configuration ZAP
zap = ZAPv2(proxies={'http': 'http://127.0.0.1:8080', 
                     'https': 'http://127.0.0.1:8080'})

# URL cible
target = 'http://example.com'

print('Démarrage du scan passif...')
# Accéder à l'URL cible
zap.urlopen(target)
time.sleep(2)

print('Démarrage du spider...')
# Lancer le spider pour découvrir les URLs
scanid = zap.spider.scan(target)
time.sleep(2)

# Attendre la fin du spider
while int(zap.spider.status(scanid)) < 100:
    print(f'Progression spider: {zap.spider.status(scanid)}%')
    time.sleep(5)

print('Spider terminé')

print('Démarrage du scan actif...')
# Lancer le scan actif
scanid = zap.ascan.scan(target)

# Attendre la fin du scan
while int(zap.ascan.status(scanid)) < 100:
    print(f'Progression scan: {zap.ascan.status(scanid)}%')
    time.sleep(5)

print('Scan terminé')

# Récupérer les alertes
print('Alertes trouvées:')
alerts = zap.core.alerts()
for alert in alerts:
    print(f"- {alert['risk']} : {alert['alert']} dans {alert['url']}")

# Générer un rapport HTML
with open('rapport_zap.html', 'w') as f:
    f.write(zap.core.htmlreport())

print('Rapport généré: rapport_zap.html')

---

🔍 Burp Suite

Burp Suite

Plateforme intégrée pour les tests de sécurité des applications web. Outil de référence utilisé par les professionnels de la sécurité pour identifier et exploiter les vulnérabilités web.

Composants principaux de Burp Suite

🔄

Proxy

Intercepte et modifie le trafic HTTP/HTTPS entre le navigateur et l'application web pour analyser les requêtes et réponses.

🕷️

Spider

Explore automatiquement l'application web pour découvrir le contenu et cartographier la surface d'attaque.

🎯

Scanner

Effectue des tests automatisés pour identifier les vulnérabilités courantes (injection SQL, XSS, etc.).

💥

Intruder

Outil d'attaque automatisée pour tester les paramètres avec différentes charges utiles (brute force, fuzzing).

Repeater

Permet de modifier et renvoyer manuellement des requêtes HTTP pour tester des vulnérabilités spécifiques.

Sequencer

Analyse la qualité de la randomisation des tokens de session et autres identifiants.

Configuration et utilisation de Burp Suite

Configuration initiale

1. Installation : Télécharger depuis portswigger.net
2. Proxy : Configurer le navigateur sur 127.0.0.1:8080
3. Certificat : Installer le certificat CA de Burp pour HTTPS
4. Scope : Définir le périmètre de test dans Target > Scope

Fonctionnalités avancées de Burp Suite

🔍 Proxy Intercept

Intercepter et modifier les requêtes en temps réel pour tester différents scénarios d'attaque.

🎯 Target Sitemap

Visualiser l'arborescence complète de l'application et identifier les endpoints sensibles.

🔄 Match and Replace

Automatiser la modification de requêtes avec des règles de remplacement.

📊 Logger

Enregistrer tout le trafic HTTP pour analyse ultérieure et génération de rapports.

🔌 Extensions

Étendre les fonctionnalités avec des plugins (BApp Store) pour des tests spécialisés.

Exemple pratique : Test d'injection SQL avec Burp

Méthodologie de test d'injection SQL

1. RECONNAISSANCE
   - Identifier les paramètres d'entrée (GET, POST, cookies, headers)
   - Cartographier l'application avec Spider
   - Analyser les réponses pour détecter les bases de données

2. DÉTECTION
   - Injecter des caractères spéciaux : ' " ; --
   - Observer les erreurs SQL dans les réponses
   - Tester les délais avec SLEEP() ou WAITFOR

3. EXPLOITATION
   - Déterminer le nombre de colonnes : ORDER BY 1,2,3...
   - Identifier les colonnes affichées : UNION SELECT 1,2,3...
   - Extraire les données : UNION SELECT user(),database(),version()

4. ENUMÉRATION
   - Lister les bases de données : UNION SELECT schema_name FROM information_schema.schemata
   - Lister les tables : UNION SELECT table_name FROM information_schema.tables
   - Lister les colonnes : UNION SELECT column_name FROM information_schema.columns

Exemple de payload dans Burp Intruder :
- Position : id=§1§
- Payloads :
  * 1' OR '1'='1
  * 1' UNION SELECT 1,2,3--
  * 1' AND SLEEP(5)--
  * 1'; DROP TABLE users;--

Extensions Burp Suite utiles

🔍 SQLiPy

Détection automatisée des injections SQL avec différentes techniques d'exploitation.

🎯 Autorize

Test automatique des contrôles d'accès et détection des vulnérabilités d'autorisation.

📊 Logger++

Logging avancé avec filtres personnalisables et export des données.

🔐 JWT Editor

Manipulation et test des JSON Web Tokens pour identifier les failles d'authentification.

🌐 Param Miner

Découverte de paramètres cachés et d'endpoints non documentés.

🔄 Turbo Intruder

Attaques haute performance avec scripts Python personnalisés.

---

🎯 Méthodologie de tests de pénétration

Test de pénétration (Pentest)

Évaluation de sécurité autorisée qui simule une attaque réelle pour identifier les vulnérabilités exploitables dans un système, une application ou un réseau.

Phases d'un test de pénétration

1. 📋 Planification et reconnaissance

• Définition du scope : Périmètre, objectifs, contraintes
• Reconnaissance passive : OSINT, DNS, réseaux sociaux
• Reconnaissance active : Scan de ports, énumération de services

2. 🔍 Analyse et énumération

• Cartographie : Architecture, technologies, versions
• Identification des services : Web, SSH, FTP, bases de données
• Analyse des applications : Fonctionnalités, authentification

3. 🎯 Recherche de vulnérabilités

• Scan automatisé : Nessus, OpenVAS, Burp Scanner
• Tests manuels : Injection, XSS, CSRF, logique métier
• Analyse de configuration : Permissions, chiffrement

4. 💥 Exploitation

• Proof of Concept : Démonstration contrôlée
• Élévation de privilèges : Accès administrateur
• Mouvement latéral : Compromission d'autres systèmes

5. 📊 Documentation et rapport

• Classification des risques : CVSS, impact métier
• Recommandations : Correctifs prioritaires
• Preuves : Captures d'écran, logs, payloads

Outils de reconnaissance et énumération

Scripts de reconnaissance automatisée

#!/bin/bash
# Script de reconnaissance automatisée

TARGET=$1
OUTPUT_DIR="pentest_$TARGET"

if [ -z "$TARGET" ]; then
    echo "Usage: $0 <target_domain>"
    exit 1
fi

mkdir -p $OUTPUT_DIR
cd $OUTPUT_DIR

echo "[+] Démarrage de la reconnaissance pour $TARGET"

# 1. Reconnaissance DNS
echo "[+] Énumération DNS..."
dig $TARGET > dns_info.txt
nslookup $TARGET >> dns_info.txt

# Recherche de sous-domaines
echo "[+] Recherche de sous-domaines..."
sublist3r -d $TARGET -o subdomains.txt

# 2. Scan de ports
echo "[+] Scan de ports avec Nmap..."
nmap -sS -sV -O -A $TARGET -oA nmap_scan

# Scan complet des ports
nmap -p- --min-rate=1000 -T4 $TARGET -oA nmap_full_scan

# 3. Énumération web
echo "[+] Énumération des répertoires web..."
if nmap -p 80,443 $TARGET | grep -q "open"; then
    # Découverte de répertoires
    dirb http://$TARGET /usr/share/dirb/wordlists/common.txt -o dirb_results.txt

    # Scan avec Nikto
    nikto -h http://$TARGET -o nikto_results.txt

    # Énumération avec gobuster
    gobuster dir -u http://$TARGET -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -o gobuster_results.txt
fi

# 4. Recherche d'informations OSINT
echo "[+] Collecte d'informations OSINT..."
# theHarvester pour emails et sous-domaines
theHarvester -d $TARGET -l 500 -b google,bing,linkedin > osint_info.txt

# 5. Analyse SSL/TLS
echo "[+] Analyse SSL/TLS..."
if nmap -p 443 $TARGET | grep -q "open"; then
    sslscan $TARGET > ssl_analysis.txt
    testssl.sh $TARGET >> ssl_analysis.txt
fi

echo "[+] Reconnaissance terminée. Résultats dans $OUTPUT_DIR"

Framework de test d'applications web

Checklist de test d'application web

#!/usr/bin/env python3
"""
Framework de test de sécurité d'applications web
Basé sur OWASP Testing Guide v4
"""

import requests
import re
from urllib.parse import urljoin, urlparse
import time

class WebAppTester:
    def __init__(self, base_url, session=None):
        self.base_url = base_url
        self.session = session or requests.Session()
        self.vulnerabilities = []

        # Configuration des headers
        self.session.headers.update({
            'User-Agent': 'WebAppTester/1.0'
        })

    def log_vulnerability(self, vuln_type, url, description, severity='Medium'):
        """Enregistrer une vulnérabilité trouvée"""
        vuln = {
            'type': vuln_type,
            'url': url,
            'description': description,
            'severity': severity,
            'timestamp': time.time()
        }
        self.vulnerabilities.append(vuln)
        print(f"[{severity}] {vuln_type} trouvé dans {url}")

    def test_sql_injection(self, url, params):
        """Test d'injection SQL"""
        sql_payloads = [
            "' OR '1'='1",
            "' UNION SELECT 1,2,3--",
            "'; DROP TABLE users;--",
            "' AND SLEEP(5)--"
        ]

        for param in params:
            for payload in sql_payloads:
                test_params = params.copy()
                test_params[param] = payload

                try:
                    start_time = time.time()
                    response = self.session.get(url, params=test_params, timeout=10)
                    response_time = time.time() - start_time

                    # Détection par erreur SQL
                    sql_errors = [
                        'mysql_fetch_array',
                        'ORA-01756',
                        'Microsoft OLE DB Provider',
                        'PostgreSQL query failed',
                        'SQLite/JDBCDriver'
                    ]

                    for error in sql_errors:
                        if error.lower() in response.text.lower():
                            self.log_vulnerability(
                                'SQL Injection',
                                f"{url}?{param}={payload}",
                                f"Erreur SQL détectée avec payload: {payload}",
                                'High'
                            )

                    # Détection par délai (time-based)
                    if 'SLEEP' in payload and response_time > 4:
                        self.log_vulnerability(
                            'Time-based SQL Injection',
                            f"{url}?{param}={payload}",
                            f"Délai de {response_time:.2f}s détecté",
                            'High'
                        )

                except requests.RequestException as e:
                    print(f"Erreur lors du test SQL: {e}")

    def test_xss(self, url, params):
        """Test de Cross-Site Scripting"""
        xss_payloads = [
            '<script>alert("XSS")</script>',
            '"><script>alert("XSS")</script>',
            "javascript:alert('XSS')",
            '<img src=x onerror=alert("XSS")>',
            '<svg onload=alert("XSS")>'
        ]

        for param in params:
            for payload in xss_payloads:
                test_params = params.copy()
                test_params[param] = payload

                try:
                    response = self.session.get(url, params=test_params)

                    # Vérifier si le payload est reflété sans échappement
                    if payload in response.text:
                        self.log_vulnerability(
                            'Reflected XSS',
                            f"{url}?{param}={payload}",
                            f"Payload XSS reflété: {payload}",
                            'High'
                        )

                except requests.RequestException as e:
                    print(f"Erreur lors du test XSS: {e}")

    def test_directory_traversal(self, url, params):
        """Test de Directory Traversal"""
        traversal_payloads = [
            '../../../etc/passwd',
            '..\\..\\..\\windows\\system32\\drivers\\etc\\hosts',
            '....//....//....//etc/passwd',
            '%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd'
        ]

        for param in params:
            for payload in traversal_payloads:
                test_params = params.copy()
                test_params[param] = payload

                try:
                    response = self.session.get(url, params=test_params)

                    # Rechercher des signatures de fichiers système
                    if re.search(r'root:.*:0:0:', response.text) or \
                       'localhost' in response.text.lower():
                        self.log_vulnerability(
                            'Directory Traversal',
                            f"{url}?{param}={payload}",
                            f"Accès à des fichiers système détecté",
                            'High'
                        )

                except requests.RequestException as e:
                    print(f"Erreur lors du test Directory Traversal: {e}")

    def test_security_headers(self, url):
        """Vérifier les en-têtes de sécurité"""
        try:
            response = self.session.get(url)
            headers = response.headers

            security_headers = {
                'X-Frame-Options': 'Protection contre le clickjacking',
                'X-XSS-Protection': 'Protection XSS du navigateur',
                'X-Content-Type-Options': 'Protection contre le MIME sniffing',
                'Strict-Transport-Security': 'Forcer HTTPS',
                'Content-Security-Policy': 'Politique de sécurité du contenu'
            }

            for header, description in security_headers.items():
                if header not in headers:
                    self.log_vulnerability(
                        'Missing Security Header',
                        url,
                        f"En-tête manquant: {header} - {description}",
                        'Low'
                    )

        except requests.RequestException as e:
            print(f"Erreur lors du test des en-têtes: {e}")

    def run_full_test(self, test_urls):
        """Exécuter tous les tests"""
        print(f"[+] Démarrage des tests sur {self.base_url}")

        for url_path, params in test_urls.items():
            full_url = urljoin(self.base_url, url_path)
            print(f"[+] Test de {full_url}")

            # Tests de vulnérabilités
            self.test_sql_injection(full_url, params)
            self.test_xss(full_url, params)
            self.test_directory_traversal(full_url, params)
            self.test_security_headers(full_url)

        # Rapport final
        self.generate_report()

    def generate_report(self):
        """Générer un rapport des vulnérabilités"""
        print("\n" + "="*50)
        print("RAPPORT DE SÉCURITÉ")
        print("="*50)

        if not self.vulnerabilities:
            print("Aucune vulnérabilité détectée.")
            return

        # Grouper par sévérité
        by_severity = {}
        for vuln in self.vulnerabilities:
            severity = vuln['severity']
            if severity not in by_severity:
                by_severity[severity] = []
            by_severity[severity].append(vuln)

        # Afficher par ordre de sévérité
        for severity in ['Critical', 'High', 'Medium', 'Low']:
            if severity in by_severity:
                print(f"\n{severity.upper()} ({len(by_severity[severity])} vulnérabilités):")
                for vuln in by_severity[severity]:
                    print(f"  - {vuln['type']}: {vuln['description']}")
                    print(f"    URL: {vuln['url']}")

# Exemple d'utilisation
if __name__ == "__main__":
    # Configuration des tests
    target_url = "http://testphp.vulnweb.com"

    test_endpoints = {
        "/artists.php": {"artist": "1"},
        "/search.php": {"searchFor": "test"},
        "/login.php": {"uname": "admin", "pass": "password"}
    }

    # Lancement des tests
    tester = WebAppTester(target_url)
    tester.run_full_test(test_endpoints)

---

🔧 Autres outils de sécurité

Outils de scan de vulnérabilités

🔍

Nessus

Scanner de vulnérabilités commercial avec une large base de plugins pour détecter les failles de sécurité.

🆓

OpenVAS

Alternative open source à Nessus, scanner complet avec interface web et rapports détaillés.

🌐

Nikto

Scanner web spécialisé dans la détection de vulnérabilités et configurations dangereuses des serveurs web.

🗂️

DirBuster

Outil de découverte de répertoires et fichiers cachés sur les serveurs web par force brute.

Outils d'analyse de code

🔍 SonarQube

Analyse statique de code pour détecter les vulnérabilités, bugs et code smells.

🛡️ Bandit

Scanner de sécurité spécialisé pour le code Python, détecte les pratiques dangereuses.

📦 OWASP Dependency Check

Analyse les dépendances pour identifier les composants avec des vulnérabilités connues.

🔐 Semgrep

Outil d'analyse statique multi-langages avec règles de sécurité personnalisables.

Installation et utilisation d'outils de sécurité

Installation et configuration d'outils essentiels

#!/bin/bash
# Script d'installation d'outils de sécurité

echo "[+] Installation des outils de sécurité..."

# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Outils de base
sudo apt install -y nmap nikto dirb gobuster hydra john sqlmap

# Installation de Burp Suite Community
wget -O burpsuite.sh "https://portswigger.net/burp/releases/download?product=community&type=Linux"
chmod +x burpsuite.sh
sudo ./burpsuite.sh

# Installation d'OWASP ZAP
sudo apt install -y zaproxy

# Installation de Metasploit
curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall
chmod 755 msfinstall
sudo ./msfinstall

# Outils Python
pip3 install requests beautifulsoup4 python-nmap

# Configuration de Burp Suite
echo "[+] Configuration de Burp Suite..."
mkdir -p ~/.java/.userPrefs/burp
cat > ~/.java/.userPrefs/burp/prefs.xml << 'EOF'
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">
<preferences EXTERNAL_XML_VERSION="1.0">
  <root type="user">
    <map>
      <entry key="burp.proxy.listener.port" value="8080"/>
      <entry key="burp.proxy.listener.interface" value="127.0.0.1"/>
    </map>
  </root>
</preferences>
EOF

echo "[+] Installation terminée!"
echo "Outils installés:"
echo "- Nmap (scan de ports)"
echo "- Nikto (scan web)"
echo "- Dirb/Gobuster (découverte de répertoires)"
echo "- Hydra (brute force)"
echo "- SQLMap (injection SQL)"
echo "- Burp Suite (proxy/scanner web)"
echo "- OWASP ZAP (scanner web)"
echo "- Metasploit (framework d'exploitation)"

---

📊 Documentation et rapport

Structure d'un rapport de test de pénétration

Sections principales du rapport

1. Résumé exécutif : Synthèse pour la direction
2. Méthodologie : Approche et outils utilisés
3. Résultats : Vulnérabilités par ordre de criticité
4. Recommandations : Mesures correctives prioritaires
5. Annexes : Détails techniques et preuves

### Classification des risques

Sévérité	Score CVSS	Impact	Délai de correction
Critique	9.0 - 10.0	Compromission totale du système	Immédiat (24h)
Élevé	7.0 - 8.9	Accès non autorisé aux données	1 semaine
Moyen	4.0 - 6.9	Exposition d'informations	1 mois
Faible	0.1 - 3.9	Impact limité	3 mois

💡 Bonnes pratiques pour les rapports :

• Preuves visuelles : Captures d'écran annotées
• Reproductibilité : Steps détaillés pour reproduire
• Impact métier : Conséquences concrètes
• Solutions pratiques : Recommandations applicables
• Timeline : Priorités et délais de correction

---

📚 Pour aller plus loin

🔗 Ressources complémentaires :

• OWASP.org : Documentation et outils officiels
• PortSwigger Web Security Academy : Formation Burp Suite
• VulnHub : Machines virtuelles vulnérables pour s'entraîner
• HackTheBox : Plateforme d'entraînement au pentest
• PTES (Penetration Testing Execution Standard) : Méthodologie standardisée

---

✅ Points clés à retenir

1. OWASP : Référence incontournable pour la sécurité web
2. Burp Suite : Outil professionnel pour les tests d'applications web
3. Méthodologie : Approche structurée et documentée
4. Automatisation : Combiner outils automatiques et tests manuels
5. Documentation : Rapport détaillé avec preuves et recommandations

🎓 Prochaine étape : Dans le cours B3.6, nous aborderons la conformité réglementaire et la veille sécurité (RGPD, normes, identité numérique).