Clawdstrike

EDR pour l'âge de l'essaim.
Échouer en position fermée. Signez la vérité.

Statut : bêta pré-1.0. Les API publiques sont stables ; les valeurs par défaut peuvent encore être durcies avant 1.0.

Clawdstrike est un moteur de politique, un EDR, et une chaîne d'audit signée en un seul binaire. Le tool_call d'un agent IA se trouve dans la même taxonomie d'événements qu'un file_access au niveau du noyau, process_exec, network_flow, dylib_load, ou launch_persistence. Un seul moteur de politique les évalue. Un seul graphe causal signé Ed25519 les enregistre. Par défaut, échec fermé.

Le même moteur est disponible en tant que crate Rust, SDK TypeScript, paquet Python, module Go, CLI, agent EDR de bureau (macOS Endpoint Security + Network Extension ; Linux Tetragon + Hubble), et un plan de contrôle entreprise.

Démarrage rapide  ·  Gardes  ·  Politiques  ·  Vérification formelle  ·  Entreprise  ·  Conception

Démarrage rapide

Installez via votre gestionnaire de paquets préféré :

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

Créez un projet et démarrez le démon :

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

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

Trois refus, chacun signé :

$ clawdstrike check --action-type file --ruleset strict ~/.ssh/id_rsa
BLOCKED [Critical]: Accès au chemin interdit : ~/.ssh/id_rsa

$ clawdstrike check --action-type egress --ruleset strict api.openai.com:443
BLOCKED [Error]: Sortie vers api.openai.com bloquée par la politique

$ clawdstrike check --action-type mcp --ruleset strict shell_exec
BLOCKED [Error]: L'outil 'shell_exec' est bloqué par la politique

Vérifiez que la politique elle-même se compile et est cohérente en interne :

$ clawdstrike verify --policy strict
Consistency:  PASS  (47 formules, 0 conflits)
Completeness: PASS  (4/4 types d'action couverts)
Inheritance:  PASS  (0 prohibitions affaiblies)

Exécutez un agent réel sous contrainte :

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

L'agent s'exécute normalement. Chaque appel d'outil frappe d'abord le moteur. Les refus génèrent une erreur typée dans votre SDK et émettent un reçu signé.

Cluster : chart Helm et plan de contrôle

Pour les déploiements de flotte, installez la chart Helm. hushd et les signeurs Spine sont en échec fermé et ont besoin de clés lors de l'installation, donc créez préalablement les Secrets et référencez-les dans la 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

Cela démarre hushd, le checkpointer + témoin Spine, et le NATS JetStream intégré. L'API de contrôle (inscription, commandes de posture, bundles de complétion signés en retour) et les ponts de télémétrie Tetragon/Hubble sont optionnels.

Voir le README de la chart pour l'ensemble complet des paramètres, et Inscription entreprise pour l'intégration complète des agents.

Comment ça marche

flowchart LR
    A[Agent / capteur] --> B[Événement canonique]
    B --> C[Moteur de politique + pile de gardes]
    C -->|autoriser| D[L'action s'exécute]
    C -->|refuser| E[Bloqué, échec fermé]
    C --> F[Reçu Ed25519]
    F --> G[Graphe causal]
    G -.->|entreprise| H[Chaîne d'audit Spine]

Les adaptateurs SDK et les capteurs au niveau du système d'exploitation alimentent le même événement canonique dans le moteur de politique. Les adaptateurs couvrent les appels d'outils d'agents IA ; les capteurs du noyau (macOS Endpoint Security et Network Extension, Linux Tetragon et Hubble) couvrent les événements de fichier, processus, réseau, dylib et persistance. La pile de gardes renvoie un verdict, le verdict est accompagné d'un reçu Ed25519, et chaque reçu est haché par contenu dans un graphe causal par session qui relie l'identité de l'agent à travers les événements OS en aval.

Lorsqu'une décision franchit un seuil de réponse, le moteur émet un effet signé : mettre en quarantaine un fichier, restreindre une destination sortante, suspendre un arbre de processus, révoquer une approbation précédemment émise. Les effets sont réversibles lorsque c'est possible. Les observations passées restent sur un enregistreur de vol sur disque, de sorte qu'une politique renforcée peut être simulée contre l'état de la semaine précédente avant d'être déployée. En mode entreprise, la chaîne de reçus est envoyée via NATS au checkpointer Spine ; un témoin indépendant co-signe chaque lot.

Les logs sont des histoires ; la preuve est une signature.

Gardes

Chaque garde est un contrôle composable à la frontière de l'outil. Renvoie un verdict avec preuve. Échouement rapide ou agrégation ; configuré par politique.

Source de vérité : crates/libs/clawdstrike/src/guards/.

Politiques

Code de politique versionné et déterministe. Schéma 1.5.0 (rétrocompatible avec 1.1.0+). Supporte extends à partir de politiques intégrées, fichiers locaux, URL distantes et références git. Le extends distant est mis en liste blanche d'hôtes et épinglé par intégrité via #sha256=<64-hex>.

Règles intégrées : permissive · default · strict · ai-agent · ai-agent-posture · cicd · remote-desktop · remote-desktop-permissive · remote-desktop-strict · spider-sense.

La boucle opérationnelle (observer, synthétiser, resserrer) :

# Génère un candidat à moindre privilège à partir des événements observés
clawdstrike policy synth run.events.jsonl \
  --extends clawdstrike:default --out candidate.yaml

# Rejoue les événements contre le candidat
clawdstrike policy simulate candidate.yaml run.events.jsonl --fail-on-deny

# Diff du candidat par rapport à la base
clawdstrike policy diff clawdstrike:default candidate.yaml

Voir schéma de politique, schéma de posture, et le guide d'observation, synthèse et resserrement.

Vérification formelle

Le noyau de logique de décision du moteur de politique est spécifié en Lean 4 et testé différentiellement par rapport à l'implémentation Rust via le pipeline de traduction Aeneas.

Prouvé en Lean (5 propriétés sur 44 des 45 fonctions principales) :

• Monotonie du refus : tout refus de garde refuse le verdict global
• Ordre total de sévérité : l'ordonnancement est cohérent et transitif
• Rejet de cycles : les chaînes extends circulaires sont toujours détectées
• Aller-retour de signature : signer puis vérifier Ed25519 réussit
• Autorisation de garde désactivée : une garde désactivée ne peut pas produire un refus fantôme

Hors du périmètre de la preuve : les gardes au-delà de la logique de décision centrale, les E/S, le réseau et les primitives cryptographiques elles-mêmes (nous nous reposons sur ed25519-dalek).

clawdstrike verify --policy strict       # Analyse Z3 de la politique
cargo test -p formal-diff-tests          # Tests différentiels nocturnes
cd formal/lean4/ClawdStrike && lake build

Voir le guide de vérification formelle.

Reçus

Chaque verdict est livré avec une attestation signée Ed25519 contenant la décision, la politique qui l'a rendue et la preuve. Les reçus sont canonicalisés avec la canonisation JSON RFC 8785, de sorte qu'une signature se vérifie octet pour octet en Rust, TypeScript et Python.

Les déploiements entreprise transfèrent les reçus via Spine, un journal d'enveloppes signé Ed25519 et chaîné par hachage. Altérez un enregistrement et tous les enregistrements ultérieurs échouent à la vérification.

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

Entreprise

Le même moteur plus un plan de contrôle géré : API de contrôle, transport NATS JetStream, chaîne d'audit Spine, et une console de contrôle pour le workflow SOC. Inscription via mTLS, commandes de posture avec accusés de réception requête/réponse, bundles de complétion signés retournés à l'API.

Voir inscription entreprise et architecture adaptative.

Conformité

Clawdstrike n'est pas un produit certifié. Il produit des preuves qui correspondent aux cadres de contrôle standards : attestations d'actions signées, pistes d'audit chaînées par intégrité, évaluation de politique déterministe.

Les correspondances de conformité sont des brouillons. Ouvrez un ticket si vous avez besoin qu'un cadre soit formalisé.

Principes de conception

Échouer en position fermée. Les politiques invalides sont rejetées au chargement. Les erreurs d'évaluation refusent l'accès. La configuration manquante est par défaut restrictive. Toute dégradation de sécurité nécessite une action explicite et vérifiable.

Preuve, pas de logs. Les reçus Ed25519 sont des attestations cryptographiques, pas des lignes de log que quelqu'un peut éditer. Le JSON canonique (RFC 8785) garantit que les signatures se vérifient identiquement en Rust, TypeScript et Python.

Même enveloppe, n'importe quel canal. Une enveloppe Spine signée est identique octet par octet, qu'elle voyage via NATS à 100K msg/s, libp2p gossipsub sur internet résidentiel, ou une radio LoRa à 1200 bps. Le transport est invisible pour la couche de vérité.

Atténuation uniquement. Les agents délèguent des sous-ensembles de leurs capacités, jamais d'escalade. Les jetons de délégation portent des plafonds de capacité cryptographiques. L'escalade de privilèges n'est pas empêchée par la politique ; elle est empêchée par les mathématiques.

Propriétaire de votre pile. Apache-2.0. Auto-hébergeable. Aucune dépendance à un fournisseur pour l'infrastructure critique de sécurité. Le même moteur tourne sur un laptop de développeur, une flotte d'entreprise, et un Raspberry Pi sur un maillage radio.

Documentation

Sécurité

Si vous découvrez une vulnérabilité :

• Sensible : envoyez un email à [email protected]. Réponse sous 48 heures.
• Non sensible : ouvrez un ticket GitHub avec le label security.

Voir SECURITY.md et THREAT_MODEL.md.

Contribuer

Voir CONTRIBUTING.md.

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

Licence

Licence Apache 2.0. Voir LICENSE.