stanislav-web/opendoorOWASP-Plattform für Web-Reconnaissance & Verzeichnis-Erkennung
# OpenDoor — OWASP Web-Recon- & Directory-Discovery-Plattform
**OpenDoor** ist eine quelloffene CLI-Recon-Plattform für autorisierte Web-Reconnaissance, Directory Discovery, Subdomain-Enumeration, Fingerprints, WAF-Erkennung, Bypass-Probing, Response-Filterung, Reporting, Open-Redirect-Prüfungen, begrenztes Crawling und transportbasierte Scan-Workflows.
Sie hilft Sicherheitsforschern, Penetrationstestern, Bug-Bounty-Jägern, DevSecOps-Ingenieuren und Entwicklern, exponierte Pfade, Login-Panels, Verzeichnisauflistungen, eingeschränkte Ressourcen, Backup-Dateien, Web-Shells, Subdomains und andere potenziell sensible Web-Assets zu identifizieren.
> Verwende OpenDoor nur auf Systemen, die dir gehören oder für die du eine ausdrückliche Testgenehmigung hast.
---
## ✅ Projektstatus
[](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/)
## 🧪 CI-Matrix
| Plattform | 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) |
---
## 🚀 Schnellzugriffe
- [Dokumentation](https://opendoor.readthedocs.io/)
- [Schnellstart](https://opendoor.readthedocs.io/quickstart/)
- [Installation und Aktualisierung](https://opendoor.readthedocs.io/Installation-and-update/)
- [Nutzungsanleitung](https://opendoor.readthedocs.io/Usage/)
- [Praktische Beispiele](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Changelog](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md)
- [PyPI-Paket](https://pypi.org/project/opendoor/)
- [Homebrew-Formeln](https://formulae.brew.sh/formula/opendoor)
- [Docker-Image](https://github.com/users/stanislav-web/packages/container/package/opendoor)
- [AUR-Paket](https://aur.archlinux.org/packages/opendoor)
- [BlackArch-Paket](https://blackarch.org/webapp.html)
- [Issues](https://github.com/stanislav-web/OpenDoor/issues)
- [Mitwirkende](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## ✨ Funktionen
- Directory Discovery;
- rekursive Directory Discovery;
- begrenztes Same-Origin-Crawling;
- Folgen von Redirects;
- Subdomain-Enumeration;
- Multithreading-Scans für schnellere Lookups;
- Eingabemodi für einzelnes Ziel, Zieldatei, stdin, IPv4-CIDR und IPv4-Bereich;
- benutzerdefinierte Wortlisten, Präfixe, Shuffling zum Aufbrechen von Scan-Mustern und Erweiterungsfilter, Unterstützung für Remote-Wortlisten;
- benutzerdefinierte Request-Header, Cookie-Weiterleitung und rohe HTTP-Request-Templates;
- Response-Filter nach Status, Größe, Text, Regex und Body-Länge;
- Response-Sniffer zur Erkennung von Verzeichnisauflistungen, leeren Antworten, bekannten Dateiexpositionen, aktiven Shadow-Copy-Probes, Kollationierung, möglichen exponierten Secrets, clientseitig exponierten Endpunkten, Fehlern, exponierten Debug-Stacktraces und verifizierten Open-Redirect-Schwachstellen;
- intelligente Auto-Kalibrierung für Soft-404-, Wildcard-, Catch-All-, semantische Response-Diff- und DNS-Wildcard-Fälle;
- Technologie-Fingerprint-Erkennung für CMS, E-Commerce-Plattformen, Frameworks, Runtime-Stacks, Infrastruktur und HSTS-Posture;
- passive Datenschutzrisiko-Prüfungen in `--fingerprint`, einschließlich möglicher HSTS-, ETag/Cache- und Supercookie-Oberflächen.
- passive WAF-Erkennung und Bypass im sicheren Scan-Modus;
- WAF-Guard-Stop-Bedingung zum Beenden wenig wertvoller Scans, wenn die initial klassifizierten Antworten überwiegend WAF-blockiert sind;
- kontrollierte Header- und Pfad-Bypass-Probes für blockierte `401`- und `403`-Ressourcen;
- fehlertolerante Scan-Runtime mit Retries, Fail-Streak-Schutz, Behandlung von Transportfehlern, fortsetzbaren Sitzungen und Laufzeit-Pause/Resume-Steuerung;
- CI/CD-Fail-on-Result-Bucket-Regeln;
- differenzieller Report-Vergleich für vorherige/aktuelle JSON- oder SQLite-Reports;
- Reports in Terminal-, Text-, JSON-, CSV-, HTML-, SARIF- und SQLite-Formaten;
- Proxy-, OpenVPN-, WireGuard-, Legacy-TLS- und mTLS-Client-Zertifikat-Transportunterstützung;
- sequenzielle Transport-Rotation pro Ziel für Batch-Workflows;
- Konfigurationsassistent für wiederholbare Scan-Profile;
- integrierte Wortlisten (aktualisiert 2026-08)
---
## 🧭 Wo ergibt OpenDoor Sinn?
Es ist für reale Ziele konzipiert, bei denen Geschwindigkeit allein nicht ausreicht: WAFs, CDNs, Soft-404-Seiten, Wildcard-Routen, eingeschränkte Ressourcen, authentifizierte Bereiche, instabile Netzwerke, Multi-Target-Batches und transportgesteuerte Scans.
Seit dem ersten Start im Jahr 2016 bis heute hat sich OpenDoor dramatisch verändert und ist von einem primitiven Brute-Forcer zu einem neuen adaptiven Discovery-Framework gewachsen. Es ist DevOps- und QA-freundlich geworden.
OpenDoor konzentriert sich auf **kontextbewusste Discovery** statt auf blinde Enumeration.
### Was OpenDoor anders macht
| Fähigkeit | Warum sie wichtig ist |
|---|---|
| **Fingerprint-First-Scanning** | OpenDoor kann wahrscheinliche CMS-Plattformen, Frameworks, Infrastruktur-Anbieter und WAF-Signale identifizieren, bevor eine tiefere Discovery erfolgt. Das hilft dir, mit Kontext zu scannen, statt blind eine generische Wortliste auf das Ziel zu werfen. |
| **WAF-bewusstes Verhalten** | OpenDoor kann wahrscheinliches WAF-/Anti-Bot-Verhalten erkennen und mit `--waf-safe-mode` auf ein sichereres Laufzeitprofil umschalten, wodurch verrauschte blockierte Scans reduziert und defensive Antworten leichter verständlich werden. |
| **WAF-Guard-Stop-Bedingung** | OpenDoor kann einen Scan früh stoppen, wenn die initial klassifizierten Antworten überwiegend WAF-blockiert sind. Das vermeidet lange Läufe mit Wortlisten, die nur wiederholte Edge-/WAF-Blockseiten erzeugen. |
| **Kontrollierte Bypass-Evidenz** | OpenDoor kann blockierte `401`- und `403`-Ressourcen optional mit kontrollierten Header-Injection- und Pfadmanipulationsvarianten prüfen. Es zeichnet exakte Evidenz auf, wie Bypass-Typ, Header- oder Pfadvariante, Probe-Wert, ursprünglicher Statuscode und resultierender Statuscode, ohne globale Scan-Header zu verändern. |
| **Multi-Signal-Auto-Kalibrierung** | OpenDoor verlässt sich nicht nur auf Statuscode oder Response-Größe. Es vergleicht mehrere Response-Signale wie Body-Hashes, sichtbaren Text, semantische Soft-404-Phrasen, DOM-Token-Struktur, Titel, Redirects, stabile Header, Wortanzahl, Zeilenanzahl, Textdichte, normalisierte dynamische Tokens und DNS-Wildcard-Baselines, um Soft-404- und Wildcard-False-Positives zu reduzieren. |
| **Begrenztes Same-Origin-Crawling** | `--crawl` kann Directory-Scans mit Same-Origin-Links aus bereits gescannten HTML-Antworten in einem Hop anreichern. Es nutzt die bestehende Scan-Pipeline, globale Request-Deduplizierung, Deduplizierung pro Bucket im Report und begrenzte Speicherobergrenzen, statt zu einem Spider oder Browser-Renderer zu werden. |
| **Heuristisches Sniffer-Plugin-System** | OpenDoor enthält eine pluggable Response-Analyse-Schicht für heuristische Sniffer wie Secrets, Stacktraces, Verzeichnisauflistungen, Malware-Indikatoren, Shadow Copies, verdächtige Dateien, Open Redirects und wiederkehrende Soft-Error-Templates. Dadurch können Scans aussagekräftige Evidenz aus Response-Bodies aufdecken, statt nur Statuscodes und Größen zu melden. |
| **Transport-Level-Workflows** | OpenDoor unterstützt direkte, Proxy-, OpenVPN- und WireGuard-Transportmodi. Es kann außerdem Transportprofile pro Ziel in autorisierten Batch-Scans rotieren, was nicht dasselbe ist wie das manuelle Starten eines VPN vor dem Ausführen eines Scanners. |
| **Proxy-Pool-Unterstützung** | OpenDoor kann Proxy-Pools über `--proxy-list` verwenden, verfügbare Proxies vor dem Scannen validieren und Requests über den Live-Pool rotieren. Das hilft langen autorisierten Scans, unzuverlässige Routen zu überstehen, ohne einen einzelnen Proxy-Endpunkt fest zu verdrahten. |
| **Fehlertolerante Scan-Runtime** | OpenDoor ist darauf ausgelegt, Scans auf instabilen Zielen und unzuverlässigen Netzwerken nützlich zu halten. Es kombiniert Request-Retries, Schutz vor aufeinanderfolgenden Fehlern, Behandlung wiederherstellbarer Transportfehler, Proxy-Rotation, WAF-bewusste Stop-Bedingungen, Checkpoint-Sitzungen und interaktive Pause/Resume-Steuerung, damit lange Scans sicher fehlschlagen können, statt stillschweigend Abdeckung zu verlieren. |
| **Fortsetzbare lange Scans** | OpenDoor kann Scan-Checkpoints speichern und später fortsetzen. Das ist wichtig, wenn Scans durch Abstürze, instabile Netzwerke, blockierte Routen, Terminal-Trennungen oder lange Multi-Target-Jobs unterbrochen werden. |
| **Laufzeit-Pause/Resume** | Drücke während eines Scans einmal `Ctrl+C`, um Worker zu pausieren, und wähle dann `C` zum Fortsetzen oder `E` zum Abbrechen, ohne Sitzungsdateien einzubeziehen. |
| **Differenzieller Report-Vergleich** | OpenDoor kann mit `--diff old:new` einen vorherigen und aktuellen SQLite/JSON-Report vergleichen und hinzugefügte, entfernte und geänderte Findings anzeigen, ohne das Ziel erneut zu scannen. Das macht Scan-Reports zu Release-zu-Release-Exposure-Regression-Checks. |
| **CI/CD-fähige Ergebnisse** | OpenDoor kann nur dann einen fehlschlagenden Exit-Code zurückgeben, wenn ausgewählte Result-Buckets gefunden werden, wodurch es als Release-Gate oder Exposure-Regression-Check ohne benutzerdefinierte Nachbearbeitungsskripte nutzbar ist. |
| **Auditierbares Engineering** | OpenDoor wird mit Multi-Plattform-CI, Coverage-Checks, Paket-Checks, Dokumentations-Builds und einer großen Unittest-Suite gepflegt, was Auditierung, Beiträge und Abhängigkeit erleichtert. |
## 🧬 Erkannte Technologien
OpenDoor enthält eine heuristische Fingerprint-Engine zur Erkennung wahrscheinlicher Application-Stacks, CMS-Plattformen, Frameworks, Site-Builder, Static-Site-Tooling, Infrastruktur-Anbieter, HSTS-/Preload-Bereitschaft und WAF-/Anti-Bot-Systeme.
| Kategorie | Beispiele |
|----------------------------|---|
| 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 / App-Plattformen | Laravel, Symfony, Django, Flask, FastAPI, Express, NestJS, Next.js, Nuxt, Rails, Spring |
| Runtime-/Sprach-Stack | PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, Static-Site-Ziele |
| Site-Builder | Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder |
| Static-/Docs-Generatoren | MkDocs, Docusaurus, Hugo, Jekyll, VitePress |
| Infrastruktur / Hosting | Cloudflare, AWS, Vercel, Netlify, GitHub Pages, GitLab Pages, Heroku, Azure, Google Cloud, Fastly, Akamai, Hostinger, DDoS-Guard, Tencent Cloud |
| Infrastruktur / 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 |
| Security-Header | HSTS-Präsenz, max-age, includeSubDomains, preload-Direktive, lokale Preload-Bereitschaft |
Vollständige Liste der unterstützten Technologien:
[Fingerprinting-Technologien](https://opendoor.readthedocs.io/detection/fingerprinting)
Fingerprint-Erkennung ausführen:
```bash
opendoor --host https://example.com --fingerprint
```
Nachdem der Fingerprint-Durchlauf abgeschlossen ist, gibt OpenDoor eine kompakte Zusammenfassung vor dem Scan aus, bevor die Wörterbuch-Enumeration beginnt:
```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/)
## 📦 Installation
### pipx
Empfohlen für die meisten CLI-Nutzer:
```bash
pipx install opendoor
```
### pip
```bash
python3 -m pip install --upgrade opendoor
```
### Windows / Chocolatey
OpenDoor ist im Chocolatey Community Package Repository verfügbar:
```powershell
choco install opendoor -y
```
Chocolatey-Pakete können hinter der neuesten GitHub/PyPI-Version zurückbleiben, während die Community-Moderation abgeschlossen wird.
### Arch Linux / AUR
OpenDoor ist im Arch User Repository verfügbar:
```bash
yay -S opendoor
```
### Homebrew
OpenDoor ist auch im Brew-Paketmanager verfügbar:
```bash
brew install opendoor
```
### Docker
OpenDoor ist als offizielles Projekt-Docker-Image über die GitHub Container Registry verfügbar.
```bash
docker pull ghcr.io/stanislav-web/opendoor:latest
docker run --rm -it ghcr.io/stanislav-web/opendoor:latest --version
```
Führen Sie einen Scan aus und schreiben Sie Berichte auf den 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 ist in BlackArch Linux verfügbar:
```bash
sudo pacman -Syu
sudo pacman -S opendoor
```
### Aus der Quelle
```bash
git clone https://github.com/stanislav-web/OpenDoor.git
cd OpenDoor
python3 -m pip install -r requirements.txt
python3 opendoor.py --help
```
Siehe die vollständige [Installationsanleitung](https://opendoor.readthedocs.io/Installation-and-update/).
---
## 🚀 Schnellstart
### Grundlegender Verzeichnis-Scan
```bash
opendoor --host https://example.com
```
### Same-Origin-Links crawlen
```bash
opendoor --host https://example.com --crawl
```
`--crawl` ist optional und funktioniert nur mit Verzeichnis-Scans. Es verwendet `GET`, extrahiert konservative HTML-Attribute aus bereits gescannten Antworten, behält nur URLs mit gleichem Ursprung bei, respektiert ignorierte Erweiterungen, überspringt POST-Formulare und externe Ursprünge und meldet entdeckte URLs über die normalen Ergebnis-Buckets.
### Subdomain-Scan
```bash
opendoor --host example.com --scan subdomains
```
### Zielliste
```bash
opendoor --hostlist targets.txt
```
Zieldateien können URLs, Domains, IPv4-Adressen, IPv4-CIDR-Blöcke und inklusive IPv4-Bereiche mischen:
```text
https://example.com
app.example.com
192.168.1.10
192.168.1.0/24
192.168.1.10-192.168.1.50
```
### Standardeingabe
```bash
cat targets.txt | opendoor --stdin
```
Dasselbe gemischte Zielformat wird über STDIN unterstützt.
### Scan mit geringem Rauschen
```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-Sniffer
Response-Sniffer klassifizieren interessante Antwortinhalte während der Erkennung. Sie sind nützlich, wenn Statuscode und Größe nicht ausreichen, um zu verstehen, was gefunden wurde.
```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
```
Nützliche Sniffer umfassen:
| Sniffer | Zweck |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof` | Erkennt Verzeichnislistungsseiten. |
| `file` | Erkennt bekannte Muster für die Offenlegung sensibler Dateien. |
| `collation` | Erkennt wiederholte oder redirect-ähnliche Fallback-Antworten, die zu Fehlalarmen führen können. |
| `skipempty` | Überspringt leere Antworten. |
| `skipsizes=46` | Überspringt Antworten mit exakt bekannten Rauschgrößen. |
| `skipsizes=46:1024` | Überspringt Antworten innerhalb eines verrauschten Größenbereichs. |
| `stacktrace` | Erkennt offengelegte Debug-/Runtime-Stacktraces und interne Fehlerdetails. |
| `secret` | Erkennt möglicherweise offengelegte API-Schlüssel, Tokens, private Schlüssel und Anmeldedaten mit redigierten Berichtsmetadaten. |
| `shadow` | Prüft aktiv bestätigte dateiähnliche `200 OK`-Treffer auf begrenzte Backup-/Shadow-Varianten wie `.bak`, `.old` und Pfadvorlagen . |
| `openredirect` | Verifiziert aktiv redirect-ähnliche Query-Parameter mit kontrollierten Marker-URLs und meldet nur bestätigte Open-Redirect-Schwachstellen. |
| `endpoint` | Erkennt passiv clientseitig exponierte WebSocket-, Socket.IO-, SSE/EventSource- und AJAX-Endpunkte aus bereits abgerufenen Antworten. |
| `malware` | Erkennt möglicherweise schädliche Inhalte, Webshell-Marker, injizierte Skripte oder obfuskierte Payloads. |
Body-abhängige Sniffer erzwingen intern automatisch `GET`, wenn die konfigurierte Methode `HEAD` ist.
Mehr erfahren: [Sniffers reference](https://opendoor.readthedocs.io/Sniffers/)
### Authentifizierter Scan aus roher Anfrage
```bash
opendoor \
--raw-request request.txt \
--scheme https \
--method GET \
--auto-calibrate \
--reports json,html,sqlite,sarif
```
### WAF-sicherer Scan
```bash
opendoor \
--host https://example.com \
--waf-safe-mode \
--timeout 60 \
--retries 5 \
--delay 0.5
```
### Fehlertoleranter Scan
Verwenden Sie ein konservativeres Laufzeitprofil für instabile Ziele, langsame Netzwerke, temporäre WAF-Blockierungen, Proxy-Instabilität oder lang laufende autorisierte Scans.
```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
```
Dieses Profil macht Scans widerstandsfähiger, indem es das Timeout pro Anfrage und die Wiederholungstoleranz erhöht, Abbrüche auf wiederholt ausgeschöpfte Pfade beschränkt, Soft-404- und Catch-All-Antworten mit automatischer Kalibrierung filtert, Scans mit geringem Nutzen stoppt, wenn WAF-blockierte Antworten dominieren, und den Checkpoint-Status für eine spätere Fortsetzung speichert.
Den Scan später fortsetzen:
```bash
opendoor --session-load session.json
```
Während eines aktiven Scans drücken Sie einmal `Ctrl+C`, um die Worker anzuhalten, und wählen Sie dann `C`, um fortzufahren, oder `E`, um abzubrechen.
### Header- und Pfad-Bypass-Sonden
Verwenden Sie dies nur auf Systemen, die Sie testen dürfen. Die Funktion ist optional und sondiert blockierte Ressourcen mit kontrollierten temporären Headern und sicheren Pfadvarianten.
```bash
opendoor \
--host https://example.com \
--method GET \
--waf-detect \
--header-bypass \
--header-bypass-limit 32 \
--reports std,json,csv,sarif,sqlite
```
Wenn --header-bypass aktiviert ist, versucht OpenDoor zuerst konfigurierte Header-Injection-Varianten und dann sichere Pfadmanipulationsvarianten wie abschließenden Schrägstrich, Punktsegment, Semikolon-Suffix, Groß-/Kleinschreibung-Variation und URL-kodiertes Segment.
Passen Sie Trigger-Status, vertrauenswürdige IP-Werte und Header an:
```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
```
### Proxy-Routing
Einen einzelnen expliziten Proxy verwenden:
```bash
opendoor --host https://example.com --proxy socks5://127.0.0.1:9050
```
Verwenden Sie den mitgelieferten rotierenden Proxy-Pool:
```bash
opendoor --host https://example.com --proxy-pool
```
Verwenden Sie eine benutzerdefinierte rotierende Proxy-Liste:
```bash
opendoor --host https://example.com --proxy-list proxies.txt
```
### OpenVPN-Transport
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn
```
Wenn OpenVPN außerhalb des `PATH` installiert ist, übergeben Sie das Backend explizit:
```bash
opendoor \
--host https://example.com \
--transport openvpn \
--transport-profile ./profile.ovpn \
--transport-bin /opt/homebrew/sbin/openvpn
```
Unter Windows kann `--transport-bin` auf `C:\Program Files\OpenVPN\bin\openvpn.exe` verweisen. Wenn ein GUI-Client oder ein Unternehmens-VPN-Agent bereits den Tunnel besitzt, starten Sie dieses VPN außerhalb von OpenDoor und führen Sie OpenDoor im Direktmodus aus.
### WireGuard-Transport
```bash
opendoor \
--host https://example.com \
--transport wireguard \
--transport-profile ./profile.conf
```
Weitere Beispiele:
- [Basic scans](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Batch scans](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Authenticated scans](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [WAF-safe scans](https://opendoor.readthedocs.io/examples/waf-safe-scans/)
- [Header-bypass scans](https://opendoor.readthedocs.io/examples/header-bypass-scans/)
- [VPN transport scans](https://opendoor.readthedocs.io/examples/vpn-transport-scans/)
- [CI/CD examples](https://opendoor.readthedocs.io/examples/ci-cd/)
---
### Vergleich differentieller Berichte
OpenDoor kann genau zwei vorherige/aktuelle Berichte vergleichen, ohne einen neuen Scan durchzuführen. Verwenden Sie dies, wenn Sie sehen möchten, was zwischen zwei autorisierten Scan-Ergebnissen aufgetreten, verschwunden oder geändert wurde.
Unterstützte Eingabepaare sind nur SQLite-zu-SQLite und JSON-zu-JSON. Gemischte Formate, fehlende Dateien, ungültige Berichte und nicht unterstützte Berichtstypen schlagen mit einem ordnungsgemäßen Validierungsfehler fehl.
```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
```
### SARIF-Berichte für CI/CD
OpenDoor kann Befunde als SARIF 2.1.0 für GitHub Code Scanning und SARIF-kompatible Sicherheitspipelines exportieren.
```bash
opendoor \
--host https://example.com \
--reports sarif,json \
--reports-dir ./reports
```
GitHub-Actions-Upload-Beispiel:
```yaml
- name: Upload OpenDoor SARIF
uses: github/codeql-action/upload-sarif@v3
with:
sarif_file: reports/example.com/example.com.sarif
category: opendoor
```
## 🎓 OpenDoor meistern
Praktische Artikelreihe zum Erlernen von OpenDoor anhand reproduzierbarer, autorisierter Web-Reconnaissance-Workflows.
- [Teil 1 — Kontextbewusste Web-Recon jenseits von Directory Brute Force](https://medium.com/@stanisov/mastering-opendoor-context-aware-web-recon-beyond-directory-brute-force-part-1-cc13eda8cd3d)
- [Teil 2 — Low-Noise-Recon mit Redirects, Endpoint-Sniffing und begrenztem Crawl](https://medium.com/@stanisov/mastering-opendoor-low-noise-recon-with-redirects-endpoint-sniffing-and-bounded-crawl-part-2-411b92675d6d)
- [Begleitseite zur Serie](https://opendoor.readthedocs.io/guides/mastering-opendoor/)
## 📚 Dokumentation
Die vollständige Dokumentation ist auf ReadTheDocs verfügbar:
- [Startseite](https://opendoor.readthedocs.io/)
- [Quickstart](https://opendoor.readthedocs.io/quickstart/)
- [Installation und Aktualisierung](https://opendoor.readthedocs.io/Installation-and-update/)
- [Nutzungsanleitung](https://opendoor.readthedocs.io/Usage/)
- [Zieleingabe](https://opendoor.readthedocs.io/concepts/target-input/)
- [Berichte](https://opendoor.readthedocs.io/concepts/reports/)
- [Fingerprinting](https://opendoor.readthedocs.io/detection/fingerprinting/)
- [WAF-Erkennung und Safe Mode](https://opendoor.readthedocs.io/detection/waf-detection/)
- [WAF Guard](https://opendoor.readthedocs.io/detection/waf-guard/)
- [Header Injection Bypass](https://opendoor.readthedocs.io/detection/header-bypass/)
- [Auto-Kalibrierung](https://opendoor.readthedocs.io/detection/auto-calibration/)
- [Netzwerk-Transports](https://opendoor.readthedocs.io/transports/overview/)
- [TLS-Kompatibilität und mTLS](https://opendoor.readthedocs.io/transports/tls/)
- [OpenVPN-Transport](https://opendoor.readthedocs.io/transports/openvpn/)
- [WireGuard-Transport](https://opendoor.readthedocs.io/transports/wireguard/)
- [Praktische Beispiele](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Testing](https://opendoor.readthedocs.io/Testing/)
- [Mitwirken](https://opendoor.readthedocs.io/Contribution/)
---
## 🧪 Entwicklung
Entwicklungsabhängigkeiten installieren:
```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 .
```
Tests ausführen:
```bash
python -m unittest
```
Abdeckung ausführen:
```bash
coverage run -m unittest discover -s tests -p "test_*.py"
coverage report -m
```
Dokumentation erstellen:
```bash
python3 -m venv .docs-venv
source .docs-venv/bin/activate
python -m pip install -r docs/requirements.txt
python -m mkdocs build --strict
```
Build-Paket-Artefakte:
```bash
python -m build
```
Siehe den vollständigen [Testing-Leitfaden](https://opendoor.readthedocs.io/Testing/) und [Contribution-Leitfaden](https://opendoor.readthedocs.io/Contribution/).
---
## 🔐 Sicherheit und Hygiene bei Secrets
Committen Sie keine echten Secrets oder privaten Transport-Profile.
Veröffentlichen Sie niemals:
- echte OpenVPN-Profile;
- WireGuard Private Keys;
- mTLS-Client-Zertifikate und Private Keys;
- auth-user-pass-Dateien;
- Cookies;
- Bearer Tokens;
- Kunden-Ziellisten;
- private Scan-Berichte;
- sensible CI-Artefakte.
Verwenden Sie ausschließlich Platzhalter-Beispiele.
---
## ⚖️ Verantwortungsvolle Nutzung
OpenDoor ist ein Sicherheitstest-Tool.
Verwenden Sie es nur gegen Systeme, die Ihnen gehören oder für die Sie eine ausdrückliche Testgenehmigung haben.
Funktionen wie WAF-Erkennung, WAF-sicheres Scannen, Raw-Request-Replay, Transport-Profile und Header-Injection-Bypass-Probes sind für autorisierte Sicherheitstests, defensive Validierung und Exposure-Regression-Checks gedacht.
Das Projekt gewährt keine Genehmigung, Drittsysteme, Organisationen, kommerzielle Dienste oder öffentliche Infrastruktur ohne Autorisierung zu scannen.
---
## 🧾 Changelog
Siehe [CHANGELOG.md](https://github.com/stanislav-web/opendoor/blob/master/CHANGELOG.md) und [GitHub Releases](https://github.com/stanislav-web/OpenDoor/releases).
---
## 🤝 Mitwirken
Pull Requests sind willkommen.
Lesen Sie vor einem Beitrag den [Contribution-Leitfaden](https://opendoor.readthedocs.io/Contribution/) und führen Sie die relevanten Tests aus.
OpenDoor verbessert sich durch Code-Beiträge, Dokumentations-Updates, Tests, Issue-Berichte, Sicherheits-Feedback, Feature-Ideen und Community-Validierung.
Danke an alle, die geholfen haben, das Projekt zu verbessern.
[](https://github.com/stanislav-web/OpenDoor/graphs/contributors)
---
## 📄 Lizenz
OpenDoor wird unter der GNU General Public License v3.0 only veröffentlicht.
Siehe [LICENSE](https://github.com/stanislav-web/opendoor/blob/master/LICENSE).
---
## Support
Wenn OpenDoor Ihre autorisierte Sicherheitsarbeit unterstützt, können Sie die laufende Wartung über Giveth unterstützen.
[OpenDoor auf Giveth unterstützen](https://giveth.io/project/opendoor)
---
[](https://deepwiki.com/stanislav-web/OpenDoor) [](https://www.gnu.org/licenses/gpl-3.0)