stanislav-web/opendoorPiattaforma OWASP per ricognizione web e scoperta di directory
# OpenDoor — Piattaforma OWASP per Web Recon e Directory Discovery
**OpenDoor** è una piattaforma CLI Recon open-source per web reconnaissance autorizzata, directory discovery, enumerazione di sottodomini, fingerprinting, rilevamento WAF, probing di bypass, filtraggio delle risposte, reporting, controlli open-redirect, crawl limitato e flussi di scansione basati su trasporto.
Aiuta ricercatori di sicurezza, penetration tester, bug bounty hunter, ingegneri DevSecOps e sviluppatori a identificare percorsi esposti, pannelli di login, directory listing, risorse limitate, file di backup, web shell, sottodomini e altre risorse web potenzialmente sensibili.
> Usa OpenDoor solo su sistemi di tua proprietà o per i quali hai esplicita autorizzazione al test.
---
## ✅ Stato del progetto
[](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
| Piattaforma | 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) |
---
## 🚀 Link rapidi
- [Documentazione](https://opendoor.readthedocs.io/)
- [Quickstart](https://opendoor.readthedocs.io/quickstart/)
- [Installazione e aggiornamento](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guida all'uso](https://opendoor.readthedocs.io/Usage/)
- [Esempi pratici](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Changelog](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md)
- [Pacchetto PyPI](https://pypi.org/project/opendoor/)
- [Formule Homebrew](https://formulae.brew.sh/formula/opendoor)
- [Immagine Docker](https://github.com/users/stanislav-web/packages/container/package/opendoor)
- [Pacchetto AUR](https://aur.archlinux.org/packages/opendoor)
- [Pacchetto BlackArch](https://blackarch.org/webapp.html)
- [Issue](https://github.com/stanislav-web/OpenDoor/issues)
- [Contributori](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## ✨ Funzionalità
- directory discovery;
- directory discovery ricorsivo;
- crawl limitato same-origin;
- follow dei redirect;
- enumerazione dei sottodomini;
- scansioni multi-threading per ricerche più rapide;
- modalità di input singolo target, file di target, stdin, IPv4 CIDR e intervallo IPv4;
- wordlist personalizzate, prefissi, shuffling per rompere i pattern di scansione e filtri di estensione, supporto a wordlist remote;
- header di richiesta personalizzati, inoltro dei cookie e template di richieste HTTP raw;
- filtri delle risposte per status, dimensione, testo, regex e lunghezza del body;
- sniffer delle risposte per rilevare directory listing, risposte vuote, esposizioni di file note, probe attivi su shadow-copy, collation, possibili segreti esposti, endpoint esposti lato client, errori, stack trace di debug esposti e vulnerabilità open redirect verificate;
- auto-calibrazione intelligente per casi soft-404, wildcard, catch-all, response-diff semantico e DNS wildcard;
- rilevamento fingerprint tecnologico per CMS, piattaforme e-commerce, framework, stack runtime, infrastruttura e postura HSTS;
- controlli passivi di rischio privacy in `--fingerprint`, incluse possibili superfici HSTS, ETag/cache e supercookie.
- rilevamento WAF passivo e bypass in modalità di scansione sicura;
- condizione di stop WAF guard per terminare scansioni a basso valore quando le risposte classificate iniziali sono in stragrande maggioranza bloccate da WAF;
- probe controllati di bypass header e path per risorse bloccate `401` e `403`;
- runtime di scansione fault-tolerant con retry, protezione da fail-streak, gestione dei fallimenti di trasporto, sessioni ripristinabili e controlli runtime di pausa/ripresa;
- regole CI/CD fail-on per bucket di risultati;
- confronto differenziale dei report per report JSON o SQLite precedenti/attuali;
- report in formato terminale, testo, JSON, CSV, HTML, SARIF e SQLite;
- supporto trasporto proxy, OpenVPN, WireGuard, TLS legacy e mTLS con certificato client;
- rotazione sequenziale del trasporto per target per flussi batch;
- wizard di configurazione per profili di scansione ripetibili;
- wordlist integrate (agg. 2026-08)
---
## 🧭 Quando ha senso usare OpenDoor?
È progettato per target reali dove la sola velocità non basta: WAF, CDN, pagine soft-404, route wildcard, risorse limitate, aree autenticate, reti instabili, batch multi-target e scansioni controllate a livello di trasporto.
Dal suo primo rilascio nel 2016 fino ad oggi, OpenDoor è cambiato radicalmente, evolvendo da un primitivo brute forcer a un nuovo framework di discovery adattivo. È diventato DevOps e QA friendly.
OpenDoor si concentra sulla **discovery context-aware** invece dell'enumerazione cieca.
### Cosa rende OpenDoor diverso
| Capacità | Perché è importante |
|---|---|
| **Scansione fingerprint-first** | OpenDoor può identificare probabili piattaforme CMS, framework, provider di infrastruttura e segnali WAF prima della discovery più profonda. Questo aiuta a scansionare con contesto invece di lanciare ciecamente una wordlist generica contro il target. |
| **Comportamento WAF-aware** | OpenDoor può rilevare probabili comportamenti WAF / anti-bot e passare a un profilo runtime più sicuro con `--waf-safe-mode`, riducendo le scansioni bloccate rumorose e rendendo più comprensibili le risposte difensive. |
| **Condizione di stop WAF guard** | OpenDoor può interrompere anticipatamente una scansione quando le risposte classificate iniziali sono in stragrande maggioranza bloccate da WAF. Questo evita di spendere lunghe esecuzioni su wordlist che producono solo ripetute pagine di blocco edge/WAF. |
| **Evidenza controllata di bypass** | OpenDoor può opzionalmente sondare risorse bloccate `401` e `403` con varianti controllate di header-injection e path-manipulation. Registra evidenza esatta come tipo di bypass, variante header o path, valore del probe, status code originale e status code risultante senza mutare gli header globali di scansione. |
| **Auto-calibrazione multi-segnale** | OpenDoor non si basa solo sullo status code o sulla dimensione della risposta. Confronta molteplici segnali di risposta come hash del body, testo visibile, frasi semantiche soft-404, struttura dei token DOM, titoli, redirect, header stabili, conteggio parole, conteggio righe, densità del testo, token dinamici normalizzati e baseline DNS wildcard per ridurre i falsi positivi soft-404 e wildcard. |
| **Crawl limitato same-origin** | `--crawl` può arricchire le scansioni di directory con link same-origin a un salto 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 contenuti invece di diventare uno spider o un renderer browser. |
| **Sistema di plugin sniffer euristici** | OpenDoor include un livello di analisi delle risposte pluggable per sniffer euristici come segreti, stack trace, directory listing, indicatori di malware, shadow copy, file sospetti, open redirect e template di soft-error ripetuti. Questo permette alle scansioni di far emergere evidenza significativa dai body delle risposte invece di riportare solo status code e dimensioni. |
| **Flussi a livello di trasporto** | OpenDoor supporta modalità di trasporto direct, proxy, OpenVPN e WireGuard. Può anche ruotare profili di trasporto per target in scansioni batch autorizzate, cosa diversa dall'avviare manualmente una VPN prima di eseguire uno scanner. |
| **Supporto proxy pool** | OpenDoor può usare proxy pool 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 inaffidabili senza hardcodare un singolo endpoint proxy. |
| **Runtime di scansione fault-tolerant** | OpenDoor è progettato per mantenere le scansioni utili su target instabili e reti inaffidabili. Combina retry delle richieste, protezione da fallimenti consecutivi, gestione recuperabile degli errori di trasporto, rotazione proxy, condizioni di stop WAF-aware, sessioni checkpoint e controlli interattivi di pausa/ripresa, così le lunghe scansioni possono fallire in sicurezza invece di perdere silenziosamente copertura. |
| **Scansioni lunghe ripristinabili** | OpenDoor può salvare checkpoint di scansione e riprendere successivamente. Questo conta quando le scansioni vengono interrotte da crash, reti instabili, route bloccate, disconnessioni del terminale o lunghi job multi-target. |
| **Pausa/ripresa 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 file di sessione. |
| **Confronto differenziale dei report** | OpenDoor può confrontare un report SQLite/JSON precedente e uno attuale con `--diff old:new`, mostrando finding aggiunti, rimossi e modificati senza riscansionare il target. Questo trasforma i report di scansione in controlli di regressione dell'esposizione da release a release. |
| **Risultati CI/CD-ready** | OpenDoor può restituire un exit code di fallimento solo quando vengono trovati bucket di risultati selezionati, rendendolo utilizzabile come gate di rilascio o controllo di regressione dell'esposizione senza script di post-processing personalizzati. |
| **Ingegneria verificabile** | OpenDoor è mantenuto con CI multi-piattaforma, controlli di coverage, controlli dei pacchetti, build della documentazione e una vasta suite di unittest, rendendolo più facile da verificare, a cui contribuire e su cui fare affidamento. |
## 🧬 Tecnologie riconosciute
OpenDoor include un motore di fingerprint euristico per rilevare probabili stack applicativi, piattaforme CMS, framework, site builder, tooling per siti statici, provider di infrastruttura, readiness HSTS / preload e sistemi WAF / anti-bot.
| Categoria | Esempi |
|----------------------------|---|
| 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, target 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, readiness preload locale |
Elenco completo delle tecnologie supportate:
[Tecnologie di fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting)
Esegui il rilevamento fingerprint:
```bash
opendoor --host https://example.com --fingerprint
```
Dopo che la fase di fingerprinting è terminata, OpenDoor stampa un riepilogo compatto pre-scansione prima che inizi l'enumerazione del dizionario:
```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready
```
Read more:
- [Fingerprinting guide](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [WAF detection guide](https://opendoor.readthedocs.io/detection/waf-detection/)
## 📦 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 dal Chocolatey Community Package Repository:
```powershell
choco install opendoor -y
```
I pacchetti Chocolatey possono rimanere indietro rispetto all'ultima release GitHub/PyPI mentre la moderazione della community viene completata.
### 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
```
### Dal sorgente
```bash
git clone https://github.com/stanislav-web/OpenDoor.git
cd OpenDoor
python3 -m pip install -r requirements.txt
python3 opendoor.py --help
```
Consulta la [guida completa all'installazione](https://opendoor.readthedocs.io/Installation-and-update/).
---
## 🚀 Utilizzo rapido
### Scansione di base di una directory
```bash
opendoor --host https://example.com
```
### Scansione dei 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 URL della stessa origine, rispetta le estensioni ignorate, salta i form POST e le origini esterne, e segnala gli URL scoperti attraverso i normali bucket dei risultati.
### Scansione dei sottodomini
```bash
opendoor --host example.com --scan subdomains
```
### Elenco dei target
```bash
opendoor --hostlist targets.txt
```
I file di destinazione possono contenere un mix di 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 target 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
```
### Response sniffers
I response sniffer 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
```
Gli sniffer utili includono:
| Sniffer | Scopo |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof` | Rileva pagine di directory listing. |
| `file` | Rileva pattern noti di esposizione di file sensibili. |
| `collation` | Rileva risposte ripetute o di fallback simili a redirect che possono generare falsi positivi. |
| `skipempty` | Salta le risposte vuote. |
| `skipsizes=46` | Salta le risposte con dimensioni note e rumorose esatte. |
| `skipsizes=46:1024` | Salta le risposte all'interno di un intervallo di dimensioni rumoroso. |
| `stacktrace` | Rileva stack trace di debug/runtime esposti e dettagli di errori interni. |
| `secret` | Rileva possibili chiavi API, token, chiavi private e credenziali esposte con metadati del report oscurati. |
| `shadow` | Sonda attivamente i risultati confermati `200 OK` simili a 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 segnala solo vulnerabilità di open redirect confermate. |
| `endpoint` | Rileva passivamente endpoint WebSocket, Socket.IO, SSE/EventSource e AJAX esposti dal client dalle risposte già recuperate. |
| `malware` | Rileva possibili contenuti malevoli, marker di webshell, script iniettati o payload offuscati. |
Gli sniffer dipendenti dal body forzano automaticamente `GET` internamente quando il metodo configurato è `HEAD`.
Per saperne di più: [Riferimento Sniffers](https://opendoor.readthedocs.io/Sniffers/)
### Scansione autenticata da richiesta raw
```bash
opendoor \
--raw-request request.txt \
--scheme https \
--method GET \
--auto-calibrate \
--reports json,html,sqlite,sarif
```
### Scansione sicura per WAF
```bash
opendoor \
--host https://example.com \
--waf-safe-mode \
--timeout 60 \
--retries 5 \
--delay 0.5
```
### Scansione fault-tolerant
Usa un profilo di runtime più conservativo 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 gli abort ai percorsi ripetutamente esauriti, filtrando le risposte soft-404 e catch-all con auto-calibrazione, interrompendo le scansioni a basso valore quando le risposte bloccate dal WAF dominano, e salvando lo stato del checkpoint per riprendere in seguito.
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, poi scegli `C` per continuare o `E` per interrompere.
### Sonde di bypass di header e path
Usa questa funzione solo su sistemi che sei autorizzato a testare. La funzione è opt-in e sonda le risorse bloccate con header temporanei controllati e varianti di path sicure.
```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 di header-injection configurate e poi varianti sicure di manipolazione del percorso come slash finale, segmento punto, suffisso punto e virgola, variazione di maiuscole/minuscole e segmento codificato URL.
Personalizza gli stati di attivazione, 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 una lista di proxy rotanti personalizzata:
```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 del `PATH`, passare esplicitamente il backend:
```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 differenziale dei report
OpenDoor può confrontare esattamente due report precedenti/attuali senza eseguire una nuova scansione. Usalo 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 gestito.
```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 riproducibili e autorizzati.
- [Parte 1 — Ricognizione web context-aware oltre il brute force delle directory](https://medium.com/@stanisov/mastering-opendoor-context-aware-web-recon-beyond-directory-brute-force-part-1-cc13eda8cd3d)
- [Parte 2 — Ricognizione a basso rumore con redirect, sniffing degli endpoint e crawl limitato](https://medium.com/@stanisov/mastering-opendoor-low-noise-recon-with-redirects-endpoint-sniffing-and-bounded-crawl-part-2-411b92675d6d)
- [Pagina complementare della serie](https://opendoor.readthedocs.io/guides/mastering-opendoor/)
## 📚 Documentazione
La documentazione completa è disponibile su ReadTheDocs:
- [Home](https://opendoor.readthedocs.io/)
- [Quickstart](https://opendoor.readthedocs.io/quickstart/)
- [Installazione e aggiornamento](https://opendoor.readthedocs.io/Installation-and-update/)
- [Guida all'uso](https://opendoor.readthedocs.io/Usage/)
- [Input dei target](https://opendoor.readthedocs.io/concepts/target-input/)
- [Report](https://opendoor.readthedocs.io/concepts/reports/)
- [Fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [Rilevamento WAF e modalità sicura](https://opendoor.readthedocs.io/detection/waf-detection/)
- [WAF guard](https://opendoor.readthedocs.io/detection/waf-guard/)
- [Bypass dell'iniezione di header](https://opendoor.readthedocs.io/detection/header-bypass/)
- [Auto-calibrazione](https://opendoor.readthedocs.io/detection/auto-calibration/)
- [Trasporti di rete](https://opendoor.readthedocs.io/transports/overview/)
- [Compatibilità TLS e mTLS](https://opendoor.readthedocs.io/transports/tls/)
- [Trasporto OpenVPN](https://opendoor.readthedocs.io/transports/openvpn/)
- [Trasporto WireGuard](https://opendoor.readthedocs.io/transports/wireguard/)
- [Esempi pratici](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Testing](https://opendoor.readthedocs.io/Testing/)
- [Contribuzione](https://opendoor.readthedocs.io/Contribution/)
---
## 🧪 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
```
Esegui la copertura:
```bash
coverage run -m unittest discover -s tests -p "test_*.py"
coverage report -m
```
Compila la documentazione:
```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
```
Consulta la [guida completa ai test](https://opendoor.readthedocs.io/Testing/) e la [guida alla contribuzione](https://opendoor.readthedocs.io/Contribution/).
---
## 🔐 Sicurezza e igiene dei segreti
Non eseguire il commit di segreti reali o profili di trasporto privati.
Non pubblicare mai:
- profili OpenVPN reali;
- chiavi private WireGuard;
- certificati client mTLS e chiavi private;
- file auth-user-pass;
- cookie;
- bearer token;
- liste di target dei clienti;
- report di scansione privati;
- artefatti CI sensibili.
Usa solo esempi segnaposto.
---
## ⚖️ Uso responsabile
OpenDoor è uno strumento di security testing.
Usalo solo contro sistemi di tua proprietà o per i quali hai esplicita autorizzazione a testare.
Funzionalità come il rilevamento WAF, la scansione WAF-safe, il replay di richieste raw, i profili di trasporto e le sonde Header Injection Bypass sono destinate a test di sicurezza autorizzati, validazione difensiva e verifiche di regressione dell'esposizione.
Il progetto non concede il permesso di scansionare sistemi di terze parti, organizzazioni, servizi commerciali o infrastrutture pubbliche senza autorizzazione.
---
## 🧾 Changelog
Consulta [CHANGELOG.md](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md) e le [GitHub Releases](https://github.com/stanislav-web/OpenDoor/releases).
---
## 🤝 Contribuire
Le pull request sono benvenute.
Prima di contribuire, leggi la [guida alla contribuzione](https://opendoor.readthedocs.io/Contribution/) ed esegui i test pertinenti.
OpenDoor migliora grazie ai contributi al codice, agli aggiornamenti della documentazione, ai test, alle segnalazioni di problemi, al feedback sulla sicurezza, alle idee per nuove funzionalità e alla validazione della community.
Grazie a tutti coloro che hanno contribuito a migliorare il progetto.
[](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## 📄 Licenza
OpenDoor è rilasciato sotto GNU General Public License v3.0 only.
Consulta [LICENSE](https://github.com/stanislav-web/opendoor/blob/master/LICENSE).
---
## Supporto
Se OpenDoor aiuta il tuo lavoro di sicurezza autorizzato, puoi sostenere la manutenzione continua tramite Giveth.
[Sostieni OpenDoor su Giveth](https://giveth.io/project/opendoor)
---
[](https://deepwiki.com/stanislav-web/OpenDoor) [](https://www.gnu.org/licenses/gpl-3.0)