Skip to main content

Confidential Client Node Attestation

:::note SKR mode Confidential Client mode is a SKR mode capability. It requires Platform-Managed custody and a deployment whose workloads run inside attested TEEs. :::

For high-throughput workloads — a data pipeline encrypting gigabytes per second, an ML training job batching millions of records, a bulk-export streaming a large collection — routing every cryptographic operation through Kibo becomes a network bottleneck. In SKR mode, the Confidential Client mode resolves this: your workload runs inside its own TEE (Intel TDX or AMD SEV-SNP), proves to Kibo via hardware attestation that it is genuinely an attested enclave running unmodified code, and Kibo releases the plaintext DEK over a channel keyed to the client TEE's attestation. The plaintext DEK only ever exists inside hardware-attested enclaves on both ends.

The architectural treatment of Confidential Client mode is in Kibo Overview §3. This tutorial covers the deployment-side operational steps.

Prerequisites​

  • A Kilimanjaro project in SKR mode deployment with Platform-Managed custody
  • A client workload that can run inside a TEE — typical substrates: GCP Confidential VMs, Azure Confidential Computing, OVHcloud SEV-SNP-enabled instances
  • The Kilimanjaro CLI and SDK for the language your workload is built in (per the SDK reference and the CLI reference)

Step 1 — Verify your TEE substrate​

The workload must run inside a TEE that Kibo's attestation verifier recognises (Intel TDX, AMD SEV-SNP). The substrate's verification flow chains the local TEE's attestation document to the silicon vendor's published roots (Intel DCAP, AMD VCEK).

If your substrate's local attestation does not chain to a Kibo-recognised root, the workload cannot operate in Confidential Client mode. Resolve the substrate issue before proceeding.

Step 2 — Initialise the confidential client​

Inside the TEE-resident workload, initialise the platform's confidential-client surface per the SDK's documented API (see the SDK reference for the canonical method names and the configuration parameters).

The initialisation, conceptually, performs three steps:

  1. Generates a keypair inside the client TEE
  2. Requests a hardware attestation report from the TEE, binding the report to the public key's hash
  3. Submits the attestation report and the public key to Kibo, which verifies the attestation against the silicon vendor's published roots

On verification failure, initialisation rejects; no plaintext DEK is shared.

Step 3 — Request a DEK and perform bulk encryption​

Once the confidential client is initialised, request a per-workload DEK via the SDK's documented primitive. The flow:

  1. Client requests a DEK; submits the attestation context
  2. Kibo verifies the attestation context is still valid (and rejects stale or rotated workload measurements)
  3. Kibo generates the DEK inside its own TEE, wraps the plaintext with the client's attested public key, returns both the wrapped DEK ciphertext (for storage) and the per-channel-encrypted plaintext DEK
  4. Client TEE decrypts the plaintext DEK with its enclave-resident private key, caches it with bounded TTL, performs bulk encryption locally, discards the plaintext on cache eviction
Client TEEIntel TDX or AMD SEV-SNPgenerates keypairattestation reportcaches DEK, bounded TTLbulk encryption locallyKiboattestation verifierverifies attestation reportagainst vendor rootsgenerates DEK in its TEEwraps DEK with client keypublic key + attestation reportDEK request + attestation contextwrapped DEK ciphertextplaintext DEK, channel-encryptedSilicon vendor rootsIntel DCAP, AMD VCEK
The attested client TEE receives the plaintext DEK from Kibo only after Kibo has verified its attestation against the silicon vendor roots.

Throughput is bounded only by your local TEE's CPU, not by Kibo round-trip latency. For multi-GB workloads, this is multiple orders of magnitude faster than per-record encryption round-trips.

Step 4 — Read it back​

On the read path, the same model applies in reverse: the client unwraps the stored wrapped DEK over the attested channel, decrypts locally, and discards the plaintext on cache eviction. The DEK is cached inside the client TEE per the configured TTL/byte limits; consecutive reads against the same DEK hit the cache.

Step 5 — Verify the attestation chain in the audit log​

Every Confidential Client operation appears in Kibo's audit ledger with the attestation context preserved: the TEE vendor + measurement that Kibo verified, the verification timestamp, the Gate-side attestation chain identifier. If your workload's TEE measurement changes (a code redeploy with new measurements), the next initialisation re-attests against the new measurement, and the new attestation chain appears in subsequent ledger entries.

The full audit-ledger field surface is documented in Kibo Audit Ledger.

Step 6 — Understand the bounded blast radius​

The trust model shift is intentional and worth being explicit about:

  • In standard Enclaved Mode (the default in SKR mode), the plaintext DEK only exists in Kibo's TEE. A compromised client workload cannot extract the DEK because it never had it.
  • In Confidential Client Mode, the plaintext DEK is shared with the attested client TEE. A compromised client TEE (a vulnerability in the workload code running inside the enclave, even though the enclave itself is genuine) can extract the DEK.

The mitigations that bound this:

  1. TTL + max-bytes eviction — the cached DEK is short-lived; the blast radius of a compromise is bounded by what the workload encrypts during the cache window
  2. Per-workload DEK — if you scope DEKs per workload (rather than sharing one DEK across many client workloads), a single compromise does not expose data the other workloads encrypted
  3. Audit visibility — every DEK distribution event records the attesting workload; an unusual attestation pattern (a workload requesting DEKs at an anomalous rate) is observable in the audit log
  4. Re-attestation on workload restart — restarting the workload generates a new keypair; an attacker who exfiltrated the keypair material from a previous run cannot use it after restart

Confidential Client Mode is the right choice when throughput requirements outweigh the marginal trust transfer. For most application-layer workloads in SKR mode, standard Enclaved Mode is the better default. Projects outside SKR mode use software-protected in-process encryption, which imposes no TEE round-trip overhead at all.

What just happened​

You wired a TEE-resident client workload to Kibo for high-throughput bulk encryption in SKR mode, without surrendering the platform's audit guarantees. The plaintext DEK only ever existed inside hardware-attested enclaves; the attestation chain is preserved in the audit log; the throughput-vs-security trade-off is explicit and bounded.

Next​