OpenDoor — Piattaforma di Web Recon & Directory Discovery di OWASP

OpenDoor è una piattaforma CLI di Recon open-source per la ricognizione web autorizzata, la scoperta di directory, l'enumerazione di sottodomini, le fingerprint, il rilevamento WAF, i test di bypass, il filtraggio delle risposte, il reporting, i controlli di open redirect, il crawl limitato e i flussi di scansione basati sul trasporto.

Aiuta ricercatori di sicurezza, penetration tester, cacciatori di bug bounty, ingegneri DevSecOps e sviluppatori a identificare percorsi esposti, pannelli di login, elenchi di directory, risorse limitate, file di backup, web shell, sottodomini e altre risorse web potenzialmente sensibili.

Utilizza OpenDoor solo su sistemi di tua proprietà o per i quali hai ricevuto esplicita autorizzazione a testare.

✅ Stato del progetto

Chocolatey Version

🧪 Matrice CI

🚀 Collegamenti rapidi

✨ Funzionalità

scoperta di directory;
scoperta ricorsiva di directory;
crawl limitato alla stessa origine;
gestione dei reindirizzamenti;
enumerazione di sottodomini;
scansioni multi-thread per ricerche più rapide;
modalità di input per bersaglio singolo, file di bersagli, stdin, IPv4 CIDR e intervalli IPv4;
wordlist personalizzate, prefissi, mescolamento per rompere i modelli di scansione e filtri per estensione, supporto per wordlist remote;
header di richiesta personalizzati, inoltro dei cookie e modelli di richiesta HTTP grezzi;
filtri delle risposte per stato, dimensione, testo, regex e lunghezza del corpo;
sniffer delle risposte per rilevare elenchi di directory, risposte vuote, esposizioni note di file, probe attivi di shadow copy, collation, possibili segreti esposti, endpoint esposti al client, errori, trace di stack di debug esposti e vulnerabilità verificate di open redirect;
auto-calibrazione intelligente per casi di soft-404, wildcard, catch-all, differenze semantiche di risposta e DNS wildcard;
rilevamento di fingerprint tecnologiche per CMS, piattaforme e-commerce, framework, stack runtime, infrastrutture e postura HSTS;
controlli passivi sui rischi per la privacy in --fingerprint, incluse possibili superfici HSTS, ETag/cache e supercookie.
rilevamento passivo di WAF e bypass in modalità di scansione sicura;
condizione di arresto WAF guard per terminare scansioni di scarso valore quando le risposte classificate iniziali sono in gran parte bloccate dal WAF;
probe controllati di bypass tramite header e percorsi per risorse bloccate 401 e 403;
runtime di scansione tollerante ai guasti con retry, protezione dalle serie di errori, gestione dei guasti di trasporto, sessioni ripristinabili e controlli di pausa/ripresa del runtime;
regole CI/CD di fail-on per bucket di risultati;
confronto differenziale dei report per report JSON o SQLite precedenti/correnti;
report nei formati terminale, testo, JSON, CSV, HTML, SARIF e SQLite;
supporto al trasporto per proxy, OpenVPN, WireGuard, TLS legacy e certificato client mTLS;
rotazione sequenziale del trasporto per bersaglio nei flussi batch;

🧭 Dove ha senso usare OpenDoor?

È progettato per bersagli reali dove la sola velocità non basta: WAF, CDN, pagine soft-404, route wildcard, risorse limitate, aree autenticate, reti instabili, batch multi-bersaglio e scansioni controllate dal trasporto. Dal suo primo lancio nel 2016 fino ad oggi, OpenDoor è cambiato drasticamente, crescendo da un semplice brute forcer a un nuovo framework di discovery adattivo. È diventato amichevole per DevOps e QA. OpenDoor si concentra sulla discovery contestuale invece dell'enumerazione cieca.

Cosa rende diverso OpenDoor

🧬 Tecnologie riconosciute

OpenDoor include un motore di fingerprint euristico per rilevare probabili stack di applicazioni, piattaforme CMS, framework, site builder, tooling per siti statici, provider di infrastruttura, prontezza HSTS / preload e sistemi WAF / anti-bot.

Elenco completo delle tecnologie supportate: Tecnologie di fingerprinting

Esegui il rilevamento delle fingerprint:```bash opendoor --host https://example.com --fingerprint

Dopo che la fase di fingerprinting termina, OpenDoor stampa un riepilogo pre-scan compatto prima che inizi l'enumerazione del dizionario:```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready

Leggi di più:

📦 Installazione

pipx

Consigliato per la maggior parte degli utenti CLI:```bash pipx install opendoor

### pip```bash
python3 -m pip install --upgrade opendoor

Windows / Chocolatey

OpenDoor è disponibile tramite il Chocolatey Community Package Repository:```powershell choco install opendoor -y

I pacchetti Chocolatey possono restare indietro rispetto all'ultima release GitHub/PyPI mentre la moderazione della community è in corso.

### Arch Linux / AUR

OpenDoor è disponibile nell'Arch User Repository:```bash
yay -S opendoor

Homebrew

OpenDoor è disponibile anche nel gestore di pacchetti Brew:```bash brew install opendoor

### Docker

OpenDoor è disponibile come immagine Docker ufficiale del progetto tramite GitHub Container Registry.```bash
docker pull ghcr.io/stanislav-web/opendoor:latest
docker run --rm -it ghcr.io/stanislav-web/opendoor:latest --version

Esegui una scansione e scrivi i report sull'host:```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 è disponibile in BlackArch Linux:```bash
sudo pacman -Syu
sudo pacman -S opendoor

I don't see any source content to translate in this chunk. The input after "### From source" appears to be empty.

Please provide the chunk content, and I'll translate it from English to Italian.```bash git clone https://github.com/stanislav-web/OpenDoor.git cd OpenDoor

python3 -m pip install -r requirements.txt python3 opendoor.py --help

Vedi la [guida completa all'installazione](https://opendoor.readthedocs.io/Installation-and-update/).

---

## 🚀 Uso rapido

### Scansione di directory di base```bash
opendoor --host https://example.com

Scansiona i link same-origin```bash

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

`--crawl` è opt-in e funziona solo con le scansioni di directory. Utilizza `GET`, estrae attributi HTML conservativi dalle risposte già scansionate, mantiene solo gli URL same-origin, rispetta le estensioni ignorate, salta i moduli POST e le origini esterne, e segnala gli URL scoperti tramite i normali bucket di risultati.

### Scansione dei sottodomini```bash
opendoor --host example.com --scan subdomains

Lista dei target```bash

opendoor --hostlist targets.txt

I file target possono mescolare URL, domini, indirizzi IPv4, blocchi CIDR IPv4 e intervalli IPv4 inclusivi:```text
https://example.com
app.example.com
192.168.1.10
192.168.1.0/24
192.168.1.10-192.168.1.50

Input standard```bash

cat targets.txt | opendoor --stdin

Lo stesso formato di destinazione misto è supportato tramite STDIN.

### Scansione a basso rumore```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

Sniffer di risposta

Gli sniffer di risposta classificano i corpi di risposta interessanti durante la fase di discovery. Sono utili quando il codice di stato e la dimensione non sono sufficienti per capire cosa è stato trovato.```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

Utili sniffer includono:

| Sniffer             | Scopo                                                                                                                                |
|---------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| `indexof`           | Rileva pagine di elenco directory.                                                                                                   |
| `file`              | Rileva pattern noti di esposizione di file sensibili.                                                                                |
| `collation`         | Rileva risposte ripetute o simili a reindirizzamenti di fallback che possono creare falsi positivi.                                  |
| `skipempty`         | Salta risposte vuote.                                                                                                                |
| `skipsizes=46`      | Salta risposte con dimensioni note esatte e rumorose.                                                                                |
| `skipsizes=46:1024` | Salta risposte all'interno di un intervallo di dimensioni rumoroso.                                                                  |
| `stacktrace`        | Rileva trace di stack di debug/runtime esposte e dettagli di errori interni.                                                         |
| `secret`            | Rileva possibili chiavi API, token, chiavi private e credenziali esposti con metadati di report oscurati.                            |
| `shadow`            | Sonda attivamente i riscontri `200 OK` confermati di tipo file per varianti limitate di backup/shadow come `.bak`, `.old` e template di percorso. |
| `openredirect`      | Verifica attivamente i parametri di query simili a redirect con URL marker controllati e riporta solo vulnerabilità di open redirect confermate. |
| `endpoint`          | Rileva passivamente endpoint WebSocket, Socket.IO, SSE/EventSource e AJAX esposti al client dalle risposte già recuperate.           |
| `malware`           | Rileva possibili contenuti dannosi, marker di webshell, script iniettati o payload offuscati.                                        |

Gli sniffer dipendenti dal corpo impongono automaticamente `GET` internamente quando il metodo configurato è `HEAD`.

Leggi di più: [Riferimento Sniffers](https://opendoor.readthedocs.io/Sniffers/)

### Scansione autenticata dalla richiesta raw```bash
opendoor \
  --raw-request request.txt \
  --scheme https \
  --method GET \
  --auto-calibrate \
  --reports json,html,sqlite,sarif

Scansione WAF-safe```bash

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

### Scansione tollerante ai guasti

Usa un profilo di runtime più prudente per target instabili, reti lente, blocchi WAF temporanei, instabilità del proxy o scansioni autorizzate di lunga durata.```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

Questo profilo rende le scansioni più resilienti aumentando il timeout per richiesta e la tolleranza ai tentativi, limitando le interruzioni ai percorsi esauriti ripetutamente, filtrando le risposte soft-404 e catch-all con auto-calibrazione, interrompendo le scansioni a basso valore quando le risposte bloccate da WAF predominano e salvando lo stato del checkpoint per una ripresa successiva.

Riprendi la scansione in seguito:```bash opendoor --session-load session.json

Durante una scansione attiva, premi `Ctrl+C` una volta per mettere in pausa i worker, quindi scegli `C` per continuare o `E` per interrompere.

### Sonde di bypass di header e percorso

Usalo solo su sistemi che sei autorizzato a testare. La funzionalità è opt-in e sonda le risorse bloccate con header temporanei controllati e varianti sicure del percorso.```bash
opendoor \
  --host https://example.com \
  --method GET \
  --waf-detect \
  --header-bypass \
  --header-bypass-limit 32 \
  --reports std,json,csv,sarif,sqlite

Quando --header-bypass è abilitato, OpenDoor prova prima le varianti configurate di iniezione degli header e poi le varianti sicure di manipolazione del percorso, come barra finale, segmento con punto, suffisso con punto e virgola, variazione di maiuscole/minuscole e segmento codificato in URL. Personalizza gli stati di trigger, i valori IP attendibili e gli header:```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

### Routing del proxy

Usa un singolo proxy esplicito:```bash
opendoor --host https://example.com --proxy socks5://127.0.0.1:9050

Usa il pool di proxy rotanti incluso:```bash opendoor --host https://example.com --proxy-pool

Usa un elenco personalizzato di proxy rotanti:```bash
opendoor --host https://example.com --proxy-list proxies.txt

Trasporto OpenVPN```bash

opendoor
--host https://example.com
--transport openvpn
--transport-profile ./profile.ovpn

Se OpenVPN è installato al di fuori di `PATH`, passa il backend esplicitamente:```bash
opendoor \
  --host https://example.com \
  --transport openvpn \
  --transport-profile ./profile.ovpn \
  --transport-bin /opt/homebrew/sbin/openvpn

Su Windows, --transport-bin può puntare a C:\Program Files\OpenVPN\bin\openvpn.exe. Se un client GUI o un agente VPN aziendale possiede già il tunnel, avvia quella VPN al di fuori di OpenDoor ed esegui OpenDoor in modalità diretta.

Trasporto WireGuard```bash

opendoor
--host https://example.com
--transport wireguard
--transport-profile ./profile.conf

Altri esempi:

- [Scansioni di base](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Scansioni batch](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Scansioni autenticate](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [Scansioni WAF-safe](https://opendoor.readthedocs.io/examples/waf-safe-scans/)
- [Scansioni con bypass degli header](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [Scansioni con trasporto VPN](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [Esempi CI/CD](https://opendoor.readthedocs.io/examples/ci-cd/)

---

### Confronto dei report differenziali

OpenDoor può confrontare esattamente due report precedenti/attuali senza eseguire una nuova scansione. Utilizzalo quando vuoi vedere cosa è apparso, scomparso o cambiato tra due risultati di scansione autorizzati.

Le coppie di input supportate sono solo SQLite-to-SQLite e JSON-to-JSON. Formati misti, file mancanti, report non validi e tipi di report non supportati falliscono con un errore di validazione controllato.```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

Report SARIF per CI/CD

OpenDoor può esportare i risultati come SARIF 2.1.0 per GitHub Code Scanning e pipeline di sicurezza compatibili con SARIF.```bash opendoor
--host https://example.com
--reports sarif,json
--reports-dir ./reports

Esempio di upload con 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

🎓 Padroneggiare OpenDoor

Serie di articoli pratici per imparare OpenDoor attraverso flussi di lavoro di ricognizione web autorizzati e riproducibili.

OpenDoor

📚 Documentazione

La documentazione completa è disponibile su ReadTheDocs:

🧪 Sviluppo

Installa le dipendenze di sviluppo:```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 .

Esegui i test:```bash
python -m unittest

Copertura dell'esecuzione:```bash coverage run -m unittest discover -s tests -p "test_*.py" coverage report -m

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

Crea gli artefatti del pacchetto:```bash python -m build

Vedi la [guida di test](https://opendoor.readthedocs.io/Testing/) completa e la [guida al contributo](https://opendoor.readthedocs.io/Contribution/).

---

## 🔐 Sicurezza e igiene dei segreti

Non committare segreti reali né profili di trasporto privati.

Non pubblicare mai:

- profili OpenVPN reali;
- chiavi private WireGuard;
- certificati client mTLS e chiavi private;
- file auth-user-pass;
- cookie;
- token bearer;
- elenchi di target dei clienti;
- report di scansione privati;
- artefatti CI sensibili.

Usa solo esempi segnaposto.

---

## ⚖️ Uso responsabile

OpenDoor è uno strumento di test di sicurezza.

Usalo solo su sistemi di tua proprietà o per i quali hai l'esplicita autorizzazione a effettuare test.

Funzionalità come il rilevamento WAF, la scansione WAF-safe, la riproduzione di richieste raw, i profili di trasporto e le sonde Header Injection Bypass sono pensate per test di sicurezza autorizzati, validazione difensiva e controlli di regressione delle esposizioni.

Il progetto non concede il permesso di scansionare sistemi di terze parti, organizzazioni, servizi commerciali o infrastrutture pubbliche senza autorizzazione.

---

## 🧾 Registro delle modifiche

Vedi [CHANGELOG.md](https://github.com/stanislav-web/opendoor/blob/HEAD/CHANGELOG.md) e le [Release di GitHub](https://github.com/stanislav-web/OpenDoor/releases).

---

## 🤝 Contributi

Le pull request sono benvenute.

Prima di contribuire, leggi la [guida al contributo](https://opendoor.readthedocs.io/Contribution/) ed esegui i test pertinenti.
OpenDoor migliora grazie a contributi di codice, aggiornamenti della documentazione, test, segnalazioni di problemi, feedback sulla sicurezza, idee per nuove funzionalità e validazione da parte della community.
Grazie a tutti coloro che hanno contribuito a migliorare il progetto.

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

---

## 📄 Licenza

OpenDoor è rilasciata solo sotto la GNU General Public License v3.0.

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

---

## Supporto

Se OpenDoor ti aiuta nel tuo lavoro di sicurezza autorizzato, puoi sostenere la manutenzione in corso tramite Giveth.

[Sostieni OpenDoor su 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)

Scansione basata sulle fingerprint	OpenDoor può identificare probabili piattaforme CMS, framework, provider di infrastruttura e segnali WAF prima della discovery più approfondita. Questo aiuta a scansionare con contesto invece di lanciare alla cieca una wordlist generica contro il bersaglio.
Comportamento consapevole del WAF	OpenDoor può rilevare probabili comportamenti WAF / anti-bot e passare a un profilo di runtime più sicuro con `--waf-safe-mode`, riducendo le scansioni rumorose bloccate e rendendo più facili da comprendere le risposte difensive.
Condizione di arresto WAF guard	OpenDoor può interrompere una scansione in anticipo quando le risposte classificate iniziali sono in gran parte bloccate dal WAF. Questo evita di sprecare lunghe esecuzioni su wordlist che producono solo ripetute pagine di blocco edge/WAF.
Prove di bypass controllate	OpenDoor può opzionalmente testare risorse bloccate `401` e `403` con varianti controllate di iniezione di header e manipolazione dei percorsi. Registra prove esatte come tipo di bypass, variante di header o percorso, valore del probe, codice di stato originale e codice di stato risultante senza modificare gli header globali della scansione.
Auto-calibrazione multi-segnale	OpenDoor non si affida solo al codice di stato o alla dimensione della risposta. Confronta più segnali di risposta come hash del corpo, testo visibile, frasi semantiche di soft-404, struttura dei token DOM, titoli, reindirizzamenti, header stabili, conteggio parole, conteggio righe, densità del testo, token dinamici normalizzati e baseline DNS wildcard per ridurre i falsi positivi da soft-404 e wildcard.
Crawl limitato alla stessa origine	`--crawl` può arricchire le scansioni di directory con link same-origin a un hop trovati nelle risposte HTML già scansionate. Usa la pipeline di scansione esistente, la deduplicazione globale delle richieste, la deduplicazione dei report per bucket e limiti di memoria predefiniti, invece di diventare uno spider o un renderer browser.
Sistema di plugin sniffer euristici	OpenDoor include un livello pluggabile di analisi delle risposte per sniffer euristici come segreti, trace di stack, elenchi di directory, indicatori di malware, shadow copy, file sospetti, open redirect e modelli ripetuti di soft-error. Questo consente alle scansioni di far emergere prove significative dai corpi delle risposte invece di riportare solo codici di stato e dimensioni.
Flussi di lavoro a livello di trasporto	OpenDoor supporta modalità di trasporto diretto, proxy, OpenVPN e WireGuard. Può anche ruotare i profili di trasporto per ogni bersaglio nelle scansioni batch autorizzate, il che non equivale ad avviare manualmente una VPN prima di eseguire uno scanner.
Supporto per pool di proxy	OpenDoor può utilizzare pool di proxy tramite `--proxy-list`, validare i proxy disponibili prima della scansione e ruotare le richieste sul pool attivo. Questo aiuta le lunghe scansioni autorizzate a sopravvivere a route instabili senza hardcodare un singolo endpoint proxy.
Runtime di scansione tollerante ai guasti	OpenDoor è progettato per mantenere utili le scansioni su bersagli instabili e reti inaffidabili. Combina retry delle richieste, protezione dagli errori consecutivi, gestione recuperabile degli errori di trasporto, rotazione dei proxy, condizioni di arresto consapevoli del WAF, sessioni checkpoint e controlli interattivi di pausa/ripresa, così le scansioni lunghe possono fallire in sicurezza invece di perdere silenziosamente copertura.
Scansioni lunghe ripristinabili	OpenDoor può salvare checkpoint di scansione e riprendere in seguito. Questo è importante quando le scansioni vengono interrotte da crash, reti instabili, route bloccate, disconnessioni del terminale o lunghi lavori multi-bersaglio.
Pausa/ripresa del runtime	Premi `Ctrl+C` una volta durante una scansione per mettere in pausa i worker, poi scegli `C` per continuare o `E` per interrompere senza coinvolgere i file di sessione.
Confronto differenziale dei report	OpenDoor può confrontare un report SQLite/JSON precedente e uno attuale con `--diff old:new`, mostrando risultati aggiunti, rimossi e modificati senza riscansionare il bersaglio. Questo trasforma i report di scansione in controlli di regressione dell'esposizione release-to-release.
Risultati pronti per CI/CD	OpenDoor può restituire un codice di uscita di errore solo quando vengono trovati bucket di risultati selezionati, rendendolo utilizzabile come gate di rilascio o controllo di regressione dell'esposizione senza script personalizzati di post-elaborazione.
Ingegneria verificabile	OpenDoor è mantenuto con CI multi-piattaforma, controlli di copertura, controlli dei pacchetti, build della documentazione e una grande suite di unittest, rendendolo più facile da verificare, a cui contribuire e su cui fare affidamento.

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
Framework / piattaforme app	Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring
Stack runtime / linguaggio	PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, bersagli statici
Site builder	Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder
Generatori statici / docs	MkDocs, Docusaurus, Hugo, Jekyll, VitePress
Infrastruttura / hosting	Cloudflare, AWS, Vercel, Netlify, GitHub Pages, GitLab Pages, Heroku, Azure, Google Cloud, Fastly, Akamai, Hostinger, DDoS-Guard, Tencent Cloud
Infrastruttura / server	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
Header di sicurezza	Presenza HSTS, max-age, includeSubDomains, direttiva preload, prontezza preload locale