OpenDoor — Plateforme de Recon Web et de Découverte de Répertoires OWASP

OpenDoor est une plateforme CLI de Recon open source conçue 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, les tests de contournement, le filtrage des réponses, le reporting, les vérifications de redirections ouvertes, le crawl limité et les workflows de scan basés sur le transport.

Elle 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 listages 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 dont vous êtes propriétaire ou pour lesquels vous disposez d'une autorisation explicite de test.

✅ État du projet

Chocolatey Version

🧪 Matrice d'intégration continue

🚀 Liens rapides

✨ Fonctionnalités

découverte de répertoires ;
découverte récursive de répertoires ;
crawl limité à la même origine ;
suivi des redirections ;
énumération de sous-domaines ;
scans multi-threads pour des recherches plus rapides ;
modes d'entrée : cible unique, fichier de cibles, stdin, CIDR IPv4 et plage IPv4 ;
wordlists personnalisées, préfixes, mélange pour briser les schémas de scan, filtres d'extension et prise en charge de wordlists distantes ;
en-têtes de requête personnalisés, transfert de cookies et modèles de requête HTTP bruts ;
filtres de réponse par statut, taille, texte, regex et longueur du corps ;
sniffers de réponse pour détecter les listages de répertoires, les réponses vides, les expositions de fichiers connus, les sondes actives de copies fantômes, les collations, les secrets potentiellement exposés, les endpoints exposés côté client, les erreurs, les traces de pile de débogage exposées et les vulnérabilités confirmées de redirection ouverte ;
auto-étalonnage intelligent pour les cas de soft-404, wildcard, catch-all, de différence sémantique de réponse et de DNS wildcard ;
détection d'empreintes technologiques pour CMS, plateformes e-commerce, frameworks, piles d'exécution, infrastructure et posture HSTS ;
vérifications passives des risques de confidentialité dans --fingerprint, y compris les surfaces HSTS, ETag/cache et supercookies possibles.
détection passive de WAF et contournement en mode de scan sécurisé ;
condition d'arrêt de la garde WAF pour terminer les scans de faible valeur lorsque les réponses initiales classifiées sont massivement bloquées par le WAF ;
sondes de contournement contrôlées par en-têtes et chemins pour les ressources bloquées 401 et 403 ;
exécution de scan tolérante aux pannes avec nouvelles tentatives, protection contre les échecs consécutifs, gestion des erreurs de transport, sessions reprises et contrôles d'interruption/reprise à l'exécution ;
règles CI/CD d'échec en fonction des buckets de résultats ;
comparaison différentielle de rapports pour les rapports JSON ou SQLite précédents/actuels ;
rapports au format terminal, texte, JSON, CSV, HTML, SARIF et SQLite ;
prise en charge du transport par proxy, OpenVPN, WireGuard, TLS hérité et certificat client mTLS ;

🧭 Où OpenDoor est-il pertinent ?

Il est conçu pour des cibles réelles où la vitesse seule ne suffit pas : WAF, CDN, pages soft-404, routes wildcard, ressources restreintes, zones authentifiées, réseaux instables, lots multi-cibles et scans contrôlés par le transport. Depuis son premier lancement en 2016 jusqu'à aujourd'hui, OpenDoor a considérablement évolué, passant d'un simple bruteforceur primitif à un nouveau framework de découverte adaptatif. Il est devenu compatible 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

🧬 Technologies reconnues

OpenDoor inclut un moteur d'empreintes heuristiques pour détecter les piles d'applications probables, les plateformes CMS, les frameworks, les constructeurs de sites, les outils de sites statiques, les fournisseurs d'infrastructure, la préparation HSTS / preload et les systèmes WAF / anti-bot.

Liste complète des technologies prises en charge : Technologies d'empreintes

Exécuter la détection d'empreintes :```bash opendoor --host https://example.com --fingerprint

Une fois la passe de fingerprinting terminée, OpenDoor affiche un résumé compact de pré-analyse avant que l'énumération par dictionnaire ne commence :```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready

En savoir plus :

📦 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 Chocolatey Community Package Repository:```powershell choco install opendoor -y

Les paquets Chocolatey peuvent accuser un retard par rapport à la dernière version GitHub/PyPI le temps que la modération communautaire soit terminée.

### 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 une analyse 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

Voir le [guide d'installation complet](https://opendoor.readthedocs.io/Installation-and-update/).

---

## 🚀 Utilisation rapide

### Analyse de répertoire de base```bash
opendoor --host https://example.com

Explorer les liens de même origine```bash

opendoor --host https://example.com --crawl

`--crawl` est facultatif et ne fonctionne qu'avec les scans de répertoires. Il utilise `GET`, extrait des attributs HTML conservateurs des réponses déjà scanné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.

### Scan de sous-domaines```bash
opendoor --host example.com --scan subdomains

Liste des cibles```bash

opendoor --hostlist targets.txt

Les fichiers cibles peuvent contenir un mélange d'URL, de domaines, d'adresses IPv4, de blocs CIDR IPv4 et de 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 cible mixte est pris en charge via STDIN.

### Scan à 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

Sniffers de réponses

Les sniffers de réponses classifient les corps de réponses intéressants pendant 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étecte les pages de listage de répertoires.                                                                                         |
| `file`              | Détecte les motifs connus d'exposition de fichiers sensibles.                                                                        |
| `collation`         | Détecte les réponses de secours répétées ou de type redirection qui peuvent créer des faux positifs.                                 |
| `skipempty`         | Ignore les réponses vides.                                                                                                           |
| `skipsizes=46`      | Ignore les réponses ayant des tailles bruyantes exactes connues.                                                                     |
| `skipsizes=46:1024` | Ignore les réponses comprises dans une plage de tailles bruyantes.                                                                   |
| `stacktrace`        | Détecte les traces de pile de débogage/exécution exposées et les détails d'erreurs internes.                                        |
| `secret`            | Détecte d'éventuelles clés API, jetons, clés privées et identifiants exposés, avec des métadonnées de rapport expurgées.            |
| `shadow`            | Sonde activement les occurrences confirmées de type fichier `200 OK` à la recherche de variantes limitées de sauvegarde/ombre telles que `.bak`, `.old` et modèles de chemin . |
| `openredirect`      | Vérifie activement les paramètres de requête de type redirection avec des URL de marqueur contrôlées et ne signale que les vulnérabilités de redirection ouverte confirmées. |
| `endpoint`          | Détecte 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étecte d'éventuels contenus malveillants, marqueurs de webshell, scripts injectés ou 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/)

### Scan authentifié à partir d'une requête brute```bash
opendoor \
  --raw-request request.txt \
  --scheme https \
  --method GET \
  --auto-calibrate \
  --reports json,html,sqlite,sarif

Scan à l'épreuve des WAF```bash

opendoor
--host https://example.com
--waf-safe-mode
--timeout 60
--retries 5
--delay 0.5

### Scan tolérant aux pannes

Utilisez un profil d'exécution plus conservateur pour les cibles instables, les réseaux lents, les blocages WAF temporaires, l'instabilité du proxy ou les scans autorisés 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 timeout par requête et la tolérance aux nouvelles tentatives, en limitant les abandons aux chemins épuisés répétés, en filtrant les réponses soft-404 et catch-all grâce à l'auto-étalonnage, en arrêtant les scans à faible valeur ajoutée lorsque les réponses bloquées par le WAF dominent, et en enregistrant l'état du point de contrôle pour une reprise ultérieure.

Reprendre le scan plus tard :```bash opendoor --session-load session.json

Lors d'un scan actif, appuyez une fois sur `Ctrl+C` pour mettre les workers en pause, puis choisissez `C` pour continuer ou `E` pour abandonner.

### Sondes de contournement d'en-têtes et de chemins

Utilisez ceci uniquement sur des systèmes que vous êtes autorisé à tester. Il s'agit d'une fonctionnalité opt-in qui sonde les ressources bloquées avec des en-têtes temporaires contrôlés et des variantes de chemins 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 de point, le suffixe point-virgule, la variation de casse et le segment encodé en URL. Personnalisez les statuts de déclenchement, les valeurs d'adresses 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 du 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 inclus :```bash opendoor --host https://example.com --proxy-pool

Utilisez une liste personnalisée de proxys rotatifs:```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 de `PATH`, spécifiez 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 graphique 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 de contournement d'en-têtes](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [Analyses par transport VPN](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [Exemples CI/CD](https://opendoor.readthedocs.io/examples/ci-cd/)

---

### Comparaison différentielle de rapports

OpenDoor peut comparer exactement deux rapports précédents/actuels sans lancer une nouvelle analyse. Utilisez cette fonctionnalité lorsque vous souhaitez voir ce qui est apparu, 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 explicite.```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 avec 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 via des workflows de reconnaissance web reproductibles et autorisés.

OpenDoor

📚 Documentation

La documentation complète est disponible sur ReadTheDocs :

🧪 Développement

Installer 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

Couverture d'exécution :```bash coverage run -m unittest discover -s tests -p "test_*.py" coverage report -m

Documentation de compilation:```bash
python3 -m venv .docs-venv
source .docs-venv/bin/activate
python -m pip install -r docs/requirements.txt
python -m mkdocs build --strict

Construire les artefacts du paquet:```bash python -m build

Voir le [guide de test](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 ;
- de clés privées WireGuard ;
- de certificats clients mTLS et de clés privées ;
- de fichiers auth-user-pass ;
- de cookies ;
- de jetons bearer ;
- de listes de cibles clients ;
- de rapports de scan privés ;
- d'artefacts CI sensibles.

Utilisez uniquement des exemples factices.

---

## ⚖️ Utilisation responsable

OpenDoor est un outil de test de sécurité.

Utilisez-le uniquement sur des systèmes que vous possédez ou pour lesquels vous avez une autorisation explicite de tester.

Des fonctionnalités telles que la détection WAF, le scan compatible WAF, le rejeu de requêtes brutes, les profils de transport et les sondes Header Injection Bypass sont destinées aux tests de sécurité autorisés, à la validation défensive et aux contrôles de régression d'exposition.

Le projet n'accorde pas la permission de scanner des systèmes tiers, des organisations, des services commerciaux ou des infrastructures publiques sans autorisation.

---

## 🧾 Journal des modifications

Voir [CHANGELOG.md](https://github.com/stanislav-web/opendoor/blob/HEAD/CHANGELOG.md) et [GitHub Releases](https://github.com/stanislav-web/OpenDoor/releases).

---

## 🤝 Contribution

Les pull requests sont les bienvenues.

Avant de contribuer, lisez le [guide de contribution](https://opendoor.readthedocs.io/Contribution/) et exécutez les tests pertinents.
OpenDoor s'améliore grâce aux contributions de code, aux mises à jour de documentation, aux tests, aux rapports de problèmes, aux retours de sécurité, aux idées de fonctionnalités et à la validation communautaire.
Merci à toutes les personnes qui ont contribué à améliorer le projet.

[![Contributors](https://contrib.rocks/image?repo=stanislav-web/OpenDoor)](https://github.com/stanislav-web/OpenDoor/graphs/contributors)

---

## 📄 Licence

OpenDoor est distribué sous la licence GNU General Public License v3.0 uniquement.

Voir [LICENSE](https://github.com/stanislav-web/opendoor/blob/HEAD/LICENSE).

---

## Soutien

Si OpenDoor vous aide dans votre travail de sécurité autorisé, vous pouvez soutenir la maintenance continue via Giveth.

[Soutenir OpenDoor sur Giveth](https://giveth.io/project/opendoor)

---
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/stanislav-web/OpenDoor) [![License: GPL v3](https://img.shields.io/badge/license-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

Scan basé sur les empreintes	OpenDoor peut identifier les CMS probables, les frameworks, les fournisseurs d'infrastructure et les signaux WAF avant une découverte plus approfondie. Cela permet de scanner avec contexte au lieu d'envoyer aveuglément une wordlist générique sur la cible.
Comportement conscient du WAF	OpenDoor peut détecter un comportement WAF / anti-bot probable et basculer vers un profil d'exécution plus sûr avec `--waf-safe-mode`, réduisant les scans bloqués et bruyants et facilitant la compréhension des réponses défensives.
Condition d'arrêt de la garde WAF	OpenDoor peut arrêter un scan prématurément lorsque les réponses initiales classifiées sont massivement bloquées par le WAF. Cela évite de passer de longues exécutions sur des wordlists qui ne produisent que des pages de blocage périphériques/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êtes et de manipulation de chemins. Il enregistre des preuves exactes telles que le type de contournement, la variante d'en-tête ou de chemin, la valeur de la sonde, le code de statut d'origine et le code de statut résultant, sans modifier les en-têtes de scan globaux.
Auto-étalonnage multi-signaux	OpenDoor ne se fie pas uniquement au code de statut ou à la taille de la réponse. Il compare plusieurs signaux de réponse tels que les hachages du 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 DNS wildcard pour réduire les faux positifs de soft-404 et de wildcard.
Crawl limité à la même origine	`--crawl` peut enrichir les scans de répertoires avec les 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 limites de mémoire bornées au lieu de devenir un spider ou un moteur de rendu navigateur.
Système de plugins sniffers heuristiques	OpenDoor inclut une couche d'analyse de réponses enfichable pour les sniffers heuristiques tels que les secrets, les traces de pile, les listages de répertoires, les indicateurs de malware, les copies fantômes, les fichiers suspects, les redirections ouvertes et les modèles d'erreurs logicielles répétées. Cela permet aux scans de faire remonter des preuves significatives depuis les corps de réponse au lieu de ne rapporter que des codes de statut et des tailles.
Workflows au niveau du transport	OpenDoor prend en charge les modes de transport direct, proxy, OpenVPN et WireGuard. Il peut également faire pivoter les profils de transport par cible dans les 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 des pools de proxys	OpenDoor peut utiliser des pools de proxys via `--proxy-list`, valider les proxys disponibles avant de scanner, et faire pivoter les requêtes sur le pool actif. Cela aide les longs scans autorisés à survivre aux routes peu fiables sans coder en dur un seul endpoint 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 les nouvelles tentatives de requêtes, la protection contre les échecs consécutifs, la gestion récupérable des erreurs de transport, la rotation des proxys, les conditions d'arrêt conscientes du WAF, les sessions avec points de contrôle et les contrôles interactifs d'interruption/reprise afin que les longs scans puissent échouer en toute sécurité sans perdre silencieusement de la couverture.
Scans longs repris	OpenDoor peut enregistrer des points de contrôle de scan et reprendre plus tard. Cela compte lorsque les scans sont interrompus par des crashs, des réseaux instables, des routes bloquées, des déconnexions de terminal ou de longs travaux multi-cibles.
Interruption/reprise à l'exécution	Appuyez une fois sur `Ctrl+C` pendant un scan pour interrompre 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`, en affichant les résultats ajoutés, supprimés et modifiés sans rescanner la cible. Cela transforme les rapports de scan en vérifications de régression d'exposition de version en version.
Résultats prêts pour CI/CD	OpenDoor peut renvoyer un code de sortie d'échec uniquement lorsque des buckets de résultats sélectionnés sont trouvés, ce qui le rend utilisable comme porte de publication ou vérification de régression d'exposition sans scripts de post-traitement personnalisés.
Ingénierie auditable	OpenDoor est maintenu avec une CI multiplateforme, des vérifications de couverture, des vérifications de paquets, des builds de documentation et une vaste suite de tests unitaires, ce qui facilite son audit, sa contribution et sa dépendance.

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 d'applications	Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring
Pile 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 de sites statiques / docs	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 locale au preload