Confidential Computing

Creates a hardware-backed enclave—a private region of memory within the CPU—that isolates code and data from the host operating system, hypervisor, and other virtual machines. Even a compromised OS kernel or a malicious cloud administrator cannot inspect or tamper with data inside the enclave.

• Encrypted memory pages at the hardware level
• Physical isolation from all software outside the TCB
• Protects against privileged insider threats

A process where the TEE generates a cryptographically signed measurement of its initial state—including firmware, software, and configuration—and presents it to a remote verifier. This proves the enclave's identity and integrity before any secrets are provisioned.

• MRENCLAVE and MRSIGNER hash verification
• DCAP infrastructure for scalable, private attestation
• Establishes a trust anchor for distributed confidential workloads

Closes the final gap in the data lifecycle security triad. While encryption at rest (disk encryption) and encryption in transit (TLS) are standard, Confidential Computing ensures data remains encrypted even while actively processed in CPU registers and cache.

• Runtime memory encryption via hardware engines
• Transparent to applications; no code changes required for Confidential VMs
• Protects against cold boot attacks and memory scraping

Extends TEE protections to machine learning workloads, enabling Confidential AI. During private inference, a client's input data and the server's proprietary model weights remain mutually confidential—both are only decrypted inside the attested enclave.

• Protects model intellectual property from theft
• Ensures client data privacy during inference
• NVIDIA Confidential Computing extends this to GPU-accelerated training

Integrates TEE lifecycle management into cloud-native platforms like Kubernetes. Enclave-aware orchestration handles attestation verification, secret injection, and scheduling of confidential containers and VMs across clusters.

• Confidential Containers combine agility with hardware security
• Automated attestation verification before pod scheduling
• Frameworks like CCF enable tamper-proof multi-party governance

A mechanism that cryptographically binds data to a specific enclave's identity and security version. The enclave can seal secrets to untrusted storage and retrieve them only on the same platform, ensuring state persists securely across reboots.

• Tied to enclave measurement or signer identity
• Protects against rollback attacks via version binding
• Enables stateful confidential services without exposing keys

Protects the intellectual property of the model and the privacy of the user's prompt during inference. The model weights are decrypted only inside a secure enclave, preventing the cloud operator or any unauthorized process from extracting the proprietary model or logging sensitive user inputs.

• Mutual Protection: Shields the model owner's IP and the client's data simultaneously.
• Regulatory Compliance: Enables processing of PII/PHI in the cloud without exposing raw data to the infrastructure provider.
• Example: A healthcare startup uses NVIDIA Confidential Computing to run an AI diagnostic model on patient medical images, ensuring the hospital's data and the startup's model weights remain mutually confidential.

Allows competing organizations or regulated entities to jointly analyze or train models on their combined sensitive datasets without revealing the raw data to each other. Data remains encrypted in use within the enclave, and the results are only released via approved, aggregated outputs.

• Anti-Trust Safe Harbors: Enables banks to train fraud detection models on industry-wide transaction patterns without exposing individual customer records.
• Pharmaceutical Research: Allows rival pharma companies to benchmark drug efficacy against a shared, encrypted control group.
• Governance: Frameworks like the Confidential Consortium Framework (CCF) provide tamper-proof audit logs of all data access and code execution.

Migrates legacy applications to the cloud without requiring code refactoring for security. Technologies like Intel TDX and AMD SEV-SNP encrypt the entire virtual machine's memory, creating a Confidential VM. This allows organizations to lift-and-shift sensitive databases or monolithic applications directly into a protected environment.

• No Code Changes: The encryption is transparent to the guest OS and application.
• Kubernetes Integration: Enclave-Aware Orchestration via projects like Kata Containers allows standard pods to run inside hardware-isolated VMs.
• Use Case: A financial institution moves an unmodified legacy risk analysis application to the public cloud, with the entire runtime memory encrypted and invisible to the hypervisor.

Mitigates the risk of Maximal Extractable Value (MEV) and front-running in decentralized finance. Smart contracts and transaction ordering logic are executed inside a TEE, keeping transaction details encrypted until they are finalized on-chain.

• Dark Pools: Enables sealed-bid auctions and private order books where trade details are invisible to block builders.
• Decentralized Oracles: Protects the confidentiality of data feeds provided to smart contracts, ensuring data integrity from source to execution.
• Example: A DeFi protocol uses TEEs to run a sealed-bid auction mechanism, preventing validators from censoring or reordering transactions to extract value.

Hardens the central aggregation server in a Federated Learning architecture. Instead of trusting a central server to not inspect individual model updates (which can leak data via gradient leakage), the aggregation logic is placed inside an attested enclave.

• Secure Aggregation: The enclave decrypts client updates, performs the weighted averaging, and discards individual contributions, all within a protected memory region.
• Attestation Guarantee: Clients verify the enclave's MRENCLAVE measurement before sending their updates, cryptographically proving the server is running the exact approved aggregation code.
• Use Case: A consortium of hospitals trains a tumor detection model where each hospital's model updates are aggregated inside a TEE, preventing any single party from reconstructing a patient's scan from the gradients.

Protects high-value machine learning models deployed on untrusted edge devices or remote servers. The model is encrypted at rest and only decrypted inside a TEE during inference, preventing the device operator from extracting the model weights or architecture.

• Anti-Piracy: Prevents reverse engineering of proprietary algorithms on devices in the field.
• Licensing Enforcement: Allows model vendors to enforce usage limits and revoke access remotely, tied to the enclave's identity.
• Example: An autonomous vehicle supplier deploys a perception model to a car manufacturer's compute unit. The model runs exclusively inside an ARM CCA Realm, preventing the manufacturer from accessing the supplier's core IP.

A cryptographic hash of the initial code, data, and configuration loaded into an enclave, serving as a unique, unforgeable fingerprint. During attestation, the verifier compares the reported measurement against a known-good reference value to confirm the enclave is running the exact expected software.

• MRENCLAVE (Intel SGX): Hash of the enclave's code and initial data—changes with every build
• MRSIGNER (Intel SGX): Hash of the signing authority's public key—enables trust based on vendor identity
• Launch measurement (AMD SEV-SNP): Cryptographically binds the VM's initial state to its identity
• Purpose: Detects any tampering, including a single byte modification to the enclave binary

The security practice of encrypting data while it is actively being processed in memory, closing the final vulnerability gap left by protecting data at rest (disk encryption) and data in transit (TLS). Traditional computing requires data to be decrypted in RAM for processing, exposing it to privileged software and hardware attacks.

• The three states: Data at rest → Data in transit → Data in use (the previously unprotected state)
• Mechanism: Transparent memory encryption at the hardware level, invisible to applications
• Threat model addressed: Malicious insiders, compromised hypervisors, firmware backdoors
• Runtime encryption: The entire memory space of a VM or process remains encrypted in RAM