stanislav-web/opendoorPlateforme OWASP de reconnaissance web et de découverte de répertoires
# OpenDoor — Plateforme de reconnaissance web et de découverte de répertoires OWASP
**OpenDoor** est une plateforme de reconnaissance CLI open-source pour la reconnaissance web autorisée, la découverte de répertoires, l'énumération de sous-domaines, les empreintes, la détection de WAF, le sondage de contournement, le filtrage des réponses, la génération de rapports, les vérifications de redirection ouverte, l'exploration limitée et les workflows de scan basés sur le transport.
Il aide les chercheurs en sécurité, les testeurs d'intrusion, les chasseurs de bug bounty, les ingénieurs DevSecOps et les développeurs à identifier les chemins exposés, les panneaux de connexion, les listes de répertoires, les ressources restreintes, les fichiers de sauvegarde, les web shells, les sous-domaines et autres actifs web potentiellement sensibles.
> N'utilisez OpenDoor que sur des systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation explicite de test.
---
## ✅ État du projet
[](https://pypi.org/project/opendoor/)
[](https://formulae.brew.sh/formula/opendoor)
[](https://www.python.org/)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/docker-image.yml)
[](https://codecov.io/github/stanislav-web/OpenDoor)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/github-code-scanning/codeql)
[](https://github.com/stanislav-web/OpenDoor/actions/workflows/codacy.yml)
[](https://opendoor.readthedocs.io/)
## 🧪 Matrice CI
| Plateforme | Python 3.12 | Python 3.13 | Python 3.14 | Python 3.15 |
|---|---|---|---|---|
| Linux | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-linux-py315.yml) |
| macOS | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-macos-py315.yml) |
| Windows | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py312.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py313.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py314.yml) | [](https://github.com/stanislav-web/OpenDoor/actions/workflows/ci-windows-py315.yml) |
---
## 🚀 Liens rapides
- [Documentation](https://opendoor.readthedocs.io/)
- [Démarrage rapide](https://opendoor.readthedocs.io/quickstart/)
- [Installation et mise à jour](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guide d'utilisation](https://opendoor.readthedocs.io/Usage/)
- [Exemples pratiques](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Journal des modifications](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md)
- [Paquet PyPI](https://pypi.org/project/opendoor/)
- [Formules Homebrew](https://formulae.brew.sh/formula/opendoor)
- [Image Docker](https://github.com/users/stanislav-web/packages/container/package/opendoor)
- [Paquet AUR](https://aur.archlinux.org/packages/opendoor)
- [Paquet BlackArch](https://blackarch.org/webapp.html)
- [Problèmes](https://github.com/stanislav-web/OpenDoor/issues)
- [Contributeurs](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## ✨ Fonctionnalités
- découverte de répertoires ;
- découverte récursive de répertoires ;
- exploration limitée de même origine ;
- suivi des redirections ;
- énumération de sous-domaines ;
- scans multi-thread pour des recherches plus rapides ;
- modes d'entrée : cible unique, fichier de cibles, stdin, CIDR IPv4 et plage IPv4 ;
- listes de mots personnalisées, préfixes, mélange pour casser les motifs de scan et les filtres d'extension, prise en charge des listes de mots distantes ;
- en-têtes de requête personnalisés, transfert de cookies et modèles de requêtes HTTP brutes ;
- filtres de réponse par statut, taille, texte, regex et longueur du corps ;
- analyseurs de réponse pour détecter les listes de répertoires, les réponses vides, les expositions de fichiers connus, les sondes actives de copies fantômes, la collation, les secrets potentiellement exposés, les points de terminaison exposés côté client, les erreurs, les traces de pile de débogage exposées et les vulnérabilités de redirection ouverte vérifiées ;
- auto-calibration intelligente pour les cas de soft-404, wildcard, catch-all, diff sémantique de réponse et wildcard DNS ;
- détection d'empreintes technologiques pour les CMS, plateformes e-commerce, frameworks, stacks d'exécution, infrastructure et posture HSTS ;
- vérifications passives des risques de confidentialité dans `--fingerprint`, incluant les surfaces possibles HSTS, ETag/cache et supercookie.
- détection passive de WAF et contournement en mode de scan sécurisé ;
- condition d'arrêt WAF guard pour terminer les scans à faible valeur lorsque les réponses classifiées initiales sont massivement bloquées par un WAF ;
- sondes contrôlées de contournement par en-tête et chemin pour les ressources bloquées `401` et `403` ;
- exécution de scan tolérante aux pannes avec réessais, protection contre les séries d'échecs, gestion des échecs de transport, sessions reprenables et contrôles de pause/reprise à l'exécution ;
- règles de bucket de résultats d'échec CI/CD ;
- comparaison différentielle de rapports pour les rapports JSON ou SQLite précédents/actuels ;
- rapports aux formats terminal, texte, JSON, CSV, HTML, SARIF et SQLite ;
- prise en charge du transport par proxy, OpenVPN, WireGuard, TLS hérité et certificat client mTLS ;
- rotation séquentielle du transport par cible pour les workflows par lots ;
- assistant de configuration pour des profils de scan reproductibles ;
- listes de mots intégrées (maj 2026-08)
---
## 🧭 Où OpenDoor a-t-il du sens ?
Il est conçu pour des cibles réelles où la vitesse seule ne suffit pas : WAFs, CDNs, pages soft-404, routes wildcard, ressources restreintes, zones authentifiées, réseaux instables, lots multi-cibles et scans contrôlés par transport.
Depuis son premier lancement en 2016 jusqu'à aujourd'hui, OpenDoor a considérablement évolué, passant d'un brute forcer primitif à un nouveau framework de découverte adaptatif. Il est devenu convivial pour DevOps et QA.
OpenDoor se concentre sur la **découverte contextuelle** plutôt que sur l'énumération aveugle.
### Ce qui rend OpenDoor différent
| Capacité | Pourquoi c'est important |
|---|---|
| **Scan axé sur les empreintes** | OpenDoor peut identifier les plateformes CMS probables, les frameworks, les fournisseurs d'infrastructure et les signaux WAF avant une découverte plus approfondie. Cela vous aide à scanner avec contexte au lieu de lancer aveuglément une liste de mots générique contre la cible. |
| **Comportement conscient du WAF** | OpenDoor peut détecter un comportement probable de WAF / anti-bot et basculer vers un profil d'exécution plus sûr avec `--waf-safe-mode`, réduisant les scans bloqués bruyants et rendant les réponses défensives plus faciles à comprendre. |
| **Condition d'arrêt WAF guard** | OpenDoor peut arrêter un scan prématurément lorsque les réponses classifiées initiales sont massivement bloquées par un WAF. Cela évite de passer de longues exécutions sur des listes de mots qui ne produisent que des pages de blocage edge/WAF répétées. |
| **Preuves de contournement contrôlées** | OpenDoor peut éventuellement sonder les ressources bloquées `401` et `403` avec des variantes contrôlées d'injection d'en-tête et de manipulation de chemin. Il enregistre les preuves exactes telles que le type de contournement, la variante d'en-tête ou de chemin, la valeur de sonde, le code de statut d'origine et le code de statut résultant sans modifier les en-têtes de scan globaux. |
| **Auto-calibration multi-signaux** | OpenDoor ne se repose pas uniquement sur le code de statut ou la taille de la réponse. Il compare plusieurs signaux de réponse tels que les hachages de corps, le texte visible, les phrases sémantiques de soft-404, la structure des jetons DOM, les titres, les redirections, les en-têtes stables, le nombre de mots, le nombre de lignes, la densité de texte, les jetons dynamiques normalisés et les lignes de base wildcard DNS pour réduire les faux positifs de soft-404 et wildcard. |
| **Exploration limitée de même origine** | `--crawl` peut enrichir les scans de répertoires avec des liens de même origine à un saut trouvés dans les réponses HTML déjà scannées. Il utilise le pipeline de scan existant, la déduplication globale des requêtes, la déduplication des rapports par bucket et des plafonds de mémoire bornés au lieu de devenir un spider ou un moteur de rendu de navigateur. |
| **Système de plugins d'analyse heuristique** | OpenDoor inclut une couche d'analyse de réponse enfichable pour des analyseurs heuristiques tels que les secrets, les traces de pile, les listes de répertoires, les indicateurs de malware, les copies fantômes, les fichiers suspects, les redirections ouvertes et les modèles d'erreurs douces répétées. Cela permet aux scans de faire remonter des preuves significatives à partir des corps de réponse au lieu de ne rapporter que les codes de statut et les tailles. |
| **Workflows au niveau du transport** | OpenDoor prend en charge les modes de transport direct, proxy, OpenVPN et WireGuard. Il peut également faire tourner les profils de transport par cible dans des scans par lots autorisés, ce qui n'est pas la même chose que de démarrer manuellement un VPN avant d'exécuter un scanner. |
| **Prise en charge du pool de proxys** | OpenDoor peut utiliser des pools de proxys via `--proxy-list`, valider les proxys disponibles avant le scan, faire tourner les requêtes sur le pool actif. Cela aide les longs scans autorisés à survivre à des routes peu fiables sans coder en dur un seul point de terminaison proxy. |
| **Exécution de scan tolérante aux pannes** | OpenDoor est conçu pour maintenir l'utilité des scans sur des cibles instables et des réseaux peu fiables. Il combine des réessais de requêtes, une protection contre les échecs consécutifs, une gestion récupérable des erreurs de transport, une rotation de proxy, des conditions d'arrêt conscientes du WAF, des sessions de point de contrôle et des contrôles interactifs de pause/reprise afin que les longs scans puissent échouer en toute sécurité au lieu de perdre silencieusement la couverture. |
| **Longs scans reprenables** | OpenDoor peut enregistrer des points de contrôle de scan et reprendre plus tard. Cela compte lorsque les scans sont interrompus par des plantages, des réseaux instables, des routes bloquées, des déconnexions de terminal ou de longs travaux multi-cibles. |
| **Pause/reprise à l'exécution** | Appuyez une fois sur `Ctrl+C` pendant un scan pour mettre en pause les workers, puis choisissez `C` pour continuer ou `E` pour abandonner sans impliquer de fichiers de session. |
| **Comparaison différentielle de rapports** | OpenDoor peut comparer un rapport SQLite/JSON précédent et actuel avec `--diff old:new`, montrant les découvertes ajoutées, supprimées et modifiées sans rescanner la cible. Cela transforme les rapports de scan en contrôles de régression d'exposition de version à version. |
| **Résultats prêts pour CI/CD** | OpenDoor peut renvoyer un code de sortie en échec uniquement lorsque les buckets de résultats sélectionnés sont trouvés, ce qui le rend utilisable comme barrière de version ou contrôle de régression d'exposition sans scripts de post-traitement personnalisés. |
| **Ingénierie auditable** | OpenDoor est maintenu avec une CI multiplateforme, des contrôles de couverture, des contrôles de paquets, des builds de documentation et une large suite de tests unitaires, ce qui le rend plus facile à auditer, à enrichir et sur lequel s'appuyer. |
## 🧬 Technologies reconnues
OpenDoor inclut un moteur d'empreintes heuristique pour détecter les stacks applicatives probables, les plateformes CMS, les frameworks, les constructeurs de sites, l'outillage de sites statiques, les fournisseurs d'infrastructure, la préparation HSTS / preload et les systèmes WAF / anti-bot.
| Catégorie | Exemples |
|----------------------------|---|
| CMS | WordPress, Drupal, Joomla, TYPO3, GravCMS, Open Journal Systems, InstantCMS, DiafanCMS, CMS.S3 / Megagroup, Discuz!, NetCat |
| E-commerce | Magento, WooCommerce, Shopify, PrestaShop, OpenCart, Shopware, Webasyst / Shop-Script |
| Frameworks / plateformes applicatives | Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring |
| Stack d'exécution / langage | PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, cibles de sites statiques |
| Constructeurs de sites | Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder |
| Générateurs statiques / de documentation | MkDocs, Docusaurus, Hugo, Jekyll, VitePress |
| Infrastructure / hébergement | Cloudflare, AWS, Vercel, Netlify, GitHub Pages, GitLab Pages, Heroku, Azure, Google Cloud, Fastly, Akamai, Hostinger, DDoS-Guard, Tencent Cloud |
| Infrastructure / serveurs | Nginx, Apache HTTP Server, Microsoft IIS, Caddy, LiteSpeed, lighttpd, Tornado, Gunicorn, Uvicorn, Hypercorn, Waitress, Apache Tomcat, Eclipse Jetty, Envoy, Traefik |
| WAF / anti-bot | Cloudflare, AWS WAF, Azure Front Door, Akamai, Imperva, Sucuri, ModSecurity, DataDome, Kasada, BunkerWeb, F5 BIG-IP ASM |
| En-têtes de sécurité | Présence HSTS, max-age, includeSubDomains, directive preload, préparation preload locale |
Liste complète des technologies prises en charge :
[Technologies d'empreinte](https://opendoor.readthedocs.io/detection/fingerprinting)
Exécuter la détection d'empreinte :
```bash
opendoor --host https://example.com --fingerprint
```
Une fois la passe d'empreinte terminée, OpenDoor affiche un résumé compact de pré-analyse avant que l'énumération du dictionnaire ne commence :
```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready
```
Pour en savoir plus :
- [Guide d'empreinte numérique](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Guide de détection de WAF](https://opendoor.readthedocs.io/detection/waf-detection/)
## 📦 Installation
### pipx
Recommandé pour la plupart des utilisateurs de CLI :
```bash
pipx install opendoor
```
### pip
```bash
python3 -m pip install --upgrade opendoor
```
### Windows / Chocolatey
OpenDoor est disponible depuis le dépôt de paquets communautaires Chocolatey :
```powershell
choco install opendoor -y
```
Les paquets Chocolatey peuvent être en retard par rapport à la dernière version GitHub/PyPI pendant que la modération communautaire se termine.
### Arch Linux / AUR
OpenDoor est disponible dans l'Arch User Repository :
```bash
yay -S opendoor
```
### Homebrew
OpenDoor est également disponible dans le gestionnaire de paquets Brew :
```bash
brew install opendoor
```
### Docker
OpenDoor est disponible en tant qu'image Docker officielle du projet via GitHub Container Registry.
```bash
docker pull ghcr.io/stanislav-web/opendoor:latest
docker run --rm -it ghcr.io/stanislav-web/opendoor:latest --version
```
Exécutez un scan et écrivez les rapports sur l'hôte :
```bash
mkdir -p reports
docker run --rm \
-v "$PWD/reports:/work/reports" \
ghcr.io/stanislav-web/opendoor:latest \
--host https://example.com \
--reports json,html \
--reports-dir reports
```
### BlackArch Linux
OpenDoor est disponible dans BlackArch Linux :
```bash
sudo pacman -Syu
sudo pacman -S opendoor
```
### Depuis la source
```bash
git clone https://github.com/stanislav-web/OpenDoor.git
cd OpenDoor
python3 -m pip install -r requirements.txt
python3 opendoor.py --help
```
Consultez le [guide d'installation complet](https://opendoor.readthedocs.io/Installation-and-update/).
---
## 🚀 Utilisation rapide
### Analyse de base d'un répertoire
```bash
opendoor --host https://example.com
```
### Explorer les liens de même origine
```bash
opendoor --host https://example.com --crawl
```
`--crawl` est optionnel et ne fonctionne qu'avec les analyses de répertoires. Il utilise `GET`, extrait des attributs HTML conservateurs à partir des réponses déjà analysées, ne conserve que les URL de même origine, respecte les extensions ignorées, ignore les formulaires POST et les origines externes, et signale les URL découvertes via les buckets de résultats normaux.
### Analyse de sous-domaines
```bash
opendoor --host example.com --scan subdomains
```
### Liste des cibles
```bash
opendoor --hostlist targets.txt
```
Les fichiers cibles peuvent mélanger des URL, des domaines, des adresses IPv4, des blocs CIDR IPv4 et des plages IPv4 inclusives :
```text
https://example.com
app.example.com
192.168.1.10
192.168.1.0/24
192.168.1.10-192.168.1.50
```
### Entrée standard
```bash
cat targets.txt | opendoor --stdin
```
Le même format de cible mixte est pris en charge via STDIN.
### Analyse à faible bruit
```bash
opendoor \
--host https://example.com \
--method GET \
--auto-calibrate \
--include-status 200-299,301,302,403 \
--exclude-status 404,429,500-599 \
--exclude-size-range 0-256 \
--sniff endpoint,secret,shadow,openredirect,malware,skipempty,collation,indexof,file,stacktrace \
--reports std,json,csv,sarif
```
### Analyseurs de réponses
Les analyseurs de réponses classifient les corps de réponse intéressants lors de la découverte. Ils sont utiles lorsque le code de statut et la taille ne suffisent pas à comprendre ce qui a été trouvé.
```bash
opendoor \
--host https://example.com \
--method GET \
--sniff endpoint,secret,shadow,openredirect,malware,stacktrace,indexof,file,collation \
--reports std,json,csv,html,sqlite,sarif
```
Les sniffers utiles incluent :
| Sniffer | Objectif |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof` | Détecter les pages de listage de répertoires. |
| `file` | Détecter les motifs connus d'exposition de fichiers sensibles. |
| `collation` | Détecte les réponses de repli répétées ou de type redirection pouvant générer des faux positifs. |
| `skipempty` | Ignorer les réponses vides. |
| `skipsizes=46` | Ignorer les réponses dont la taille exacte est connue comme bruyante. |
| `skipsizes=46:1024` | Ignorer les réponses dont la taille se situe dans une plage bruyante. |
| `stacktrace` | Détecter les traces de pile de débogage/exécution exposées et les détails d'erreurs internes. |
| `secret` | Détecter les éventuelles clés d'API, jetons, clés privées et identifiants exposés avec des métadonnées de rapport expurgées. |
| `shadow` | Sonder activement les correspondances confirmées `200 OK` de type fichier pour des variantes bornées de sauvegarde/shadow telles que `.bak`, `.old`, et des modèles de chemin . |
| `openredirect` | Vérifier activement les paramètres de requête de type redirection avec des URL marqueurs contrôlées et ne signaler que les vulnérabilités de redirection ouverte confirmées. |
| `endpoint` | Détecter passivement les points de terminaison WebSocket, Socket.IO, SSE/EventSource et AJAX exposés côté client à partir des réponses déjà récupérées. |
| `malware` | Détecter les contenus potentiellement malveillants, les marqueurs de webshell, les scripts injectés ou les charges utiles obfusquées. |
Les sniffers dépendants du corps forcent automatiquement `GET` en interne lorsque la méthode configurée est `HEAD`.
En savoir plus : [Référence des sniffers](https://opendoor.readthedocs.io/Sniffers/)
### Analyse authentifiée à partir d'une requête brute
```bash
opendoor \
--raw-request request.txt \
--scheme https \
--method GET \
--auto-calibrate \
--reports json,html,sqlite,sarif
```
### Analyse sécurisée pour WAF
```bash
opendoor \
--host https://example.com \
--waf-safe-mode \
--timeout 60 \
--retries 5 \
--delay 0.5
```
### Analyse tolérante aux pannes
Utilisez un profil d'exécution plus conservateur pour les cibles instables, les réseaux lents, les blocages temporaires de WAF, l'instabilité des proxys ou les analyses autorisées de longue durée.
```bash
opendoor \
--host https://example.com \
--method GET \
--timeout 60 \
--retries 5 \
--retries-fail-streak 25 \
--auto-calibrate \
--waf-detect \
--waf-guard \
--session-save session.json \
--reports std,json,html
```
Ce profil rend les scans plus résilients en augmentant le délai d'attente par requête et la tolérance aux nouvelles tentatives, en limitant les abandons aux chemins épuisés de façon répétée, en filtrant les réponses soft-404 et catch-all avec auto-calibration, en arrêtant les scans à faible valeur lorsque les réponses bloquées par WAF dominent, et en sauvegardant l'état de point de contrôle pour une reprise ultérieure.
Reprendre le scan plus tard :
```bash
opendoor --session-load session.json
```
Pendant un scan actif, appuyez une fois sur `Ctrl+C` pour mettre en pause les workers, puis choisissez `C` pour continuer ou `E` pour abandonner.
### Sondes de contournement d'en-tête et de chemin
Utilisez cette fonctionnalité uniquement sur des systèmes que vous êtes autorisé à tester. Elle est optionnelle et sonde les ressources bloquées avec des en-têtes temporaires contrôlés et des variantes de chemin sûres.
```bash
opendoor \
--host https://example.com \
--method GET \
--waf-detect \
--header-bypass \
--header-bypass-limit 32 \
--reports std,json,csv,sarif,sqlite
```
Lorsque --header-bypass est activé, OpenDoor essaie d'abord les variantes d'injection d'en-tête configurées, puis les variantes sûres de manipulation de chemin telles que la barre oblique finale, le segment point, le suffixe point-virgule, la variation de casse et le segment encodé en URL.
Personnalisez les statuts de déclenchement, les valeurs d'IP de confiance et les en-têtes :
```bash
opendoor \
--host https://example.com \
--method GET \
--header-bypass \
--header-bypass-status 401,403 \
--header-bypass-ips 127.0.0.1,10.0.0.1 \
--header-bypass-headers X-Original-URL,X-Rewrite-URL,X-Forwarded-For,X-Real-IP \
--reports json,html,sqlite,sarif,csv
```
### Routage par proxy
Utilisez un seul proxy explicite :
```bash
opendoor --host https://example.com --proxy socks5://127.0.0.1:9050
```
Utilisez le pool de proxys rotatifs intégré :
```bash
opendoor --host https://example.com --proxy-pool
```
Utilisez une liste de proxys rotatifs personnalisée :
```bash
opendoor --host https://example.com --proxy-list proxies.txt
```
### Transport OpenVPN
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn
```
Si OpenVPN est installé en dehors du `PATH`, passez explicitement le backend :
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn \
--transport-bin /opt/homebrew/sbin/openvpn
```
Sur Windows, `--transport-bin` peut pointer vers `C:\Program Files\OpenVPN\bin\openvpn.exe`. Si un client GUI ou un agent VPN d'entreprise possède déjà le tunnel, démarrez ce VPN en dehors d'OpenDoor et exécutez OpenDoor en mode direct.
### Transport WireGuard
```bash
opendoor \
--host https://example.com \
--transport wireguard \
--transport-profile ./profile.conf
```
Autres exemples :
- [Analyses de base](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Analyses par lots](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Analyses authentifiées](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [Analyses compatibles WAF](https://opendoor.readthedocs.io/examples/waf-safe-scans/)
- [Analyses avec contournement d'en-têtes](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [Analyses via transport VPN](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [Exemples CI/CD](https://opendoor.readthedocs.io/examples/ci-cd/)
---
### Comparaison de rapports différentiels
OpenDoor peut comparer exactement deux rapports précédent/actuel sans lancer une nouvelle analyse. Utilisez cette fonctionnalité lorsque vous souhaitez voir ce qui est apparu, a disparu ou a changé entre deux résultats d'analyse autorisés.
Les paires d'entrée prises en charge sont uniquement SQLite-vers-SQLite et JSON-vers-JSON. Les formats mixtes, les fichiers manquants, les rapports invalides et les types de rapports non pris en charge échouent avec une erreur de validation gérée proprement.
```bash
opendoor --diff reports/baseline/example.com.sqlite:reports/current/example.com.sqlite --reports std,json
opendoor --diff reports/baseline/example.com.json:reports/current/example.com.json --reports std,json --reports-dir ./diff
```
### Rapports SARIF pour CI/CD
OpenDoor peut exporter les résultats au format SARIF 2.1.0 pour GitHub Code Scanning et les pipelines de sécurité compatibles SARIF.
```bash
opendoor \
--host https://example.com \
--reports sarif,json \
--reports-dir ./reports
```
Exemple de téléversement GitHub Actions :
```yaml
- name: Upload OpenDoor SARIF
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: reports/example.com/example.com.sarif
category: opendoor
```
## 🎓 Maîtriser OpenDoor
Série d'articles pratiques pour apprendre OpenDoor à travers des workflows de reconnaissance web reproductibles et autorisés.
- [Partie 1 — Reconnaissance web contextuelle au-delà du brute force de répertoires](https://medium.com/@stanisov/mastering-opendoor-context-aware-web-recon-beyond-directory-brute-force-part-1-cc13eda8cd3d)
- [Partie 2 — Reconnaissance à faible bruit avec redirections, détection de points de terminaison et exploration bornée](https://medium.com/@stanisov/mastering-opendoor-low-noise-recon-with-redirects-endpoint-sniffing-and-bounded-crawl-part-2-411b92675d6d)
- [Page compagnon de la série](https://opendoor.readthedocs.io/guides/mastering-opendoor/)
## 📚 Documentation
La documentation complète est disponible sur ReadTheDocs :
- [Accueil](https://opendoor.readthedocs.io/)
- [Démarrage rapide](https://opendoor.readthedocs.io/quickstart/)
- [Installation et mise à jour](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guide d'utilisation](https://opendoor.readthedocs.io/Usage/)
- [Saisie de la cible](https://opendoor.readthedocs.io/concepts/target-input/)
- [Rapports](https://opendoor.readthedocs.io/concepts/reports/)
- [Empreinte](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Détection WAF et mode sécurisé](https://opendoor.readthedocs.io/detection/waf-detection/)
- [Garde WAF](https://opendoor.readthedocs.io/detection/waf-guard/)
- [Contournement par injection d'en-tête](https://opendoor.readthedocs.io/detection/header-bypass/)
- [Auto-calibration](https://opendoor.readthedocs.io/detection/auto-calibration/)
- [Transports réseau](https://opendoor.readthedocs.io/transports/overview/)
- [Compatibilité TLS et mTLS](https://opendoor.readthedocs.io/transports/tls/)
- [Transport OpenVPN](https://opendoor.readthedocs.io/transports/openvpn/)
- [Transport WireGuard](https://opendoor.readthedocs.io/transports/wireguard/)
- [Exemples pratiques](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Tests](https://opendoor.readthedocs.io/Testing/)
- [Contribution](https://opendoor.readthedocs.io/Contribution/)
---
## 🧪 Développement
Installez les dépendances de développement :
```bash
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip setuptools wheel
python -m pip install -r requirements-dev.txt
python -m pip install -e .
```
Exécuter les tests :
```bash
python -m unittest
```
Exécuter la couverture :
```bash
coverage run -m unittest discover -s tests -p "test_*.py"
coverage report -m
```
Générer la documentation :
```bash
python3 -m venv .docs-venv
source .docs-venv/bin/activate
python -m pip install -r docs/requirements.txt
python -m mkdocs build --strict
```
Compiler les artefacts du paquet :
```bash
python -m build
```
Consultez le [guide de test complet](https://opendoor.readthedocs.io/Testing/) et le [guide de contribution](https://opendoor.readthedocs.io/Contribution/).
---
## 🔐 Sécurité et hygiène des secrets
Ne committez pas de vrais secrets ni de profils de transport privés.
Ne publiez jamais :
- de vrais profils OpenVPN ;
- des clés privées WireGuard ;
- des certificats clients mTLS et clés privées ;
- des fichiers auth-user-pass ;
---
[Read more](https://github.com/stanislav-web/opendoor)