Clawdstrike

EDR für das Zeitalter des Schwarms.
Fail closed. Sign the truth.

Status: Pre-1.0-Beta. Die öffentlichen APIs sind stabil; die Standardeinstellungen können sich vor 1.0 noch verschärfen.

Clawdstrike ist eine Policy-Engine, ein EDR und eine signierte Audit-Kette in einer einzigen Binärdatei. Ein tool_call eines KI-Agenten liegt in derselben Ereignistaxonomie wie ein Kernel-Level-file_access, process_exec, network_flow, dylib_load oder launch_persistence. Eine Policy-Engine wertet sie aus. Ein kausaler Graph, signiert mit Ed25519, zeichnet sie auf. Standardmäßig: Fail closed.

Dieselbe Engine wird als Rust-Crate, TypeScript-SDK, Python-Paket, Go-Modul, CLI, Desktop-EDR-Agent (macOS Endpoint Security + Network Extension; Linux Tetragon + Hubble) und als Enterprise-Kontrollplattform ausgeliefert.

Quick Start  ·  Guards  ·  Policies  ·  Formale Verifikation  ·  Enterprise  ·  Design

Quick Start

Installation über den bevorzugten Paketmanager:

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

Ein Projekt anlegen und den Daemon starten:

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

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

Drei Ablehnungen, alle signiert:

$ 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

Überprüfen, ob die Policy selbst kompiliert und intern konsistent ist:

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

Einen echten Agenten unter Durchsetzung ausführen:

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

Der Agent läuft normal. Jeder Tool-Call trifft zuerst auf die Engine. Ablehnungen werfen einen typisierten Fehler im SDK und geben eine signierte Quittung aus.

Cluster: Helm-Chart und Kontrollplattform

Für Flottenbereitstellungen das Helm-Chart installieren. hushd und die Spine-Signer sind fail-closed und benötigen Schlüssel zur Installationszeit, also die Secrets vorher erstellen und im Chart referenzieren:

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

Damit werden hushd, der Spine-Checkpointer + Witness und das gebündelte NATS JetStream gestartet. Die Control-API (Enrollment, Posture-Befehle, signierte Completion-Bundles zurück) sowie die Tetragon-/Hubble-Telemetriebrücken sind optional.

Siehe Chart-README für den vollständigen Parametersatz und Enterprise-Enrollment für die End-to-End-Agenten-Onboarding.

Wie es funktioniert

flowchart LR
    A[Agent / sensor] --> B[Canonical event]
    B --> C[Policy engine + guard stack]
    C -->|allow| D[Action runs]
    C -->|deny| E[Blocked, fail-closed]
    C --> F[Ed25519 receipt]
    F --> G[Causal graph]
    G -.->|enterprise| H[Spine audit chain]

SDK-Adapter und Betriebssystem-Sensoren speisen dasselbe kanonische Ereignis in die Policy-Engine ein. Adapter decken KI-Agent-Tool-Aufrufe ab; Kernel-Sensoren (macOS Endpoint Security und Network Extension, Linux Tetragon und Hubble) decken Datei-, Prozess-, Netzwerk-, Dylib- und Persistenzereignisse ab. Der Guard-Stack gibt ein Urteil zurück, das Urteil wird mit einer Ed25519-Quittung versehen, und jede Quittung wird inhaltlich gehasht in einen pro-Sitzung kausalen Graphen eingebettet, der die Agentenidentität mit nachgelagerten Betriebssystemereignissen verknüpft.

Wenn eine Entscheidung einen Reaktionsschwellwert überschreitet, gibt die Engine eine signierte Wirkung aus: Quarantäne einer Datei, Einschränkung eines Egress-Ziels, Suspendierung eines Prozessbaums, Widerruf einer zuvor erteilten Genehmigung. Wirkungen sind wo möglich reversibel. Vergangene Beobachtungen bleiben auf einem diskettenbasierten Flugschreiber, sodass eine verschärfte Policy gegen den Zustand der letzten Woche simuliert werden kann, bevor sie ausgerollt wird. Im Enterprise-Modus wird die Quittungskette über NATS an den Spine-Checkpointer gesendet; ein unabhängiger Witness signiert jedes Bündel mit.

Logs sind Geschichten; Beweis ist eine Signatur.

Guards

Jeder Guard ist eine zusammensetzbare Prüfung an der Tool-Grenze. Gibt ein Urteil mit Beweisen zurück. Fail-fast oder aggregiert; pro Policy konfigurierbar.

Quelle der Wahrheit: crates/libs/clawdstrike/src/guards/.

Policies

Versionierte, deterministische Policy-as-Code. Schema 1.5.0 (abwärtskompatibel mit 1.1.0+). Unterstützt extends aus Built-ins, lokalen Dateien, entfernten URLs und Git-Refs. Remote-extends ist host-allowlisted und per #sha256=<64-hex> integritätsgeschützt.

Mitgelieferte Rulesets: permissive · default · strict · ai-agent · ai-agent-posture · cicd · remote-desktop · remote-desktop-permissive · remote-desktop-strict · spider-sense.

Der operative Kreislauf (beobachten, synthetisieren, verschärfen):

# Least-Privilege-Kandidaten aus beobachteten Ereignissen generieren
clawdstrike policy synth run.events.jsonl \
  --extends clawdstrike:default --out candidate.yaml

# Ereignisse gegen den Kandidaten abspielen
clawdstrike policy simulate candidate.yaml run.events.jsonl --fail-on-deny

# Kandidaten gegen die Baseline differenzieren
clawdstrike policy diff clawdstrike:default candidate.yaml

Siehe Policy-Schema, Posture-Schema und den Leitfaden Beobachten, Synthetisieren, Verschärfen.

Formale Verifikation

Die Kernentscheidungslogik der Policy-Engine ist in Lean 4 spezifiziert und wird mittels der Aeneas-Übersetzungspipeline differenzial gegen die Rust-Implementierung getestet.

In Lean bewiesen (5 Eigenschaften über 44 von 45 Kernfunktionen):

• Deny-Monotonie: Jede Guard-Ablehnung lehnt das Gesamturteil ab
• Severity-Gesamtordnung: Die Ordnung ist konsistent und transitiv
• Zyklenzurückweisung: Zirkuläre extends-Ketten werden immer erkannt
• Signatur-Roundtrip: Ed25519 sign-then-verify ist erfolgreich
• Disabled-Guard-Allow: Ein deaktivierter Guard kann keine Phantom-Ablehnung erzeugen

Nicht im Beweisumfang: Guards jenseits der Kernentscheidungslogik, IO, Netzwerk und die Kryptoprimitive selbst (wir verlassen uns auf ed25519-dalek).

clawdstrike verify --policy strict       # Z3-Policy-Analyse
cargo test -p formal-diff-tests          # nächtliche Differenzialtests
cd formal/lean4/ClawdStrike && lake build

Siehe den Leitfaden zur formalen Verifikation.

Quittungen

Jedes Urteil wird mit einer Ed25519-signierten Bescheinigung ausgeliefert, die die Entscheidung, die zugrundeliegende Policy und die Beweise enthält. Quittungen werden mittels RFC 8785-JSON-Kanonisierung kanonikalisiert, sodass eine Signatur byteidentisch in Rust, TypeScript und Python verifiziert wird.

Enterprise-Bereitstellungen leiten Quittungen über Spine weiter, ein Ed25519-signiertes und hashverkettetes Umschlagprotokoll. Manipulieren Sie einen Datensatz und jeder spätere Datensatz schlägt bei der Verifikation fehl.

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

Enterprise

Dieselbe Engine plus eine verwaltete Kontrollplattform: Control-API, NATS JetStream-Transport, Spine-Audit-Kette und eine Control Console für SOC-Workflows. Enrollment über mTLS, Posture-Befehle mit Request/Reply-Acks, signierte Completion-Bundles zurück an die API.

Siehe Enterprise-Enrollment und adaptive Architektur.

Compliance

Clawdstrike ist kein zertifiziertes Produkt. Es erzeugt Nachweise, die auf Standard-Kontrollrahmenwerke abbildbar sind: signierte Aktionsbescheinigungen, integritätsverkettete Audit-Trails, deterministische Policy-Auswertung.

Compliance-Zuordnungen sind Entwürfe. Eröffnen Sie ein Issue, wenn Sie ein formales Rahmenwerk benötigen.

Designprinzipien

Fail closed. Ungültige Policies werden beim Laden abgewiesen. Auswertungsfehler verweigern den Zugriff. Fehlende Konfiguration wird restriktiv vorgegeben. Sicherheitsverschlechterung erfordert explizites, auditierbares Handeln.

Beweis, nicht Logs. Ed25519-Quittungen sind kryptografische Bescheinigungen, keine Logzeilen, die jemand bearbeiten kann. Kanonisches JSON (RFC 8785) stellt sicher, dass Signaturen in Rust, TypeScript und Python identisch verifiziert werden.

Gleicher Umschlag, beliebige Leitung. Ein signierter Spine-Umschlag ist byteidentisch, egal ob er über NATS mit 100K msg/sec, über libp2p gossipsub über das private Internet oder über ein LoRa-Funkgerät mit 1.200 bps reist. Der Transport ist für die Wahrheitsschicht unsichtbar.

Nur Abschwächung. Agenten delegieren Teilmengen ihrer Fähigkeiten, niemals Eskalationen. Delegationstoken tragen kryptografische Fähigkeitsobergrenzen. Privilegieneskalation wird nicht durch die Policy verhindert, sondern durch Mathematik.

Eigener Stack. Apache-2.0. Selbst hostbar. Keine Herstellerabhängigkeit für sicherheitskritische Infrastruktur. Dieselbe Engine läuft auf einem Entwickler-Laptop, einer Unternehmensflotte und einem Raspberry Pi in einem Funkmesh.

Dokumentation

Sicherheit

Wenn Sie eine Schwachstelle entdecken:

• Sensitiv: E-Mail an [email protected]. Antwort innerhalb von 48 Stunden.
• Nicht sensitiv: Eröffnen Sie ein GitHub-Issue mit dem Label security.

Siehe SECURITY.md und THREAT_MODEL.md.

Mitwirken

Siehe CONTRIBUTING.md.

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

Lizenz

Apache License 2.0. Siehe LICENSE.