Jede Maschinenaktion, die Ihr Agent ausführt, sollte eine Grenze zwischen Ihren Geheimnissen und dem offenen Internet überschreiten. Pipelock wird zu dieser Grenze, wenn der Agent durch seinen Proxy, MCP-Wrapper, Sandbox, Host-Containment-Modell oder Cluster-Deployment-Topologie geleitet wird. Es scannt vermittelten ausgehenden und eingehenden Datenverkehr, blockiert oder markiert Angriffe je nach Modus und zeichnet signierte Beweise der Entscheidung auf.

---

## Überprüfen Sie es selbst

Die meisten Agent-Sicherheitstools verlangen, dass Sie ihrem Dashboard vertrauen. Pipelock gibt Ihnen eine signierte Quittung und ermöglicht es Ihnen, diese selbst offline mit einem von Ihnen verwahrten Schlüssel zu überprüfen. Kein Konto und kein Server.

Die eingebaute Demo startet echte Angriffsszenarien, blockiert sie und schreibt signierte Quittungen sowie den öffentlichen Schlüssel ohne Konfiguration und ohne Netzwerk auf die Festplatte:```bash
pipelock demo --receipts-dir ./out                                   # runs attack scenarios, writes 7 signed receipts + signer.pub
pipelock verify-receipt "$(ls ./out/*.json | head -1)" --key ./out/signer.pub  # check a signature yourself (each receipt is <action-id>.json)

Zwei Ehrlichkeitshinweise vorab. Die Demo signiert mit einem ephemeren Schlüssel, den sie für den Durchlauf ausgibt, was beweist, dass die Belege in sich konsistent sind und nicht an eine benannte Identität gebunden sind. Der öffentliche Pipelock-Playground ist ein separater Pfad, der gegen einen von Pipelock veröffentlichten Schlüssel verifiziert. Und der Betreiber, der Pipelock ausführt, besitzt den Signaturschlüssel, sodass ein Beleg beweist, was die Grenze entschieden hat und dass der Schlüsselinhaber ihn signiert hat, nicht dass der Betreiber ehrlich ist. `pipelock anchor receipts` zeichnet Belegketten-Checkpoints in einem lokalen Backend oder einem Rekor-Transparenzlogbuch zur späteren Prüfung auf, und die betreiberunabhängige Verifizierung gegen diesen Anker wird noch Ende-zu-Ende nachgewiesen.

Das vollständige Argument, warum Beweise besser sind als Versprechungen, findet sich in [Demonstration über Attestierung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/security/demonstration-over-attestation.md).

---

## Quick Start```bash
# Install from source (Go 1.25+)
go install github.com/luckyPipewrench/pipelock/cmd/pipelock@latest

# Set up local agent integrations and generate a config
pipelock init

# Test the scanner
pipelock check --url "https://evil.com/?k=AKIAIOSFODNN7EXAMPLE"  # blocked: AWS Access ID
pipelock check --url "https://docs.python.org/3/"                # allowed

- **Eingangsscanning:** MCP-Client-Anfragen werden auf DLP-Lecks und Injection in Tool-Argumenten überprüft.
- **Antwortscanning:** Server-Antworten werden gescannt, bevor der Agent sie sieht.
- **Tool-Poisoning:** `tools/list`-Beschreibungen werden auf versteckte Anweisungen und Mid-Session-Rug-Pull-Änderungen überprüft.
- **Tool-Richtlinie:** 17 integrierte Regeln blockieren destruktive Dateilöschungen, Credential-Zugriff, Reverse Shells, Persistenzmechanismen, codierte Befehlsausführung und verwandte hochriskante Tool-Aufrufe vor der Ausführung.
- **Tool-Aufrufketten:** 10 integrierte Kategorie-Achsen-Muster erkennen Reconnaissance, Credential-Diebstahl, Data Staging, Persistenz, Exfiltration und Callback-Ketten mit konfigurierbarer Lückentoleranz.
- **A2A-Inspektion:** Google Agent-to-Agent-Protokollverkehr wird auf den Vorwärts- und MCP-Pfaden inspiziert; Pipelock ist kein eigenständiger A2A-Proxy.
- **Authentifizierte MCP-HTTP-Listener (v3.2.0):** Nicht-Loopback-MCP-Listener schlagen standardmäßig geschlossen fehl und erfordern `--mcp-auth-token-file` oder ein explizites `--mcp-allow-unauthenticated` für netzwerkrichtlinienisolierte Bereitstellungen. Tokenlose Loopback-Listener lehnen DNS-Rebound- und falsche Port-Host-Autoritäten ab und entfernen Listener-Anmeldeinformationen aus Headern.

### Eindämmung

Die prozessuale Eindämmung ohne Privilegien verwendet OS-native Primitive. Linux verwendet Landlock, seccomp und Netzwerk-Namespaces. macOS verwendet `sandbox-exec`-Profile. In Containern behält `--best-effort` Landlock und seccomp bei, wenn die Namespace-Erstellung eingeschränkt ist, während die Netzwerkscanning Proxy-basiertes Routing verwendet.```bash
pipelock sandbox --config pipelock.yaml -- python agent.py
pipelock sandbox --best-effort -- python agent.py
pipelock mcp proxy --sandbox --config pipelock.yaml -- npx server

`pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` verwaltet ein 3-UID-Modell aus Operator / Proxy / Agent mit nftables-owner-match-Routing, systemd-Dienst-Einrichtung, Wrapper-Befehlen, Workspace-ACLs, CA-Aktualisierung und Posture-Evidence. Siehe [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md).

### Evidence-Nachweise und Quittungen

- **Flugschreiber:** Hash-verkettetes JSONL-Evidence-Protokoll mit Ed25519-signierten Checkpoints und DLP-Redaktion. `pipelock init` richtet ein Recorder-Verzeichnis und einen Signaturschlüssel für Standardinstallationen ein, während der Recorder inaktiv bleibt, bis ein Verzeichnis und ein Schlüssel vorhanden sind. Siehe [Flugschreiber](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/flight-recorder.md).
- **Aktionsquittungen:** Signierte Datensätze, die für vermittelte Aktionen ausgegeben werden und das Urteil, den Policy-Hash, den Transport und die Scanner-Ebene enthalten. Blöcke erzeugen Quittungen; die Durchsetzung von Allow-Path-Quittungen erfordert `flight_recorder.require_receipts`. Überprüfung mit `pipelock verify-receipt --key <signer.pub>`. Nicht-gepinnte Ausführungen sind nur strukturell und beenden mit einem Fehler, es sei denn, `--allow-unpinned` wird übergeben.
- **Vermittlungs-Envelope:** RFC 8941 Sideband-Metadaten auf weitergeleiteten HTTP-Anfragen und MCP `_meta`, mit Aktionstyp, Urteil, Akteursidentität, Policy-Hash, Taint-Kontext und Quittungs-Korrelations-ID. Siehe [Föderationsanleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md).
- **Quittungskonformität:** Vier unabhängige sprachübergreifende Verifizierer-Implementierungen (Go, TypeScript, Rust und Python) laufen gegen einen gemeinsamen [Konformitätskorpus](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/conformance/), einschließlich fehlerhafter und fälschbarer Eingaben wie doppelte Schlüssel, Integer-Überlauf und ungepaarte Surrogate. Eine Browser-WASM-Oberfläche verwendet die Go-Verifizierer-Implementierung. AARP/SVID-Bewertung bleibt ein Offline-Verifiziererprofil, keine Laufzeit-Identitätsdurchsetzung.
- **Anker:** `pipelock anchor receipts` zeichnet Quittungsketten-Checkpoints in einem lokalen Backend oder Rekor auf. Rekor-Ankerung ist Beweismaterial für spätere Audits; die Rekor-Überprüfung erfordert gepinnte Log-Schlüssel, und der End-to-End-Pfad zur Operator-Unabhängigkeit wird noch nachgewiesen.
- **Posture-Kapsel:** `pipelock posture emit` und `pipelock posture verify` erstellen und prüfen eine signierte Momentaufnahme des Durchsetzungs-Posture einer Bereitstellung, mit einem CI-Gate und Bewertungsmodell, damit ein Prüfer bestätigen kann, dass die Grenze wie behauptet konfiguriert wurde.

### Flotte und Unternehmen

- **Operator-Dashboard:** `pipelock dashboard serve` ist eine schreibgeschützte Konsole über signierten Evidence. Pro entsperrt die Ansichten Übersicht, Evidence, Ausnahmen, Agenten, Budgets und Vertrauen & Schlüssel; Enterprise fügt die Ansichten Flotte, Arbeitsbank und Vorfälle hinzu. Siehe [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md).
- **Kostenloser Evidence-Viewer:** `pipelock evidence serve` und `pipelock evidence view` rendern eine ausgewählte Recorder-Sitzung ohne Lizenz oder agentenübergreifende Aufzählung. `pipelock evidence verify-cert` überprüft offline von Pro ausgestellte Deckungszertifikate.
- **Conductor:** Enterprise-Flottensteuerungsebene für signierte Policy-Bundle-Verteilung, signierten Evidence-Sink (`pipelock fleet-sink`), Registrierung, Remote-Kill, Rollback, Trockenlauf, Entscheidungs-Wiederholung und Laufzeit-/Apply-Status-Abweichungsprüfung über mTLS/SPIFFE. Folger setzen lokal durch; der Standardmodus für veraltete Policy aktiviert nach seinem Gnadenfenster eine unabhängige Verweigerungsquelle, während der dokumentierte `continue_last_known_good`-Override diese Haltung schwächt. Conductor besitzt keine Agentengeheimnisse. Siehe die [Conductor-Anleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md).
- **Rechtliche Aufbewahrung:** `pipelock dashboard legal-hold add/list/review` verwaltet Aufbewahrungsanordnungen als Compliance-Metadaten, die außerhalb der HTTP-Autorität des Dashboards gespeichert werden, sodass ein kompromittiertes Dashboard Aufbewahrungen lesen, aber niemals fälschen oder löschen kann.
- **Verhaltens-Baseline:** Profilieren-dann-Sperren für das MCP-Toolverhalten mit `pipelock baseline list/show/ratify/forget` zur Operator-Freigabe und zum Neulernen. Siehe [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md).

### Betriebsfähigkeit

- **Kill-Schalter:** Sechs unabhängige Aktivierungsquellen: Konfigurationsdatei, Remote-API, SIGUSR1, Sentinel-Datei, Conductor-Remote-Kill und veraltetes Bundle-Erkennung. Jede aktive Quelle blockiert den Datenverkehr, mit Endpunkt- und IP-Ausnahmen im Controller.
- **Scan-API:** Programmgesteuertes Scannen für `url`-, `dlp`-, `prompt_injection`- und `tool_call`-Urteile mit Bearer-Token-Authentifizierung, Ratenbegrenzung pro Token, strukturierten Befunden und Prometheus-Metriken. Siehe [docs/scan-api.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/scan-api.md).
- **Dateisystem-Sentinel:** Überwacht Arbeitsverzeichnisse von Agenten auf auf die Festplatte geschriebene Geheimnisse und ordnet Schreibvorgänge der MCP-Subprozess-Abstammung unter Linux zu. Siehe [docs/guides/filesystem-sentinel.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/filesystem-sentinel.md).
- **Ereignisausgabe:** Leitet Audit-Ereignisse an SIEMs, Webhook-Empfänger, Syslog, CEF, OTLP und Metrikausgaben weiter, ohne den Proxy-Hot-Path zu blockieren. Siehe [docs/guides/siem-integration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/siem-integration.md).
- **Sicherheitsbewertung:** `pipelock assess init`, `pipelock assess run` und `pipelock assess finalize` orchestrieren Angriffssimulation, Konfigurationsbewertung, Installationsprüfung und MCP-Erkennung in einem reproduzierbaren Evidence-Bundle. Kritische Gefährdungen wie ungeschützte MCP-Server begrenzen die Note unabhängig vom numerischen Score. Die kostenlose Zusammenfassung zeigt Ihre Note, Bereichsergebnisse und Top-Befunde; eine Lizenz entsperrt den vollständigen Bericht mit server-spezifischen Befunden, Abhilfebefehlen und Ed25519-signierten Evidence.

<details>
<summary>Weitere Funktionen</summary>

| Funktion | Was sie tut |
|---------|-------------|
| **Audit-Berichte** | `pipelock report --input events.jsonl` erzeugt HTML/JSON/Bundle-Berichte mit Risikobewertung, Zeitstrahl und Evidence-Anhang. Ed25519-Signierung mit `--sign`. ([Beispielbericht](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/sample-report.html)) |
| **Diagnose** | `pipelock diagnose` führt 7 lokale Prüfungen durch, um Ihre Konfiguration ohne Netzwerk Ende-zu-Ende zu verifizieren. |
| **Durchsetzungsarzt** (v2.5) | `pipelock doctor` meldet den konfigurierten vs. durchsetzbaren Status für Proxying, TLS-Interception, Request-Body-Scanning, Browser Shield, MCP-Wrapping, MCP-Binär-Integrität, Tool-Provenienz, file_sentry, Sentry und Bereitstellungsgrenzen-Signale. |
| **Request-Body-Injection-Blockierung** (v2.5) | Request-Body-Prompt-Injection und kritische DLP-Befunde blockieren in „Enforce“-Modus hart Nicht-Provider-Ziele über Forward-, Reverse-, TLS-Intercept- und WebSocket-Transporte hinweg, mit Block-Grund-Headern zur operator-sichtbaren Diagnose. |
| **Anfragepolicy** (v2.6) | Standardmäßig erlauben, verweigern/warnen von Schienen auf ausgehenden API-Operationen: Übereinstimmung von Route plus GraphQL-Operations-Prädikaten, Rekursion in JSON `$batch`-Envelopes, Fehlschließen bei unparsbaren oder undurchsichtigen Bodies, und Ausführung vor dem Vertragsgate. Siehe die [Anfragepolicy-Anleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/request-policy.md). |
| **TLS-Interception** | Optionaler CONNECT-Tunnel-MITM: Entschlüsseln, Scannen von Bodies/Headern/Antworten, Wiederverschlüsseln. `pipelock tls init` erzeugt eine CA, dann gibt `pipelock tls install-ca` Schritte zur Installation des Plattform-Vertrauensspeichers aus. |
| **Block-Hinweise** | Optionales `explain_blocks: true` fügt Korrekturvorschläge zu blockierten Antworten hinzu. |
| **Projekt-Audit** | `pipelock audit ./project` scannt auf Sicherheitsrisiken und erzeugt eine maßgeschneiderte Konfiguration. |
| **Konfigurationsbewertung** (v2.6) | `pipelock audit score --config pipelock.yaml` bewertet die Sicherheitslage in 23 Kategorien mit einem 170-Punkte-Budget und einer Buchstabennote. |
| **Dateiintegrität** | SHA256-Manifeste erkennen geänderte, hinzugefügte oder gelöschte Workspace-Dateien. |
| **Git-Schutz** | `git diff \| pipelock git scan-diff` fängt Geheimnisse vor dem Commit ab. |
| **Ed25519-Signierung** | Schlüsselverwaltung, Dateisignierung und Signaturüberprüfung für Multi-Agent-Vertrauen. |
| **Sitzungsprofilierung** | Sitzungsbezogene Verhaltensanalyse für Domain-Bursts und Volumenspitzen. |
| **Adaptive Durchsetzung** | Sitzungsbezogener Bedrohungswert mit Eskalation von Warnen zu Blockieren, Deeskalations-Timer und Domain-Burst-Erkennung. |
| **Adaptive Operator-CLI** (v2.5) | `pipelock adaptive status / flush / whoami` gibt den Laufzeit-Adaptivstatus über die authentifizierte Admin-API frei. Siehe [`docs/cli/adaptive.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/adaptive.md). |
| **Befundunterdrückung** | Bekannte False-Positives durch Konfigurationsregeln oder Inline-`pipelock:ignore`-Kommentare unterdrücken. |
| **Multi-Agent-Unterstützung** | Agent-Identifikation über `X-Pipelock-Agent`-Header für agentenbezogene Filterung. |
| **Flottenüberwachung** | Instanzbezogene Prometheus-Metriken plus [Grafana-Dashboard](https://github.com/luckypipewrench/pipelock/blob/HEAD/configs/grafana-dashboard.json) zum Importieren. Kostenlose Einzelinstanzüberwachung, zu unterscheiden von Conductor. |
| **Operator-Dashboard** (v3.1, Pro/Enterprise) | `pipelock dashboard serve` bietet schreibgeschützte Ansichten für Übersicht, Evidence, Ausnahmen, Agenten, Budgets, Vertrauen & Schlüssel, Flotte, Arbeitsbank und Vorfälle mit Token-, OIDC- oder mTLS-Authentifizierung, begrenztem RBAC, Rohansicht-Erhöhung, Backup/Wiederherstellung, Ausnahmen-Lebenszyklus-Datensätzen und Deckungszertifikaten. Siehe [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md). |
| **Kostenloser Evidence-Viewer** (v3.1) | `pipelock evidence serve` stellt eine ausgewählte Recorder-Sitzung als schreibgeschützten HTML-Bericht ohne Lizenz und ohne agentenübergreifende Aufzählung bereit. `pipelock evidence verify-cert` überprüft offline von Pro ausgestellte Deckungszertifikate. |
| **Conductor: Flottensteuerungsebene** (v2.7, Enterprise) | Signierte Policy-Bundle-Verteilung, signierter Evidence-Audit-Sink (`pipelock fleet-sink`), Registrierung, Remote-Kill, Policy-Rollback, Trockenlauf, Entscheidungs-Wiederholung und Laufzeit-/Apply-Status-Abweichungsprüfung über mTLS/SPIFFE. Gesteuert durch die `fleet`-Lizenzfunktion; Verhalten bei veralteter Policy ist explizit und standardmäßig strikt verweigern. Siehe die [Conductor-Anleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md). |
| **A2A-Scanning** | Agent Card-Poisoning-Erkennung, Card-Drift-Überwachung und Session-Schmuggel-Prävention für Googles Agent-to-Agent-Protokoll auf Forward-/MCP-Pfaden. |
| **Verhaltens-Baseline** | Profilieren-dann-Sperren für das MCP-Toolverhalten mit `pipelock baseline list/show/ratify/forget` zur Operator-Freigabe und zum Neulernen. Siehe [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md). |
| **Denial-of-Wallet** | Agentenbezogene MCP-Budgets für gesamte Tool-Aufrufe, gleiche Tool-Wiederholungen, Schleifen-/Zyklenerkennung und Wanduhrzeit. |
| **Taint-Eskalation** | Belastungsbasierte Policy-Eskalation über MCP- und Aufgaben-Grenzen hinweg, bis das Vertrauen wiederhergestellt ist. |
| **Vermittlungs-Envelope** | RFC 8941 Sideband-Metadaten auf weitergeleiteten HTTP-Anfragen und MCP `_meta`, mit eingehender Überprüfung, Wiederholungsschutz, SPIFFE-Akteursformat und einem RFC 9421-Signaturschlüsselverzeichnis. Siehe [Föderationsanleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Quittungskonformität** | Implementierungsübergreifender Quittungsverifizierungssatz (`sdk/conformance/`) über unabhängige Go-, TypeScript-, Rust- und Python-Implementierungen, plus eine Browser-WASM-Oberfläche basierend auf Go. `EvidenceReceipt v2` verwendet RFC 8785/JCS-Kanonisierung. AARP/SVID-Bewertung bleibt offline verifiziererseitig. |
| **Lernen-und-Sperren** (v2.4) | Agentenbezogene Verhaltensverträge: Datenverkehr beobachten, einen signierten Kandidatenvertrag erstellen, aufgezeichnete Beobachtungen im Schattenmodus wiedergeben, pro Regel ratifizieren, das signierte aktive Manifest übernehmen und auf URL-tragenden Transporten sowie MCP-Tool-Aufrufen durchsetzen. Siehe [Lernen-und-Sperren-Anleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/learn-and-lock.md). |
| **Block-Grund-Header** (v2.4) | `X-Pipelock-Block-Reason` auf HTTP-fähigen Block-Pfaden, mit dem gleichen Grundvokabular auf MCP-JSON-RPC-Fehlermetadaten. Siehe [Block-Grund-Header](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/block-reason-header.md). |
| **Keil-Erkennungs-Watchdog** (v2.4) | `health_watchdog` gibt `/health` 503 zurück, wenn ein Subsystem-Herzschlag veraltet ist. Siehe [Health-Endpunkt-Anleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/health.md). |
| **Redaktionsanbieter-Plugin-Form** (v2.4) | Eigenentwickelte Redaktionsparser für Anthropic-, OpenAI- und Gemini-Chat-APIs, mit einem Anbieter-Plugin-Form für Drittanbieter-Parser. |
| **Audit-Packet v0-Schema + Verifizierer** (v2.5) | Eigenentwickeltes kanonisches Audit-Packet-Schema mit Go-, TypeScript- und Rust-Verifizierer-Implementierungen, plus eigenständige [`pipelock-verifier`](https://github.com/luckypipewrench/pipelock/blob/HEAD/cmd/pipelock-verifier/)-CLI. Schema unter [`sdk/audit-packet/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/audit-packet/); Verifizierer-Pakete unter [`sdk/verifiers/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/verifiers/). |
| **Host-Containment-Lebenszyklus** (v2.5) | `pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` verwaltet das 3-UID-Containment-Modell. Siehe [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md). |
| **MCP-Integritätsmanifeste** (v2.5) | `pipelock mcp integrity manifest generate / verify / sign / verify-signature` pinnt MCP-Server-Binärdateien/Skripte durch Hash und kann eine vertrauenswürdige Manifestsignatur vor dem Subprozessstart verlangen. Siehe [`docs/cli/mcp-integrity.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/mcp-integrity.md). |
| **Kubernetes-MCP-Starter-Vertrag** (v2.5) | `pipelock init sidecar --mcp-upstream` gibt Begleiter-Listener-Konfiguration, Service-Port, Workload-Annotationen, NetworkPolicy-Erlaubnis, `PIPELOCK_MCP_PROXY_URL` und eingebundenes `PIPELOCK_MCP_CONFIG` aus. Siehe [`docs/cli/init-sidecar.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/init-sidecar.md). |
| **Föderations-Strict-Modus** (v2.5) | Eingehende Vermittlungs-Envelope-Überprüfung erfordert standardmäßig SPIFFE-Format-Akteure, Vertragstombstones werden durchgesetzt, und `pipelock envelope trust add/list/remove/verify` verwaltet lokales Vertrauen. Siehe [Föderationsanleitung](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Medien-Policy** | Entfernt steganografische Metadaten aus JPEG/PNG, lehnt Audio/Video standardmäßig ab, härtet SVG-Aktivinhalt und erzwingt Bildgrößenbeschränkungen. Siehe [Medien-Policy](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/media-policy.md). |
| **Compliance-Zuordnungen** | OWASP MCP Top 10, OWASP Agentic Top 15, OWASP LLM Top 10, NIST 800-53, EU AI Act sowie Beschaffungs-/Audit-Zuordnungen. |

</details>

---

## Kostenlos, Pro und Enterprise

Alle Erkennungs-, Durchsetzungs-, Containment- und Einzelagenten-Evidence sind unter Apache 2.0 für immer kostenlos. Kostenpflichtige Stufen fügen Multi-Agent-Koordination (Pro) sowie Flotten-Governance und Compliance (Enterprise) hinzu.

| Fähigkeit | Kostenlos | Pro | Enterprise |
|---|:--:|:--:|:--:|
| Scanning und Erkennung (geordnete URL-Pipeline, DLP, Injection, SSRF, Streaming-SSE, Redaktion, Adressschutz) | Ja | Ja | Ja |
| MCP- und A2A-Scanning (Eingabe, Antwort, Tool-Policy, Tool-Kette, Poisoning, Integrität, authentifizierte Listener) | Ja | Ja | Ja |
| Containment, Sandbox, Host `contain`, 6-Quellen-Kill-Schalter | Ja | Ja | Ja |
| Aktionsquittungen, Flugschreiber, Anker, kostenloser Evidence-Viewer, `verify-cert`, eigenständiger Verifizierer | Ja | Ja | Ja |
| Kanarienvogel-Tokens, Skill-Scan, `explain`, Einzelinstanz-Prometheus und Grafana | Ja | Ja | Ja |
| Agentenbezogene Profile: Identität, Budgets, Konfigurations- und Scanner-Isolation, agentenbezogene Sandbox | Nein | Ja | Ja |
| Agentenbezogenes Routing durch Quell-CIDR und Netzwerk-Selektor | Nein | Ja | Ja |
| Operator-Dashboard: Übersicht, Evidence, Ausnahmen, Agenten, Budgets, Vertrauen & Schlüssel | Nein | Ja | Ja |
| Agentenbezogene Deckungszertifikate | Nein | Ja | Ja |
| Rechtliche Aufbewahrung und Compliance-Metadaten | Nein | Ja | Ja |
| Conductor-Flottensteuerungsebene, `fleet-sink`-Audit-Sink, Remote-Kill, Rollback, Entscheidungs-Wiederholung, Abweichungsprüfung | Nein | Nein | Ja |
| mTLS-Folger-Registrierung und rostergeprüfte signierte Policy-Verteilung | Nein | Nein | Ja |
| Dashboard-Flottenansichten: Flotte, Arbeitsbank, Vorfall | Nein | Nein | Ja |

Der signierte `pipelock assess`-Bericht ist eine separate `assess`-Berechtigung, unabhängig von Pro und Enterprise. Die kostenlose assess-Note bleibt unverändert.

---

## So funktioniert es

Pipelock verwendet **Fähigkeitentrennung**: In einer erzwungenen Bereitstellung besitzt der Agent-Prozess Geheimnisse, aber keinen direkten Netzwerkzugriff. Pipelock hat Netzwerkzugriff, aber keine Agentengeheimnisse. Selbst wenn der Agent einer Prompt-Injection ausgesetzt wird, kann er nicht auf die Kontrollen der Firewall zugreifen.

Drei HTTP-Proxy-Modi (gleicher Port), plus ein dedizierter MCP-Proxy und A2A-Inspektion auf den Forward- und MCP-Pfaden:

- **Fetch-Proxy** (`/fetch?url=...`): Ruft die URL ab, extrahiert Text, scannt auf Injection, gibt sauberen Inhalt zurück.
- **Forward-Proxy** (`HTTPS_PROXY`): Standard-HTTP-CONNECT-Tunneling ohne Anwendungscode-Änderungen. Proxy-Konfiguration ist weiterhin erforderlich. Optionale TLS-Interception ermöglicht Payload-Scanning.
- **WebSocket-Proxy** (`/ws?url=ws://...`): Bidirektionales Frame-Scanning mit DLP- und Injection-Erkennung.
- **MCP-Proxy** (`pipelock mcp proxy`): Kapselt stdio- oder HTTP-MCP-Server mit bidirektionalem Scanning.
- **A2A-Inspektion**: Inspiziert Google Agent-to-Agent-Protokollverkehr, während er die Forward- und MCP-Pfade durchläuft.

![Pipelock-Fähigkeitentrennung: Agentenverkehr wird von der Firewall gescannt, bevor er Internetdienste erreicht](https://raw.githubusercontent.com/luckypipewrench/pipelock/HEAD/docs/assets/how-it-works.svg)

<details>
<summary>Textdiagramm (für Terminals)</summary>```
┌──────────────────────────────────────────────────────────┐
│ PRIVILEGED ZONE                                          │
│                                                          │
│ AI Agent                                                 │
│ - API keys, credentials, private code and context        │
│ - Network-isolated by deployment                         │
└────────────────────────────┬─────────────────────────────┘
                             │ mediated request
                             │ fetch / CONNECT / WS / MCP / A2A
                             ▼
┌──────────────────────────────────────────────────────────┐
│ FIREWALL ZONE                                            │
│                                                          │
│ Pipelock Agent Firewall                                  │
│ - Destination: URL, SSRF, and DNS checks                 │
│ - Data: DLP, secret detection, and budgets               │
│ - Content: prompt injection and tool poisoning           │
│ - Policy: allow, block, or redact                        │
│ - No agent secrets                                       │
└────────────────────────────┬─────────────────────────────┘
                             │ approved request
                             ▼
┌──────────────────────────────────────────────────────────┐
│ INTERNET                                                 │
│                                                          │
│ Web APIs, websites, MCP servers, tools, and A2A services │
└──────────────────────────────────────────────────────────┘

Internet -- response --> Pipelock -- scanned content --> AI Agent

| CLI Preset | Mode | Action | Best For |
|------------|------|--------|----------|
| `balanced` | balanced | warn | Allgemeiner Zweck (Standard) |
| `strict` | strict | block | Hochsicherheits-, regulierte Branchen |
| `audit` | audit | warn | Nur-Protokoll-Auswertung |
| `claude-code` | balanced | block | Claude Code unbeaufsichtigt |
| `cursor` | balanced | block | Cursor IDE |
| `generic-agent` | balanced | warn | Neue Agenten während der Abstimmung |
| `hostile-model` | strict | block | Nicht zensierte/abliterierte Modelle |

Konfigurationsänderungen werden per Dateiüberwachung oder SIGHUP übernommen. Vollständige Referenz: **[docs/configuration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/configuration.md)**

Für False-Positive-Abstimmung: **[docs/false-positive-tuning.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/false-positive-tuning.md)**

---

## Integrationsanleitungen

- **[Claude Code](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/claude-code.md):** MCP-Proxy-Setup, `.claude.json`-Konfiguration
- **[OpenAI Codex](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/codex.md):** MCP-Proxy-Wrapping, Forward-Proxy, Sandbox-Integration
- **[Cline](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/cline.md):** MCP-Proxy-Wrapping für Clines `mcp.json`
- **[OpenCode](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/opencode.md):** MCP-Proxy-Wrapping für OpenCode lokale und entfernte MCP-Server
- **[Zed](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/zed.md):** MCP-Proxy-Wrapping für Zeds `context_servers`-Block in `settings.json`
- **[OpenAI Agents SDK](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openai-agents.md):** `MCPServerStdio`, Multi-Agent-Übergaben
- **[Google ADK](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/google-adk.md):** `McpToolset`, `StdioConnectionParams`
- **[AutoGen](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/autogen.md):** `StdioServerParams`, `mcp_server_tools()`
- **[CrewAI](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/crewai.md):** `MCPServerStdio`-Wrapping, `MCPServerAdapter`
- **[LangGraph](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/langgraph.md):** `MultiServerMCPClient`, `StateGraph`
- **[Hermes](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/hermes.md):** Vollständige Plugin-Abdeckung oder leichteres MCP-Only-Wrapping für Nous Researchs Agent mit Auth-Header-Sidecar-Erhalt
- **[JetBrains/Junie](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/jetbrains.md):** MCP-Proxy-Wrapping für IntelliJ, PyCharm, GoLand ([Walkthrough](https://pipelab.org/learn/jetbrains-integration/))
- **Cursor:** `pipelock cursor install` registriert Pipelock als Cursor-Hook für Shell-Ausführung, MCP-Tool-Aufrufe und Dateilesungen; verwenden Sie `--config`, um einen validierten Policy-Pfad einzubetten, und `pipelock cursor remove`, um Pipelock-verwaltete Hooks zu entfernen. Sie können auch `configs/cursor.yaml` mit demselben MCP-Proxy-Muster wie [Claude Code](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/claude-code.md) verwenden ([Walkthrough](https://pipelab.org/learn/cursor-integration/))
- **VS Code:** `pipelock vscode install` überschreibt `.vscode/mcp.json`, um jeden MCP-Server durch den MCP-Proxy zu leiten; `--global` zielt auf das benutzerebene `mcp.json`
- **[OpenClaw](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openclaw.md):** Gateway-Sidecar, Init-Container, Konfigurations-Wrapping
- **Jeder andere MCP-Client:** `pipelock generate mcporter` liest jede JSON-Datei mit einem obersten `mcpServers`-Objekt und wickelt jeden Server durch Pipelocks Proxy, sodass ein Client, der nicht in der obigen Liste steht, mit einem Befehl trotzdem durch Scannen geroutet wird.

---

## Bereitstellung```bash
# Docker
docker pull ghcr.io/luckypipewrench/pipelock:latest
docker run -p 8888:8888 -v ./pipelock.yaml:/config/pipelock.yaml:ro \
  ghcr.io/luckypipewrench/pipelock:latest \
  run --config /config/pipelock.yaml --listen 0.0.0.0:8888

# Network-isolated agent with Docker Compose
pipelock generate docker-compose --agent claude-code -o docker-compose.yaml
docker compose up

# Kubernetes with Helm
helm install pipelock charts/pipelock/

Die Aktion lädt ein vorkompiliertes Binary herunter, führt `pipelock audit` aus, durchsucht den PR-Diff nach durchgesickerten Geheimnissen und lädt den Auditbericht als Workflow-Artefakt hoch. Siehe [`examples/ci-workflow.yaml`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/ci-workflow.yaml) für einen vollständigen Workflow.

### Ausführbare Demo: Tool-Response-Injection

Die Testumgebung [`examples/tool-response-injection/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/tool-response-injection/) führt eine End-to-End-Demo durch, bei der ein MCP-Tool mit einem harmlosen Namen und einer harmlosen Beschreibung eine Prompt-Injection-Nutzlast in seiner Antwort verbirgt. Pipelock blockiert die Antwort, bevor sie den Agenten erreicht, und gibt signierte Aktionsquittungen aus, die von einem Dritten überprüft werden können. Dieselbe Demo läuft mit einem gemeinsamen Signaturschlüssel über drei Transporte:

- MCP stdio
- MCP HTTP upstream
- HTTP fetch```bash
cd examples/tool-response-injection
python3 demo.py    # needs python3 + cryptography + pipelock on PATH

Regelbündel sind signiert und versionsgesperrt. Der vollständige Lebenszyklus ist ein ausgelieferter Befehl, keine Konfigurationsbearbeitung:```bash
pipelock rules list                    # what is installed
pipelock rules diff pipelock-community # what a new version would change
pipelock rules update pipelock-community
pipelock rules verify                  # confirm signatures against the trusted keyring
pipelock rules remove pipelock-community

---

## Tests

Pipelock wird wie ein Sicherheitsprodukt getestet. Der Open-Source-Kern verfügt über Unit-, Integrations- und End-to-End-Tests. Eine separate private Adversarial-Suite übt Angriffsklassen gegen die Produktionsbinary aus. Jeder Bypass wird vor der Veröffentlichung in einen Regressionstest überführt.

| Metrik | Wert |
|--------|-------|
| Go-Tests (mit `-race`) | Unit-, Integrations- und End-to-End-Pfade |
| Coverage-Gate (codecov) | 91% Apache-2.0 Kernprojekt, 95% Patch bei neuem Code |
| Umgehungsabdeckung | Öffentliche Bypass-Resistenz-Matrix + privates Adversarial-Korpus |
| Overhead des Scanner-Hot-Path | ~40us pro URL-Scan (Hot-Path-Benchmark; siehe [docs/performance.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/performance.md)) |
| CI-Matrix | Go 1.25 + 1.26, CodeQL, golangci-lint |
| Lieferkette | SLSA-Provenienz, CycloneDX-SBOM, cosign-Signaturen |

Führen Sie `make test` aus, um lokal zu überprüfen. Unabhängiger Benchmark: das öffentliche Korpus [agent-egress-bench](https://github.com/luckyPipewrench/agent-egress-bench). Siehe die [Live-Ergebnisse](https://pipelab.org/gauntlet/).

---

## Danksagungen

- Architektur beeinflusst durch [Anthropics Claude Code Sandboxing](https://www.anthropic.com/engineering/claude-code-sandboxing) und [sandbox-runtime](https://github.com/anthropic-experimental/sandbox-runtime)
- Bedrohungsmodell basierend auf dem [OWASP Agentic AI Top 10](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/)
- Siehe [docs/comparison.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/comparison.md) für den Vergleich von Pipelock mit anderen Tools in diesem Bereich
- Beiträge zur Sicherheitsüberprüfung von Dylan Corrales

Beiträge sind willkommen. Siehe [CONTRIBUTING.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/CONTRIBUTING.md) für Richtlinien.

Falls Pipelock nützlich ist, bitte [dieses Repository mit einem Stern markieren](https://github.com/luckyPipewrench/pipelock). Es hilft anderen, das Projekt zu finden.

---

## Lizenz

Pipelock-Kern ist lizenziert unter der **Apache License 2.0**. Copyright 2026 Joshua Waldrep.

Multi-Agent-Funktionen (pro-Agent-Identität, Budgets und Konfigurationsisolierung) befinden sich im Verzeichnis `enterprise/`, sind durch das Build-Tag `enterprise` geschützt und unter der **Elastic License 2.0 (ELv2)** lizenziert. Diese Funktionen werden mit einem gültigen Lizenzschlüssel aktiviert.

Der Open-Source-Kern funktioniert unabhängig ohne kostenpflichtige Funktionen. Alle Scan-, Erkennungs- und Einzel-Agent-Schutzfunktionen sind kostenlos.

Vorgefertigte Release-Artefakte (Homebrew, GitHub-Releases, Docker-Images) enthalten Code der kostenpflichtigen Stufe, der mit einem gültigen Lizenzschlüssel aktiviert wird. Das Erstellen aus dem Quellcode mit `go install` oder dem `Dockerfile` des Repositorys erzeugt ein Community-Only-Binary.

Siehe [LICENSE](https://github.com/luckypipewrench/pipelock/blob/HEAD/LICENSE) für den Apache-2.0-Text und [enterprise/LICENSE](https://github.com/luckypipewrench/pipelock/blob/HEAD/enterprise/LICENSE) für den ELv2-Text.