Clawdstrike

EDR para a era do enxame.
Feche com falha. Assine a verdade.

Status: beta pré-1.0. As APIs públicas estão estáveis; os padrões podem ser endurecidos antes da versão 1.0.

Clawdstrike é um mecanismo de políticas, um EDR e uma cadeia de auditoria assinada em um único binário. Um tool_call de um agente de IA está na mesma taxonomia de eventos que um file_access, process_exec, network_flow, dylib_load ou launch_persistence em nível de kernel. Um mecanismo de políticas os avalia. Um grafo causal assinado com Ed25519 os registra. Os padrões fecham com falha.

O mesmo mecanismo é distribuído como uma crate Rust, um SDK TypeScript, um pacote Python, um módulo Go, uma CLI, um agente EDR para desktop (macOS Endpoint Security + Network Extension; Linux Tetragon + Hubble) e um painel de controle corporativo.

Início Rápido  ·  Guardas  ·  Políticas  ·  Verificação Formal  ·  Corporativo  ·  Design

Início Rápido

Instale via seu gerenciador de pacotes preferido:

brew install backbay-labs/tap/clawdstrike   # macOS, Linux
npm  install @clawdstrike/sdk               # TypeScript
pip  install clawdstrike                    # Python
cargo add clawdstrike                       # Rust
go   get github.com/backbay-labs/clawdstrike-go

Crie um projeto e inicie o daemon:

clawdstrike init --keygen
# escreve policy.yaml, config.toml, keys/clawdstrike.key{,.pub}

clawdstrike daemon start && clawdstrike daemon status
# Status: healthy | Versão: 0.2.7 | Uptime: 2s

Três negações, cada uma assinada:

$ clawdstrike check --action-type file --ruleset strict ~/.ssh/id_rsa
BLOQUEADO [Crítico]: Acesso a caminho proibido: ~/.ssh/id_rsa

$ clawdstrike check --action-type egress --ruleset strict api.openai.com:443
BLOQUEADO [Erro]: Egresso para api.openai.com bloqueado por política

$ clawdstrike check --action-type mcp --ruleset strict shell_exec
BLOQUEADO [Erro]: Ferramenta 'shell_exec' está bloqueada por política

Verifique se a própria política compila e é internamente consistente:

$ clawdstrike verify --policy strict
Consistência:  PASS  (47 fórmulas, 0 conflitos)
Completude:    PASS  (4/4 tipos de ação cobertos)
Herança:       PASS  (0 proibições enfraquecidas)

Execute um agente real sob aplicação de políticas:

clawdstrike run --policy clawdstrike:strict -- python my_agent.py

O agente executa normalmente. Cada chamada de ferramenta atinge o mecanismo primeiro. As negações geram um erro tipado no seu SDK e emitem um recibo assinado.

Cluster: Helm chart e painel de controle

Para implantações em frota, instale o Helm chart. hushd e os signatários Spine fecham com falha e precisam de chaves no momento da instalação, então crie previamente os Secrets e faça referência a eles a partir do chart:

NS=clawdstrike-system
kubectl create namespace "$NS"

kubectl -n "$NS" create secret generic clawdstrike-hushd-auth \
  --from-literal=CLAWDSTRIKE_API_KEY="$(openssl rand -hex 32)" \
  --from-literal=CLAWDSTRIKE_ADMIN_KEY="$(openssl rand -hex 32)" \
  --from-literal=CLAWDSTRIKE_AUTH_PEPPER="$(openssl rand -hex 32)"

kubectl -n "$NS" create secret generic clawdstrike-spine \
  --from-literal=SPINE_LOG_SEED_HEX="$(openssl rand -hex 32)" \
  --from-literal=SPINE_WITNESS_SEED_HEX="$(openssl rand -hex 32)"

helm install clawdstrike \
  oci://ghcr.io/backbay-labs/clawdstrike/helm/clawdstrike --version 0.2.0 \
  --namespace "$NS" \
  --set hushd.auth.existingSecret=clawdstrike-hushd-auth \
  --set spine.secrets.existingSecret=clawdstrike-spine

Isso traz hushd, o checkpointer + testemunha Spine e o NATS JetStream agrupado. A API de Controle (inscrição, comandos de postura, pacotes de conclusão assinados) e as pontes de telemetria Tetragon/Hubble são opt-in.

Veja o README do chart para o conjunto completo de parâmetros e Inscrição Corporativa para integração ponta a ponta de agentes.

Como funciona

flowchart LR
    A[Agente / sensor] --> B[Evento canônico]
    B --> C[Mecanismo de políticas + pilha de guardas]
    C -->|permitir| D[Ação executada]
    C -->|negar| E[Bloqueado, falha fechada]
    C --> F[Recibo Ed25519]
    F --> G[Grafo causal]
    G -.->|corporativo| H[Cadeia de auditoria Spine]

Adaptadores SDK e sensores de nível de SO alimentam o mesmo evento canônico no mecanismo de políticas. Os adaptadores cobrem chamadas de ferramentas de agentes de IA; sensores de kernel (macOS Endpoint Security e Network Extension, Linux Tetragon e Hubble) cobrem eventos de arquivo, processo, rede, dylib e persistência. A pilha de guardas retorna um veredito, o veredito é enviado com um recibo Ed25519, e cada recibo é hash de conteúdo em um grafo causal por sessão que vincula a identidade do agente através de eventos subsequentes do SO.

Quando uma decisão ultrapassa um limite de resposta, o mecanismo emite um efeito assinado: quarentena de um arquivo, restrição de um destino de egresso, suspensão de uma árvore de processos, revogação de uma aprovação emitida anteriormente. Os efeitos são reversíveis quando possível. Observações passadas permanecem em um gravador de voo baseado em disco, para que uma política endurecida possa ser simulada contra o estado da semana anterior antes de ser implantada. No modo corporativo, a cadeia de recibos é enviada via NATS para o checkpointer Spine; uma testemunha independente co-assina cada lote.

Logs são histórias; prova é uma assinatura.

Guardas

Cada guarda é uma verificação composável no limite da ferramenta. Retorna um veredito com evidências. Falha rápida ou agrega; configurado por política.

Fonte da verdade: crates/libs/clawdstrike/src/guards/.

Políticas

Política como código versionada e determinística. Esquema 1.5.0 (compatível com versões anteriores a partir de 1.1.0+). Suporta extends a partir de built-ins, arquivos locais, URLs remotas e refs git. extends remoto é permitido por host e fixado por integridade via #sha256=<64-hex>.

Conjuntos de regras built-in: permissive · default · strict · ai-agent · ai-agent-posture · cicd · remote-desktop · remote-desktop-permissive · remote-desktop-strict · spider-sense.

O loop operacional (observar, sintetizar, endurecer):

# Gera um candidato de privilégios mínimos a partir de eventos observados
clawdstrike policy synth run.events.jsonl \
  --extends clawdstrike:default --out candidato.yaml

# Reproduz os eventos contra o candidato
clawdstrike policy simulate candidato.yaml run.events.jsonl --fail-on-deny

# Diferencia o candidato da linha de base
clawdstrike policy diff clawdstrike:default candidato.yaml

Veja esquema de política, esquema de postura e o guia observar, sintetizar, endurecer.

Verificação formal

A lógica central de decisão do mecanismo de políticas é especificada em Lean 4 e testada diferencialmente contra a implementação Rust via pipeline de tradução Aeneas.

Provado em Lean (5 propriedades em 44 de 45 funções centrais):

• Monotonicidade de negação: qualquer negação de guarda nega o veredito geral
• Ordem total de severidade: a ordenação é consistente e transitiva
• Rejeição de ciclo: cadeias de extends circulares são sempre capturadas
• Roundtrip de assinatura: assinar e verificar Ed25519 é bem-sucedido
• Permissão de guarda desabilitada: uma guarda desabilitada não pode produzir uma negação fantasma

Fora do escopo da prova: guardas além da lógica central de decisão, IO, rede e as próprias primitivas criptográficas (confiamos em ed25519-dalek).

clawdstrike verify --policy strict       # Análise de políticas Z3
cargo test -p formal-diff-tests          # Testes diferenciais noturnos
cd formal/lean4/ClawdStrike && lake build

Veja o guia de verificação formal.

Recibos

Cada veredito é enviado com uma atestação assinada com Ed25519 contendo a decisão, a política que a tomou e as evidências. Os recibos são canonicalizados com Canonicalização JSON RFC 8785, para que uma assinatura seja verificada byte-identicamente em Rust, TypeScript e Python.

Implantações corporativas encaminham recibos através do Spine, um log de envelopes assinado com Ed25519 e encadeado por hash. Adultere qualquer registro e todos os registros posteriores falham na verificação.

SDKs

TypeScript

npm install @clawdstrike/sdk

import { HushEngine, loadPolicy } from "@clawdstrike/sdk";

const engine = new HushEngine(await loadPolicy("clawdstrike:strict"));
const verdict = await engine.check({
  actionType: "file",
  target: "~/.ssh/id_rsa",
});
// verdict.decision === "deny"
// verdict.receipt is Ed25519-signed

Python

pip install clawdstrike

from clawdstrike import HushEngine, load_policy

engine = HushEngine(load_policy("clawdstrike:strict"))
verdict = engine.check(action_type="file", target="~/.ssh/id_rsa")
# verdict.decision == "deny"

Rust

[dependencies]
clawdstrike = "0.2"

use clawdstrike::{HushEngine, Policy, Action, Decision};

let policy = Policy::load_builtin("strict")?;
let engine = HushEngine::new(policy);
let verdict = engine.check(&Action::file("~/.ssh/id_rsa"))?;
assert_eq!(verdict.decision, Decision::Deny);

Go

go get github.com/backbay-labs/clawdstrike-go

engine, _ := clawdstrike.NewEngine(clawdstrike.LoadBuiltin("strict"))
verdict, _ := engine.Check(clawdstrike.FileAction{Target: "~/.ssh/id_rsa"})
// verdict.Decision == clawdstrike.Deny

Plugins

Corporativo

O mesmo mecanismo mais um painel de controle gerenciado: API de Controle, transporte NATS JetStream, cadeia de auditoria Spine e um Console de Controle para fluxo de trabalho SOC. Inscrição via mTLS, comandos de postura com acks de requisição/resposta, pacotes de conclusão assinados de volta para a API.

Veja inscrição corporativa e arquitetura adaptativa.

Conformidade

Clawdstrike não é um produto certificado. Ele produz evidências que mapeiam para estruturas de controle padrão: atestações de ação assinadas, trilhas de auditoria encadeadas por integridade, avaliação determinística de políticas.

Os mapeamentos de conformidade são rascunhos. Abra uma issue se precisar de uma estrutura formalizada.

Princípios de design

Falha fechada. Políticas inválidas são rejeitadas no carregamento. Erros de avaliação negam acesso. Configuração ausente assume padrão restritivo. Degradação de segurança requer ação explícita e auditável.

Prova, não logs. Recibos Ed25519 são atestações criptográficas, não linhas de log que alguém pode editar. JSON canônico (RFC 8785) garante que as assinaturas sejam verificadas identicamente em Rust, TypeScript e Python.

Mesmo envelope, qualquer pipe. Um envelope Spine assinado é byte-idêntico, quer viaje sobre NATS a 100K msg/seg, libp2p gossipsub sobre internet residencial ou um rádio LoRa a 1.200 bps. O transporte é invisível para a camada de verdade.

Apenas atenuação. Agentes delegam subconjuntos de suas capacidades, nunca as escalam. Tokens de delegação carregam tetos criptográficos de capacidade. Escalação de privilégio não é prevenida por política; é prevenida por matemática.

Tenha sua própria pilha. Apache-2.0. Auto-hospedável. Nenhuma dependência de fornecedor para infraestrutura crítica de segurança. O mesmo mecanimo roda em um laptop de desenvolvedor, em uma frota corporativa e em um Raspberry Pi em uma malha de rádio.

Documentação

Segurança

Se você descobrir uma vulnerabilidade:

• Sensível: envie um e-mail para [email protected]. Resposta em 48 horas.
• Não sensível: abra uma issue no GitHub com o rótulo security.

Veja SECURITY.md e THREAT_MODEL.md.

Contribuindo

Veja CONTRIBUTING.md.

cargo fmt --all && cargo clippy --workspace -- -D warnings && cargo test --workspace

Licença

Licença Apache 2.0. Veja LICENSE.