**Projektweise Installation** — auf ein Repository beschränkt, läuft über `npx hound` oder ein npm-Skript:```bash
npm install --save-dev context-hound

## Schnellstart```bash
# Scaffold a config file
hound init

# Scan your project
hound scan --dir ./my-ai-project

# Or via npm script (scans current directory)
npm run hound

# Verbose output, shows remediations and confidence levels
hound scan --verbose

# Fail the build on any critical finding
hound scan --fail-on critical

# Export JSON and SARIF reports
hound scan --format console,json,sarif --out results

# GitHub Annotations (for CI step summaries)
hound scan --format github-annotations

# Markdown report with findings tables
hound scan --format markdown --out report

# Stream findings as JSONL (one JSON object per line)
hound scan --format jsonl | jq '.severity'

# List all rules
hound scan --list-rules

# Explain a rule (or a rule family by prefix)
hound explain INJ-001
hound explain PST --format json

# Fast PR gate — scan only files changed vs. origin/main
hound scan --diff

# Interactive HTML report (self-contained, open in browser)
hound scan --format html --out report

# Re-scan on file changes
hound scan --watch

# Parallel scanning (default is 8; tune for your machine)
hound scan --concurrency 16

# Disable incremental cache for a clean run
hound scan --no-cache

# Baseline mode — only report findings new since the last saved scan
hound scan --format json --out baseline          # save a baseline
hound scan --baseline baseline.json             # compare future scans against it

# Load a custom rule from a local plugin file
hound scan  # plugin declared in .contexthoundrc.json "plugins" field

# Only run high-confidence rules
hound scan --config .contexthoundrc.json  # set minConfidence: "high"

# Fail if any single file scores >= 40
hound scan --fail-file-threshold 40

steps:
  - uses: actions/checkout@v4

  - uses: actions/setup-node@v4
    with:
      node-version: '20'

  - run: npm install -g context-hound

  - run: hound scan --format console,sarif,github-annotations --out results.sarif

  - name: Upload to GitHub Code Scanning
    if: always()
    uses: github/codeql-action/upload-sarif@v3
    with:
      sarif_file: results.sarif

Ergebnisse werden im **Security > Code scanning**-Tab Ihres Repositorys angezeigt. Das `github-annotations`-Format veröffentlicht Inline-PR-Kommentare und schreibt eine Zusammenfassungstabelle in die GitHub-Schrittübersicht.

---

## Konfiguration

Führen Sie `hound init` aus, um eine `.contexthoundrc.json` zu erstellen, oder erstellen Sie eine manuell:```json
{
  "include": ["**/*.ts", "**/*.js", "**/*.py", "**/*.go", "**/*.rs", "**/*.md", "**/*.txt", "**/*.yaml"],
  "exclude": [
    "**/node_modules/**",
    "**/dist/**",
    "**/tests/**",
    "**/attacks/**"
  ],
  "threshold": 60,
  "formats": ["console", "sarif"],
  "out": "results",
  "verbose": false,
  "failOn": "critical",
  "maxFindings": 50,
  "excludeRules": ["JBK-002"],
  "includeRules": [],
  "minConfidence": "medium",
  "failFileThreshold": 80,
  "concurrency": 8,
  "cache": true,
  "plugins": ["./rules/my-custom-rule.js"],
  "baseline": "./baseline.json"
}

- `hound-disable-line [RULE...]` — Unterdrückt Fundstellen in derselben Zeile
- `hound-disable-next-line [RULE...]` — Unterdrückt Fundstellen in der folgenden Zeile
- `hound-disable [RULE...]` … `hound-enable [RULE...]` — Unterdrückt einen Block (wird am Dateiende automatisch geschlossen)
- Lassen Sie Regel-IDs weg, um **alle** Regeln an dieser Stelle zu unterdrücken; listen Sie eine oder mehrere (durch Leerzeichen/Kommas getrennt) auf, um den Bereich einzugrenzen
- Text nach `--` ist eine freiformatierte Begründung, die in Berichten angezeigt wird

Führen Sie mit `--report-unused-suppressions` aus, um Direktiven aufzulisten, die keiner Fundstelle mehr entsprechen, damit tote Unterdrückungen bereinigt werden können:```bash
hound scan --report-unused-suppressions

| Voreinstellung | Regeln |
|--------|-------|
| `owasp-llm-top10` | INJ, JBK, EXF, OUT, RAG, TOOL, SCH, DOS, VIS |
| `injection` | INJ, RAG, ENC |
| `jailbreak` | JBK |
| `exfiltration` | EXF |
| `agentic` | AGT, MCP, TOOL |
| `mcp` | MCP |
| `supply-chain` | SCH |
| `prompt-files` | INJ, JBK, EXF, ENC, SKL |

### pre-commit-Hook

ContextHound wird mit einem [pre-commit](https://pre-commit.com)-Hook ausgeliefert. Fügen Sie ihn Ihrer `.pre-commit-config.yaml` hinzu:```yaml
repos:
  - repo: https://github.com/IulianVOStrut/ContextHound
    rev: v2.0.0
    hooks:
      - id: contexthound
        # optional — scan only changed files and fail on high-severity findings:
        # args: ["--diff", "HEAD", "--fail-on", "high"]

Verweise es in der `.contexthoundrc.json`:```json
{ "plugins": ["./my-rule.js"] }

Findings are matched by `ruleId + file` — Zeilenverschiebungen lösen keine falschen Neu-Fund-Meldungen aus.

### Nur geänderte Dateien (`--diff`)

Für schnelle Pull-Request-Prüfungen durchsuchen Sie nur die Dateien, die sich gegenüber einem Git-Referenz geändert haben, anstatt des gesamten Baums:```bash
hound scan --diff               # vs. origin/main (default)
hound scan --diff main          # vs. a named branch
hound scan --diff HEAD~5        # vs. an arbitrary ref

Punkte werden summiert, auf 100 begrenzt und klassifiziert:

| Score | Level | Suggested action |
|-------|-------|-----------------|
| 0-29 | 🟢 Niedrig | Keine Maßnahme erforderlich |
| 30-59 | 🟡 Mittel | Vor dem Merge prüfen |
| 60-79 | 🟠 Hoch | Vor dem Merge beheben |
| 80-100 | 🔴 Kritisch | Bereitstellung blockieren |

Wenn Ihre Prompts explizite Sicherheitssprache enthalten (Eingabe-Trennzeichen, Anweisungen zur Verweigerung der Preisgabe, Tool-Allowlists), werden die Risikopunkte für diesen Prompt proportional reduziert.

---

## Regeln

### A. Injection (INJ)

| ID | Severity | Beschreibung |
|----|----------|-------------|
| INJ-001 | High | Direkte Benutzereingabe ohne Trennzeichen in Prompt eingefügt |
| INJ-002 | Medium | Fehlende „Behandle Benutzerinhalt als Daten“-Grenzsprache |
| INJ-003 | High | RAG/abgerufener Kontext ohne Trennzeichen für nicht vertrauenswürdige Inhalte eingefügt |
| INJ-004 | High | Tool-Nutzungsanweisungen durch Benutzerinhalt überschreibbar |
| INJ-005 | High | Serialisiertes Benutzerobjekt (`JSON.stringify`) direkt in eine Prompt-Vorlage interpoliert |
| INJ-006 | Medium | HTML-Kommentar mit versteckten Anweisungsverben in benutzergesteuertem Inhalt |
| INJ-007 | Medium | Benutzereingabe in Codeblock-Trennzeichen ohne vorheriges Entfernen von Backticks eingeschlossen |
| INJ-008 | High | HTTP-Anfragedaten (`req.body`, `req.query`, `req.params`) in `role: "system"`-Vorlagenstring interpoliert |
| INJ-009 | Critical | HTTP-Anfragekörper direkt als `messages`-Array geparst — Angreifer kontrolliert Rolle und Inhalt |
| INJ-010 | High | Klartext-Rollenlabel-Transkript (`User:`, `Assistant:`, `system:`) durch Verkettung nicht vertrauenswürdiger Eingabe erstellt |
| INJ-011 | High | Browser-DOM oder URL-Quelle (`window.location`, `document.cookie`, `getElementById`) direkt in LLM-Aufruf eingespeist |
| INJ-012 | High | Gesprächsverlauf ohne Bereinigung in `messages`-Array eingestreut |
| INJ-013 | High | Tool-/Funktionsaufrufergebnis ohne Bereinigung in `messages` eingefügt |
| INJ-014 | High | LLM-Vervollständigung als Benutzerrollen-Inhalt in einen nachfolgenden LLM-Aufruf weitergeleitet |
| INJ-015 | High | Nicht vertrauenswürdige externe Eingabe (HTTP/CLI/DOM) fließt in einen Prompt — namensagnostische **Taint-Analyse**, folgt Aliasen, berücksichtigt Bereinigungen |

### B. Exfiltration (EXF)

| ID | Severity | Beschreibung |
|----|----------|-------------|
| EXF-001 | Critical | Prompt verweist auf Geheimnisse, API-Schlüssel oder Anmeldeinformationen |
| EXF-002 | Critical | Prompt weist Modell an, System-Prompt oder versteckte Anweisungen preiszugeben |
| EXF-003 | High | Prompt zeigt Zugriff auf vertrauliche oder private Daten an |
| EXF-004 | High | Prompt enthält interne URLs oder Infrastruktur-Hostnamen |
| EXF-005 | High | Sensible Variable (Token, Passwort, Schlüssel) als Base64 in der Ausgabe codiert |
| EXF-006 | High | Vollständiger Prompt oder `message`-Array via `console.log` / `logger.*` ohne Schwärzung protokolliert |
| EXF-007 | Critical | Tatsächlicher Geheimniswert in Prompt eingebettet zusammen einer „niemals preisgeben“-Anweisung |

### C. Jailbreak (JBK)

| ID | Severity | Beschreibung |
|----|----------|-------------|
| JBK-001 | Critical | Bekannter Jailbreak-Satz erkannt („ignore instructions“, „DAN“, usw.) |
| JBK-002 | High | Schwache Sicherheitsformulierung („always comply“, „no matter what“) |
| JBK-003 | High | Rollenspiel-Notausstieg, der Sicherheitsbeschränkungen untergräbt |
| JBK-004 | High | Agent angewiesen, ohne Bestätigung oder menschliche Überprüfung zu handeln („proceed automatically“, „no confirmation needed“) |
| JBK-005 | High | Spurenlöschungs- oder Vertuschungsanweisung („delete logs“, „leave no trace“) |
| JBK-006 | High | Policy-Legitimitätsrahmen kombiniert mit einer unsicheren Handlungsanfrage („as a penetration tester, escalate privileges“) |
| JBK-007 | High | Modellidentitäts-Spoofing — behauptet, ein anderes KI-Modell zu sein, kombiniert mit einer Sicherheitsumgehungsanweisung |
| JBK-008 | High | Prompt-Komprimierungsangriff — Anweisung, den System-Prompt zu komprimieren oder zusammenzufassen |
| JBK-009 | High | Verschachtelte Anweisungsinjektion — imperative Befehle, eingewickelt in einen „sicheren/harmlosen Zusammenfassungs/Übersetzungs“-Rahmen |

### D. Unsafe Tool Use (TOOL)

| ID | Severity | Beschreibung |
|----|----------|-------------|
| TOOL-001 | Critical | Unbegrenzte Tool-Ausführung („run any command“, „browse anywhere“, Backtick-Shell-Ersetzung) |
| TOOL-002 | Medium | Tool-Nutzung ohne Allowlist oder Nutzungsrichtlinie beschrieben |
| TOOL-003 | High | Code-Ausführung ohne Sandbox-Einschränkungen erwähnt |
| TOOL-004 | Critical | Tool-Beschreibung oder Schema-Feld aus einer benutzergesteuerten Variable bezogen |
| TOOL-005 | Critical | Tool-Name oder Endpunkt-URL aus benutzergesteuerter Eingabe (`req.body`, `req.query`, usw.) bezogen |

### E. Command Injection (CMD)

Erkennt anfällige Muster im Code rund um KI-Tools, bei denen eine erfolgreiche Prompt-Injection zu einer vollständigen Befehlsausführung eskalieren kann. Basierend auf echten CVEs, die von Cyera Research Labs (2025) in Googles Gemini CLI gefunden wurden.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| CMD-001 | Critical | Shell-Befehl mit unbereinigter Variableninterpolation erstellt — JS/TS (`execSync(\`cmd ${var}\``), Python (`subprocess.run(f"cmd {var}")`), PHP (`shell_exec($var)`), Go (`exec.Command` + `fmt.Sprintf`), Rust (`Command::new` + `format!`) |
| CMD-002 | High | Unvollständige Befehlsersetzungsfilterung: blockiert `$()` aber nicht Backticks oder umgekehrt |
| CMD-003 | High | Dateipfad von `glob.sync` oder `readdirSync` direkt in einem Shell-Befehl ohne Bereinigung verwendet |
| CMD-004 | Critical | Python `subprocess.run`/`subprocess.call` mit `shell=True` und einem Variablen- oder f-String-Befehlsargument aufgerufen |
| CMD-005 | Critical | PHP `shell_exec`, `system`, `passthru`, `exec` oder `popen` mit einem `$variable`-Argument aufgerufen |

### F. RAG Poisoning (RAG)

Erkennt architektonische Fehler in Retrieval-Augmented-Generation-Pipelines, die es abgerufenen oder aufgenommenen Inhalten erlauben, systemseitige Anweisungen zu überschreiben.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| RAG-001 | High | Abgerufener oder externer Inhalt der Rolle `system` in einem `messages`-Array zugewiesen |
| RAG-002 | High | Anweisungsähnliche Phrasen („system prompt:“, „always return“, „never redact“) in einer Dokumentenaufnahmeschleife erkannt |
| RAG-003 | High | Agent-Gedächtnisspeicher direkt aus benutzergesteuerter Eingabe ohne Validierung geschrieben |
| RAG-004 | Medium | Prompt weist Modell an, abgerufenen Kontext als höchste Priorität zu behandeln und Entwickleranweisungen zu überschreiben |
| RAG-005 | Medium | Provenienzfreies Retrieval — Chunks ohne Prüfung der Quellmetadaten in Prompt eingefügt |
| RAG-006 | High | Kein ACL- oder Vertrauensstufenfilter angewendet, bevor das Retrieval in den Prompt gelangt |

### G. Encoding (ENC)

Erkennt codierungsbasierte Injektions- und Umgehungstechniken, bei denen Base64 oder ähnliche Codierungen verwendet werden, um Anweisungen an stringbasierten Filtern vorbeizuschmuggeln.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| ENC-001 | Medium | `atob`, `btoa` oder `Buffer.from(x, 'base64')` auf einer benutzergesteuerten Variable in der Nähe der Prompt-Konstruktion aufgerufen |
| ENC-002 | High | Versteckte Unicode-Steuerzeichen (Nullbreitenzeichen, bidirektionale Überschreibungen) in der Nähe von Anweisungsschlüsselwörtern erkannt |

### H. Output Handling (OUT)

Behandelt die Ausgabeseite der LLM-Pipeline — wie Ihre Anwendung Modellantworten verarbeitet. Unsichere Verarbeitung kann eine Prompt-Injection-Nutzlast in einen Exploit auf Anwendungsebene verwandeln.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| OUT-001 | Critical | `JSON.parse()` (JS/TS) oder `json.loads()` (Python) auf LLM-Ausgabe ohne Schema-Validierung (Zod, AJV, Joi, Pydantic, Marshmallow, usw.) aufgerufen |
| OUT-002 | Critical | LLM-generiertes Markdown oder HTML ohne DOMPurify oder gleichwertigen Bereiniger gerendert |
| OUT-003 | Critical | LLM-Ausgabe direkt als Argument für `exec()`, `eval()` oder `db.query()` verwendet |
| OUT-004 | Critical | Python `eval()` oder `exec()` mit LLM-generierter Ausgabe als Argument aufgerufen |

### I. Multimodal (VIS)

Behandelt Vertrauensgrenzverletzungen spezifisch für Vision, Audio/Video und OCR-Pipelines. Multimodale Eingaben sind ein aufkommender Injektionsvektor: Ein Angreifer, der eine Bild-URL, eine Audiodatei oder ein gescanntes Dokument kontrolliert, kann die Muster dieser Regeln nutzen, um Anweisungen in das Modell einzuschleusen.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| VIS-001 | Critical | Benutzergelieferte Bild-URL oder Base64-Daten ohne Domain- oder MIME-Validierung an eine Vision-API weitergeleitet (gpt-4o, Claude 3, Gemini Vision) |
| VIS-002 | Critical | `fs.readFile`/`readFileSync` mit einem benutzergesteuerten Pfad in einer Datei aufgerufen, die auch eine Vision-API-Nachricht erstellt — Pfad-Traversal in multimodale Eingabe |
| VIS-003 | High | Audio/Video-Transkriptionsausgabe (Whisper, AssemblyAI, Deepgram, usw.) direkt ohne Bereinigung in Prompt-Nachrichten eingespeist — RAG-Vergiftung durch Audioquelle |
| VIS-004 | High | OCR-Ausgabe (Tesseract, Google Vision) in eine `role: "system"`-Nachricht oder System-Prompt-Variable interpoliert |

### J. Skills Marketplace (SKL) — v1.1

Zielt auf OpenClaw `SKILL.md`-Dateien und alle Markdown-Dateien in `skills/`-Verzeichnissen ab. Schlägt an bei Selbstautorisierungsangriffen, Remote-Skill-Laden, injizierten Anweisungen, unsicherem Befehlsversand, Zugriff auf sensible Pfade, Privilegieneskalationsbehauptungen und hartcodierten Anmeldeinformationen im YAML-Frontmatter.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| SKL-001 | Critical | Skill-Körper weist Agenten an, andere Skill-Dateien zu schreiben oder zu ändern — Selbstautorisierungsangriff, der über Agent-Neustarts hinweg bestehen bleibt |
| SKL-002 | Critical | Skill-Körper weist Agenten an, Skills von einer externen URL abzurufen oder zu laden — erlaubt Angreifer, Skill-Verhalten nach der Installation zu ändern |
| SKL-003 | Critical | Skill-Körper enthält Prompt-Injektionsphrasen, die auf Kernanweisungen des Agenten abzielen (`ignore previous instructions`, `you are now unrestricted`, usw.) |
| SKL-004 | High | Skill-Frontmatter verwendet `command-dispatch: tool` mit `command-arg-mode: raw` — leitet rohe Benutzereingabe an ein Tool weiter und umgeht die Sicherheitslogik des Modells |
| SKL-005 | High | Skill-Körper verweist auf sensible Dateisystempfade (`~/.ssh`, `~/.env`, `/etc/passwd`, `../../`) für den Agenten zum Lesen und potenziellen Exfiltrieren |
| SKL-006 | High | Skill-Körper beansprucht erhöhte Privilegien oder weist Agenten an, andere installierte Skills zu überschreiben oder zu deaktivieren |
| SKL-007 | Critical | Hartcodierter Anmeldeinformationswert (API-Schlüssel, Token, Passwort) im YAML-Frontmatter gefunden — für jeden offengelegt, der den Skill erhält oder installiert |
| SKL-008 | Critical | Heartbeat C2 — Skill plant periodischen Remote-Abruf, um nach einer sauberen Installation stillschweigend seine eigenen Anweisungen zu überschreiben |
| SKL-009 | Critical | Agentenidentitätsverweigerung — Skill weist Agenten an zu leugnen, KI zu sein, zu behaupten, menschlich zu sein, oder eine trügerische Persona anzunehmen |
| SKL-010 | Critical | Anti-Scanner-Umgehung — Skill enthält Text, der explizit dazu entwickelt wurde, Sicherheitsaudit-Tools in die Irre zu führen |
| SKL-011 | Critical | SOUL.md / IDENTITY.md-Persistenz — Skill schreibt Anweisungen in Agentenidentitätsdateien, die eine Deinstallation überleben |
| SKL-012 | High | Selbstverbreitender Wurm — Skill weist Agenten an, sich per SSH oder `curl\|bash` auf erreichbare Hosts auszubreiten |
| SKL-013 | High | Autonome Finanztransaktionen — Skill führt Kryptotransaktionen aus oder hält private Schlüssel ohne pro-Transaktions-Benutzerbestätigung |

> **Scanning von OpenClaw-Skills:** Führen Sie `npx hound scan --dir ./skills` aus oder fügen Sie `**/skills/**/*.md` und `**/SKILL.md` zu Ihrer `include`-Konfiguration hinzu. ContextHound gibt Skill-Dateien automatisch als `code-block` für mehrzeilige Regelanalyse aus.

### K. Agentic (AGT) — v1.3 / v1.9

Zielt auf Risiken ab, die spezifisch für mehrstufige agentische Systeme sind: unbegrenzte Ausführungsschleifen, unvalidierte Speicherschreibvorgänge, Benutzereingabe, die in Agentenplanung einfließt, Vertrauensgrenzverletzungen zwischen Agenten und OWASP Agentic AI Security Issues (ASI)-Lücken.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| AGT-001 | Critical | Tool-Call-Parameter empfängt System-Prompt-Inhalt — `tool_call`/`function_call`-Argumentwert enthält `system:`- oder `instructions:`-Feldinhalte |
| AGT-002 | High | Agentenschleife ohne Iterations- oder Zeitüberschreitungsschutz — keine `max_iterations`, `max_steps`, `max_turns`, `timeout` oder `recursion_limit` in Agentenkonfiguration oder -code |
| AGT-003 | High | Agentenspeicher aus unvalidierter LLM-Ausgabe geschrieben — `memory.save()`, `memory.add()` oder `vectorstore.upsert()` mit einer rohen Modellantwortvariable aufgerufen |
| AGT-004 | High | Plan-Injection — Benutzereingabe direkt in Agentenplanungs-, Aufgaben- oder Ziel-Prompt ohne Vertrauensgrenzen-Umhüllung interpoliert |
| AGT-005 | Critical | Agent vertraut beanspruchter Identität ohne kryptografische Verifikation — Vertrauensentscheidung basierend auf `agentId`-, `sender`-, `source`- oder `from_agent`-Feld ohne HMAC-, JWT- oder Shared-Secret-Verifikation |
| AGT-006 | High | Rohe Agentenausgabe ohne Validierung als Eingabe für einen anderen Agenten verkettet — `.run()`, `.invoke()` oder `.generate()` mit direktem `.output`/`.content`/`.result` eines anderen Agenten als Argument aufgerufen |
| AGT-007 | Critical | Agentenselbstmodifikation — Agent überschreibt zur Laufzeit seinen eigenen `system_prompt`, `instructions` oder `tools`-Liste mit LLM-generiertem Inhalt |
| AGT-008 | Critical | ASI03 — Agent ruft `assumeRole`, `grantAccess` oder `setPermissions` mit einem aus LLM-Ausgabe abgeleiteten Wert auf; Privilegieneskalation durch Prompt-Injection |
| AGT-009 | High | ASI04 — Agent lädt zur Laufzeit ein Tool oder Plugin aus einem variablen Pfad oder dynamischen Import, was Supply-Chain-Substitution ermöglicht |
| AGT-010 | High | ASI07 — Rohe Agentenausgabe per `send`/`route`/`dispatch` ohne HMAC, JWT-Signierung oder Schema-Validierung an einen anderen Agenten weitergeleitet |
| AGT-011 | High | ASI08 — Fehler im Agentenplanschritt still abgefangen (kein Rethrow, kein Fehlerzustands-Flag); nachgelagerte Schritte fahren mit schlechtem oder unvollständigem Zustand fort |

### L. MCP Security (MCP) — v1.7 / v1.8

Behandelt Vertrauensgrenz- und Supply-Chain-Risiken, die spezifisch für das Model Context Protocol sind. MCP führt eine neue Angriffsfläche ein: Tool-Beschreibungen, Transport-URLs, Ereignis-Nutzlasten und gemeinsamer serverübergreifender Zustand können alle Injektions- oder Privilegieneskalations-Nutzlasten tragen.

| ID | Severity | Beschreibung |
|----|----------|-------------|
| MCP-001 | Critical | MCP-Tool-Beschreibung ohne Bereinigung in LLM-Prompt injiziert — roher `tool.description`-Wert in `role: "system"` oder `messages.push()` verwendet |
| MCP-002 | High | MCP-Tool mit dynamischem Namen oder Beschreibung registriert — erstes Argument von `server.tool()` ist eine Variable oder ein Template-Literal, was Rug-Pull-Angriffe nach der Genehmigung ermöglicht |
| MCP-003 | High | MCP sampling/createMessage-Handler ohne menschliche Genehmigungssicherung — `setRequestHandler(CreateMessageRequestSchema)` ohne `requireHumanApproval`-, `confirm`- oder `approve`-Prüfung |
| MCP-004 | Medium | MCP-Transport-URL aus Variable konstruiert — `SSEClientTransport` oder `WebSocketClientTransport` mit `new URL(variable)` anstelle eines statischen Strings initialisiert |
| MCP-005 | High | MCP stdio-Transport verwendet `shell: true` — macht den Befehlsstring shell-interpoliert und injizierbar, wenn ein Argument benutzergesteuert ist |
| MCP-006 | Critical | MCP Confused Deputy — Auth-Token aus MCP-Anfrage ohne erneute Validierung an nachgelagerte API weitergeleitet; `Authorization`-Header-Wert direkt von `request.params`, `context` oder `event` bezogen |
| MCP-007 | High | Cross-MCP-Kontextvergiftung — geteilter/globaler Kontextspeicher aus MCP-Ausgabe ohne Hash-, Signatur- oder Provenienzprüfung geschrieben |
| MCP-008 | High | MCP stdio-Transportbefehl aus variablem Pfad geladen — `StdioClientTransport`/`StdioServerTransport` `command:`-Feld ist eine Variable anstelle eines statischen String-Literals |
| MCP-009 | High | MCP-Sitzungs-ID als Authentifizierungsentscheidung ohne Ablaufprüfung verwendet — `sessionId`/`connectionId`-Gleichheitsvergleich ohne TTL, `expiresAt` oder `isExpired`-Schutz (Replay-Angriff) |
| MCP-010 | Critical | MCP-Transportereignis-Nutzlast ohne Bereinigung in LLM-Kontext injiziert — Ereignis-/Nachrichten-`.data`, `.content` oder `.payload` direkt in `messages.push()` oder einem `content:`-Feld verwendet |

---

## Beispielausgabe```
=== ContextHound Prompt Audit ===

src/prompts/assistant.ts (file score: 73)
  [HIGH] INJ-001: Direct user input concatenation without delimiter
    File: src/prompts/assistant.ts:12
    Evidence: Answer the user's question: ${userInput}
    Confidence: medium
    Risk points: 23
    Remediation: Wrap user input with clear delimiters (e.g., triple backticks)
                 and label it as "untrusted user content".

  [CRITICAL] EXF-001: Prompt references secrets, API keys, or credentials
    File: src/prompts/assistant.ts:8
    Evidence: The database password is: secret123.
    Confidence: high
    Risk points: 50
    Remediation: Remove all secret values from prompts. Use environment
                 variables server-side; never embed credentials in prompt text.

────────────────────────────────────────────────────────
Repo Risk Score: 87/100 (CRITICAL)
Threshold: 60
Total findings: 5
By severity: critical: 2  high: 2  medium: 1

✗ FAILED - score meets or exceeds threshold.

## Benchmark

ContextHound enthält einen markierten Benchmark-Datensatz zur Messung der Falsch-Positiv- und Erkennungsraten. Führen Sie ihn nach dem Erstellen aus:```bash
npm run benchmark

Der Benchmark beendet sich mit Exit-Code 1, wenn Fehlalarme (false positives) oder übersehene Bedrohungen (false negatives) gefunden werden, was ihn als CI-Qualitätsgate für Regeländerungen geeignet macht. Um eine Testvorlage hinzuzufügen, legen Sie eine Datei in `benchmarks/safe/` oder `benchmarks/unsafe/` ab und aktualisieren Sie `benchmarks/labels.json` mit den erwarteten Funden.

### Präzision/Recall pro Regel

Der Benchmark gibt außerdem eine **Signaltabelle pro Regel** aus (schlechtestes F1 zuerst), sodass Regeln mit geringer Präzision leicht zu erkennen sind – True/False Positives, False Negatives, Präzision, Recall und F1 für jede gekennzeichnete Regel. Die FP-Zahlen stammen aus den `safe/` Testvorlagen (Ground Truth: null Funde); TP/FN stammen aus den gekennzeichneten `unsafe/` Testvorlagen. Übergeben Sie `--report <path>`, um auch einen maschinenlesbaren JSON-Bericht für Dashboards oder CI-Trendverfolgung auszugeben:```bash
npm run benchmark -- --report bench-report.json