Kibo Cryptographic Erasure
Deleting a row removes it from a live table. It does not remove it from last night's backup, from a replica in another region, or from the cold-storage snapshot an auditor will ask about three years from now. For a project that must evidence a decommission — a customer offboarding, a right-to-be-forgotten request, the end of a data-retention obligation — "we ran a DELETE" is not an answer anyone can verify.
Kilimanjaro answers it cryptographically. Because every project's data is encrypted under a key unique to that project, once the key is purged (§4), every copy of that data is permanently undecryptable — live tables, replicas, and backups together — without having to locate and scrub each copy individually. Kilimanjaro delivers this as Zero-Residue: a project's encrypted data does not linger as recoverable plaintext anywhere once its key is gone. The technical descriptor is cryptographic erasure (NIST SP 800-88 "crypto-erase"); Zero-Residue is the capability built on it.
1. The mechanism — one key per project
Every Kilimanjaro project carries its own key. Data is encrypted with per-use Data Encryption Keys (DEKs), and those DEKs are wrapped under the project's own key — there is no platform-wide master key that, if compromised, would expose every project. The custody modes determine where that per-project key lives; cryptographic erasure works the same way across all of them, because the property it depends on is structural: one project, one key, and the data is unreadable without it.
Destroying the project's key is therefore the destruction of the data. A ciphertext whose key no longer exists is not "deleted" — it is mathematically inert. This is what makes the guarantee verifiable rather than asserted: an auditor does not have to trust that every copy was found and shredded; they have to verify that one key was destroyed, which the signed ledger records (§5).
The key isolation underneath this is demonstrable, not just designed. A DEK wrapped under one project's key, presented for unwrap under a different project's key, fails the cryptographic integrity check — the boundary is the key itself, and it holds.
2. What erasure covers — and what it does not
Cryptographic erasure renders permanently unreadable the data encrypted under the per-project key. That scope is precise, and it is worth stating plainly so the guarantee is never over-read:
- Vault secrets — the secret-management surface, encrypted under the project key.
- Encrypted fields — any column declared
encrypted, protected at rest under a per-project field key. - Tokenized values — the real values of tokenized fields, which live in the project vault under the project key; the customer database holds only opaque tokens.
- Values sealed by the platform's application encryption route (
crypto.encrypt, platform-managed keys) — covered by the project key's lifecycle only. They are not covered by per-subject erasure: destroying the project key unreads them with everything else, and nothing narrower exists for them.
All four wrap under the same per-project key, so a single erasure renders all of them unrecoverable together — in live storage and in backups — with no separate erasure mechanism per data type.
What erasure does not silently cover, and how those cases are handled instead:
- Columns you did not designate. A plaintext column you never marked encrypted is not protected by the per-project key, so destroying the key does not render it unreadable. On decommission, those columns are removed by row and schema deletion as the project is de-provisioned — by deletion, not by cryptography. Kilimanjaro does not claim key-destruction erases data the key never protected.
- Deterministic-token correlation. A tokenized field configured for equality matching stores a stable token in the row. The real value lives only in the vault and becomes unrecoverable when the key is destroyed; the in-row token, however, is an equality marker, and the guarantee is scoped accordingly: the value is gone, and the claim is that field ciphertext and vault-held values are unrecoverable after erasure — not that no equality-correlatable marker remains in the row.
The precise one-line scope: erasure renders permanently unreadable all data encrypted under your project's key — vault secrets, encrypted fields, and tokenized values; other columns are erased by deletion.
2.1 Backups
The guarantee extends to backups because backups inherit the same key. A logical backup is itself encrypted under a per-project backup key derived from the project key, so destroying the project key renders the backup undecryptable by the same act. The mechanism is "the backup is ciphertext and its key is gone," not "we located and deleted the backup."
2.2 Erasing one person
Erasing one person does not destroy the project key. Destroying that person's field key makes their encrypted data unreadable in live storage at once, and backup copies of it age out within 28 days. In BYOK and HYOK the key you own stays with you: Kilimanjaro detaches it from the project and does not destroy it.
3. Who can trigger it — no one administrator acts alone
Erasing a project is the most destructive operation the platform supports, and it is gated so that no one administrator can make it irreversible alone. Every erase, however your organisation is set up, sits on the same floor:
- Authenticated, single-use, and replay-protected — the erase is initiated by an authenticated request that produces a signed, single-use intent; the same authorization cannot be presented twice.
- A 24-hour window to cancel after approval, then the key is held recoverable for 28 days, so no single action is ever immediately irreversible (§4).
On top of that floor, the approval gate depends on how many administrators your organisation has:
- More than one administrator — an independent two-person approval (maker-checker) is required before the key is touched, so no one administrator can erase the project alone. The platform records the approval and a fresh passkey check, signs them, and the key-management engine verifies that signature before it acts on the key.
- A single administrator — initiating the erase requires step-up re-authentication, and it stays reversible for the full 28-day window. Nothing in the platform's API can shorten that window: the soft-deleted key is recoverable throughout, and permanent destruction is the automatic event at the end of the window — not something any customer, or the service itself, can trigger early. So no one administrator can make an erasure irreversible alone.
:::note Scope of the guarantee — what "no one administrator" means On the platform-custody modes, the erase intent is signed by a dedicated platform key on the customer's authenticated behalf — it represents your authorization; it is not signed by a key only you hold. The accurate guarantee is that no one administrator can make an erasure irreversible alone. The platform attests to the person's check; the intent isn't that person's own signature. Every erase is authenticated, single-use and replay-protected, can be cancelled in a 24-hour window, and stays recoverable for 28 days; where your organisation has more than one administrator an independent two-person approval is additionally required, so no one administrator can erase alone (§3). If your requirement is that only the customer, holding their own key, can authorize destruction — an operator-independent consent — that is the sovereignty property of BYOK and HYOK, where the key is yours and Kibo never holds it. Cryptographic erasure and key-custody sovereignty are distinct capabilities; this page describes the former. :::
4. The 28-day lifecycle
Erasure is immediate in effect and deliberate in finality. The moment an erase is authorized — call it day D — the project's key stops resolving: every key-bearing operation fails, and the data is functionally unreadable from that instant. The key itself is not yet destroyed; it is held in a recoverable state for 28 days.
That window serves three purposes at once: the data is already functionally erased, a mistaken or malicious erase can be reversed by an administrator within the window, and at D+28 the key is permanently purged and the erasure is irreversible.
| Day | State | Effect |
|---|---|---|
| D | Key stops resolving | Data functionally unreadable immediately; key recoverable |
| D → D+28 | Recoverable hold | An administrator can abort a key erase and restore the project. A project exit can't be aborted once it has fired; cancel it in the 24-hour window |
| D+28 | Permanent purge | Key destroyed; erasure irreversible |
After erasure, every key-bearing operation against the project returns a terminal K9O_PROJECT_ZEROIZED error (HTTP 410 Gone) — the project is permanently undecryptable, and the API says so explicitly rather than failing ambiguously.
5. The lifecycle is signed and auditable
Cryptographic erasure is not a silent backend event — it is recorded in the project's signed audit ledger as a chain of attributed, platform-signed entries:
KEY_ZEROIZING— the key enters its recoverable hold at D.KEY_PURGED— the signed commitment that records both the soft-delete timestamp (D) and the scheduled completion date (D+28); it is the signed promise of the 28-day timeline.KEY_ERASURE_CONFIRMED— the terminal event emitted by the D+28 reconcile job when it observes that the key has been permanently purged; this is the proof of observed completion, not just the commitment to purge. A compliance reviewer who needs to demonstrate that erasure occurred — not merely that it was scheduled — cites this entry.KEY_ZEROIZE_ABORTED— emitted if an administrator reverses the erase within the window.
Each entry is hash-chained to the one before it and signed by the platform's key, so the erasure record carries the same tamper-evidence and offline-verifiability as the rest of the ledger. The receipt is the evidence a compliance reviewer cites: not "we believe the data was deleted," but a signed, ordered, verifiable record that the project's key was zeroized, committed for permanent purge, and — at D+28 — confirmed destroyed, attributed through Gate to the identity that authorized it.
6. What cryptographic erasure is not
Two boundaries matter, because both are easy to over-read:
It is not zero-knowledge. On the platform-custody modes, Kibo holds the per-project key. Cryptographic erasure gives a signed record that the project's key was destroyed; it does not claim the platform cannot see the data while the project is live. Operator-blind, "your keys never leave your control" custody is the separate sovereignty story of BYOK and HYOK. Erasure works in those modes too — but the erasure guarantee and the custody guarantee are different claims, and Kilimanjaro keeps them distinct.
It is not full-disk encryption. The at-rest protection here is per-field and per-secret, each under the project key — not an encrypted volume. Erasure destroys what the key protects; it is not a disk-wipe.
The cryptography is classical and current-generation: AES-256-GCM-SIV for data and key-wrapping, Ed25519 for the signed erase intent, and RSA-2048 with SHA-256 for the audit ledger's signatures and hash chain. The ledger's tamper-evidence is tamper-evident — a modification is detectable — not "tamper-proof," and the chain-walk verifier is formally proven modulo its trusted primitives, the trusted-under-test boundary described for the ledger.
7. See also
- Overview — the four custody modes and where each project's key lives.
- Field Encryption & Tokenization — the
encryptedand tokenized fields whose ciphertext and vault values erasure renders unrecoverable. - Audit Ledger — the signed, hash-chained record the erasure lifecycle is written to.
- BYOK · HYOK — customer-held key custody, where erasure composes with operator-blind sovereignty.
- Security → Identity-Aware Kernel — how Gate attributes the erase authorization to a verified identity.