Skip to main content

Kibo Overview

Kibo is Kilimanjaro's sovereign secrets management plane. It runs on its own hardware, in its own jurisdiction, isolated from the data plane by design, and it ships either as a standalone package (@k9o/kibo) or composed into a Kilimanjaro plan via @k9o/core. The wire contract and SDK shape are identical across both consumption paths.

Where most secrets-management services treat key custody as a single binary choice (the vendor has the keys, or the customer does), Kibo offers four custody modes the customer moves between on their own schedule — without code changes, without re-encryption events, without operational pauses.

1. The four custody modes​

ModeWhere the CEK livesCustomer involvementTypical use case
Platform-ManagedKibo's platform key vault (software-protected)None — the platform generates and manages everythingDefault starting posture; most application data
SKR (Secure Key Release)Kibo's CVM enclaveKibo holds the key but releases it only to your own verified, attested code — unauthorized builds are refused. The integrity mode.Workloads that need cryptographic proof that only their authorized build can receive keys — ML pipelines, regulated data processing, high-assurance services
BYOK (Bring Your Own Key)Customer's KMS — AWS KMS, GCP Cloud KMS, or Azure Key VaultCustomer holds the CEK; Kibo wraps DEKs with it via cloud-native KMS primitivesCompliance regimes that require customer-held key custody; data sovereignty mandates
HYOK (Hold Your Own Key)Customer-administered key manager, attached over KMIPCustomer holds the CEK in their own HSM; Kibo wraps DEKs through the customer's HSM API surfaceMaximal-control postures — defence, intelligence, regulated finance, healthcare with HSM-rooted custody requirements

Changing custody mode is a custody-policy update on the project, not a code change. The SDK call surface is identical across all four modes; code written against Platform-Managed runs unchanged against HYOK.

Platform-Managed and SKR are both platform-custody modes — Kibo holds the Data Encryption Key. SKR is the integrity mode: it adds a measurement-policy gate so that only your own verified, attested code can receive the key. BYOK and HYOK are the sovereignty modes: Kibo never holds the plaintext key at all.

Downgrade transitions (higher → lower custody) require attestation through the IRREVERSIBLE_ACTION_GATE policy family per API → Control. Upgrades (lower → higher) require no attestation — adding custody is always permitted; surrendering it requires proof of intent. See Custody architecture.

platform custody: Kibo holds the DEKsovereignty: Kibo never holds the plaintext keyPlatform-Managedplatform key vaultsoftware-protectedSKRKibo's CVM enclavereleased only toattested codeBYOKcustomer's cloud KMSAWS · GCP · AzureKibo wraps DEKsHYOKcustomer key managerattached over KMIPcustomer's own HSMone SDK call surface across all four modes
The custody ladder: the first two modes keep the key with Kibo, the last two keep it with you, and the SDK call is the same in every mode.

2. The Application Cryptographic Oracle Protocol​

Kibo's cryptographic contract with the SDK is formalised as the Application Cryptographic Oracle Protocol. The protocol makes three load-bearing claims that downstream architecture and audit posture depend on:

Claim 1 — Plaintext keys never leave the oracle boundary. The Kibo SDK is an oracle, not a library. It never pulls plaintext Data Encryption Keys (DEKs) down to an unsecured client machine, into a database layer, or into application-layer memory. Payloads requiring encryption or decryption travel from the SDK to the Kibo oracle over a mutually authenticated channel; the cryptographic operation happens inside the oracle boundary; only sealed assets — ciphertexts, wrapped keys, signed attestations — flow back. In CVM deployment (SKR mode), the oracle runs inside a hardware-isolated Trusted Execution Environment (TEE) and the boundary is hardware-enforced: plaintext DEKs exist only inside encrypted processor memory and never occupy a host-visible page.

Claim 2 — Transit is mutually authenticated and certificate-pinned. Every connection between the SDK and Kibo runs over TLS 1.3 with mutual authentication, pinning Kibo's published certificate. Connections between Kibo and a customer's KMS pin the KMS endpoint's certificate against the vendor's published roots. A MITM that swaps either certificate is rejected at handshake before any payload moves.

Claim 3 — Re-wrap never exposes the plaintext DEK to Kibo. When a wrapped DEK is re-encrypted under a new CEK version (after customer-initiated CEK rotation), Kibo unwraps the DEK under the old CEK version and wraps it under the new one, using only decrypt and encrypt calls. Where the CEK is the customer's own — BYOK and HYOK — the plaintext CEK stays in the customer's KMS or key manager, hardware-backed on HYOK. On platform-managed custody the CEK lives in Azure Key Vault (software-protected). In every mode the DEK is held only in Kibo's isolated vault memory for the duration of the re-wrap, under the same lifetime and zeroing rules as any other DEK operation.

The full threat-model treatment of these claims — the threats they close, the TTL and zeroing discipline, the transmission vector protections — is in Security → Cryptographic Boundary.

3. Network payload strategies​

Kibo balances absolute key sequestration against the network-throughput cost of routing every cryptographic operation through a remote enclave. The platform offers two payload strategies, selected per use case:

3.1 Enclaved Field/Record Encryption (Default)​

Every encrypt or decrypt operation goes to the Kibo oracle. The SDK submits the plaintext payload over the authenticated channel; Kibo performs the cryptographic operation inside the oracle boundary; the SDK receives the sealed ciphertext. The plaintext DEK never leaves that boundary — in-process and zeroized after use on the hardened baseline, hardware-enforced inside the TEE on SKR mode.

This is the right strategy for:

  • Application-layer field encryption (PII fields, credit cards, sensitive identifiers)
  • Per-record encryption with low-to-medium throughput per record
  • Any payload where the round-trip latency to Kibo is small relative to the rest of the request

The cost is one network round-trip per operation; for typical application workloads (under a few thousand encrypt/decrypt calls per second per project, payload sizes under a megabyte), this is the right default.

3.2 Confidential Client Encryption​

Confidential Client Encryption requires SKR mode: both the client workload and the Kibo oracle run inside attested TEEs, so the plaintext DEK only ever exists inside hardware-attested enclaves on both ends.

For high-throughput workloads — a data pipeline encrypting gigabytes per second, an ML training job batching millions of records, a bulk-export job streaming a large collection — the per-operation network round-trip becomes the bottleneck. Confidential Client Encryption resolves this by securely sharing the plaintext DEK with a client workload, but only when that client workload is itself running inside an attested TEE.

The flow, at a concept level:

  1. The client workload, running inside an Intel TDX or AMD SEV-SNP TEE, generates a key pair inside the enclave and produces a hardware attestation report binding the public key to the TEE's measurement.
  2. The client requests a per-workload DEK from Kibo, attaching the attestation report.
  3. Kibo verifies the attestation report against the silicon vendor's published roots (Intel DCAP, AMD VCEK). On verification failure, the request is rejected; no plaintext DEK is transmitted.
  4. On successful verification, Kibo generates the DEK inside its own TEE, wraps the plaintext DEK with the client's attested public key, and returns both the wrapped DEK ciphertext (for storage) and the per-channel-encrypted plaintext DEK (for the client TEE to decrypt inside its enclave).
  5. The client TEE decrypts the plaintext DEK with its enclave-resident private key, caches it with bounded TTL inside the enclave, performs bulk encryption locally, and discards the plaintext on cache eviction.
Client workloadTDX / SEV-SNP TEE1key pair generated in theenclave; attestation reportbinds the public key to theTEE measurement5decrypts the DEK inside theenclave, caches it with abounded TTL, encrypts in bulkKiboinside its own TEE3verifies the report againstvendor roots (Intel DCAP,AMD VCEK); on failure therequest is rejected4generates the DEK, wraps itwith the client's attestedpublic key2 · request DEK, attachingthe attestation report4 · wrapped DEK (for storage) +channel-encrypted plaintext DEK
The plaintext DEK travels only between two attested enclaves: the client proves its TEE, and Kibo returns the key wrapped to the public key that proof binds.

The security property: the plaintext DEK only ever exists inside hardware-attested enclaves on both ends of the channel. A network adversary cannot intercept it (it is encrypted with a key only the attested client TEE can decrypt). A non-attested client cannot pose as an attested one (the attestation chain must verify against the vendor root). A compromised client enclave can decrypt the DEK — that is the trust transfer the customer accepts when adopting this mode.

The SDK primitives that drive the flow are documented in the TypeScript SDK reference and the per-language SDK pages. Confidential Client Encryption is the right strategy when the throughput-per-Kibo-round-trip ratio makes per-operation enclave routing impractical, and when the customer is willing and able to run their client workload inside a verified TEE.

4. Hardened baseline and SKR mode​

Every Kibo project runs on the hardened baseline: software-isolated, region-pinned nodes with the per-project key held in a regional vault, in-process DEKs zeroized after use, mesh mTLS + SPIFFE identity between workloads, and the platform-signed audit ledger. No hardware enclave is required — this is the default for every project.

SKR mode raises the integrity bar: the key-bearing Kibo workloads — the enclave that holds plaintext DEKs during use, the re-wrap path, the attestation verifier — run inside a hardware-isolated Trusted Execution Environment, with key release gated on remote attestation. In SKR mode, plaintext DEKs exist only inside encrypted processor memory and never occupy a host-visible page. The TEE substrate:

SubstrateTEE technology
GCP Confidential VMs, Azure Confidential ComputingIntel TDX
OVHcloud sovereign-region compute, AWS EC2, Hetzner-EUAMD SEV-SNP

The SDK looks the same regardless of the silicon underneath; the attestation chain (TDX vs SEV-SNP) is transparent to caller code. The threat-model treatment of the baseline and SKR mode is in Security → Infrastructure.

5. Where Kibo runs​

Multi-cloud, multi-jurisdiction. Kibo runs across:

  • OVHcloud sovereign regions — US and EU
  • GCP Confidential VMs — US and EU
  • AWS EC2 SEV-SNP-capable instances — US and EU
  • Hetzner-EU — EU

Project residency is set at project creation and is immutable thereafter. A project pinned to de01 keeps its keys, its DEKs, and its audit ledger inside that region for the project's lifetime. See Regions & residency for the residency model.

6. Standalone vs integrated​

Kibo ships in two consumption paths:

  • Standalone (@k9o/kibo) — Kibo as a dedicated secrets-management module, with no other Kilimanjaro plan required. The SDK, the wire contract, and the custody ladder are identical to the integrated path. Pricing is per-operation with volume tiers. See Standalone Onboarding.
  • Integrated (@k9o/core re-exports @k9o/kibo) — Kibo composed into a Kilimanjaro plan, automatically scoped to the customer's projects and orgs. Identity and audit attribution integrate with Gate and the rest of the Stack.

The SDK shape is identical across both paths. Migration from standalone to integrated is a configuration change, not a code change.

7. The Vault on a regular project is the same custody surface​

Every Kilimanjaro project — whether you use Kibo standalone or you're using the rest of the platform — has the same custody surface, surfaced as Vault mode in the Console. The four custody modes (Platform-Managed, SKR, BYOK, HYOK) and the audit ledger underneath are the same on every project regardless of which way you bought in.

The difference is what else is in the Console:

  • If you use just Kibo standalone, the Console shows Vault mode as the primary operational surface. The mode picker hides the other four modes (Workspace, Studio, Forge, Admin) because they don't apply.
  • If you have the rest of Kilimanjaro, Vault is one of five modes you can switch between. Wardens reach Vault by clicking it in the mode picker; the Admin mode Watchtower also shows a thin Vault summary with a one-click link.
  • If you use both, your Console adapts depending on which project you've switched to — a Kibo project surfaces Vault mode as primary; a regular project surfaces all five modes.

The custody substrate is identical across all three shapes; the surrounding modes are what differ.

Access to Vault mode requires two things: a project-admin role for the mode itself, plus a Vault-domain role (VAULT_OPERATOR for full mutation, VAULT_AUDITOR for read-only) for the surfaces underneath. A regular team member without admin access can't reach Vault on a regular Kilimanjaro project. A read-only auditor can browse the signed ledger without holding any custody-mutation power; that separation is the foundation of the compliance story.

8. Org-wide secrets​

Every secret is project-scoped — there is no org-level secret bucket, hidden or otherwise. A secret create call always requires a project; there's no path that omits one.

For a secret that's genuinely org-wide — a third-party API key several services share, a signing key used across projects — pick or create a project to hold it. Projects are free to create, so most orgs designate one project as the home for shared secrets rather than duplicating the same value into every project that needs it. A common pattern is a dedicated project with admin-only membership, used purely as a secrets store with no application workload attached to it — but any project works; nothing about custody or the API distinguishes a "shared-secrets project" from an application project.

9. See also​

  • SKR — the integrity mode: measurement policy, CI registration, per-release enforcement.
  • BYOK — the four BYOK providers, the re-wrap and tombstone discipline, the rotation engine.
  • HYOK — the KMIP key-manager families and the attach ceremony.
  • Audit Ledger — append-only, hash-chained, hardware-signed; the forensic backbone.
  • CLI — terminal-side vault secrets and offline ledger verification.
  • Standalone Onboarding — signing up for Kibo without a Kilimanjaro plan.
  • Security → Cryptographic Boundary — the full threat-model treatment of the Application Cryptographic Oracle Protocol.
  • Custody architecture — custody mode in the broader request flow.