Alle Scan-Tools und PoC-Ausführungen laufen in einem **BlackArch Linux** Docker-Container – nichts wird auf dem Host installiert.

---

## Werkzeuge

86 Werkzeuge, nach Kategorien organisiert. Jedes Werkzeug deklariert die unterstützten Zieltypen; der Orchestrator überspringt automatisch inkompatible Paarungen.

### Netzwerk- & Port-Scanning
| Werkzeug | Hinweise |
|------|-------|
| `nmap` | Vollständiger Port-Scan mit Dienst-/Versionserkennung |
| `rustscan` | Schneller Port-Scanner, speist in nmap ein |
| `masscan` | Hochgeschwindigkeits-TCP/UDP-Scanner |
| `naabu` | Port-Scanner mit Diensterkennung |
| `netdiscover` | ARP-basierte Host-Erkennung |

### Webanwendung
| Werkzeug | Hinweise |
|------|-------|
| `nuclei` | Vorlagenbasierter Schwachstellenscanner |
| `nikto` | Scanner für Webserver-Fehlkonfigurationen |
| `wapiti` | Black-Box-Web-Schwachstellenscanner |
| `ffuf` | Schneller Web-Fuzzer (Verzeichnisse, Parameter, Header) |
| `feroxbuster` | Inhaltserkennung mit Rekursion |
| `gobuster` | URI/DNS/vhost-Brute-Forcer |
| `wfuzz` | Webanwendungs-Fuzzer |
| `dalfox` | XSS-Scanner mit Parameteranalyse |
| `xsstrike` | Erweiterte XSS-Erkennungsengine |
| `commix` | Command Injection-Ausnutzung |
| `sqlmap` | Automatisierte SQL-Injection und -Übernahme |
| `nosqlmap` | NoSQL-Injection-Scanner |
| `httpx` | HTTP-Sondierung und Fingerprinting |
| `whatweb` | Web-Technologie-Fingerprint |
| `wafw00f` | WAF-Erkennung und Fingerprinting |
| `wpscan` | WordPress-Schwachstellenscanner |
| `acunetix` | Web-Schwachstellenscanner (API-basiert) |
| `arachni` | Webanwendungs-Sicherheitsscanner |
| `zap` | OWASP ZAP DAST-Scanner |
| `wapiti` | Black-Box-Schwachstellenscanner |
| `drheader` | HTTP-Sicherheitsheader-Analysator |
| `humble` | HTTP-Header-Sicherheitsprüfer |
| `hakrawler` | Schneller Web-Crawler für URLs und Endpunkte |
| `katana` | Next-Gen-Web-Crawling-Framework |
| `gau` | Bekannter URL-Sammler (AlienVault, WaybackMachine) |
| `jsluice` | JavaScript-Geheimnisse und URL-Extraktor |
| `corscanner` | CORS-Fehlkonfigurations-Scanner |
| `crlfuzz` | CRLF-Injection-Scanner |
| `smuggler` | HTTP-Request-Schmuggel-Detektor |
| `linkfinder` | Endpunkt-Erkennung in JavaScript/HTML-Quellen |
| `cariddi` | Web-Crawler mit Geheimnis- und Endpunkt-Erkennung |

### API & GraphQL
| Werkzeug | Hinweise |
|------|-------|
| `kiterunner` | API-Routen-Erkennung mit Kite-Dateien |
| `graphql_cop` | GraphQL-Sicherheitsprüfer |
| `restler` | Zustandsbehafteter REST-API-Fuzzer |
| `apifuzzer` | OpenAPI/Swagger-basierter Fuzzer |
| `cherrybomb` | OpenAPI-Spezifikations-Sicherheitslinter |
| `arjun` | HTTP-Parameter-Erkennung |
| `paramspider` | Parameter-Mining aus Wayback/Quellen |

### DNS & Aufklärung
| Werkzeug | Hinweise |
|------|-------|
| `amass` | Subdomain-Enumeration (passiv + aktiv) |
| `subfinder` | Schnelle passive Subdomain-Enumeration |
| `dnsx` | DNS-Resolver und Sonden-Toolkit |
| `dnsrecon` | DNS-Enumeration und Zonenübertragung |
| `fierce` | DNS-Aufklärung und Host-Erkennung |
| `theharvester` | OSINT: E-Mails, Namen, Hosts, Subdomains |
| `puredns` | Schneller Subdomain-Brute-Forcer mit Wildcard-Filterung |
| `alterx` | Subdomain-Permutations-Engine |
| `waybackurls` | Sammlung historischer URLs aus Wayback Machine |
| `httprobe` | Live-HTTP/HTTPS-Host-Prüfer |

### TLS / SSL
| Werkzeug | Hinweise |
|------|-------|
| `testssl` | TLS-Konfigurations- und Cipher-Suite-Prüfung |
| `sslyze` | TLS-Scanner (Cipher-Suites, Heartbleed, ROBOT) |
| `sslscan` | SSL/TLS-Dienst-Scanner |
| `tlsx` | Schnelles TLS-Sondieren |
| `tls_attacker` | TLS-Protokoll-Angriffswerkzeug |
| `ssh_audit` | SSH-Konfigurations- und Algorithmen-Prüfer |

### SMB & Netzwerkdienste
| Werkzeug | Hinweise |
|------|-------|
| `smbmap` | SMB-Freigabe-Enumeration und Berechtigungen |
| `enum4linux` | SMB/NetBIOS-Enumeration |
| `crackmapexec` | Active Directory und SMB-Bewertung |
| `openvas` | OpenVAS-Schwachstellenscanner |

### SAST & Code-Analyse
| Werkzeug | Hinweise |
|------|-------|
| `bandit` | Python SAST – häufige Sicherheits-Anti-Patterns |
| `semgrep` | Multi-Sprach-SAST mit Community-Regeln |
| `gosec` | Go-Sicherheitsprüfer |
| `bearer` | Datenfluss-SAST mit Datenschutz- und Sicherheitsregeln |
| `horusec` | Multi-Sprach-SAST-Engine |
| `brakeman` | Ruby on Rails SAST-Scanner |
| `flawfinder` | C/C++-Statikanalyse für häufige Fehler |
| `dependency_check` | OWASP-Abhängigkeits-Schwachstellenscanner |
| `pip_audit` | Python-Paket-Schwachstellenprüfer |

### Software Composition Analysis (SCA)
| Werkzeug | Hinweise |
|------|-------|
| `osv-scanner` | Open Source Vulnerability-Datenbank-Scanner |
| `npm-audit` | Node.js-Paket-Schwachstellenprüfung |
| `govulncheck` | Go-Modul-Schwachstellenprüfer |

### Geheimnis-Erkennung
| Werkzeug | Hinweise |
|------|-------|
| `gitleaks` | Git-Verlaufs-Geheimnisscanner |
| `trufflehog` | Tiefer entropiebasierter Geheimnis-Finder |
| `secretfinder` | Geheimnisse in JS-Dateien und Endpunkten |
| `detect-secrets` | Basislinien-basierter Geheimnisscanner |
| `noseyparker` | Hochgeschwindigkeits-Geheimnisscanner mit Musterregeln |

### IaC & Konfiguration
| Werkzeug | Hinweise |
|------|-------|
| `checkov` | Terraform/K8s/Dockerfile IaC-Scanner |
| `tfsec` | Terraform-Statikanalyse |
| `terrascan` | Multi-Cloud-IaC-Sicherheitsscanner |
| `hadolint` | Dockerfile-Best-Practice-Linter |

### Cloud-Infrastruktur
| Werkzeug | Hinweise |
|------|-------|
| `prowler` | AWS/GCP/Azure-Sicherheitslagebewertung |
| `kube-bench` | CIS-Kubernetes-Benchmark-Prüfer |

### Container & Lieferkette
| Werkzeug | Hinweise |
|------|-------|
| `trivy` | Container-Image + Dateisystem-Schwachstellenscanner |
| `grype` | Container- und Paket-Schwachstellen-Matcher |

---

## Zieltyp-Steuerung

Der Orchestrator klassifiziert jedes Ziel in einen oder mehrere Typen und führt nur Werkzeuge aus, die Unterstützung für diesen Typ deklarieren. Dies eliminiert Rauschen, z. B. von SMB-Werkzeugen, die gegen Web-URLs laufen.

| Typ | Beispiel | Passende Werkzeuge |
|------|---------|-----------------|
| `HOST` | `example.com` | DNS, SSL, Web, SMB-Werkzeuge |
| `IP` | `10.0.0.1` | Netzwerk-, Port-, SMB-Werkzeuge |
| `CIDR` | `10.0.0.0/24` | Netzwerk-Scanner |
| `URL` | `https://app.example.com` | Web-, API-, SSL-Werkzeuge |
| `PATH` | `/src/myapp` | SAST, SCA, Geheimnis, IaC-Werkzeuge |
| `REPO` | `https://github.com/org/repo` | Geheimnis, SAST, SCA-Werkzeuge |
| `IMAGE` | `myapp:latest` | Container-Scanner |
| `CLOUD` | `aws:profile=prod`, `arn:aws:…` | Cloud-Posture-Werkzeuge (prowler, kube-bench, terrascan) |

Die Klassifizierung erfolgt automatisch – geben Sie einfach die Zielzeichenkette an; der Scanner ermittelt den Typ.

Erkannte Cloud-Zielformate:
- AWS ARN: `arn:aws:iam::123456789012:root`
- Benanntes Profil-Kürzel: `aws:profile=production`
- GCP-Projekt: `projects/my-project-id`
- Azure-Abonnement-UUID: `00000000-0000-0000-0000-000000000000`

---

## Scan-Modi

| Modus | Beschreibung |
|------|-------------|
| `paranoid` | Maximale Tarnung – passive Sondierung, minimale Fußabdruck |
| `passive` | Keine aktiven Angriffe – nur Enumeration und Banner-Grabbing **(Standard)** |
| `active` | Standard-Schwachstellenprüfungen aktiviert |
| `aggressive` | Vollständiger Scan: alle Vorlagen, Brute-Force, schnelles Timing |

---

## Authentifiziertes Scannen

Anmeldedaten werden an alle anwendbaren Web-Werkzeuge weitergeleitet (nuclei, ffuf, feroxbuster, gobuster, nikto, sqlmap, dalfox, wpscan, wapiti, katana, hakrawler, arjun, wfuzz, corscanner, kiterunner, httpx).

### Globale Anmeldedaten

Auf jedes Ziel angewendet, es sei denn, es existiert eine zielübergreifende Überschreibung.

**Über Konfiguration:**```toml
[scan.auth]
bearer_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
username     = "admin"
password     = "secret"

[scan.auth.cookies]
session = "abc123"

[scan.auth.headers]
X-API-Key = "my-api-key"

**Über CLI** (nur global):```bash
vuln-scanner --targets https://app.example.com \
  --auth-bearer eyJ... \
  --auth-cookie session=abc123 \
  --auth-header X-API-Key=secret

**Auflösung:** `per-target config > global config`

---

## LLM-Analyse

Wenn ein API-Schlüssel vorhanden ist, aktiviert sich die LLM-Ebene automatisch. Sie führt vier Durchläufe der Scanergebnisse durch:

| Durchlauf | Name | Beschreibung |
|-----------|------|-------------|
| 1 | **Triage** | Weist CWE, Konfidenz, False-Positive-Flag, Ausnutzbarkeitsbewertung zu und entwirft einen PoC für jeden Fund |
| 2 | **PoC-Generierung** | Schreibt eigenständige Python/Bash-Skripte, die den Fund mithilfe der bereits im Container vorhandenen Tools bestätigen |
| 3 | **Mitigation** | Erzeugt konkrete kurzfristige Gegenmaßnahmen und dauerhafte Behebungen, optional gestützt durch PoC-Nachweise |
| 4 | **Clustering** | Gruppiert Funde nach Ursache, schreibt gemeinsame Behebungen und erstellt eine zusammenfassende Übersicht (Executive Summary) |

### Provider-Konfiguration

Der LLM-Client ist OpenAI-API-kompatibel — funktioniert mit OpenAI, Azure OpenAI, Ollama, vLLM, LM Studio, OpenRouter und jedem anderen kompatiblen Endpunkt.```toml
[llm]
enabled   = "auto"          # "auto" | true | false  (auto = on when api_key present)
api_key   = ""              # or set OPENAI_API_KEY env var
base_url  = ""              # leave empty for OpenAI; set for Ollama/vLLM/etc.
model     = "gpt-4o"        # REQUIRED when LLM is active — no default

# Sampling parameters (all OpenAI-compatible)
temperature = 0.2
top_p       = 0.95
max_tokens  = 4096
# top_k and other non-standard params go in extra_body:
# [llm.extra_body]
# top_k = 40

**vLLM Beispiel:**```toml
[llm]
base_url = "http://localhost:8000/v1"
api_key  = "token-abc123"
model    = "meta-llama/Meta-Llama-3-8B-Instruct"

**Funktionspriorität:** `tool override > category override > global`

### Benutzerdefinierte Prompts

Alle LLM-Prompts sind überschreibbar:```toml
[llm.prompts]
enrich_system    = "You are a senior penetration tester..."
mitigation_user  = "Write remediation steps for: {title}..."
# Available placeholders: {title} {severity} {description} {cwe}
#   {exploitability} {tool} {target} {cves} {raw_output}

---

## PoC-Generierung und -Ausführung

### Generierung (immer host-sicher)

Das LLM schreibt pro Fund eigenständige Python- und/oder Bash-Skripte. Die Skripte verwenden Tools, die bereits im BlackArch-Image vorhanden sind (`curl`, `sqlmap`, `nuclei`, `dalfox`, etc.) und werden in `<report>_assets/poc/` geschrieben. Die Generierung führt niemals Code aus — sie schreibt nur Dateien.```toml
[llm.poc]
languages        = ["python", "bash"]
only_severities  = ["critical", "high", "medium"]
max_pocs         = 20
allow_git_clone  = false   # permit cloning official exploit PoCs from GitHub

## Plugin-System

Legen Sie eine `.py`-Datei, die eine oder mehrere `AbstractTool`-Unterklassen definiert, in `./plugins/` (oder `~/.vuln-scanner/plugins/`) ab — sie werden beim Start automatisch erkannt, ohne dass Codeänderungen erforderlich sind.

**Erkennungsreihenfolge** (spätere Einträge überschreiben bei Namenskollision):
1. `./plugins/` (relativ zum aktuellen Arbeitsverzeichnis)
2. `~/.vuln-scanner/plugins/`
3. Zusätzliche Verzeichnisse, die über `[plugins] dirs` oder `--plugin-dir` konfiguriert werden

**Beispiel-Plugin** (`plugins/my_scanner.py`):
``````python
from vuln_scanner.tools.abstract import AbstractTool
from vuln_scanner.tools.enums import Severity, ScanStatus, TargetType
from vuln_scanner.tools.models import Finding, ScanInput, ScanResult

class MyScannerTool(AbstractTool):
    name: str = "my-scanner"
    category: str = "web"
    # Only runs against URL targets — skipped automatically for IPs, paths, etc.
    applicable_targets: frozenset[TargetType] = frozenset({TargetType.URL})

    def build_command(self, target: str, scan_input: ScanInput) -> list[str]:
        return ["my-scanner", "--target", target, "--json"]

    def parse_output(self, raw: str, target: str) -> list[Finding]:
        ...

**CLI:**```bash
vuln-scanner --plugin-dir /opt/company-scanners --targets https://app.example.com

Es gibt keinen konfigurationsseitigen plugin-spezifischen Filter pro Ziel — diese Logik gehört zum Plugin selbst.

---

## Berichtsformate

Drei Formate werden parallel erzeugt. Wählen Sie eine beliebige Kombination:```toml
[report]
formats    = ["markdown", "html", "json"]
output_dir = "./reports"

| Schritt | Aktion |
|------|--------|
| 1 | Prüft Voraussetzungen |
| 2 | Lädt `.env` (kopiert von `.env.example`, falls nicht vorhanden) |
| 3 | Startet DefectDojo-Stack |
| 4 | Wartet, bis die DefectDojo-API bereit ist |
| 5 | Holt API-Token über Admin-Anmeldedaten |
| 6 | Startet schwachstellenbehaftete Zielcontainer |
| 7 | Wartet, bis jedes Ziel erreichbar ist |
| 8 | Baut das Scanner-Docker-Image |
| 9 | Führt den Scanner aus, generiert Berichte, überträgt sie zu DefectDojo |
| 10 | Gibt Zusammenfassung mit URLs und Deinstallationsanweisungen aus |

**Mit LLM-Analyse:**```bash
# Copy the example env and add your key
cp .env.example .env
# Edit .env: set OPENAI_API_KEY and VS_LLM_MODEL
./poc.sh

**Abbau:**```bash
docker compose down -v
docker compose -f docker-compose.target.yaml down -v

---

## scanner.sh — Docker-Wrapper

`scanner.sh` ist die empfohlene tägliche Schnittstelle zum Ausführen des Scanners. Es kapselt `docker compose run`, sodass Sie nie die Compose-Aufrufung manuell eingeben müssen – übergeben Sie einfach Ziele und Flags direkt.

```bash
docker compose run --rm kitploit-scanner --help
``````bash
./scanner.sh [OPTIONS] [-- SCANNER_ARGS...]

### Was es automatisch macht

- Lädt `.env` (kopiert aus `.env.example`, falls fehlend)
- Kopiert `config.example.toml` → `config.toml`, falls keine Konfiguration existiert
- Erstellt das Docker-Netzwerk `vuln_scanner_network`, falls nicht vorhanden
- Mountet eine benutzerdefinierte `--config`-Datei in den Container unter `/app/config.toml`
- Baut das Image neu, wenn `--build` übergeben wird

---

## Konfiguration

Kopieren Sie die kommentierte Vorlage:```bash
cp config.example.toml config.toml

**Rangfolge der Konfigurationszusammenführung:** `CLI > env vars > config.toml > defaults`

---

## Umgebungsvariablen

### Kern

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `VS_TARGETS` | `--targets` | Durch Leerzeichen getrennte Zielliste |
| `VS_MODE` | `--mode` | Scanmodus |
| `VS_TIMEOUT` | `--timeout` | Timeout pro Tool (Sekunden) |
| `VS_RATE_LIMIT` | `--rate-limit` | Ratenbegrenzung (req/s) |
| `VS_MAX_CONCURRENT` | `--max-concurrent` | Parallele Tool-Slots |
| `VS_INCLUDE_TOOLS` | `--include-tools` | Tools nach Namen auf die Whitelist setzen |
| `VS_EXCLUDE_TOOLS` | `--exclude-tools` | Tools nach Namen auf die Blacklist setzen |
| `VS_INCLUDE_CATEGORIES` | `--include-categories` | Kategorien auf die Whitelist setzen |
| `VS_EXCLUDE_CATEGORIES` | `--exclude-categories` | Kategorien auf die Blacklist setzen |
| `VS_OUTPUT_DIR` | `--output-dir` | Ausgabeverzeichnis für Berichte |

### Berichte

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `VS_FORMATS` | `--formats` | Berichtsformate: `markdown html json` |

### LLM

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `OPENAI_API_KEY` | — | API-Schlüssel (Standard-Umgebungsvariable, wird als Fallback verwendet) |
| `OPENAI_BASE_URL` | — | Base-URL-Fallback (für Nicht-OpenAI-Endpunkte) |
| `VS_LLM_ENABLED` | `--no-llm` | `auto` \| `true` \| `false` |
| `VS_LLM_MODEL` | `--llm-model` | Modellname (erforderlich, wenn aktiv) |
| `VS_LLM_TEMPERATURE` | — | Sampling-Temperatur |
| `VS_LLM_MAX_TOKENS` | — | Maximale Ausgabetoken |
| `VS_LLM_FEATURE_<NAME>` | `--llm-feature NAME=on` | Globaler Funktionsumschalter, z. B. `VS_LLM_FEATURE_GENERATE_POC=false` |
| `VS_LLM_FEATURE_EXECUTE_POC` | `--llm-poc-execute` | PoC-Ausführung aktivieren (nur Container) |

### Authentifiziertes Scannen

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `VS_AUTH_BEARER_TOKEN` | `--auth-bearer` | Bearer-Token (`Authorization: Bearer …`) |
| `VS_AUTH_USERNAME` | `--auth-user` | HTTP-Basic-Benutzername |
| `VS_AUTH_PASSWORD` | `--auth-pass` | HTTP-Basic-Passwort |
| `VS_AUTH_LOGIN_URL` | `--auth-login-url` | Formularbasierte Anmelde-URL |

Cookies und zusätzliche Header müssen über die Konfigurationsdatei oder die CLI-Flags `--auth-cookie` / `--auth-header` gesetzt werden.

### Plugins

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `VS_PLUGINS_ENABLED` | `--no-plugins` | Automatische Erkennung von Plugins aktivieren/deaktivieren |
| `VS_PLUGINS_DIRS` | `--plugin-dir` | Zusätzliche Plugin-Verzeichnisse (durch Leerzeichen getrennt) |

### DefectDojo

| Variable | CLI-Flag | Beschreibung |
|----------|----------|-------------|
| `VS_DEFECTDOJO_URL` | `--defectdojo-url` | DefectDojo-Basis-URL |
| `VS_DEFECTDOJO_API_KEY` | `--defectdojo-api-key` | API-Token |
| `VS_DEFECTDOJO_PRODUCT` | — | Produktname |
| `VS_DEFECTDOJO_ENGAGEMENT` | — | Engagement-Name |

---

## Projektstruktur```
vuln_scanner/
├── config/
│   ├── models.py        # AppConfig, AppLLMConfig, PluginsConfig (pydantic)
│   └── loader.py        # 3-layer merge: TOML + env (VS_*) + CLI
│
├── tools/
│   ├── enums.py         # Severity, Confidence, ScanStatus, ScanMode, TargetType
│   ├── models.py        # Finding, ScanInput, ScanResult, AuthConfig (pydantic)
│   ├── target.py        # classify_target() — maps target string to TargetType set
│   ├── abstract.py      # AbstractTool ABC + subprocess execution helpers
│   ├── __init__.py      # TOOL_REGISTRY (86 tools)
│   └── <tool>.py        # One file per tool (86 total)
│
├── llm/
│   ├── models.py        # LLMConfig, LLMFeatures, PocConfig (pydantic)
│   ├── features.py      # resolve_features() — tool > category > global merge
│   ├── client.py        # LLMClient — thin openai SDK wrapper
│   ├── analyzer.py      # LLMAnalyzer — 4-pass analysis pipeline
│   └── prompts.py       # Default prompt templates (all overridable)
│
├── poc/
│   ├── models.py        # Poc, PocVerdict
│   ├── generator.py     # PocGenerator — writes scripts, never executes (host-safe)
│   └── runner.py        # PocRunner — executes scripts (VS_IN_CONTAINER guard)
│
├── reports/
│   ├── base.py          # AbstractReporter
│   ├── markdown.py      # Professional structured Markdown report
│   ├── html.py          # Self-contained HTML with light/dark theme
│   └── json_reporter.py # Full Assessment JSON dump
│
├── defectdojo/
│   └── client.py        # DefectDojoClient — push findings via REST API
│
├── plugins.py           # Plugin auto-discovery (./plugins/, ~/.vuln-scanner/plugins/)
├── model.py             # Assessment, Cluster, AssessmentStats
└── orchestrator.py      # ScanOrchestrator — type-gated, async concurrent execution

plugins/                 # Drop .py plugin files here (auto-discovered at startup)
main.py                  # Entry point
config.example.toml      # Fully documented configuration template
.env.example             # Environment variable reference
Dockerfile               # BlackArch-based image; bakes VS_IN_CONTAINER=1
docker-compose.yaml                # DefectDojo stack
docker-compose.scanner.yaml        # Scanner service
docker-compose.target.yaml        # Vulnerable test targets (Juice Shop, WebGoat)
scanner.sh                        # Convenience wrapper — runs the scanner via docker compose
poc.sh                            # End-to-end quick-start script (DefectDojo + targets + scanner)

def build_command(self, target: str, scan_input: ScanInput) -> list[str]:
    return ["mytool", "--target", target]

def parse_output(self, raw: str, target: str) -> list[Finding]:
    findings = []
    for line in raw.splitlines():
        if "VULN" in line:
            findings.append(Finding(
                title="Example finding",
                severity=Severity.HIGH,
                description=line,
                tool=self.name,
                target=target,
            ))
    return findings

2. Registriere es in `vuln_scanner/tools/__init__.py`:```python
from vuln_scanner.tools.mytool import MyTool

TOOL_REGISTRY: dict[str, type[AbstractTool]] = {
    ...
    "mytool": MyTool,
}

**Tipps:**
- Verwenden Sie bei Tools, die in eine Datei statt in stdout schreiben, `OUTPUT_FILE_SENTINEL` in `build_command()` und überschreiben Sie `run()`, um `self._run_with_tempfile()` aufzurufen.
- Tools mit `applicable_targets = frozenset(TargetType)` (Standard) werden für alle Zieltypen ausgeführt – verwenden Sie dies nur für wirklich universelle Tools.
- Binärdatei nicht gefunden → `ScanStatus.SKIPPED` (im Bericht verborgen). Tool-Fehler → `ScanStatus.FAILED` (in Anhang A angezeigt).

---

## Entwicklung```bash
# Install with dev dependencies
uv sync

# Run tests (host-safe only — no real tool execution)
uv run pytest tests/ -v

# Lint
uv run ruff check .
uv run ruff format .