Security model

A worm that cannot authorize itself.

A server that auto-deploys code across a datacenter looks exactly like a worm, so we treat it like one. Every hop is independently gated by consent, identity, signature, sandbox, audit, and revocation. The single property that makes it safe: the server cannot mint its own authorization.

Consent-gated, per action Hardware-rooted attestation Revocation: honest latency
The pivot

The server cannot forge its own consent

An auto-deploying control plane and a worm are the same shape: both move code from host to host and run it. The difference is authorization. In KWAM the authorization artifact is signed by a key the server never holds. A server with full read/write to its own config and disk still cannot manufacture permission to act.

What this is and is not KWAM contains blast radius; it does not claim to prevent every compromise. The defensible guarantee at the data layer remains no silently-corrupted bits (SHA-256 detection); the model is advisory and never produces a data byte. The fleet shown in the HUD is simulated and labeled: the only real bytes are SHA-gated Reed–Solomon fragments.
Consent token

The single authorization artifact

One signed, single-use, operation-bound token authorizes one action, and nothing else. It is Ed25519 / cosign-signed by an operator HSM key the server never holds, and verified at runtime, per action.

Bound to the operation: grant_id, target_set_hash, content_cid, rollout_id. Minutes-TTL for deploy. A spent-token ledger, raft-sequenced, blocks replay.

Single-use Operation-bound Minutes-TTL Unspent-in-ledger

Verified at runtime, per action

Every check must pass

# signed by an OPERATOR HSM key
# the server NEVER holds
verify signature       # cosign / Ed25519
verify freshness       # within TTL
verify unspent         # raft ledger
verify svid            # subject_glob + capability
verify content_cid     # cid matches bytes
verify ticket
authorize("one action")  # else fail closed

grant_id · target_set_hash · content_cid · rollout_id

Capabilities

A closed enum, nothing implicit

Every action maps to one capability, carried by the token and checked against the node's SVID. The language's closed enum is exactly these five; discover is non-default, per-range scoped, rate-limited and audited. (The HTTP API adds one more, enroll, for onboarding a new identity.)

CapabilityWhat it permitsDefault
discoverBounded, read-only probe of a capped candidate set (HTTP GET only)Off: per-range scoped, rate-limited, audited
replicatePlace SHA-gated RS fragments on attested nodesCapability-gated
deployMove signed, content-addressed code to a target setCapability-gated · minutes-TTL token
executeRun code inside a sandbox tier ≥ the policy floorCapability-gated · sandbox floor enforced
quarantinePer-target revoke / cordon / evictCapability-gated · rate-limited · dual-control-eligible
Sandbox tiers

A floor, enforced — none is not permitted

A client may only request a tier at or above the policy floor (default gvisor). It can never request weaker isolation than policy allows.

subprocess

Process-level isolation. The weakest permitted tier, available only where policy explicitly sets the floor this low.

seccomp

Syscall filtering on top of process isolation, narrowing the kernel attack surface.

gvisor

User-space kernel: the default policy floor. Strong syscall mediation without a full VM.

wasm

WebAssembly sandbox: capability-scoped, deterministic, memory-isolated execution.

microvm

Hardware-virtualized micro-VM: the strongest tier for untrusted or high-blast-radius payloads.

Identity

Hardware-rooted attestation, required

Any node that receives deploys or holds replicas must present a hardware-rooted attestation quote: TPM, SEV-SNP, or TDX.

Soft facts, such as MAC address, GPU-UUID, or serial number, are software-spoofable and are never sufficient alone. No quote means limited-capability / quarantine mode: the node holds no replicas and runs nothing executable.

No quote → no trust

Quarantine mode

A node without a valid hardware quote is admitted only in a degraded posture: it cannot hold replicas and cannot execute code.

TPM SEV-SNP TDX

soft facts: advisory only · never sufficient

Discovery

Bounded and read-only — a scoped probe, not a scanner

Discovery is capped at a capped candidate set and is HTTP GET only. It cannot sweep a network; it cannot write. It is a scoped probe of a pre-bounded candidate set, never a scanner.

By design discover is non-default, per-range scoped, rate-limited, and audited. Turning it on is a deliberate, logged operator decision.
Revocation

Honest latency, and layered enforcement

We do not claim "one round." 99% of the fleet is reached in O(log N) gossip rounds (~10–15s at 100k nodes), with a tail. Several independent controls cover that tail.

Connection-time enforcement

Every mTLS handshake re-checks the SVID and a short-TTL revocation epoch; a revoked node is refused at connect time.

Out-of-band mTLS push

A direct push reaches reachable nodes in sub-2s, ahead of the gossip wavefront.

Expiry backstop

A node that cannot reach the attestation authority within its short SVID TTL self-quarantines.

Mint-side pause

global_pause freezes new authorization at the source: a fleet-wide stop on deploy / replicate.

Per-target

quarantine

Revoke, cordon, or evict a single target. Capability-gated, rate-limited, dual-control-eligible, audited, and reversible.

Fleet-wide

global_pause

A mint-side freeze of deploy and replicate across the whole fleet: no new authorization is issued while paused.

Warm restart

A reboot re-validates authorization — not just integrity

On every restart KWAM re-verifies the cosign signature, confirms the signer is still trusted, checks transparency-log inclusion, and tests the bit against the current revocation / quarantine set. If the revocation list is unreachable, it fails closed.

Why it matters A reboot cannot become a quarantine bypass. Integrity alone is not enough; authorization is re-checked against the live policy state, every time.
Onboarding

KWAM_INJECT: the host pulls its own identity

An operator initiates onboarding from the HUD. The host then pulls its own identity, and the server opens zero inbound connections.

SSH-password push is explicitly rejected. Separation of duties is enforced across keys, so no single key both initiates and authorizes.

Pull, never push

Zero inbound

# operator initiates from the HUD
host pull identity        # host reaches out
server inbound = 0    # opens nothing
ssh_password_push      # REJECTED
separate(keys)          # duties split
Threat review

It detects and recommends — it never acts on its own

A built-in, read-only review that surfaces what it finds and recommends a fix. It cannot carry the fix out itself; every remediation still flows through the existing consent-gated controls.

Read-only by construction

The review observes and reports. It detects and recommends but takes no action; it cannot self-mint authority. Any remediation it suggests still has to clear the same consent, identity, and signature gates as every other action.

Deterministic & reproducible

Signature-based and deterministic: the same posture yields the same findings every time. Two reviewers, or a reviewer and an auditor, see the same result, with no model in the decision path.

Honest hardware-posture read

A read-only look at the hardware posture that reports only what it can actually read and marks everything else unavailable, never a guessed or invented value.

Detection is not authority The review can name a risk; it cannot remediate it. Knowing about a problem and being allowed to change the fleet are deliberately separated. The only path to action remains the consent-gated controls above, and the server still cannot mint its own permission.
Residual risks

Stated plainly — what KWAM does not claim to stop

KWAM contains blast radius. It does not claim to prevent every compromise. These risks remain, and we name them:

Legitimately-signed supply-chain bit HSM compromise Insider collusion AI-repair output that passes tests but is wrong Sandbox 0-day
Rollback covers only detectable failures Automatic rollback is triggered by detectable failure: an exception, a health-gate trip, an integrity check. A semantic regression that still passes its checks is caught by canary plus the health gate, and may reach a small cohort before rollback. We do not claim that no bad change ever reaches a node.

A control plane you can defend in a review

KWAM is proprietary and licensed directly. Tell us about your fleet and we'll walk the threat model with you.

Legal

Ownership & governing law

KWAM is our intellectual property, grounded in Swiss law.

Intellectual property & governing law

KWAM is the sole and exclusive property of the owners of KWAM.CH

KWAM — its source code, the KWAM language, the JHMM reconstruction orchestrator, the deterministic codec runtime, and all associated AI components — is a proprietary computer program and the sole and exclusive intellectual property of KWAM.CH. As a computer program it is a protected work under the Swiss Federal Act on Copyright and Related Rights (Copyright Act, CopA), and the exclusive rights of use vest in KWAM as employer; it is further protected as a trade secret under the Swiss Federal Act Against Unfair Competition (UCA). KWAM is offered by private licence only. All rights reserved.

CopA (SR 231.1) Art. 2 para. 3 & Art. 17 · UCA (SR 241) Art. 6 · Governed by the laws of Switzerland · Place of jurisdiction: Zürich