Clawdstrike

EDR per l'età dello sciame.
Fail closed. Firma la verità.

Stato: beta pre-1.0. Le API pubbliche sono stabili; le impostazioni predefinite potrebbero ancora essere irrigidite prima della 1.0.

Clawdstrike è un motore di policy, un EDR e una catena di audit firmata tutto in un unico binario. Un tool_call di un agente AI si colloca nella stessa tassonomia degli eventi di un file_access, process_exec, network_flow, dylib_load o launch_persistence a livello kernel. Un unico motore di policy li valuta. Un grafo causale firmato con Ed25519 li registra. Le impostazioni predefinite falliscono in chiuso (fail closed).

Lo stesso motore è distribuito come crate Rust, SDK TypeScript, pacchetto Python, modulo Go, CLI, agente EDR desktop (macOS Endpoint Security + Network Extension; Linux Tetragon + Hubble) e un piano di controllo enterprise.

Avvio rapido  ·  Guardie  ·  Policy  ·  Verifica formale  ·  Enterprise  ·  Design

Avvio rapido

Installa tramite il tuo gestore di pacchetti preferito:

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

Crea uno scheletro di progetto e avvia il demone:

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

clawdstrike daemon start && clawdstrike daemon status
# Status: healthy | Version: 0.2.7 | Uptime: 2s

Tre negazioni, ciascuna firmata:

$ clawdstrike check --action-type file --ruleset strict ~/.ssh/id_rsa
BLOCKED [Critical]: Access to forbidden path: ~/.ssh/id_rsa

$ clawdstrike check --action-type egress --ruleset strict api.openai.com:443
BLOCKED [Error]: Egress to api.openai.com blocked by policy

$ clawdstrike check --action-type mcp --ruleset strict shell_exec
BLOCKED [Error]: Tool 'shell_exec' is blocked by policy

Verifica che la policy stessa venga compilata e sia internamente coerente:

$ clawdstrike verify --policy strict
Consistency:  PASS  (47 formulas, 0 conflicts)
Completeness: PASS  (4/4 action types covered)
Inheritance:  PASS  (0 weakened prohibitions)

Esegui un agente reale sotto enforcement:

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

L'agente funziona normalmente. Ogni chiamata a uno strumento (tool call) passa prima dal motore. Le negazioni sollevano un errore tipizzato nel tuo SDK ed emettono una ricevuta firmata.

Cluster: chart Helm e piano di controllo

Per distribuzioni fleet, installa il chart Helm. hushd e i firmatari Spine sono fail-closed e necessitano di chiavi al momento dell'installazione, quindi crea in anticipo i Secret e referenziali dal 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

Questo avvia hushd, il checkpointer + witness Spine e NATS JetStream in bundle. L'API di controllo (enrollment, comandi di postura, bundle di completamento firmati di ritorno) e i bridge di telemetria Tetragon/Hubble sono opzionali.

Vedi il README del chart per l'intero set di parametri, e la guida all'enrollment Enterprise per l'onboarding end-to-end degli agenti.

Come funziona

flowchart LR
    A[Agent / sensore] --> B[Evento canonico]
    B --> C[Motore di policy + stack guardie]
    C -->|allow| D[Azione eseguita]
    C -->|deny| E[Bloccato, fail-closed]
    C --> F[Ricevuta Ed25519]
    F --> G[Grafo causale]
    G -.->|enterprise| H[Catena di audit Spine]

Gli adattatori SDK e i sensori a livello OS inviano lo stesso evento canonico al motore di policy. Gli adattatori coprono le chiamate a strumenti degli agenti AI; i sensori kernel (macOS Endpoint Security e Network Extension, Linux Tetragon e Hubble) coprono gli eventi di file, processo, rete, dylib e persistenza. Lo stack delle guardie restituisce un verdetto, il verdetto include una ricevuta firmata Ed25519, e ogni ricevuta viene hash-aggiunta a un grafo causale per sessione che lega l'identità dell'agente agli eventi OS successivi.

Quando una decisione supera una soglia di risposta, il motore emette un effetto firmato: mettere in quarantena un file, limitare una destinazione di egree, sospendere un albero di processi, revocare un'approvazione precedentemente emessa. Gli effetti sono reversibili dove possibile. Le osservazioni passate rimangono su un registratore di volo su disco, così una policy più restrittiva può essere simulata sullo stato della settimana scorsa prima di essere distribuita. In modalità enterprise, la catena delle ricevute viene inviata su NATS al checkpointer Spine; un testimone indipendente co-firma ogni batch.

I log sono storie; la prova è una firma.

Guardie

Ogni guardia è un controllo componibile al confine dello strumento. Restituisce un verdetto con evidenza. Fail-fast o aggregato; configurato per policy.

Fonte di verità: crates/libs/clawdstrike/src/guards/.

Policy

Policy-as-code versionata e deterministica. Schema 1.5.0 (compatibile all'indietro con 1.1.0+). Supporta extends da built-in, file locali, URL remoti e riferimenti git. extends remoto è sottoposto ad allowlist dell'host e bloccato per integrità tramite #sha256=<64-hex>.

Ruleset integrati: permissive · default · strict · ai-agent · ai-agent-posture · cicd · remote-desktop · remote-desktop-permissive · remote-desktop-strict · spider-sense.

Il ciclo operativo (osserva, sintetizza, stringi):

# Genera un candidato con privilegi minimi dagli eventi osservati
clawdstrike policy synth run.events.jsonl \
  --extends clawdstrike:default --out candidate.yaml

# Riproduci gli eventi contro il candidato
clawdstrike policy simulate candidate.yaml run.events.jsonl --fail-on-deny

# Confronta il candidato con la baseline
clawdstrike policy diff clawdstrike:default candidate.yaml

Vedi schema policy, schema posture e la guida osserva, sintetizza, stringi.

Verifica formale

La logica decisionale centrale del motore di policy è specificata in Lean 4 e testata in modo differenziale rispetto all'implementazione Rust tramite la pipeline di traduzione Aeneas.

Dimostrato in Lean (5 proprietà su 44 delle 45 funzioni principali):

• Monotonia della negazione: qualsiasi negazione di una guardia nega il verdetto complessivo
• Ordine totale della severità: l'ordinamento è coerente e transitivo
• Rifiuto dei cicli: le catene di extends circolari vengono sempre intercettate
• Roundtrip della firma: Ed25519 sign-then-verify ha successo
• Allow guardia disabilitata: una guardia disabilitata non può produrre una negazione fantasma

Fuori dal campo di applicazione della dimostrazione: guardie oltre la logica decisionale centrale, I/O, rete e le primitive crittografiche stesse (ci affidiamo a ed25519-dalek).

clawdstrike verify --policy strict       # Analisi policy Z3
cargo test -p formal-diff-tests          # Test differenziali notturni
cd formal/lean4/ClawdStrike && lake build

Vedi la guida alla verifica formale.

Ricevute

Ogni verdetto include un'attestazione firmata Ed25519 contenente la decisione, la policy che l'ha presa e l'evidenza. Le ricevute sono canonizzate con la Canonicalizzazione JSON RFC 8785, quindi una firma può essere verificata byte-identicamente in Rust, TypeScript e Python.

Le distribuzioni enterprise inoltrano le ricevute tramite Spine, un log di buste firmato Ed25519 e concatenato tramite hash. Manometti un record e tutti i record successivi falliranno la verifica.

SDK

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

Plugin

Enterprise

Lo stesso motore più un piano di controllo gestito: API di controllo, trasporto NATS JetStream, catena di audit Spine e una Console di Controllo per il flusso di lavoro SOC. Enrollment su mTLS, comandi di postura con acknowledgement richiesta/risposta, bundle di completamento firmati di ritorno all'API.

Vedi enrollment enterprise e architettura adattiva.

Conformità

Clawdstrike non è un prodotto certificato. Produce evidenza che si mappa ai framework di controllo standard: attestazioni di azione firmate, trail di audit concatenati per integrità, valutazione deterministica delle policy.

Le mappature di conformità sono bozze. Apri una issue se hai bisogno di un framework formalizzato.

Principi di progettazione

Fail closed. Le policy non valide vengono rifiutate al caricamento. Gli errori di valutazione negano l'accesso. La configurazione mancante è restrittiva per impostazione predefinita. Il degrado della sicurezza richiede un'azione esplicita e verificabile.

Prova, non log. Le ricevute Ed25519 sono attestazioni crittografiche, non righe di log che qualcuno può modificare. JSON Canonical (RFC 8785) garantisce che le firme vengano verificate identicamente in Rust, TypeScript e Python.

Stessa busta, qualsiasi canale. Una busta Spine firmata è byte-identica sia che viaggi su NATS a 100K msg/sec, gossipsub libp2p su Internet residenziale o una radio LoRa a 1200 bps. Il trasporto è invisibile al livello di verità.

Solo attenuazione. Gli agenti delegano sottoinsiemi delle loro capacità, mai escalation. I token di delega portano limiti di capacità crittografici. L'escalation dei privilegi non è impedita dalla policy; è impedita dalla matematica.

Possiedi il tuo stack. Apache-2.0. Auto-ospitabile. Nessuna dipendenza da un fornitore per infrastrutture critiche per la sicurezza. Lo stesso motore funziona su un laptop da sviluppatore, una flotta enterprise e un Raspberry Pi su una mesh radio.

Documentazione

Sicurezza

Se scopri una vulnerabilità:

• Sensibile: invia un'email a [email protected]. Risposta entro 48 ore.
• Non sensibile: apri una issue GitHub con l'etichetta security.

Vedi SECURITY.md e THREAT_MODEL.md.

Contribuire

Vedi CONTRIBUTING.md.

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

Licenza

Apache License 2.0. Vedi LICENSE.