discover

Custom bash scripts used to automate various penetration testing tasks including recon, scanning, 
enumeration, and malicious payload creation using Metasploit. For use with Kali Linux or Ubuntu.

* Wählen Sie **Update** (Hauptmenü-Option 16), um das Betriebssystem zu aktualisieren und Abhängigkeiten (`ffuf`, `feroxbuster`, `jq`, etc.) zu installieren.
* Dev-Scanner befinden sich unter `dev/` und sind ebenfalls über die Hauptmenü-Option **15. Dev** erreichbar.
* Einige Optionen erfordern Root-Berechtigungen zur Ausführung.

### Hauptmenü```
RECON
1.  Domain
2.  Person

SCANNING
3.  Generate target list
4.  CIDR
5.  List
6.  IP, range, or URL
7.  Rerun Nmap scripts and MSF aux

WEB
8.  Insecure direct object reference
9.  Open multiple tabs in Firefox
10. Nikto
11. SSL

MISC
12. Parse XML
13. Generate a malicious payload
14. Start a Metasploit listener
15. Dev
16. Update
17. Exit

Bitte fügen Sie den zu übersetzenden Markdown-Inhalt ein.```
dev/
├── api-scanner.sh
├── cloud-scanner.sh
├── container-scanner.sh
├── oauth-jwt-scanner.sh
├── open-redirect.sh
├── sensitive-scanner.sh
├── waf-detect.sh
├── web-api-scanner.sh
├── data/
│   ├── api-paths.txt
│   ├── openredirect-payloads.txt
│   ├── sensitive-denylist.txt
│   ├── sensitive-patterns.tsv
│   ├── sensitive-skip-paths.txt
│   ├── sensitive-web-paths-quick.txt
│   ├── sensitive-web-paths-full.txt
│   ├── waf-aliases.tsv
│   ├── waf-labels.tsv
│   ├── waf-signatures.tsv
│   ├── web-api-phases.tsv
│   ├── web-api-tech-signatures.tsv
│   └── swagger-paths.txt
└── lib/
    ├── api-scanner/
    │   └── common.sh
    ├── cloud-scanner/
    │   ├── common.sh
    │   ├── aws.sh
    │   ├── azure.sh
    │   └── gcp.sh
    ├── container-scanner/
    │   ├── common.sh
    │   ├── docker.sh
    │   └── k8s.sh
    ├── oauth-jwt-scanner/
    │   ├── common.sh
    │   ├── oauth.sh
    │   └── jwt.sh
    ├── open-redirect-scanner/
    │   ├── common.sh
    │   └── engine.py
    ├── sensitive-scanner/
    │   ├── common.sh
    │   ├── files.sh
    │   ├── web.sh
    │   ├── filescan.py
    │   ├── engine.py
    │   ├── fixtures/
    │   └── run-tests.sh
    ├── waf-detect/
    │   ├── common.sh
    │   ├── probe.sh
    │   ├── fixtures/
    │   └── run-tests.sh
    └── web-api-scanner/
        ├── common.sh
        ├── phases.sh
        ├── waf.sh
        ├── targets.sh
        ├── msf.sh
        ├── msf_parse.py
        ├── probe.sh
        ├── fixtures/
        └── run-tests.sh

Note: Passive und Active können nicht als root ausgeführt werden.

PASSIVE RECON

Verwendet Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder,
sublist3r, theHarvester, Whois und mehrere Websites.

* Holen Sie sich alle kostenlosen API-Schlüssel für maximale Ergebnisse mit theHarvester.
* Fügen Sie API-Schlüssel zu $HOME/.theHarvester/api-keys.yaml hinzu.
* Passive erstellt einen HTML-Bericht unter $HOME/data/<domain>/.
* Findet registrierte Domains und aktualisiert pages/registered-domains.htm in einem vorhandenen Bericht.
* Active verwendet httpx, whatweb und gowitness; ein optionaler NVD-API-Schlüssel beschleunigt die CVSS-Anreicherung im Active-Bericht (siehe **NVD API key** unten).

#### Namen importieren (`import-names.sh`)

Führen Sie dies nach einem passiven Scan aus, wenn Sie Kontakte aus manueller Recherche hinzufügen oder anreichern möchten (LinkedIn, Unternehmenswebsites, Telefonverzeichnisse usw.).```
Enter the location of your previous passive scan:
/home/user/data/example.com

Enter manual contacts file (or press Enter for default):

Unterstützte Importe:

* `firefox` — `pinia/scans` aus Ihrem Firefox-Profil abrufen (kostenlose Pentest-Tools-Scans)
* Firefox `pinia/scans`-Export (`pinia-scans.json`)
* Pentest-Tools-JSON (`pentest-tools-<domain>.json`)
* Pentest-Tools-Text-Export (`pentest-tools.txt`)
* Tabulatorgetrennte Host/IP-Zeilen

* Bearbeiten Sie `$HOME/data/<domain>/tools/subdomains-import.tsv` für manuelle Einträge
* Format: Subdomain, IP (tabulatorgetrennt; IP optional)
* Hosts ohne IP werden während des Imports mit `dig` aufgelöst
* Führen Sie Import von Subdomains erneut aus, wenn Sie Zeilen hinzufügen oder einen neuen Pentest-Tools-Scan durchführen

Import von Subdomains führt eine Zusammenführung mit vorhandenen `tools/subdomains` durch, weist Kategorien aus `old/subdomain-categories.tsv` zu, teilt private IPs in `tools/private-subs` auf und aktualisiert `pages/subdomains.htm` mit den Spalten Subdomain, Kategorie und IP. Führen Sie anschließend **Active** aus, um die Spalten Photo, Status, Web Server und Technologien zu füllen.

#### Active (`active.sh`)

AKTIVE AUFKLÄRUNG

Führen Sie dies nach einem passiven Scan (und optional nach Import von Subdomains) aus, wenn Sie testen möchten, welche öffentlichen Hosts über HTTP/HTTPS antworten, Technologien identifizieren und Screenshots erfassen möchten.```
Enter the location of your previous passive scan:
/home/user/data/example.com

**Kostenlosen API-Schlüssel erhalten**

1. Schlüssel anfordern: https://nvd.nist.gov/developers/request-an-api-key
2. Die von NIST gesendete E-Mail bestätigen
3. Den Schlüssel an Discover weitergeben (Shell-Export und/oder private `.env` — siehe unten)

**Wie Discover den Schlüssel findet**

Reihenfolge der Priorität (nicht-leere Werte weiter oben gewinnen immer):

1. Shell-Umgebung — `export NVD_API_KEY=...`
2. Private `.env` im Discover-Installationsverzeichnis — `$DISCOVER/.env`
3. Private `.env` in Ihrer Home-Konfiguration — `~/.discover/.env`

Beispiel für eine `.env`-Zeile (keine Anführungszeichen erforderlich):```
NVD_API_KEY=your-key-here

(z. B. `~/discover/resource/known_exploited_vulnerabilities.json`)

Quelle: https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json  
Katalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Falls der Download fehlschlägt, bleibt ein vorheriger lokaler Katalog erhalten. Die Datei wird
gitignored (durch Update aktualisiert, nicht committet).

In der aktiven Tabelle **Software-Versionen** bevorzugt **Top CVE** einen CISA KEV-Treffer,
wenn einer der NVD-CVEs des Produkts im KEV-Katalog erscheint (höchster CVSS unter den KEVs
gewinnt). Andernfalls ist Top CVE das NVD-Ergebnis mit der höchsten CVSS-Bewertung. KEV-Auswahlen
zeigen ein orangefarbenes **KEV**-Abzeichen neben der verlinkten CVE-ID.

#### SEC-Führung (Seite Names)

Für börsennotierte US-Unternehmen ruft Discover Führungskräfte und Vorstandsmitglieder von SEC
EDGAR ab, bevor der Schritt des Namensabgleichs erfolgt:

1. **DEF 14A** — Text der Vollmachtserklärung und Vorstandstabellen für vollständige Titel
2. **Form 4** — aktuelle Insider-Meldungen zur Ergänzung von Führungskräften und Vorstandsmitgliedern

* Ergebnisse werden in zsec-people geschrieben und mit den bestehenden Spalten Name, Titel, Telefon
  in tools/names zusammengeführt (Telefon bleibt leer).
* SEC-Einreichungen enthalten keine geschäftlichen E-Mail-Adressen oder personenbezogene Telefonnummern.
* Das Layout der Seite 'Names' bleibt unverändert – es wird keine E-Mail-Spalte hinzugefügt.
* Manuelle Überschreibung: tools/sec-people-manual.tsv (tabstoppgetrennt: Name, Titel, Telefon).

#### Firmenzentrale (Seite Summary)

Während der passiven Erkundung versucht Discover, den Adress- und Telefonblock auf
pages/summary.htm zwischen Firmenname und Domain zu füllen.

1. **SEC EDGAR 10-K** — für börsennotierte US-Unternehmen werden die Felder des Hauptgeschäftssitzes
   aus dem aktuellsten 10-K ausgelesen (Inline-XBRL `dei:`-Tags).
2. **Website-Footer** — falls kein SEC-Treffer vorliegt, wird der gecachte Homepage-Footer
   (und Kontaktseiten) nach Adress-/Telefonmustern durchsucht.
3. **Manuelle Überschreibung** — Einträge in tools/company-manual.tsv hinzufügen, wenn die Erkennung
   falsch oder blockiert ist.

Ergebnisse werden in tools/company.json geschrieben und in pages/summary.htm eingefügt.

#### Soziale Medien (Seite Summary)

Während der passiven Erkundung ruft Discover die Firmen-Homepage ab und extrahiert offizielle
Social-Profile-Links (Facebook, Instagram, LinkedIn, X, YouTube). Anschließend wird versucht,
die Anzahl der Follower aus jedem Profil abzurufen.

* Ergebnisse werden in tools/social.tsv geschrieben und in pages/summary.htm eingefügt.
* Wenn eine Plattform das Scraping blockiert, zeigt die Follower-Anzahl **Blockiert** an.
* Wenn die Homepage von Bots blockiert wird, fügen Sie URLs in tools/social-manual.tsv hinzu
  (tabstoppgetrennt: Plattform, URL) vor oder nach dem Scan.

### Person```
RECON

First name:
Last name:

* Verwenden Sie verschiedene Tools, um eine Zielliste zu erstellen, darunter Angry IP Scanner, arp-scan, netdiscover und Nmap pingsweep.

### CIDR, Liste, IP, Bereich, oder URL```
Type of scan:

1.  External
2.  Internal
3.  Previous menu

### Mehrere Tabs in Firefox öffnen```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
Beispiele:
* Eine Liste mit mehreren IPs und/oder URLs.
* Sie haben mehrere Websites mit Nikto gescannt und möchten jeden htm-Bericht in einem Verzeichnis öffnen.
* Verwenden Sie wget, um die robot.txt-Datei einer Domain herunterzuladen, und öffnen Sie dann alle Verzeichnisse.

### Nikto```
This option cannot be ran as root.

Run multiple instances of Nikto in parallel.

1.  List of IPs
2.  List of IP:port
3.  Previous menu
```
### SSL```
Check for SSL certificate issues.

List of IP:port.


Enter the location of your file:
```
* Verwendet sslscan, sslyze und Nmap, um SSL/TLS-Zertifikatsprobleme zu überprüfen.

## MISC
### XML parsen```
Parse XML to CSV.

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### Erzeuge eine bösartige Nutzlast```
Malicious Payloads

1.   android/meterpreter/reverse_tcp         (.apk)
2.   cmd/windows/reverse_powershell          (.bat)
3.   java/jsp_shell_reverse_tcp (Linux)      (.jsp)
4.   java/jsp_shell_reverse_tcp (Windows)    (.jsp)
5.   java/shell_reverse_tcp                  (.war)
6.   linux/x64/meterpreter_reverse_https     (.elf)
7.   linux/x64/meterpreter_reverse_tcp       (.elf)
8.   linux/x64/shell/reverse_tcp             (.elf)
9.   osx/x64/meterpreter_reverse_https       (.macho)
10.  osx/x64/meterpreter_reverse_tcp         (.macho)
11.  php/meterpreter_reverse_tcp             (.php)
12.  python/meterpreter_reverse_https        (.py)
13.  python/meterpreter_reverse_tcp          (.py)
14.  windows/x64/meterpreter_reverse_https   (multi)
15.  windows/x64/meterpreter_reverse_tcp     (multi)
16.  Previous menu
```
### Metasploit-Listener starten```
Metasploit Listeners

1.   android/meterpreter/reverse_tcp
2.   cmd/windows/reverse_powershell
3.   java/jsp_shell_reverse_tcp
4.   linux/x64/meterpreter_reverse_https
5.   linux/x64/meterpreter_reverse_tcp
6.   linux/x64/shell/reverse_tcp
7.   osx/x64/meterpreter_reverse_https
8.   osx/x64/meterpreter_reverse_tcp
9.   php/meterpreter/reverse_tcp
10.  python/meterpreter_reverse_https
11.  python/meterpreter_reverse_tcp
12.  windows/x64/meterpreter_reverse_https
13.  windows/x64/meterpreter_reverse_tcp
14.  Previous menu
```
### Update (Hauptmenü Option 16)

* Aktualisiert das Betriebssystem, führt git pull von verschiedenen Repos durch und aktualisiert die locate-Datenbank.
* Installiert Werkzeuge, die von Dev-Scannern verwendet werden (z.B. `ffuf`, `feroxbuster`, `jq`, `trivy`).

## DEV

Scan-Ergebnisse werden unter `$HOME/data/` geschrieben, sofern nicht anders angegeben. Dev-Scanner erstellen **eigenständige Berichte** in ihren eigenen Ausgabeverzeichnissen (`api-scan_*`, `cloud-scan_*`, usw.). Sie beziehen `discover.sh` für Menü-Hilfsfunktionen und Farben, wenn nötig, **schreiben aber nicht** in oder aktualisieren Discover's Recon-HTML-Bericht (`report.sh`, `$NAME`, `pages/*.htm`).

### API-Sicherheitsscanner (`dev/api-scanner.sh`)

Phasenweise API-Erkennung und Sicherheitstests. Gemeinsame Hilfsfunktionen und Wortlisten befinden sich in `dev/lib/api-scanner/` und `dev/data/`.

**Interaktives Menü**```
1. API Discovery and Testing (full)
2. API Quick Scan (discovery + docs)
3. JWT Token Analysis
4. Full API Assessment (orchestrated)
5. Previous menu
```
**CLI** (überspringt das Menü, wenn `-u` gesetzt ist):```
./dev/api-scanner.sh -u https://target.example --quick --authorized
./dev/api-scanner.sh -u https://target.example --full --token 'eyJ…' --authorized
./dev/api-scanner.sh --resume ~/data/api-scan_20260703-1200 -u https://target.example
./dev/api-scanner.sh -u https://target.example --orchestrate --authorized
./dev/api-scanner.sh --help
```
| Flagge | Zweck |
|------|---------|
| `--quick` | Nur Erkennung und Dokumentation |
| `--full` | Alle Phasen (Standard) |
| `--orchestrate` | Vollständiger Scan, dann Aufforderung für verwandte Scanner |
| `--token` | Bearer-Token für authentifizierte Anfragen |
| `--cookie-file` | Netscape-Cookie-Jar |
| `--max-parallel N` | Gleichzeitige Arbeiter (Standard: 3) |
| `--max-endpoints N` | Begrenzung der nach dem Zusammenführen getesteten Endpunkte |
| `--skip PHASE` | Eine Phase überspringen (wiederholbar) |
| `--resume DIR` | Fortsetzung mit einem vorhandenen Ausgabeverzeichnis |
| `--authorized` | Die Autorisierungsbestätigungsabfrage überspringen |
| `--aggressive-http` | TRACE-/CONNECT-Methodentests einschließen |

**Phasen (voller Scan):** HTML/JS-Link-Extraktion, ffuf/feroxbuster-Fuzzing, Pfad-Erkundung, OpenAPI/Swagger-Erkennung, GraphQL-Tests (Introspektion, Tiefe, Batching), CORS (GET + Preflight), HTTP-Methodenprüfungen, Rate-Limit-Burst, JWT-Analyse.

**Ausgabe:** `$HOME/data/api-scan_<timestamp>/api_scanner/`

* `report.txt` und `report.md` — scanner-lokale Ergebnisse (nicht in den Discover-Recon-Bericht eingefügt)
* `findings.json` — konsolidierter JSON-Export aller Ergebnisse
* `findings_registry.tsv` — tabstopp-getrenntes Ergebnisprotokoll (Quelle für JSON-Export)
* `scan.log` — Anforderungsauditprotokoll
* `.checkpoint/` — Fortsetzungsmarkierungen pro Phase

Erfordert `curl` und `jq`. Verwendet `ffuf` oder `feroxbuster`, wenn installiert (Installation über Discover **Update**). Quelle `discover.sh` bei direktem Ausführen für `f_banner` / Menü-Helfer.

### Cloud Security Scanner (`dev/cloud-scanner.sh`)

Phasenweise Cloud-Fehlkonfigurationsprüfung für AWS, Azure und GCP. Gemeinsame Helfer befinden sich in `dev/lib/cloud-scanner/`.

**Interaktives Menü**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (überspringt das Menü, wenn Provider-Flags gesetzt sind):```
./dev/cloud-scanner.sh --aws --quick
./dev/cloud-scanner.sh --azure --gcp --full
./dev/cloud-scanner.sh --aws --output-dir ~/data/cloud-scan_custom
./dev/cloud-scanner.sh --resume ~/data/cloud-scan_20260704-1200 --aws
./dev/cloud-scanner.sh --help
```
| Flagge | Zweck |
|------|---------|
| `--aws` / `--azure` / `--gcp` | Einen Anbieter ausführen (für mehrere kombinieren) |
| `--quick` | Auf Exposition fokussierte Prüfungen (öffentlicher Zugriff, MFA, offener Ingress) |
| `--full` | Umfassendes Audit mit IAM-Tiefenanalyse, Multi-Region-EC2/SG, Extras |
| `--output-dir DIR` | Benutzerdefiniertes Ausgabeverzeichnis |
| `--resume DIR` | Fortsetzen mit einem vorhandenen Scan-Verzeichnis (überspringt abgeschlossene Phasen) |
| `-h`, `--help` | Nutzung anzeigen |

Ergebnisse werden geschrieben unter `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (oder `--output-dir`):

* `findings_registry.tsv` — Schweregrad, Anbieter, Dienst, Ressource, Prüfung, Detail, Nachweis
* `findings.json` — konsolidierter JSON-Export aller Ergebnisse
* `report.txt` / `report.md` — scannereigene Zusammenfassung (nicht in Discover-Recon-Bericht eingefügt)
* `scan.log` — API-Aktivitäten und Ergebnisprotokoll
* `.checkpoint/` — Phasenmarkierungen für `--resume`

Erfordert `jq` und das entsprechende Cloud-CLI (`aws`, `az`, `gcloud`/`gsutil`) mit bereits konfigurierten Anmeldedaten vor dem Scannen. Der Scanner installiert keine CLIs automatisch und führt kein interaktives `aws configure` / `gcloud init` aus. Wenn er direkt ausgeführt wird, bezieht er `discover.sh` ein für `f_banner` / Menühilfen.

### Container-Sicherheitsscanner (`dev/container-scanner.sh`)

Umfassende Docker- und Kubernetes-Sicherheitsbewertung mittels Trivy, Docker und kubectl. Eigenständige Ausgabe unter `$HOME/data/container-scan_*` (aktualisiert keine Discover-Recon-HTML-Berichte).

* **Docker-Images** — Trivy-Schwachstellen-/Geheimnis-/Konfigurationsscan, SBOM (voller Modus), Dockerfile-Analyse
* **Docker-Container** — privilegierter Modus, Mounts, Capabilities, Laufzeitprüfungen (voller Modus)
* **Kubernetes** — RBAC, NetworkPolicies, PSS-Labels, veraltete APIs, Pod-Sicherheit

**Scan-Typen:** `docker-images`, `docker-containers`, `kubernetes` oder `all` (Standard, wenn aus Discover-Menü gestartet).

**CLI-Optionen:** `--quick`, `--full`, `--output-dir`, `--resume`, `--dockerfile-root`, `--include-ns`, `--exclude-ns`, `--trivy-jobs`, `--menu`, `-h`

**Ausgabeartefakte:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**Abhängigkeiten:** `docker`, `kubectl` (Kubernetes-Scan), `trivy`, `jq`, `numfmt` — Installation über Discover Update; keine automatische Installation.

**Umgebungsvariablen:** `CONTAINER_OUTPUT_DIR`, `CONTAINER_DOCKERFILE_ROOT`, `CONTAINER_SCAN_MODE`, `CONTAINER_EXCLUDE_NS`

### OAuth- und JWT-Sicherheitsscanner (`dev/oauth-jwt-scanner.sh`)

OAuth/OIDC-Erkennung, Live-Authorize-Probes, Offline-JWT-Analyse und optionale Live-Token-Verifizierung. Ergänzt die JWT-Prüfungen von `api-scanner.sh`. Eigenständige Ausgabe unter `$HOME/data/oauth-jwt-scan_*`.

* **OAuth/OIDC** — Erkennungsmetadaten, JWKS, redirect_uri/state/PKCE/implicit-Probes
* **JWT offline** — alg=none, RS256→HS256-Konfusion, jku/x5u/kid-Angriffe, Claim-Hygiene, Privilegieneskalations-Payloads
* **JWT live** — optionale Bearer-Tests gegen `--jwt-endpoint` (automatisch ausgefüllt von userinfo, wenn entdeckt)

**Scan-Typen:** `oauth`, `jwt` oder `all` (kombiniert).

**Menü:** OAuth-Test, JWT-Test, kombinierter Scan oder vorheriges Menü.

**CLI-Beispiele:**```bash
./dev/oauth-jwt-scanner.sh --target https://app.example.com --full
./dev/oauth-jwt-scanner.sh --jwt 'eyJhbG...' --jwt-endpoint https://app.example.com/api/me
./dev/oauth-jwt-scanner.sh --target https://app.example.com --api-scan-dir ~/data/api-scan_20260101-1200 --all
```
**Optionen:** `--target`, `--jwt`, `--jwt-file`, `--api-scan-dir`, `--jwt-endpoint`, `--client-id`, `--redirect-uri`, `--quick`, `--full`, `--oauth`, `--jwt-only`, `--all`, `--output-dir`, `--resume`, `--menu`, `-h`

**Ausgabe:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`

**Abhängigkeiten:** `curl`, `jq`

### Open Redirect Scanner (`dev/open-redirect.sh`)

Fuzzt Redirect-Parameter (injiziert und mutiert bestehende Query-Parameter) mit konfigurierbaren Canary-Hosts. Erkennt 3xx `Location` (mit One-Hop-Follow), Meta-Refresh und JavaScript-/Body-Weiterleitungen. Der Vollmodus fügt POST- und Header-Probes hinzu. Der Bestätigungsdurchlauf verwendet einen zweiten Canary-Host, um Fehlalarme zu reduzieren. Python-Engine: `dev/lib/open-redirect-scanner/engine.py`; Payloads: `dev/data/openredirect-payloads.txt`. Eigenständige Ausgabe unter `$HOME/data/openredirect-scan_*`.

**Menü:** Einzelne URL, Domain, URL-Datei, erweiterte Optionen, vorheriges Scan-Verzeichnis oder vorheriges Menü.

**CLI-Beispiele:**```bash
./dev/open-redirect.sh --url https://app.example.com/login?next=/home --full
./dev/open-redirect.sh --domain example.com --quick
./dev/open-redirect.sh --scan-dir ~/data/api-scan_20260101-1200 --crawl --quick
./dev/open-redirect.sh --file ~/targets.txt --max-requests 500 --rps 5
```
**Optionen:** `--url`, `--domain`, `--file`, `--scan-dir`, `--wordlist`, `--canary-host`, `--quick`, `--full`, `--crawl`, `--workers`, `--delay`, `--rps`, `--max-requests`, `--no-confirm`, `--quiet`, `--output-dir`, `--resume`, `--menu`, `-h`

**Ausgabe:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `openredirect_engine/results.json`, `openredirect_engine/checkpoint.json`

**Abhängigkeiten:** `python3`, `requests` (Discover Update installiert `python3-requests`), `jq`

### Scanner für sensible Informationen (`dev/sensitive-scanner.sh`)

Sucht nach Geheimnissen, Anmeldeinformationen und personenbezogenen Daten (PII) in lokalen Dateien/Verzeichnissen und offengelegten Webpfaden. Bash-Orchestrierung plus Python-Engines: `filescan.py` (einzelner Dateidurchlauf) und `engine.py` (paralleles Web-Probieren). Musterdaten: `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`. Eigenständige Ausgabe unter `$HOME/data/sensitive-scan_*`.

* **Dateiscan** — ein Durchlauf pro Datei über `filescan.py`; Denylist, Skip-Globs, Entropiefilter, Luhn/SSN/TC-Validierung; optional `gitleaks` / `trufflehog` (`--external auto`)
* **Webscan** — parallele Worker/RPS, Checkpoint-Resume pro Pfad, robots-disallow- + Sitemap-Pfade, api-scanner-Endpunktimport, Soft-404-Schutz, Erkennung von Verzeichnislisten, tiefgehendes `filescan.py` auf HTTP-200-Inhalten
* **api-scanner-Hook** — Inline-Response-Prüfungen verwenden `filescan.py`; der Orchestrator kann `--all` automatisch mit Bearer-Token starten
* **Berichte** — deduplizierte `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`; `--no-store-content` / `--shred-content` für sicherere Artefakte

**Menü:** Datei oder Ordner, URL, Datei/Ordner + vorheriges Scan-Verzeichnis, URL + api-scan-Ausgabe oder vorheriges Menü.

**Beispiele:**```
./dev/sensitive-scanner.sh --path ./myapp --files --full
./dev/sensitive-scanner.sh --url https://app.example.com --web --quick --workers 8 --rps 5
./dev/sensitive-scanner.sh --url https://app.example.com --scan-dir ~/data/api-scan_20260101-1200 --all --quick --bearer-token "$TOKEN"
./dev/sensitive-scanner.sh --path /var/www/html/config.php --files --external gitleaks
./dev/lib/sensitive-scanner/run-tests.sh
```
**Optionen:** `--path`, `--url`, `--scan-dir`, `--wordlist`, `--quick`, `--full`, `--workers`, `--delay`, `--rps`, `--max-paths`, `--bearer-token`, `--insecure`, `--no-store-content`, `--shred-content`, `--redact-emails`, `--entropy-min`, `--external`, `--files`, `--web`, `--all`, `--output-dir`, `--resume`, `--quiet`, `--menu`, `-h`

**Ausgabe:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `sensitive_info/`, `web_sensitive/engine/{results,checkpoint}.json`

**Abhängigkeiten:** `python3`, `jq`, `find`; Web-Scans benötigen `python3-requests`; optional `gitleaks`, `trufflehog`, `rg`

### WAF-Erkennung (`dev/waf-detect.sh`)

Identifiziert Web Application Firewalls und CDN-Edge-Layer vor Zielen. Modulare Bibliothek: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; Daten: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`. Eigenständige Ausgabe unter `$HOME/data/waf-detection_*`.

* **Echt passiv (Standard für api-scanner-hook)** — `--passive` sendet nur einen normalen HTTP-GET; gleicht Antwort-Header/-Body gegen `waf-signatures.tsv` ab. Kein wafw00f, keine SQLi-Trigger, keine `X-Forwarded-For`-Injektion.
* **Aktiver Modus** — wafw00f über `wafw00f_run.py` (primär, hohe Konfidenz) plus ergänzende Signatur-/Verhaltenssonden. Nicht-interaktive aktive Scans erfordern `--i-understand`.
* **Ergänzend** — `--supplemental auto` überspringt redundante Sonden nach einem sicheren wafw00f-Treffer; Verhaltensbefunde erfordern eine WAF-Header-Bestätigung.
* **Konsolidierte Ergebnisse** — eine Zeile pro Anbieter mit Konfidenz (`high`/`medium`/`low`), Quelle und Typ (`waf`/`cdn`/`both`).
* **Strukturierte Treffer** — `waf_engine/hits.jsonl` und `findings.json` `hits[]` für nachgelagerte Tools.
* **Fortsetzen** — `--resume DIR` setzt ab `waf_engine/checkpoint.json` fort.
* **Berichte** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`

**Menü:** Einzelziel, Zieldatei oder vorheriges Menü (mit aktiver/passiver Auswahl).

**Beispiele:**```
./dev/waf-detect.sh --url https://app.example.com --passive
./dev/waf-detect.sh --file ~/targets.txt --passive --delay 2
./dev/waf-detect.sh --url example.com --i-understand --output-dir ~/data/waf-test
./dev/waf-detect.sh --resume ~/data/waf-detection_20260704-1200 --workers 4
./dev/lib/waf-detect/run-tests.sh
```
**Options:** `--url`, `--file`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--waf-only`, `--insecure`, `--no-redirect`, `--proxy`, `--delay`, `--max-targets`, `--workers`, `--wafw00f`, `--supplemental`, `--input-format`, `--quiet`, `--menu`, `-h`

**Ausgabe:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`, `scan.log`, `waf_engine/{hits.jsonl,checkpoint.json,*.json}`

**Abhängigkeiten:** `curl`, `jq`, `grep`, `python3`; optional `wafw00f` (aktiver Modus, empfohlen)

**api-scanner-Integration:** `api-scanner.sh --orchestrate` fordert nach dem Hauptscan dazu auf, waf-detect auszuführen (standardmäßig passiv).

### Web- und API-Sicherheit (`dev/web-api-scanner.sh`)

Metasploit-basierte Web-/API-Bewertung. Modulare Bibliothek: `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py`; Daten: `dev/data/web-api-{phases,tech-signatures}.tsv`. Eigenständige Ausgabe unter `$HOME/data/web-api-scan_*`.

* **Stufen** — `passive` (Aufklärung) | `standard`/`--quick` (Aufklärung + Technologie-Scanner) | `intrusive` (+ SQLi/Brute) | `exploit` (+ Exploit-Prüfungen)
* **Phasensteuerung** — `--phases`, `--skip-phases`; pro Phase `msfconsole` mit `--phase-timeout`
* **Technologie-Fingerabdruck** — gewichtete `web-api-tech-signatures.tsv` (Laravel, Spring, Swagger, nginx, …)
* **WAF-erkennend** — überspringt Brute-Phasen, wenn WAF/CDN erkannt (`--scan-dir` oder Header-Signaturen)
* **Authentifizierung** — `--bearer-token`, `--cookie-file` für curl + MSF
* **api-scanner-Integration** — `--scan-dir` lädt `api_scanner/all_endpoints.txt` für `brute_dirs`-Pfade
* **Strukturierte Treffer** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **Multi-Ziel** — `--file`, `--workers`, `--max-targets`
* **Tarnung** — `--delay`, `--jitter`, `--proxy`, stufenbasiertes `THREADS`
* **MSF DB** — standardmäßig nur Prüfungen; `--msf-db-bootstrap` für optionale Einrichtung

**Menü:** URL scannen (passiv standard) oder vorheriges Menü.

**Beispiele:**```
./dev/web-api-scanner.sh --url https://app.example.com --passive
./dev/web-api-scanner.sh --url example.com --quick --scan-dir ~/data/api-scan_*/ 
./dev/web-api-scanner.sh --url example.com --tier exploit --i-understand --bearer-token "$TOKEN"
./dev/web-api-scanner.sh --file ~/targets.txt --quick --workers 2 --max-targets 10
WEBAPI_RUN_LIVE_MSF=1 ./dev/lib/web-api-scanner/run-tests.sh
```
**Optionen:** `--url`, `--file`, `--tier`, `--quick`, `--phases`, `--skip-phases`, `--scan-dir`, `--bearer-token`, `--cookie-file`, `--proxy`, `--phase-timeout`, `--workers`, `--threads`, `--jitter`, `--target-ip`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--dry-run`, `--skip-msf-db`, `--msf-db-bootstrap`, `--keep-resources`, `--no-waf-aware`, `--insecure`, `--delay`, `--quiet`, `--menu`, `-h`

**Ausgabe:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `msf_engine/`

**Abhängigkeiten:** `curl`, `jq`, `grep`, `msfconsole`; PostgreSQL wird für die MSF-Datenbank empfohlen (optional mit `--skip-msf-db`)

**api-scanner Integration:** `api-scanner.sh --orchestrate` fordert zur Ausführung von web-api-scanner auf (standardmäßig passiv).

# Fehlerbehebung

Einige Benutzer haben berichtet, dass sie keine anderen Optionen als 3, 4 und 5 verwenden können. Es passiert nichts, wenn andere Optionen (1, 2, 6 usw.) ausgewählt werden.

## Überprüfen des Download-Hashs

Die hashbasierte Überprüfung stellt sicher, dass eine Datei nicht beschädigt wurde, indem der Hash-Wert der Datei mit einem zuvor berechneten Wert verglichen wird. Wenn diese Werte übereinstimmen, wird die Datei als unverändert betrachtet.

### macOS

1. Terminal öffnen
2. shasum -a 256 /path/to/file
3. Vergleichen Sie den Wert mit der Prüfsumme auf der Website.

### Windows

1. PowerShell öffnen
2. Get-FileHash C:\path\to\file
3. Vergleichen Sie den Wert mit der Prüfsumme auf der Website.

## Ausführen von Kali unter VirtualBox oder Windows Subsystem for Linux (WSL)

Einige Benutzer haben berichtet, dass die Lösung darin besteht, das VMware-Image anstelle von WSL zu verwenden.

Andere Benutzer haben Probleme festgestellt, wenn sie ein vorgefertigtes VirtualBox-Kali-Image verwenden, anstatt das Bare-Metal-Kali-ISO über VirtualBox auszuführen. (https://www.kali.org/get-kali/#kali-bare-metal)

Falls Sie VMware Workstation nicht verwenden möchten oder können, empfehlen wir Ihnen, ein Kali-ISO als Gast-VM in VirtualBox auszuprobieren.

1. Laden Sie das von Kali bereitgestellte Bare-Metal-ISO herunter.
2. Überprüfen Sie den ISO-Hash (siehe oben).
3. Starten Sie eine neue Kali-VM in VirtualBox mit dem Bare-Metal-Kali-ISO.

Es werden einige [grundlegende Installationsanweisungen](https://www.kali.org/docs/installation/hard-disk-install/) angezeigt, die Sie während der Installation ausfüllen müssen.

Hinweis: Wenn Sie nach der Einrichtung eines Bare-Metal-ISO Probleme beim Zugriff auf root haben, lesen Sie bitte: https://linuxconfig.org/how-to-reset-kali-linux-root-password