Skip to main content

Infrastructure

The infrastructure threat surface covers everything below the platform's process boundary: the physical hardware the platform runs on, the hypervisor that schedules the platform's VMs, and the cloud-provider operations that touch both. The threats here are different in kind from application-layer threats — an attacker who controls the host operating system or the hypervisor has primitives that no software-layer defence can reach.

Kilimanjaro's baseline infrastructure posture is a hardened, mesh-secured execution environment: service-to-service communication uses mutual TLS with SPIFFE workload identity; per-project key material lives in region-pinned software vaults; DEKs are used in-process and zeroized after use. These controls defend against the threat classes below without requiring any hardware TEE.

In SKR mode, the baseline is extended with hardware isolation: workloads that handle plaintext customer data or key material run inside a hardware-isolated Trusted Execution Environment (TEE), and the memory-encryption and attestation protections are enforced by the silicon, not by the operating system or hypervisor. The remainder of this page covers both layers — the hardened baseline and the SKR extension.

1. Scope​

This surface defends against:

Threat classExample
Hypervisor compromiseA malicious or compromised hypervisor reading guest VM memory, snapshotting guest state, or inspecting register contents at scheduling boundaries
Host-level intrusionRoot access to the physical host (cloud-provider operator, insider, or external attacker who pivoted to the control plane) attempting to read tenant memory
Memory-snooping at the silicon boundaryCold-boot attacks against DRAM contents after a forced reboot; memory-bus probing in a controlled environment
VM migration interceptionAn attacker positioned on the cloud provider's internal network attempting to intercept live-migration state
Insider threats at the datacentreDatacentre staff with physical access attempting to read tenant data through the management plane

This surface explicitly does not defend against:

  • Sufficiently resourced physical attacks on the silicon itself — voltage glitching, decapping, DRAM bus interposition with custom hardware, side-channel attacks against the TEE that require physical possession of the host. These are outside the TEE threat model. The boundary the platform inherits is "no hypervisor or above-software adversary can read or modify TEE memory."
  • Side-channel attacks outside the published TEE threat model — Spectre/Meltdown-class speculative-execution attacks are mitigated by the TEE vendor's firmware updates; the platform tracks vendor advisories and patches accordingly.
  • Application-layer compromise of code running inside the TEE — the TEE protects memory and CPU state; it does not protect against bugs in the code running inside it.

2. Technical mitigation​

2a. Hardened baseline​

In every deployment, the infrastructure surface is defended by:

  • Mutual TLS + SPIFFE workload identity — all service-to-service traffic within the platform is encrypted in transit and each workload presents a cryptographically verified SPIFFE identity. A compromised workload cannot impersonate another service on the internal network.
  • Region-pinned software vaults — per-project KEKs are stored in a dedicated, region-pinned software vault; vault access requires workload identity verification; no workload outside the authorised set can reach another project's KEK.
  • In-process DEK zeroization — data-encryption keys are derived in-process for each operation and zeroized immediately after use; they are never written to disk or persisted in application memory between operations.

These controls apply to every project. They are independently verifiable through the platform's audit log and the mTLS certificate chain.

2b. SKR mode extension​

In SKR mode, the baseline is extended with hardware memory isolation. Workloads run inside one of two TEE technologies, depending on the cloud-provider substrate:

TEEVendorWhere it runs
Intel TDX (Trust Domain Extensions)IntelGCP Confidential VMs (TDX), Azure Confidential Computing (TDX SKUs)
AMD SEV-SNP (Secure Encrypted Virtualization — Secure Nested Paging)AMDOVHcloud sovereign-region compute, AWS EC2 (SEV-SNP-capable instances), Hetzner-EU

Both technologies provide the same core guarantee: the workload's memory is encrypted at the silicon level by an integrated memory encryption engine, using a key that is generated inside the CPU and is never exposed to the hypervisor, the host OS, or any management-plane software. The encryption is transparent to the workload — code runs as normal — but any read of guest memory by an external observer (hypervisor, host kernel, DMA controller, attached debugger) returns ciphertext.

External observersHypervisorHost kernelDMA controllerAttached debuggerreads returnciphertextTEE boundary: Intel TDX or AMD SEV-SNPWorkloadcode runs as normalMemory encryptionkey generated in CPUGuest memoryciphertext in DRAM
Memory is encrypted at the silicon level with a key that never leaves the CPU, so a hypervisor, host kernel, DMA controller or debugger reads only ciphertext.

The specific guarantees the TEE enforces:

  • Memory encryption at runtime. Every byte of guest memory is encrypted in DRAM. The encryption key is rotated per workload boot and is held in CPU-internal registers that no software outside the TEE can access.
  • Memory integrity. Both TDX and SEV-SNP attach integrity metadata to encrypted memory — a hypervisor cannot modify TEE memory without the modification being detected by the next read.
  • Register confidentiality. When the workload is descheduled, register state is saved into TEE-encrypted memory. The hypervisor sees only opaque ciphertext at the scheduling boundary.
  • No live-migration without re-attestation. The TEE state cannot be migrated to another host without the destination host completing its own attestation cycle; intercepted migration state is decryptable only by the original CPU.

A hypervisor or host-OS adversary at full root therefore sees: opaque encrypted memory pages, opaque register-state snapshots, and no decryption oracle. The adversary can still deny service to the workload (halt the VM, terminate the host) — denial-of-service is not in the TEE threat model — but cannot read or modify the workload's data.

3. Workload attestation (SKR mode)​

A TEE guarantees memory protection; attestation guarantees that a specific piece of code is the one actually running inside the TEE. This capability is available in SKR mode — without it, customers rely on the platform's mTLS + SPIFFE identity model and the audit log for workload integrity assurance.

In SKR mode, every TEE that handles customer data produces an attestation document at boot:

FieldWhat it certifies
Measurement hashA cryptographic hash of the exact code image (kernel + userspace) loaded into the TEE. The hash binds the attestation to a specific build.
Hardware identityThe CPU's hardware-root key signs the attestation; the signature chains back to a vendor root certificate (Intel DCAP, AMD VCEK chain).
Boot-time configurationTEE parameters (memory size, vCPU count, security policy flags) that were in effect when the workload booted.
NonceA challenge value supplied by the verifier, preventing replay of an old attestation.

Verification is offline and chains to the silicon vendor's published roots:

Verifierexpected hash, fresh nonceattestationWorkload code measurementhash of the exact code imagesigned byHardware root keyin the CPUcertified byTEE vendorIntel / AMDrooted inPublished vendor certificateIntel DCAP, AMD VCEK chain
Attestation verification chains from the workload's code measurement up to the silicon vendor's published certificate, so a modified workload or one outside a real TEE fails the check.

Downstream services (and customers running the verification flow) compute the expected measurement hash for the published platform build, request a fresh attestation from the running workload, and verify both the signature chain and the measurement match. A workload running modified code, an attacker impersonating the workload, or a workload running outside a real TEE all fail this check.

The platform exposes attestation verification as part of Identity-Aware Kernel hardening and the Kibo cryptographic boundary — both surfaces consume attestation as part of their own integrity story.

4. Operational hardening​

Beyond the TEE properties themselves, the infrastructure surface relies on operational discipline:

  • Image provenance. Every TEE workload image is built reproducibly from source, signed, and stored in an immutable registry. The published measurement hash is the input to attestation verification; if the build process drifts, attestation breaks immediately and visibly.
  • No persistent local storage. TEE workloads do not write sensitive state to local disk. Anything that needs to persist (audit-log entries, wrapped key material) is written to platform storage over an attested channel; an attacker who exfiltrates a host's local disks gets nothing of value.
  • Memory zeroing on workload exit. When a TEE workload terminates, its memory is cryptographically destroyed by the TEE itself (the per-workload encryption key is discarded). There is no post-shutdown memory dump that could be recovered.
  • Vendor advisory tracking. TDX and SEV-SNP firmware advisories are tracked continuously; the platform's deployment pipeline applies vendor-recommended mitigations per the project's configured incident-response cadence, with critical and actively-exploited classes prioritised.

5. What this surface does not cover​

The infrastructure surface stops at the TEE boundary. It does not address:

  • Cryptographic key lifecycle. Plaintext key handling — generation, wrapping, rotation, audit — is the Cryptographic Boundary surface.
  • Cross-project isolation at the data layer. Defence against one project's queries reaching another project's data is the Isolation & Privilege surface.
  • Session and token integrity. Defence against forged JWTs and impersonation is the Identity-Aware Kernel surface.
  • Query-layer manipulation. SQL / JSON-policy injection defence is the Injection surface.

Each downstream surface assumes the infrastructure surface holds: workload identity is verified (via SPIFFE at baseline; via TEE attestation in SKR mode), in-transit data is protected by mTLS, and the key vault is accessible only to authorised workloads. In SKR mode, the assumption additionally includes: TEE memory is confidential and a hypervisor adversary cannot read or modify protected state.