OpenDoor — OWASP-Web-Recon- und Directory-Discovery-Plattform

OpenDoor ist eine quelloffene CLI-Recon-Plattform für autorisierte Web-Reconnaissance, Verzeichnisermittlung, Subdomain-Enumeration, Fingerprints, WAF-Erkennung, Bypass-Erprobung, Antwortfilterung, Berichterstellung, Open-Redirect-Prüfungen, begrenztes Crawling und transportbasierte Scan-Workflows.

Es hilft Sicherheitsforschern, Penetrationstestern, Bug-Bounty-Jägern, DevSecOps-Ingenieuren und Entwicklern, offengelegte Pfade, Login-Panels, Verzeichnislisten, eingeschränkte Ressourcen, Backup-Dateien, Web-Shells, Subdomains und andere potenziell sensible Web-Assets zu identifizieren.

Verwenden Sie OpenDoor nur auf Systemen, die Ihnen gehören oder für die Sie ausdrücklich die Erlaubnis zum Testen haben.

✅ Projektstatus

Chocolatey Version

🧪 CI-Matrix

🚀 Schnellzugriff

✨ Funktionen

Verzeichnisermittlung;
rekursive Verzeichnisermittlung;
begrenztes Same-Origin-Crawling;
Folgen von Weiterleitungen;
Subdomain-Enumeration;
Multithreading-Scans für schnellere Abfragen;
Eingabemodi für einzelnes Ziel, Zieldatei, stdin, IPv4-CIDR und IPv4-Bereich;
benutzerdefinierte Wortlisten, Präfixe, Mischen zur Vermeidung von Scan-Mustern und Erweiterungsfilter, Unterstützung für entfernte Wortlisten;
benutzerdefinierte Anforderungsheader, Cookie-Weiterleitung und rohe HTTP-Anforderungsvorlagen;
Antwortfilter nach Status, Größe, Text, Regex und Body-Länge;
Antwort-Sniffer zur Erkennung von Verzeichnislisten, leeren Antworten, bekannten Datei-Expositionen, aktiven Shadow-Copy-Probes, Kollation, möglichen offengelegten Geheimnissen, clientseitig exponierten Endpunkten, Fehlern, offengelegten Debug-Stacktraces und verifizierten Open-Redirect-Schwachstellen;
intelligente Auto-Kalibrierung für Soft-404-, Wildcard-, Catch-all-, semantische Antwort-Diff- und DNS-Wildcard-Fälle;
Technologie-Fingerprint-Erkennung für CMS, E-Commerce-Plattformen, Frameworks, Laufzeit-Stacks, Infrastruktur und HSTS-Status;
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-Abbruchbedingung zum Beenden von Scans mit geringem Wert, wenn die anfänglich klassifizierten Antworten überwiegend WAF-blockiert sind;
kontrollierte Header- und Pfad-Bypass-Probes für blockierte 401- und 403-Ressourcen;
fehlertolerante Scan-Laufzeit mit Wiederholungen, Fail-Streak-Schutz, Behandlung von Transportfehlern, fortsetzbaren Sitzungen und Laufzeit-Pause/Fortsetzen-Steuerung;
CI/CD-Regeln zum Fehlschlagen bei Ergebnis-Buckets;
differenzielle Berichtsvergleiche für frühere/aktuelle JSON- oder SQLite-Berichte;
Berichte im Terminal-, Text-, JSON-, CSV-, HTML-, SARIF- und SQLite-Format;
Unterstützung für Proxy-, OpenVPN-, WireGuard-, Legacy-TLS- und mTLS-Client-Zertifikat-Transport;
sequentielle Transportrotation pro Ziel für Batch-Workflows;
Konfigurationsassistent für wiederholbare Scan-Profile;

🧭 Wo ist OpenDoor sinnvoll?

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-Ziel-Batches und transportgesteuerte Scans. Seit seinem ersten Start im Jahr 2016 bis heute hat sich OpenDoor dramatisch verändert und sich von einem primitiven Brute-Forcer zu einem neuen adaptiven Discovery-Framework entwickelt. Es ist DevOps- und QA-freundlich geworden. OpenDoor konzentriert sich auf kontextbewusste Discovery anstelle von blinder Enumeration.

Was OpenDoor anders macht

🧬 Erkannte Technologien

OpenDoor enthält eine heuristische Fingerprint-Engine zur Erkennung wahrscheinlicher Anwendungs-Stacks, CMS-Plattformen, Frameworks, Website-Baukästen, Static-Site-Tools, Infrastrukturanbieter, HSTS-/Preload-Bereitschaft und WAF-/Anti-Bot-Systeme.

Vollständige Liste der unterstützten Technologien: Fingerprinting-Technologien

Fingerprint-Erkennung ausführen:```bash opendoor --host https://example.com --fingerprint

Nachdem der Fingerprint-Durchlauf abgeschlossen ist, druckt OpenDoor eine kompakte Vorscan-Zusammenfassung, bevor die Wörterbuch-Enumeration beginnt:```text
Fingerprint result: cms/WordPress (95%)
Web stack: WordPress | PHP | Cloudflare
Security posture: HSTS preload-ready

Mehr erfahren:

📦 Installation

pipx

Empfohlen für die meisten CLI-Benutzer:```bash pipx install opendoor

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

Windows / Chocolatey

OpenDoor ist über das 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 Docker-Image des Projekts über das 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 dem 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

See the full [installation guide](https://opendoor.readthedocs.io/Installation-and-update/).

---

## 🚀 Schnelle Verwendung

### Grundlegender Verzeichnisscan```bash
opendoor --host https://example.com

Same-Origin-Links crawlen```bash

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

`--crawl` ist ein Opt-in und funktioniert nur bei Verzeichnisscans. Es verwendet `GET`, extrahiert konservative HTML-Attribute aus bereits gescannten Antworten, behält nur URLs mit gleicher Origin, respektiert ignorierte Erweiterungen, überspringt POST-Formulare und externe Origins 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

Das gleiche gemischte Zielformat wird über STDIN unterstützt.

### Rauscharmer Scan```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

Antwort-Sniffer

Antwort-Sniffer klassifizieren interessante Antwortkörper während der Erkundung. 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 sind:

| Sniffer             | Purpose                                                                                                                             |
|---------------------|-------------------------------------------------------------------------------------------------------------------------------------|
| `indexof`           | Verzeichnislisten-Seiten erkennen.                                                                                                  |
| `file`              | Bekannte Muster für exponierte sensible Dateien erkennen.                                                                           |
| `collation`         | Erkennt wiederholte oder redirect-ähnliche Fallback-Antworten, die Fehlalarme erzeugen können.                                      |
| `skipempty`         | Leere Antworten überspringen.                                                                                                       |
| `skipsizes=46`      | Antworten mit exakten bekannten Rauschgrößen überspringen.                                                                          |
| `skipsizes=46:1024` | Antworten innerhalb eines Rauschgrößenbereichs überspringen.                                                                        |
| `stacktrace`        | Exponierte Debug-/Laufzeit-Stacktraces und interne Fehlerdetails erkennen.                                                          |
| `secret`            | Mögliche exponierte API-Schlüssel, Tokens, private Schlüssel und Zugangsdaten erkennen, mit geschwärzten Berichtsmetadaten.        |
| `shadow`            | Bestätigte `200 OK`-dateiartige Treffer aktiv auf begrenzte Backup-/Shadow-Varianten wie `.bak`, `.old` und Pfadvorlagen . prüfen. |
| `openredirect`      | Redirect-ähnliche Query-Parameter mit kontrollierten Marker-URLs aktiv verifizieren und nur bestätigte Open-Redirect-Schwachstellen melden. |
| `endpoint`          | Client-exponierte WebSocket-, Socket.IO-, SSE/EventSource- und AJAX-Endpunkte passiv aus bereits abgerufenen Antworten erkennen.   |
| `malware`           | Mögliche schädliche Inhalte, Webshell-Marker, injizierte Skripte oder verschleierte Payloads erkennen.                              |

Body-abhängige Sniffer erzwingen intern automatisch `GET`, wenn die konfigurierte Methode `HEAD` ist.

Weiterlesen: [Sniffers-Referenz](https://opendoor.readthedocs.io/Sniffers/)

### Authentifizierter Scan aus einer rohen 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, vorübergehende WAF-Sperren, 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 erschöpfte Pfade begrenzt, Soft-404- und Catch-all-Antworten mit automatischer Kalibrierung herausfiltert, minderwertige Scans stoppt, wenn WAF-blockierte Antworten dominieren, und Checkpoint-Zustand für eine spätere Fortsetzung speichert.

Scan später fortsetzen:```bash opendoor --session-load session.json

Drücken Sie während eines aktiven Scans einmal `Ctrl+C`, um die Worker anzuhalten, und wählen Sie dann `C` zum Fortsetzen oder `E` zum Abbrechen.

### Header- und Pfad-Bypass-Tests

Verwenden Sie dies nur auf Systemen, die Sie testen dürfen. Die Funktion ist eine Opt-in-Funktion und testet 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 angehängten Schrägstrich, Punktsegment, Semikolon-Suffix, Groß-/Kleinschreibungsvariation und URL-kodiertes Segment. Passen Sie Trigger-Statuscodes, 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

Verwenden Sie einen einzelnen expliziten Proxy:```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 zeigen. Wenn ein GUI-Client oder ein Unternehmens-VPN-Agent den Tunnel bereits verwaltet, starten Sie dieses VPN außerhalb von OpenDoor und führen Sie OpenDoor im direkten Modus aus.

WireGuard-Transport```bash

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

Mehr Beispiele:

- [Grundlegende Scans](https://opendoor.readthedocs.io/examples/basic-scans/)
- [Stapel-Scans](https://opendoor.readthedocs.io/examples/batch-scans/)
- [Authentifizierte Scans](https://opendoor.readthedocs.io/examples/authenticated-scans/)
- [WAF-sichere 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-Beispiele](https://opendoor.readthedocs.io/examples/ci-cd/)

---

### Vergleich von Differenzberichten

OpenDoor kann genau zwei frühere/aktuelle Berichte vergleichen, ohne einen neuen Scan auszuführen. Verwenden Sie dies, wenn Sie sehen möchten, was zwischen zwei autorisierten Scan-Ergebnissen erschienen, 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 verständlichen 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 Sicherheits-Pipelines 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

Hands-on-Artikelserie zum Erlernen von OpenDoor durch reproduzierbare, autorisierte Web-Reconnaissance-Workflows.

OpenDoor

📚 Dokumentation

Die vollständige Dokumentation ist auf ReadTheDocs verfügbar:

🧪 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

Run-Abdeckung:```bash coverage run -m unittest discover -s tests -p "test_*.py" coverage report -m

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

Paketartefakte erstellen:```bash python -m build

Siehe den vollständigen [Testleitfaden](https://opendoor.readthedocs.io/Testing/) und [Beitragsleitfaden](https://opendoor.readthedocs.io/Contribution/).

---

## 🔐 Sicherheit und Geheimnishygiene

Committen Sie keine echten Geheimnisse oder privaten Transportprofile.

Veröffentlichen Sie niemals:

- echte OpenVPN-Profile;
- private WireGuard-Schlüssel;
- mTLS-Clientzertifikate und private Schlüssel;
- auth-user-pass-Dateien;
- Cookies;
- Bearer-Tokens;
- Kunden-Ziellisten;
- private Scan-Berichte;
- sensible CI-Artefakte.

Verwenden Sie ausschließlich Platzhalterbeispiele.

---

## ⚖️ Verantwortungsvolle Nutzung

OpenDoor ist ein Sicherheitstestwerkzeug.

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, Wiedergabe roher Anfragen, Transportprofile und Header-Injection-Bypass-Sonden sind für autorisierte Sicherheitstests, defensive Validierung und Regressionsprüfungen von Exponierungen gedacht.

Das Projekt erteilt keine Genehmigung, Systeme Dritter, Organisationen, kommerzielle Dienste oder öffentliche Infrastruktur ohne Autorisierung zu scannen.

---

## 🧾 Changelog

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

---

## 🤝 Mitwirken

Pull-Requests sind willkommen.

Bevor Sie beitragen, lesen Sie den [Beitragsleitfaden](https://opendoor.readthedocs.io/Contribution/) und führen Sie die relevanten Tests aus.
OpenDoor verbessert sich durch Code-Beiträge, Dokumentationsaktualisierungen, Tests, Fehlerberichte, Sicherheitsfeedback, Feature-Ideen und Community-Validierung.
Danke an alle, die dazu beigetragen haben, das Projekt zu verbessern.

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

---

## 📄 Lizenz

OpenDoor wird ausschließlich unter der GNU General Public License v3.0 veröffentlicht.

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

---

## Unterstützung

Wenn OpenDoor Ihnen bei Ihrer autorisierten Sicherheitsarbeit hilft, können Sie die laufende Wartung über Giveth unterstützen.

[OpenDoor auf Giveth unterstützen](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)

Fingerprint-first-Scanning	OpenDoor kann wahrscheinliche CMS-Plattformen, Frameworks, Infrastrukturanbieter und WAF-Signale vor der tieferen Discovery identifizieren. Das hilft Ihnen, mit Kontext zu scannen, anstatt 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 laute blockierte Scans reduziert und defensive Antworten leichter verständlich werden.
WAF-Guard-Abbruchbedingung	OpenDoor kann einen Scan frühzeitig beenden, wenn die anfänglich klassifizierten Antworten überwiegend WAF-blockiert sind. Das vermeidet lange Läufe mit Wortlisten, die nur wiederholte Edge-/WAF-Blockseiten erzeugen.
Kontrollierte Bypass-Nachweise	OpenDoor kann optional blockierte `401`- und `403`-Ressourcen mit kontrollierten Header-Injection- und Pfadmanipulationsvarianten testen. Es zeichnet genaue Nachweise auf, z. B. Bypass-Typ, Header- oder Pfadvariante, Probe-Wert, ursprünglichen Statuscode und resultierenden Statuscode, ohne globale Scan-Header zu verändern.
Auto-Kalibrierung über mehrere Signale	OpenDoor verlässt sich nicht nur auf Statuscode oder Antwortgröße. Es vergleicht mehrere Antwortsignale wie Body-Hashes, sichtbaren Text, semantische Soft-404-Phrasen, DOM-Token-Struktur, Titel, Weiterleitungen, stabile Header, Wortanzahl, Zeilenanzahl, Textdichte, normalisierte dynamische Token und DNS-Wildcard-Baselines, um Soft-404- und Wildcard-Fehlerkennungen zu reduzieren.
Begrenztes Same-Origin-Crawling	`--crawl` kann Verzeichnisscans mit One-Hop-Same-Origin-Links anreichern, die in bereits gescannten HTML-Antworten gefunden wurden. Es nutzt die bestehende Scan-Pipeline, globale Anforderungsdeduplizierung, Deduplizierung pro Berichts-Bucket und begrenzte Speicherobergrenzen, anstatt zu einem Spider oder Browser-Renderer zu werden.
Plugin-System für heuristische Sniffer	OpenDoor enthält eine pluggbare Antwortanalyse-Ebene für heuristische Sniffer wie Secrets, Stacktraces, Verzeichnislisten, Malware-Indikatoren, Shadow Copies, verdächtige Dateien, offene Weiterleitungen und wiederholte Soft-Fehler-Vorlagen. Dadurch können Scans aussagekräftige Nachweise aus Antwortkörpern an die Oberfläche bringen, anstatt nur Statuscodes und Größen zu melden.
Transportebenen-Workflows	OpenDoor unterstützt direkte, Proxy-, OpenVPN- und WireGuard-Transportmodi. Es kann auch 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` nutzen, verfügbare Proxys vor dem Scannen validieren und Anforderungen über den Live-Pool rotieren. Das hilft langen autorisierten Scans, unzuverlässige Routen zu überstehen, ohne einen einzelnen Proxy-Endpunkt fest zu codieren.
Fehlertolerante Scan-Laufzeit	OpenDoor ist darauf ausgelegt, Scans auf instabilen Zielen und unzuverlässigen Netzwerken nützlich zu halten. Es kombiniert Anforderungswiederholungen, Schutz bei aufeinanderfolgenden Fehlern, Behandlung behebbarer Transportfehler, Proxy-Rotation, WAF-bewusste Abbruchbedingungen, Checkpoint-Sitzungen und interaktive Pause/Fortsetzen-Steuerung, sodass lange Scans sicher fehlschlagen können, anstatt 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-Ziel-Aufträge unterbrochen werden.
Pause/Fortsetzen zur Laufzeit	Drücken Sie während eines Scans einmal `Ctrl+C`, um Worker anzuhalten, und wählen Sie dann `C` zum Fortsetzen oder `E` zum Abbrechen, ohne Sitzungsdateien einzubeziehen.
Differenzielle Berichtsvergleiche	OpenDoor kann mit `--diff old:new` einen früheren und einen aktuellen SQLite/JSON-Bericht vergleichen und hinzugefügte, entfernte und geänderte Ergebnisse anzeigen, ohne das Ziel erneut zu scannen. Das macht Scan-Berichte zu Belichtungs-Regressionstests von Release zu Release.
CI/CD-taugliche Ergebnisse	OpenDoor kann nur dann einen Fehler-Exitcode zurückgeben, wenn ausgewählte Ergebnis-Buckets gefunden werden, was es ohne benutzerdefinierte Nachbearbeitungsskripte als Release-Gate oder Belichtungs-Regressionsprüfung nutzbar macht.
Auditierbare Entwicklung	OpenDoor wird mit Multi-Plattform-CI, Coverage-Prüfungen, Paketprüfungen, Dokumentations-Builds und einer großen Unittest-Suite gepflegt, was die Prüfung, Mitwirkung und Abhängigkeit erleichtert.

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
Laufzeit-/Sprach-Stack	PHP, Node.js, JavaScript, Python, Ruby, .NET, Java/JVM, Elixir, Static-Site-Ziele
Website-Baukästen	Wix, Webflow, Squarespace, Tilda, Duda, Hostinger Website Builder
Static-/Doku-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
Sicherheits-Header	HSTS-Präsenz, max-age, includeSubDomains, Preload-Direktive, lokale Preload-Bereitschaft