**Comment ça fonctionne :**

1. **Claude Code** lit `CLAUDE.md` pour la méthodologie de pentest complète et orchestre le workflow en 7 phases.
2. **Sous-agents spécialisés par rôle** (Scout, Analyzer, Exploiter, Reporter) exécutent des tâches ciblées avec des modèles de prompts dédiés, des conseils d'outils et des anti-patrons.
3. **Serveur MCP WSTG** (68+ outils) fournit les procédures de test OWASP, 31 guides de techniques PortSwigger, un arbre de tâches hiérarchique, un graphe de connaissances, le contournement WAF, la priorisation des points de terminaison, la vérification des résultats, la compression de contexte, des portes de qualité et la génération de rapports.
4. **Conteneur Docker** exécute les 27 outils de sécurité — le trafic est optionnellement routé via Burp Suite pour une surveillance passive.
5. **Playwright MCP** gère les tests basés sur navigateur (DOM XSS, clickjacking, pages de connexion rendues en JS).

---

## Fonctionnalités

### Couverture OWASP complète
- **109 cas de test WSTG** répartis dans 12 catégories — de la collecte d'informations aux tests d'API
- Chaque test inclut des procédures CLI pas à pas, des charges utiles contextuelles, des critères de détection et des grilles de sévérité
- Les tests sont priorisés (MUST/SHOULD) avec des déclencheurs conditionnels pour ne rien manquer d'important

### 31 guides de techniques d'attaque PortSwigger
- Tirés de la [PortSwigger Web Security Academy](https://portswigger.net/web-security) — méthodes de détection, techniques d'exploitation, charges utiles, antisèches et patrons de contournement WAF
- Organisés par classe de vulnérabilité (SQLi, XSS, SSRF, JWT, OAuth, etc.) pour une utilisation directe lors des tests
- Intégrés dans chaque phase de test — les agents chargent automatiquement le guide de technique pertinent avant de tester chaque classe de vulnérabilité
- Tableaux de charges utiles spécifiques à la base de données/plateforme (Oracle vs MySQL vs PostgreSQL vs MSSQL pour SQLi, Jinja2 vs Twig vs Freemarker pour SSTI, etc.)
- Patrons de contournement WAF organisés par niveau de contournement (de base → intermédiaire → avancé)

### 27 outils de sécurité préconfigurés
- Tous les outils préinstallés dans une seule image Docker — `make setup` et vous êtes prêt
- Outils organisés par phase : découverte, tests d'injection, authentification, cryptographie, tests d'API
- Intégration automatique du proxy Burp Suite pour la surveillance passive du trafic

### Workflow structuré en 7 phases
- **Phase 0 :** Découverte et cartographie de l'application
- **Phase 1 :** Collecte d'informations et reconnaissance
- **Phase 2 :** Tests de configuration et de déploiement
- **Phase 3 :** Gestion de l'identité, de l'authentification, de l'autorisation et des sessions
- **Phase 4 :** Tests de validation d'entrée (pipelines XSS/SQLi/SSRF enchaînés)
- **Phase 5 :** Tests de gestion des erreurs, cryptographie, logique métier, côté client et API
- **Phase 6 :** Vérification de la couverture et rapport
- **Phase 7 :** Révision finale par le juge et correction

### Système d'assurance qualité
- **Portes de phase automatisées** — chaque phase doit passer des contrôles qualité avant de continuer
- **Sous-agent Réviseur Qualité** à chaque transition de phase identifie les lacunes et suggère des améliorations
- **Juge Final** — un agent sans contexte examine l'ensemble de l'engagement à froid, comme un réviseur QA externe
- **Portes d'épuisement** — « non vulnérable » nécessite une preuve d'effort de test suffisant (nombre minimal de techniques et tentatives de contournement)

### Résultats basés sur des preuves
- Chaque résultat nécessite des commandes curl reproductibles et des preuves complètes de requête/réponse
- **Classification à trois niveaux :** EXPLOITÉ (impact prouvé), POTENTIEL (bloqué par un contrôle), FAUX_POSITIF (le contrôle tient)
- **Cadre anti-hallucination** — « pas d'exploit = pas de résultat » appliqué à tous les niveaux
- Listes de contrôle de preuves par classe de vulnérabilité vérifiées avant que tout résultat ne soit enregistré

### Sous-agents spécialisés par rôle
- **4 rôles dédiés** avec des modèles de prompts ciblés, des conseils d'outils et des anti-patrons :
  - **Scout** — reconnaissance uniquement, cartographie la surface d'attaque sans envoyer de charges utiles (Phase 0-1)
  - **Analyzer** — identifie les points d'injection potentiels avec des charges utiles sentinelles/témoins, construit des files d'exploitation (Phase 2-5 analyse)
  - **Exploiter** — consomme la sortie d'Analyzer, prouve l'exploitation avec des preuves, enregistre les résultats confirmés (Phase 4 exploitation)
  - **Reporter** — révision qualité et Juge Final, examine les données sans envoyer de requêtes (QA + post-rapport)
- Point de contrôle de validation entre l'analyse et l'exploitation pour éviter le gaspillage d'efforts
- Chaque rôle a des listes d'outils autorisés/interdits explicites et des contrats d'entrée/sortie

### Exploitation en pipeline (Phase 4)
- 3 **pipelines à deux étages** indépendants exécutés en parallèle : XSS, Injection (SQLi/CMDi), SSRF/SSTI
- Chaque pipeline : Analyzer (découvrir → analyser → mettre en file) → point de contrôle de validation → Exploiter (exploiter → enregistrer)
- Chaque pipeline charge son guide de techniques PortSwigger pour les méthodes de détection, les antisèches et les patrons de contournement WAF
- Renseignement WAF partagé entre tous les pipelines
- Charges utiles témoins contextuelles pour 13 types de points d'injection

### Contournement WAF adaptatif
- **Empreinte WAF automatique** à partir des en-têtes de réponse, du corps et des codes d'état — identifie 12 fournisseurs WAF (Cloudflare, AWS WAF, Akamai, Imperva, ModSecurity, F5, FortiWeb, Sucuri, Barracuda, Wordfence, NAXSI, Citrix)
- **Charges utiles de contournement spécifiques au fournisseur** organisées par niveau de complexité (de base → intermédiaire → avancé)
- Renseignement WAF partagé entre tous les agents via le système de livrables
- Les agents identifient automatiquement le WAF dès le premier blocage de réponse et basculent vers des charges utiles de contournement adaptées

### Graphe de connaissances inter-phases
- **Graphe entité-relation** suit les points de terminaison, paramètres, technologies, résultats, cookies, domaines et rôles utilisateur
- **Chaînage automatisé des vulnérabilités** via la recherche de chemin BFS avec 7 patrons de chaînage prédéfinis :
  - XSS + CSP manquant, XSS + cookie faible (pas de HttpOnly), Redirection ouverte + callback OAuth
  - IDOR + rôle admin, SSRF + métadonnées cloud, Pas de verrouillage + pas de MFA, CORS + point de terminaison sensible
- Amélioration de la sévérité lorsque le chaînage augmente matériellement l'impact
- Peuplé tout au long des tests, interrogé après la Phase 4 pour la découverte de chaînes

### Arbre de tâches hiérarchique
- Structure arborescente persistante (phases comme branches, tests comme feuilles) empêche le biais de profondeur LLM et la perte de contexte
- L'agent principal maintient une vue macroscopique stratégique ; les sous-agents ne mettent à jour que leurs nœuds feuilles assignés
- Auto-propagation : lorsque tous les enfants sont terminés, le parent se termine automatiquement
- Pourcentages de complétion par phase pour une prise de décision éclairée

### Priorisation du risque des points de terminaison
- Note et trie les points de terminaison par risque pour des tests priorisés — le plus risqué testé en premier
- Facteurs de notation : nombre de paramètres, indicateurs de risque technologique, confiance dans la chaîne de contamination, convergence des outils, exigences d'authentification, noms de paramètres injectables
- Intégré dans la génération de la carte des points de terminaison de la Phase 0

### Analyse de sortie des outils
- **13 analyseurs intégrés** pour les outils CLI courants (nmap, nuclei, sqlmap, ffuf, httpx, whatweb, testssl, nikto, dalfox, katana, gau, wapiti, commix)
- Condense la sortie brute des outils de 3 à 5 fois tout en préservant les résultats clés, les points de terminaison et les erreurs
- Verbosité configurable : résumé (~15 lignes), détaillé (~50 lignes), complet (sortie analysée complète)

### Vérification des résultats des outils CLI
- Validation automatique de la qualité de la sortie des outils CLI — détecte les sorties vides, les erreurs de proxy, les problèmes de permission et les résultats suspects
- **10 validateurs par outil** (nmap, nuclei, sqlmap, ffuf, feroxbuster, testssl, dalfox, wapiti, katana, httpx) avec suggestions de commandes corrigées
- Lorsqu'un outil produit une sortie vide ou suspecte, le validateur suggère des correctifs (par exemple, ajouter `-Pn` pour nmap, supprimer les variables d'environnement proxy, essayer différents indicateurs)
- Intégré dans le flux de travail d'exécution des outils — les agents appellent `verify_tool_result()` après chaque exécution d'outil CLI

### Compression progressive du contexte
- **Résumés de phase** (~500-800 mots) générés automatiquement lorsque les portes de phase sont franchies — capturant les résultats, la couverture, les résultats des outils et la surface d'attaque sous forme compressée
- Empêche la dégradation du contexte dans les engagements de longue durée en remplaçant les données historiques brutes par des résumés structurés
- `get_engagement_summary()` combine tous les résumés de phase en un seul aperçu pour injection dans les nouveaux prompts des sous-agents
- Les résumés sont stockés comme livrables — accessibles par tout agent en aval sans nécessiter l'historique complet de l'engagement

### Analyse contrefactuelle (découverte en second passage)
- Après qu'un Analyzer a terminé avec des vulnérabilités trouvées, un **deuxième Analyzer** est généré avec des instructions pour « supposer que ces vulnérabilités sont corrigées »
- L'Analyzer contrefactuel recherche des vulnérabilités **supplémentaires** : différents points de terminaison, différents paramètres, différents contextes d'injection, failles logiques
- Les résultats sont ajoutés à la file d'exploitation existante (fusion automatique avec déduplication par point de terminaison+paramètre et incrémentation automatique des IDs)
- Basé sur la recherche d'ablation PenHeal montrant +71% de couverture des vulnérabilités avec un prompting contrefactuel

### Support multi-domaines
- Détection et gestion automatiques SSO/OAuth/OIDC/SAML
- Enregistrement, exploration et test du périmètre par domaine
- Gestion du conteneur de cookies pour la persistance de session inter-domaines
- Escalade d'échec d'authentification à 6 niveaux (subventions alternatives → PKCE → navigateur sans tête → extraction de jeton → provisionnement utilisateur → non authentifié)

### Gestion d'engagement résistante aux crashs
- `findings.md` et `progress.log` en mode ajout seulement survivent aux crashs
- Point de contrôle Git avec capacité de retour en arrière
- **Reprise automatique sur interruption** — `resume-prompt.md` généré automatiquement à chaque point de contrôle avec le contexte complet (cible, identifiants, phase actuelle, tests restants, périmètre). Collez dans une nouvelle session pour continuer exactement là où vous vous êtes arrêté
- Granularité des points de contrôle en milieu de phase — suit quels tests au sein d'une phase sont terminés, pas seulement l'état au niveau de la phase
- Piste d'audit complète de chaque appel d'outil MCP avec horodatage

### Rapports professionnels
- Rapports Markdown avec résumé exécutif, résultats par sévérité, matrice de couverture des tests et couverture des outils
- Pourcentages de couverture par catégorie et analyse des lacunes
- Analyse du chaînage des vulnérabilités documentée
- Observations du Juge Final et notes de qualité incluses

---

## Système de rôles des agents

AutoPentest utilise 4 rôles d'agents spécialisés au lieu de sous-agents génériques. Chaque rôle a un modèle de prompt dédié avec des conseils d'outils ciblés, des contrats d'entrée/sortie et des anti-patrons.

| Rôle | Modèle | Objectif | Phases |
|------|--------|----------|--------|
| **Scout** | `templates/agent-roles/scout.md` | Reconnaissance et cartographie de la surface d'attaque | Phase 0-1, découverte du code source |
| **Analyzer** | `templates/agent-roles/analyzer.md` | Découverte de vulnérabilités avec charges utiles sentinelles/témoins | Phase 2-5 analyse |
| **Exploiter** | `templates/agent-roles/exploiter.md` | Preuve d'exploitation avec preuves | Phase 4 exploitation |
| **Reporter** | `templates/agent-roles/reporter.md` | Révision qualité et Juge Final | Transitions de phase, post-rapport |

### Comment fonctionne le pipeline

La Phase 4 (tests à plus fort impact) utilise un pipeline en deux étages par classe de vulnérabilité :```
┌──────────────────────────────────────────────────────────────┐
│                    Pipeline 1: XSS                           │
│                                                              │
│  Analyzer (75 turns)          Exploiter (75 turns)           │
│  ┌─────────────────────┐      ┌─────────────────────┐        │
│  │ Discover endpoints  │      │ Load Analyzer queue │        │
│  │ Send canary payloads│─────▶│ Attempt exploitation│        │
│  │ Build exploit queue │ gate │ Prove impact        │        │
│  │ Save deliverable    │      │ Log findings        │        │
│  └─────────────────────┘      └─────────────────────┘        │
│                          ▲                                   │
│               validate_exploitation_queue()                  │
└──────────────────────────────────────────────────────────────┘

Voilà. Les 27 outils de sécurité sont maintenant installés et prêts à l'intérieur du conteneur Docker.

### Vérifier l'installation```bash
# Check all tools are installed
make verify-tools

# Expected output:
# [+] nuclei: installed
# [+] httpx: installed
# [+] katana: installed
# ... (27 tools total)

Ensuite, dites à Claude quoi tester :```
Run a full WSTG assessment against https://target.example.com

Claude demandera toute information manquante (comme les identifiants) et commencera le workflow en 7 phases.

### Option B: Mode piloté par configuration (Recommandé)

Créez un fichier de configuration YAML pour des évaluations reproductibles et cohérentes :```yaml
# configs/my-target.yaml
target:
  url: https://app.example.com
  scope:
    - app.example.com
    - api.example.com
  exclude:
    - cdn.example.com

authentication:
  login_type: form
  login_url: https://app.example.com/login
  credentials:
    username: [email protected]
    password: secret123
  login_flow:
    - "Type $username into the email field"
    - "Type $password into the password field"
    - "Click the 'Sign In' button"
  success_condition:
    type: url_contains
    value: "/dashboard"

rules:
  avoid:
    - description: "Do not test logout"
      type: path
      url_path: "/logout"
  focus:
    - description: "Prioritize API endpoints"
      type: path
      url_path: "/api"

reporting:
  tester_name: "Security Team"

### Option C: Tests ciblés

Exécutez des tests WSTG spécifiques sur des points de terminaison spécifiques:```
Run WSTG-INPV-05 (SQL Injection) against https://app.example.com/search?q=

### Divers

- [Envizon](https://github.com/evait-security/envizon) - outil de visualisation réseau axé sur les besoins des équipes rouges et bleues
- [WiFi Pineapple](https://www.wifipineapple.com/) - plateforme d'audit sans fil de Hak5
- [Pwnagotchi](https://pwnagotchi.ai/) - apprentissage par renforcement profond instrumenté avec bettercap pour le piratage WiFi
- [HackRF One](https://greatscottgadgets.com/hackrf/) - périphérique Software Defined Radio capable d'émettre ou de recevoir des signaux radio de 1 MHz à 6 GHz, conçu pour permettre les tests et le développement de technologies radio modernes et de nouvelle génération
- [PortSwigger Burp Suite Community Edition](https://portswigger.net/burp/communitydownload) - outil complet de test de sécurité des applications web / API avec un flux de travail de test d'intrusion 100 % manuel. Les autres flux de travail (par exemple, l'analyse automatisée / manuelle) nécessitent une licence Professional après une courte période d'essai
- [rotorouter](https://github.com/CheckPointSW/rotorouter) - permet de router les connexions TCP vers un hôte distant, où la pile TCP/IP propre au système est utilisée pour acheminer la communication, réduisant ainsi les risques d'interférence avec la connexion provenant de l'outil lui-même
- [CyberChef](https://gchq.github.io/CyberChef/) - couteau suisse cybernétique - une application web pour le chiffrement, l'encodage, la compression et l'analyse de données
- [pypykatz](https://github.com/skelsec/pypykatz) - implémentation de Mimikatz en Python pur
- [PowerShx](https://github.com/AlteredSecurity/PowerShx) - exécuter Powershell sans restrictions logicielles
- [ADRecon](https://github.com/adrecon/ADRecon) - collecter des informations sur Microsoft Active Directory
- [Graylog](https://github.com/Graylog2/graylog2-server) - gestion de logs de niveau entreprise
- [sttr](https://github.com/abhimanyu003/sttr) - application CLI multiplateforme pour effectuer diverses opérations sur les chaînes de caractères
- [CyberChef Magic](https://github.com/SecurityBagel/cyberchef-magic) - améliorer l'expérience CyberChef
- [RemoteTLSCallbackInjection](https://github.com/joaoviictorti/RemoteTLSCallbackInjection) - utilise les callbacks TLS pour exécuter une charge utile sans créer de threads dans un processus distant
- [SystemBC](https://github.com/c3rb3ru5d3d53c/SystemBC) - serveur Command & Control et implant utilisant des proxys SOCKS5 - Service caché Tor - évasion de pare-feu - ransomware - C2 - évasion - vivre de la terre
- [plumber](https://github.com/geeks-r-us/plumber) - exécuter un shellcode dans différents processus sous Windows x86-x64 en utilisant divers appels WinAPI
- [NimExec](https://github.com/frkngksl/NimExec) - exécuter des commandes sur plusieurs machines Windows distantes en utilisant SMB, des pipes nommés et MSRPC sans téléverser de fichiers
- [RustChain](https://github.com/Kudaes/RustChain) - cacher des artefacts mémoire en utilisant ROP et des points d'arrêt matériels
- [Havoc](https://github.com/HavocFramework/Havoc) - framework de commandement et contrôle post-exploitation moderne et malléable
- [Phoenix](https://github.com/PhoenixC2/Phoenix) - framework C2 post-exploitation multiplateforme utilisant Nim
- [AceLdr](https://github.com/kyleavery/AceLdr) - UDRL Cobalt Strike pour l'évasion des scanners mémoire
- [AtomLdr](https://github.com/NUL0x4C/AtomLdr) - chargeur de DLL avec des fonctionnalités d'évasion avancées
- [TitanLdr](https://github.com/NUL0x4C/TitanLdr) - chargeur réflectif avec un projet de DLL implanté
- [RustHound-CE](https://github.com/g0h4n/RustHound-CE) - outil collecteur BloodHound CE écrit en Rust pour les systèmes Windows et Linux. Ingère des fichiers parquet dans BloodHound Community Edition
- [Nimbo-C2](https://github.com/elesiuta/nimbo-c2) - agent et serveur C2 multiplateforme écrits en Nim - SMB - TCP - chiffré - furtif
- [mystique](https://github.com/mach1el/mystique) - PowerShell pour échapper à la détection en mémoire - AMSI - ETW - SBL - modules - scripts
- [Hooka](https://github.com/Flangvik/Hooka) - effectuer du hooking d'API en utilisant Hell's Hall - Appels système - Appels système directs - Appels système indirects
- [Revil](https://github.com/cerbersec/Revil) - réimplémentation du ransomware Revil
- [ScareCrow](https://github.com/Tylous/ScareCrow) - framework de création de charges utiles conçu pour contourner les EDR
- [DLLMainThreadHijacking](https://github.com/nickheyer/DLLMainThreadHijacking) - technique d'injection de processus exploitant DLLMain pour exécuter un shellcode
- [Tetanus](https://github.com/0xTriboulet/Tetanus) - agent C2 écrit en Rust avec implant et serveur gRPC
- [NoPPS](https://github.com/ergoadr/NoPPS) - contourner les règles de réduction de la surface d'attaque (ASR) de Windows Defender
- [Evasor](https://github.com/0xTriboulet/Evasor) - outil automatisé d'évaluation de la sécurité pour Windows
- [AtlasReaper](https://github.com/peewpw/AtlasReaper) - outil en ligne de commande pour la reconnaissance et l'exploitation des instances Confluence, issu de ThreatReaper
- [NomadELF](https://github.com/nomad-delft/NomadELF) - analyseur de binaire ELF pour la sécurité offensive
- [NomadPE](https://github.com/nomad-delft/NomadPE) - analyseur de binaire PE pour la sécurité offensive
- [godoh](https://github.com/sensepost/godoh) - C2 DNS-over-HTTPS
- [Rustclaw](https://github.com/0xflux/RustClaw) - chargeur de shellcode écrit en Rust - injection de processus local/distant - hachage d'API - sans fichier
- [Falco](https://github.com/falcosecurity/falco) - sécurité d'exécution cloud native
- [PPLBlade](https://github.com/tastypepperoni/PPLBlade) - outil de dump de processus protégés prenant en charge l'obfuscation du dump mémoire et son transfert via tous les canaux bruts (disque et réseau) sans le sauvegarder sur le disque
- [ProcMonX](https://github.com/zodiacon/ProcMonX) - outil étendu de type moniteur de processus basé sur Event Tracing for Windows (ETW)
- [EDRSilencer](https://github.com/netero1010/EDRSilencer) - exploite la plateforme de filtrage Windows (WFP) pour empêcher les agents de détection et de réponse des terminaux (EDR) d'envoyer de la télémétrie au serveur de gestion
- [HackBot](https://github.com/morpheuslord/hackbot) - chatbot de cybersécurité basé sur l'IA conçu pour assister les tests d'intrusion
- [TeamFiltration](https://github.com/Flangvik/TeamFiltration) - framework multiplateforme pour l'aspersion de mots de passe, l'administration de jetons et d'AAD, et d'autres tâches de gestion Microsoft Teams
- [Flipper Zero](https://flipperzero.one/) - multi-outil portable pour pentesters et passionnés de matériel, avec un aspect de jouet. Il adore pirater les objets numériques qui l'entourent, tels que les protocoles radio, les systèmes de contrôle d'accès, le matériel, et bien plus encore
- [pem](https://github.com/serializingme/pem) - outil de post-exploitation unix/linux
- [PIC-burglar](https://github.com/kyleavery/PIC-burglar) - preuve de concept pour générer un shellcode qui lit et analyse le PEB afin de localiser les fonctions DLL sans parcourir InMemoryOrderModuleList
- [DarkWidow](https://github.com/R3yMag1c/DarkWidow) - dépose plusieurs fichiers encodés sur le disque dans un format Base64 non conforme à la RFC avec des remplacements de caractères clés
- [USBHelper](https://github.com/py7hon/USBHelper) - énumération des périphériques USB sur les systèmes Windows
- [dazzleUP](https://github.com/hlldz/dazzleUP) - outil qui détecte les vulnérabilités d'élévation de privilèges causées par des mauvaises configurations ou des mises à jour manquantes dans le système d'exploitation Windows. Peuple également automatiquement le système pour tester les exploits
- [Flatline](https://github.com/Print3M/Flatline) - active les caractères de remplacement de droite à gauche et la transparence compatible ANSI en manipulant l'affichage de la console sans privilèges administrateur
- [XOR-Obfuscator](https://github.com/rwn4u/XOR-Obfuscator) - obfusque les scripts Powershell en chiffrant la charge utile avec XOR
- [PyHTools](https://github.com/dmdhrumilmistry/PyHTools) - boîte à outils de piratage Python avec divers outils et utilitaires
- [obfshellcode](https://github.com/rex979/obfshellcode) - obfusque un shellcode en utilisant différentes méthodes
- [HackyPi](https://github.com/sbcshop/HackyPi) - outil de piratage USB DIY à but éducatif
- [PowerRun](https://github.com/lefterispan/powerrun) - le plus petit outil capable d'exécuter des exécutables avec les privilèges les plus élevés (TrustedInstaller, SYSTEM)
- [CrabClaw](https://github.com/Souhardya/CrabClaw) - vole des mots de passe et d'autres données sur les systèmes Windows en simulant un clavier USB
- [MacDBG](https://github.com/blankwall/macdbg) - débogue le noyau macOS en utilisant des points d'arrêt matériels
- [Qu1Ckdr0P2](https://github.com/cube0x0/Qu1Ckdr0P2) - alternative à Quick Drop - exfiltre des fichiers depuis des systèmes Windows en utilisant Koadic
- [RustHound-CE-Collector](https://github.com/nichealpham/RustHound-CE-Collector) - outil collecteur pour rassembler les données Active Directory destinées à BloodHound CE
- [ADCSKiller](https://github.com/grimlockx/ADCSKiller) - outil d'exploitation et d'automatisation ADCS
- [Pwndoc-ng](https://github.com/pwndoc-ng/pwndoc-ng) - outil de génération de rapports de pentest
- [FleetingMDE](https://github.com/password123456/FleetingMDE) - contournement de Microsoft Defender for Endpoint sans privilèges administrateur
- [Kudzu](https://github.com/checkpoint-rest-api/kudzu) - ensemble d'outils pour la réponse aux incidents et la chasse aux menaces, contenant diverses fonctions d'analyse, de collecte et de détection de données
- [RomBuster](https://github.com/EntySec/RomBuster) - exploite les vulnérabilités des routeurs pour obtenir leurs mots de passe
- [AMSI Bypass](https://github.com/nickvourd/AMSI-Bypass) - une liste de techniques de contournement AMSI pour les équipes rouges
- [BlindHound](https://github.com/whokilleddb/BlindHound) - exfiltre les données Active Directory via une relation de confiance aveugle compromise
- [RegSvr32](https://github.com/Flangvik/RegSvr32) - alternative à regsvr32.exe avec prise en charge des scriptlets COM et de l'enregistrement de DLL
- [ShellcodeMutator](https://github.com/TheD1rkMtr/ShellcodeMutator) - mutation de shellcode en utilisant diverses techniques
- [PentestGPT](https://github.com/GreyDGL/PentestGPT) - outil de test d'intrusion assisté par des modèles GPT
- [Anti-Virus-Evasion-Tool](https://github.com/1y0n/AV_Evasion_Tool) - génère des charges utiles d'évasion AV
- [IOCTLance](https://github.com/alfarom256/IOCTLance) - énumération des vulnérabilités des codes de contrôle utilisateur vers noyau
- [Lantern](https://github.com/tom-carver/Lantern) - framework C2 avec chiffrement multicouche et furtivité
- [KapeDocs](https://github.com/EricZimmerman/KapeDocs) - documentation pour KAPE (Kroll Artifact Parser and Extractor)
- [Snaffler](https://github.com/SnaffCon/Snaffler) - acquiert des informations d'identification et d'autres données intéressantes depuis Active Directory
- [Lilith](https://github.com/Ch0pin/lilith) - application Android pour l'installation de certificats CA et l'interception de trafic
- [PhishMailer](https://github.com/BiZken/PhishMailer) - génère des e-mails de phishing professionnels
- [RedCloud-OS](https://github.com/khast3x/Redcloud-OS) - distribution de test d'intrusion avec des outils préinstallés
- [PSAmsi](https://github.com/cobbr/PSAmsi) - outil pour auditer et contourner AMSI
- [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) - identifie les octets que Microsoft Defender signalera
- [SigFlip](https://github.com/med0x2e/SigFlip) - patcher des fichiers PE signés Authenticode sans invalider la signature
- [PowerLurk](https://github.com/Sw4mpf0x/PowerLurk) - ensemble d'outils Powershell pour créer des abonnements aux événements WMI pour la persistance
- [SharpUnhooker](https://github.com/GetRektBoy724/SharpUnhooker) - outil basé en C# pour défaire les hooks d'API placés par les EDR/AV
- [TikiTorch](https://github.com/rasta-mouse/TikiTorch) - framework C2 utilisant des pipes nommés
- [RainbowCrack](https://project-rainbowcrack.com/) - génère des tables arc-en-ciel pour craquer les hachages de mots de passe
- [FrostByte](https://github.com/jordanjoewatson/FrostByte) - framework C2 avec des tunnels DNS personnalisés écrit en Python
- [Mythic](https://github.com/its-a-feature/Mythic) - framework de red teaming multiplateforme, post-exploitation, axé sur la collaboration
- [Sliver](https://github.com/BishopFox/sliver) - framework d'implant multiplateforme polyvalent prenant en charge plusieurs protocoles C2
- [COFFLoader](https://github.com/trustedsec/COFFLoader) - charge et exécute des fichiers COFF (Common Object File Format) en mémoire
- [SauronEye](https://github.com/vivami/SauronEye) - recherche des fichiers contenant des mots-clés spécifiques
- [Shhhloader](https://github.com/icyguider/Shhhloader) - chargeur de shellcode avec des fonctionnalités anti-détection
- [RustyLoader](https://github.com/fluhusguy/RustyLoader) - chargeur de DLL réflectif écrit en Rust
- [Talon](https://github.com/Sentinel-One/Talon) - framework pour exécuter du code dans un processus cible en utilisant RPC
- [RedWarden](https://github.com/mgeeky/RedWarden) - redirecteur C2 flexible
- [Artillery](https://github.com/BinaryDefense/artillery) - honeypot / outil de surveillance pour détecter et prévenir les attaques
- [GhostWriter](https://github.com/GhostManager/Ghostwriter) - plateforme de rapport et de collaboration pour le red teaming
- [ReelPhish](https://github.com/fireeye/ReelPhish) - outil de phishing en temps réel à deux facteurs
- [DefenderCheck](https://github.com/matterpreter/DefenderCheck) - identifie les octets exacts qui déclenchent les détections antivirus
- [PowerShellArmoury](https://github.com/LuemmelSec/PowerShellArmoury) - un arsenal Powershell pour les pentesters
- [NetLoader](https://github.com/Flangvik/NetLoader) - charge des binaires C# arbitraires depuis la mémoire
- [KeeThief](https://github.com/HarmJ0y/KeeThief) - extrait les mots de passe KeePass de la mémoire
- [DInjector](https://github.com/snovvcrash/DInjector) - collection de techniques d'injection de shellcode packagées dans une DLL weaponized D/Invoke```
Run all authentication tests (WSTG-ATHN) against https://app.example.com

---

## Phases de Test

### Phase 0 : Découverte et Cartographie de l'Application

La phase de fondation critique. Claude effectue de manière autonome :

1. **Vérifications pré-vol** — vérifie l'accessibilité de la cible, détecte les redirections et l'authentification inter-domaines
2. **Lance 10+ outils en arrière-plan en parallèle** (katana, ffuf, nuclei, whatweb, gau, nmap, feroxbuster, wapiti, httpx)
3. **Exploration récursive** — suit les liens jusqu'à une profondeur de 2-3, analyse HTML/JS pour les points de terminaison
4. **Bruteforce de répertoires** — chemins courants + listes de mots spécifiques à la technologie
5. **Ingestion des résultats d'outils** — lit toutes les sorties des outils en arrière-plan et les fusionne en une carte de points de terminaison unifiée
6. **Construit un inventaire structuré des points de terminaison** avec paramètres, exigences d'authentification et classements de priorité

**Résultat :** Une carte complète des points de terminaison organisée par domaine, prête pour des tests systématiques.

### Phase 1-2 : Reconnaissance et Configuration

- Empreinte du serveur, détection de la technologie, examen des métadonnées
- Analyse des en-têtes de sécurité (HSTS, CSP, CORS, X-Frame-Options)
- Test de configuration TLS, découverte d'interface d'administration
- Test des méthodes HTTP, gestion des extensions de fichier

### Phase 3 : Authentification, Autorisation et Gestion de Session

- **Treillis de rôles/Privilèges** construit avant les tests (cartographie des gardes, middleware et tests de contournement)
- Test IDOR avec plusieurs ID alternatifs par point de terminaison
- Test CSRF sur chaque point de terminaison modifiant l'état
- Fixation de session, détournement et analyse de jeton
- Test de vulnérabilité JWT (si applicable)
- Test de faiblesse OAuth/OIDC (si applicable)

### Phase 4 : Validation d'Entrée (Impact le plus élevé)

Trois pipelines indépendants en deux étapes s'exécutent en parallèle, chacun utilisant la répartition des rôles Analyseur→Exploiteur :

| Pipeline | Classes de vulnérabilité | Outils | Guides de techniques |
|----------|--------------------------|--------|----------------------|
| Pipeline XSS | XSS Réfléchi, XSS Stocké, XSS DOM | dalfox, Playwright | XSS, DOM |
| Pipeline d'Injection | Injection SQL, Injection de commandes, Injection NoSQL | sqlmap, commix, nosqli | SQLI, CMDI, NOSQLI |
| Pipeline SSRF/SSTI | SSRF, SSTI, Contournement de chemin | sstimap, ssrfmap | SSRF, SSTI, PTRAV |

Chaque pipeline : **Analyseur** (découvrir → analyser → construire la file d'exploitation) → point de contrôle de validation → **Exploiteur** (tenter l'exploitation → prouver l'impact → enregistrer les résultats). L'intelligence de contournement WAF est partagée entre tous les pipelines.

### Phase 5 : Gestion des Erreurs, Cryptographie, Logique Métier, Côté Client et API

- Divulgation de trace de pile et de message d'erreur
- Test TLS/SSL via testssl.sh
- Contournement de la logique métier (circulation de workflow, falsification de requête)
- Test côté client (clickjacking, redirections ouvertes, manipulation DOM)
- Test d'API GraphQL et REST
- Analyse de chaînage de vulnérabilités sur tous les résultats

### Phase 6 : Rapport

- Vérification de la couverture (couverture de test + couverture d'outil)
- Déduplication des résultats et calibrage de la sévérité
- Génération de rapport Markdown avec résumé exécutif, résultats, matrices de couverture

### Phase 7 : Examen Final du Juge

Un agent sans contexte examine l'ensemble de l'engagement à froid — sans connaissance des décisions ou difficultés de test. Il examine :

- **Intégrité de la couverture** — tests approuvés automatiquement, points de terminaison manquants
- **Détection de cascade N/A** — catégories avec des marquages "non applicable" excessifs
- **Qualité des résultats** — exhaustivité des preuves, cohérence de la sévérité, opportunités de chaînage
- **Utilisation des outils** — outils exécutés mais sorties jamais examinées, raisons de saut paresseuses
- **Surface d'attaque manquée** — points de terminaison non testés, paramètres non testés, domaines non testés

Le verdict (PASS/CONDITIONAL_PASS/FAIL) déclenche des actions de remédiation spécifiques avant la livraison du rapport.

---

## Outils de Sécurité

### Découverte et Reconnaissance (Phase 0)

| Outil | Objectif | Drapeaux clés |
|-------|----------|---------------|
| **katana** | Crawler web avec rendu JavaScript | `-jc` pour le crawling JavaScript |
| **httpx** | Sondage HTTP, détection de technologie | `-tech-detect -status-code -title` |
| **ffuf** | Fuzzing de répertoires/paramètres | `-w wordlist -mc all -fc 404` |
| **feroxbuster** | Énumération récursive de répertoires | `--smart --auto-tune` |
| **nuclei** | Scanner de vulnérabilités basé sur des modèles | `-t cves/ -t misconfigurations/` |
| **nikto** | Mauvaise configuration du serveur web | `-Tuning 1234567890` |
| **whatweb** | Empreinte de technologies | `--aggression 3` |
| **nmap** | Scan de ports et services | `-sV -sC --top-ports 1000` |
| **gau** | Découverte d'URL historiques | `--blacklist png,jpg,gif` |
| **subfinder** | Énumération de sous-domaines | `-silent -all` |

### Test d'Injection (Phase 4)

| Outil | Objectif | Drapeaux clés |
|-------|----------|---------------|
| **sqlmap** | Injection SQL (toutes techniques) | `--batch --risk 3 --level 5` |
| **dalfox** | Scan et exploitation XSS | `--skip-bav --deep-domxss` |
| **commix** | Injection de commandes | `--batch --all` |
| **sstimap** | Injection de modèles côté serveur | `-u <url>` |
| **ssrfmap** | Exploitation SSRF | `-r request.txt` |
| **nosqli** | Injection NoSQL | `-u <url>` |
| **crlfuzz** | Injection CRLF / Découpage HTTP | `-u <url>` |
| **smuggler** | Contrebande de requêtes HTTP | `-u <url>` |

### Authentification et Session (Phase 3)

| Outil | Objectif | Drapeaux clés |
|-------|----------|---------------|
| **hydra** | Brute-force d'identifiants | `-L users.txt -P pass.txt` |
| **jwt_tool** | Analyse et exploitation de jetons JWT | `-t <token> -M at` |

### Cryptographie et API (Phase 5)

| Outil | Objectif | Drapeaux clés |
|-------|----------|---------------|
| **testssl.sh** | Test de configuration TLS/SSL | `--severity HIGH --sneaky` |
| **graphql-cop** | Test de sécurité GraphQL | `-t <url>` |
| **websocat** | Test WebSocket | `ws://<url>` |

### Infrastructure (Phase 2)

| Outil | Objectif |
|-------|----------|
| **corscanner** | Scan de mauvaise configuration CORS |
| **dnsreaper** | Détection de prise de contrôle de sous-domaine |

### Automatisation du Navigateur

| Outil | Objectif |
|-------|----------|
| **Playwright** | Preuve XSS DOM, clickjacking, connexion rendue par JS, inspection du stockage côté client |

---

## Base de Connaissances WSTG

109 cas de test répartis dans 12 catégories OWASP, chacun avec des procédures CLI spécifiques :

| Code | Catégorie | Tests | Exemples |
|------|-----------|:-----:|----------|
| **INFO** | Collecte d'Informations | 10 | Découverte par moteur de recherche, empreinte du serveur, examen des métadonnées |
| **CONF** | Configuration et Déploiement | 14 | En-têtes de sécurité, CORS, CSP, HSTS, interfaces d'administration |
| **IDNT** | Gestion des Identités | 5 | Définitions de rôles, inscription, énumération de comptes |
| **ATHN** | Authentification | 11 | Identifiants par défaut, verrouillage, contournement d'authentification, MFA, politique de mot de passe |
| **ATHZ** | Autorisation | 5 | Contournement de répertoire, contournement d'authentification, escalade de privilèges, IDOR |
| **SESS** | Gestion de Session | 11 | Attributs de cookie, CSRF, fixation/détournement de session, JWT |
| **INPV** | Validation d'Entrée | 20 | XSS, SQLi, CMDi, SSTI, SSRF, contournement de chemin, XXE, LDAP |
| **ERRH** | Gestion des Erreurs | 2 | Messages d'erreur, traces de pile |
| **CRYP** | Cryptographie | 4 | Configuration TLS, oracle de remplissage, chiffrement faible |
| **BUSL** | Logique Métier | 10 | Contournement de flux, falsification de requête, téléchargement de fichier, limites de débit |
| **CLNT** | Côté Client | 14 | XSS DOM, clickjacking, redirections ouvertes, WebSockets, stockage |
| **APIT** | Test d'API | 3 | GraphQL, REST, SOAP |

Chaque fichier de test comprend :
- Procédures CLI étape par étape (commandes curl, invocations d'outils)
- Charges utiles organisées par niveau de contournement (basique, intermédiaire, avancé)
- Critères de détection avec grilles d'évaluation de sévérité
- Conseils de correction avec références

---

## Guides de Techniques PortSwigger

31 guides de référence de techniques d'attaque provenant de [PortSwigger Web Security Academy](https://portswigger.net/web-security), organisés par classe de vulnérabilité pour une utilisation directe lors d'engagements réels de pentest.

### Ce qui est Inclus

| Code | Catégorie | Correspondance WSTG | Contenu clé |
|------|-----------|---------------------|-------------|
| **SQLI** | Injection SQL | INPV-05 | Techniques UNION/aveugle/erreur/temporelle/OOB, antisèches spécifiques à la base de données (Oracle, MySQL, PostgreSQL, MSSQL), contournement WAF |
| **XSS** | Cross-Site Scripting | INPV-01, INPV-02, CLNT-01 | Contextes réfléchi/stocké/DOM, charges utiles de balises et de gestionnaires d'événements, contournement CSP, évasion de filtre |
| **CMDI** | Injection de commandes OS | INPV-12 | Caractères de séparation, techniques aveugles (délai temporel, OOB), charges utiles spécifiques à l'OS |
| **SSTI** | Injection de modèles côté serveur | INPV-18 | Détection et exploitation Jinja2/Twig/Freemarker/Velocity/ERB, évasions de sandbox |
| **SSRF** | Falsification de requête côté serveur | INPV-19 | Astuces de schéma d'URL, obscurcissement IP, rebinding DNS, métadonnées cloud, contournement de filtre |
| **PTRAV** | Contournement de chemin | INPV-04 | Variations d'encodage, injection d'octet nul, contournement de wrapper |
| **XXE** | Entités externes XML | INPV-07 | Récupération de fichier, SSRF via XXE, XXE aveugle avec OOB, entités de paramètre |
| **AUTHN** | Authentification | ATHN-01 à ATHN-07 | Brute force, contournement 2FA, empoisonnement de réinitialisation de mot de passe, credential stuffing |
| **AUTHZ** | Contrôle d'Accès | ATHZ-01 à ATHZ-04 | IDOR, escalade de privilèges, contournement horizontal/vertical, contrôles basés sur le référent |
| **JWT** | Jetons Web JSON | SESS-10 | Confusion d'algorithme (none/HS256→RS256), injection kid, exploitation JWK/JKU |
| **OAUTH** | OAuth 2.0 | ATHZ-05 | Vol de code d'autorisation, redirection ouverte, mise à niveau de scope, CSRF sur les flux OAuth |
| **CSRF** | Cross-Site Request Forgery | SESS-05 | Contournement de jeton, contournement SameSite, contournement de validation du référent |
| **SMUGGLE** | Contrebande de requêtes HTTP | INPV-15 | CL.TE, TE.CL, TE.TE, rétrogradation HTTP/2, tunnel de requête |
| **DOM** | Vulnérabilités basées sur le DOM | CLNT-01 | Sources/sinks, DOM clobbering, gadgets de pollution de prototype |
| **CORS** | Cross-Origin Resource Sharing | CONF-13, CLNT-07 | Réflexion d'origine, origine nulle, exploitation de la confiance de sous-domaine |
| **NOSQLI** | Injection NoSQL | INPV-05 | Injection d'opérateur MongoDB, injection JavaScript, extraction aveugle |
| **GRAPHQL** | GraphQL | APIT-01 | Introspection, suggestion de champ, attaques par lot, contournement d'autorisation |
| **RACE** | Conditions de Course | BUSL-04 | Dépassement de limite, TOCTOU, courses à point de terminaison unique, synchronisation de dernière image |
| **UPLOAD** | Téléchargement de Fichier | BUSL-08, BUSL-09 | Contournement d'extension, manipulation du type de contenu, web shells, fichiers polyglottes |
| **HOST** | Injection d'En-tête Hôte | INPV-17 | Empoisonnement de réinitialisation de mot de passe, empoisonnement de cache, SSRF basé sur le routage |

Plus 11 autres : CLICK, WS, CACHEPOIS, CACHEDEC, DESER, INFO, BUSL, PROTO, API, LLM, SKILLS.

### Comment Ils Sont Utilisés

Les guides de techniques sont intégrés dans chaque phase de test via l'outil MCP `get_technique_guide()` :```
Phase 2 → CORS guide for CONF-13 testing
Phase 3 → AUTHN, AUTHZ, CSRF, JWT, OAUTH guides for auth/session testing
Phase 4 → SQLI, XSS, CMDI, SSTI, SSRF, PTRAV, XXE guides for input validation
Phase 5 → DOM, CLICK, GRAPHQL, RACE, UPLOAD guides for client-side & business logic

Le solveur a deux modes :
- **autopentest** (par défaut) : Exécute Claude Code depuis la racine du projet, en chargeant `.mcp.json` (serveur MCP avec plus de 68 outils) et `CLAUDE.md` (méthodologie de pentest). Mesure la capacité complète d'AutoPentest.
- **raw** (`RAW=1`) : Exécute Claude Code nu, sans serveur MCP ni méthodologie. Base de référence pour mesurer la valeur ajoutée d'AutoPentest par rapport à la capacité brute de l'LLM.

Chaque défi est une application Docker Compose avec un flag injecté lors de la construction. L'extraction du flag depuis la sortie de Claude détermine le succès ou l'échec. Les résultats sont notés par défi, par tag et par niveau de difficulté.

### Mode CTF

Pour les défis CTF et les petites applications, activez le mode CTF pour des critères de qualité assouplis :```yaml
mode: ctf
target:
  url: https://target.com

### Exemple de constatation (Injection SQL)

Extrait du rapport — une constatation critique d'injection SQL avec preuve complète d'exploitation :```
FINDING-017: SQL Injection in /catalog category parameter — Full Data Extraction

Severity: Critical
WSTG Reference: WSTG-INPV-05

The category parameter is vulnerable to UNION-based SQL injection.
The attacker can:
  1. Inject a single quote to cause a 500 error (confirming injection)
  2. Use UNION SELECT with 8 columns to extract arbitrary data
  3. Enumerate tables: PRODUCTS, TRACKING, USERS
  4. Extract credentials from the USERS table

Evidence (reproducible curl command):
  curl -sk "https://ginandjuice.shop/catalog?category='+UNION+SELECT+1,USERNAME,PASSWORD,
  1,1,USERNAME,1,USERNAME+FROM+USERS+LIMIT+10--"

### Configuration du serveur MCP

Le fichier `.mcp.json` enregistre deux serveurs MCP :```json
{
  "mcpServers": {
    "wstg-pentest": {
      "command": "uv",
      "args": ["--directory", "./server", "run", "server.py"]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp"]
    }
  }
}

Tous les domaines sont automatiquement enregistrés dans le périmètre avec leur type (app, auth_provider, api, cdn).

### Tests par domaine

Chaque test WSTG est évalué par domaine – pas seulement le domaine principal :

- Les outils de découverte (katana, ffuf, nuclei) s'exécutent contre **tous** les domaines
- Les outils de validation d'entrée (sqlmap, dalfox) ciblent les points de terminaison sur **chaque** domaine avec traitement côté serveur
- Un test est « non applicable » uniquement lorsqu'**aucun** domaine ne possède la fonctionnalité testée

### Authentification inter-domaines

Protocoles SSO pris en charge :
- **OAuth 2.0 / OIDC** (Authorization Code, PKCE, Password Grant, Client Credentials)
- **SAML** (flux initié par le SP)
- **Keycloak**, **Auth0**, **Okta**, **Azure AD**
- **SSO personnalisé** (suivi de chaîne de redirection avec cookie jar)

La procédure d'escalade d'authentification (6 niveaux) garantit que les tests peuvent se poursuivre même avec des flux d'authentification complexes.

---

## Reprise après incident

AutoPentest est conçu pour survivre aux interruptions :

### Point de contrôle automatique
- Les portes de phase sauvegardent automatiquement les points de contrôle en cas de PASS
- `git_checkpoint()` crée des instantanés git de l'espace de travail d'engagement
- Les journaux en mode ajout uniquement (`findings.md`, `progress.log`) survivent aux plantages

### Reprise automatique via resume-prompt.md (Recommandé)

Chaque point de contrôle et porte de phase génère automatiquement `engagements/<eid>/resume-prompt.md` — une invite complète et autonome avec tout ce dont une nouvelle session a besoin :

- URL cible, identifiants d'authentification et domaines du périmètre
- Phase actuelle et quels tests spécifiques restent (précision en milieu de phase)
- Statut du cookie jar et instructions de ré-authentification
- Règles d'évitement/concentration et références de carte des points de terminaison

**Pour reprendre après une interruption :**
1. Ouvrez une nouvelle session Claude Code
2. Collez le contenu de `engagements/<eid>/resume-prompt.md`
3. Claude reprend exactement là où il s'est arrêté — aucun contexte manuel nécessaire

### Reprise à partir du point de contrôle (Alternative)```
Resume engagement pentest-2026-02-11-myapp

### Retour en arrière en cas d'échec

Si une phase produit de mauvais résultats, revenez au point de contrôle précédent :```
Roll back the engagement to the last checkpoint

---

## Prérequis

| Prérequis | Version | Notes |
|-----------|---------|-------|
| Docker | 20.10+ | Docker Desktop sur macOS/Windows |
| Claude Code | Dernière | `npm install -g @anthropic-ai/claude-code` |
| uv | 0.1+ | `curl -LsSf https://astral.sh/uv/install.sh \| sh` |
| Node.js | 18+ | Pour le serveur MCP Playwright |
| Python | 3.10+ | Géré par uv (pas d'installation manuelle nécessaire) |
| Burp Suite Pro | Dernière | **Optionnel** — pour la surveillance passive du trafic |

**Plateformes prises en charge :** macOS (Apple Silicon & Intel), Linux (x86_64 & ARM64)

---

## FAQ

**Q : Est-ce que cela remplace un testeur d'intrusion humain ?**

Non. AutoPentest automatise les parties systématiques et méthodiques d'un pentest. Il excelle dans la couverture (s'assurer que rien n'est oublié) et la cohérence (chaque test suit la même procédure). Cependant, la logique métier complexe, les chaînes d'exploitation créatives et l'évaluation des risques dépendant du contexte bénéficient encore de l'expertise humaine. Considérez-le comme un multiplicateur de force.

**Q : Combien de temps dure une évaluation complète ?**

Cela dépend de la taille et de la complexité de l'application. Une application web moyenne (50 à 100 endpoints) prend quelques heures. Les applications multi-domaines avec SSO prennent plus de temps. L'architecture en pipeline de la Phase 4 parallélise les tests les plus longs.

**Q : Puis-je l'exécuter sans Burp Suite ?**

Oui. Burp Suite est optionnel et utilisé uniquement pour la surveillance passive du trafic. Toutes les requêtes HTTP passent par `docker exec curl` et tous les outils de sécurité s'exécutent dans le conteneur Docker. Sans Burp, vous perdez la possibilité de consulter le trafic dans l'historique du proxy de Burp, mais toutes les fonctionnalités de test fonctionnent.

**Q : Quels sont les guides de techniques PortSwigger ?**

31 guides de référence d'attaque couvrant la détection, les techniques d'exploitation, les payloads, les antisèches et les motifs de contournement WAF — provenant de la PortSwigger Web Security Academy. Pendant les tests, les agents chargent automatiquement le guide pertinent (par exemple, le guide SQLi lors des tests d'injection SQL) pour une référence complète des techniques et des payloads. Consultez [`docs/adding-knowledge-base-resources.md`](https://github.com/bhavsec/autopentest-ai/blob/main/docs/adding-knowledge-base-resources.md) pour ajouter vos propres guides.

**Q : Comment ajouter des wordlists ou des payloads personnalisés ?**

Placez les wordlists dans `templates/wordlists/` ; elles seront disponibles à l'intérieur du conteneur Docker via le montage de volume. Les fichiers de test WSTG dans `knowledge-base/` peuvent également être personnalisés avec des payloads supplémentaires. Pour ajouter de nouveaux guides de techniques d'attaque, suivez les instructions dans [`docs/adding-knowledge-base-resources.md`](https://github.com/bhavsec/autopentest-ai/blob/main/docs/adding-knowledge-base-resources.md).

**Q : Puis-je tester des applications derrière un VPN ?**

Oui. Le conteneur Docker hérite du réseau de votre hôte (sur Linux avec `--network host`) ou rejoint l'hôte via `host.docker.internal` (sur macOS/Windows). Si votre VPN est actif sur l'hôte, le conteneur peut atteindre les cibles protégées par VPN.

**Q : Que se passe-t-il si un pentest est interrompu (plantage, limite d'utilisation, timeout) ?**

AutoPentest génère automatiquement un fichier `resume-prompt.md` à chaque point de contrôle avec tout le nécessaire pour continuer. Ouvrez une nouvelle session Claude Code, collez le contenu de `engagements/<eid>/resume-prompt.md`, et les tests reprennent exactement là où ils se sont arrêtés — y compris la progression en cours de phase, les identifiants, le périmètre et les tests restants.

**Q : Qu'en est-il de la limitation de débit (rate limiting) ?**

AutoPentest inclut une classification d'erreurs à trois niveaux (Transitoire/Limitation de débit/Permanente) avec backoff automatique. Si la cible limite le débit des requêtes, les outils ralentissent automatiquement. Vous pouvez également définir des règles d'évitement dans la configuration pour ignorer des endpoints spécifiques.

**Q : Quels sont les rôles des agents ?**

AutoPentest utilise 4 rôles spécialisés (Éclaireur, Analyste, Exploiteur, Rapporteur) au lieu de sous-agents génériques. Chaque rôle dispose d'un modèle de prompt dédié avec des conseils d'outils ciblés, des listes d'outils restreintes et des anti-patrons. Cela évite que les agents confondent reconnaissance, analyse, exploitation et rapport — améliorant la concentration et l'isolation des défaillances. Consultez [`templates/agent-roles/README.md`](https://github.com/bhavsec/autopentest-ai/blob/main/templates/agent-roles/README.md) pour l'index complet des rôles.

**Q : Comment fonctionne le contournement WAF ?**

Lorsqu'un payload est bloqué (403, page de blocage), AutoPentest identifie automatiquement le fournisseur WAF à partir des caractéristiques de la réponse, puis charge les payloads de contournement spécifiques au fournisseur, organisés par niveau de complexité. 12 fournisseurs WAF sont pris en charge (Cloudflare, AWS WAF, Akamai, Imperva, ModSecurity, F5, etc.). Les informations WAF sont partagées entre tous les agents via le système de livrables.

**Q : Qu'est-ce que l'analyse contrefactuelle ?**

Après le premier passage d'analyse qui trouve des vulnérabilités, AutoPentest peut lancer un second Analyste qui suppose que toutes les vulnérabilités connues sont corrigées. Cela force l'agent à chercher différents vecteurs d'attaque — différents endpoints, paramètres, contextes d'injection et failles logiques. Les résultats sont fusionnés dans la file d'exploitation existante avec déduplication automatique. Cette technique est basée sur la recherche académique (étude d'ablation PenHeal) montrant une amélioration de +71% de la couverture des vulnérabilités.

**Q : Comment fonctionne la vérification des résultats ?**

Lorsque les outils CLI (nmap, nuclei, sqlmap, etc.) produisent des sorties vides ou suspectes, l'outil `verify_tool_result()` détecte les problèmes courants (erreur de proxy, permission refusée, mauvais flags) et suggère des commandes corrigées. Cela empêche les agents de compter silencieusement des exécutions d'outils défaillantes comme « terminées » — une mode de défaillance courante dans le pentesting automatisé.

**Q : Comment fonctionne le chaînage des vulnérabilités ?**

Le graphe de connaissances suit les entités (endpoints, paramètres, findings, cookies, domaines) et les relations découvertes pendant les tests. Après la Phase 4, `find_chains()` utilise BFS pour découvrir des chemins d'attaque multi-sauts et vérifie 7 motifs de chaîne prédéfinis (par exemple, XSS + CSP manquant, SSRF + métadonnées cloud, IDOR + rôle admin). Les chaînes qui augmentent l'impact déclenchent une mise à niveau automatique de la sévérité.

---

## Avis de non-responsabilité

**Cet outil est destiné aux tests de sécurité autorisés uniquement.** N'utilisez AutoPentest que contre des applications pour lesquelles vous avez une autorisation explicite. L'accès non autorisé à des systèmes informatiques est illégal. Les auteurs ne sont pas responsables de toute utilisation abusive de cet outil.

Assurez-vous toujours d'avoir :
- Une autorisation écrite du propriétaire de l'application
- Un périmètre clairement défini de ce qui peut et ne peut pas être testé
- Une compréhension de l'environnement de test (production vs préproduction)
- Des règles d'évitement appropriées configurées pour les endpoints destructeurs ou sensibles

---

<p align="center">
  Construit avec <a href="https://modelcontextprotocol.io">Model Context Protocol</a>
</p>