Skip to Content
Book a Meeting

Confidential Computing: Protecting Data in Use, and What It Actually Guarantees

On This Page

The previous articles in this series have walked through the main approaches used today to protect data in the cloud. Encryption in transit, typically via TLS, is effectively universal: no serious cloud service operates without it. Encryption at rest, covered in depth in an earlier article, is similarly ubiquitous, enabled by default on virtually every major platform. End-to-end encryption is a different story. The concept is by now well understood, and its value is widely acknowledged, but in practice it remains the exception rather than the rule, reserved for specific categories of workload where the threat model justifies the operational trade-offs.

Confidential computing is another technology built on cryptographic and hardware-based principles, but it addresses a different problem: enabling secure server-side data processing, which is precisely the scenario that end-to-end encryption (E2EE) cannot handle by design.

The specific gap that confidential computing targets is what happens when data is actually being used. A CPU cannot compute on ciphertext. At some point, for the server to do anything meaningful with the data, plaintext has to exist somewhere in memory. That moment is what confidential computing is designed to address.

This article looks at what confidential computing actually provides off-the-shelf, how it works, where it fits relative to encryption at rest and end-to-end encryption, and what its limits are. As with the previous articles in this series, the goal is not to sell the technology, but to position it accurately in a threat model.

The three states of data, and the processing gap

Data security is often described in terms of three states: in transit, at rest, and in use. The first two are well-understood problems with mature solutions. Protocols like TLS handle data in transit. Encryption at rest, with all the nuances covered in the previous article, handles data on disk.

Data in use is where the gap lies. By definition, when data is being processed, the CPU needs to read it. When the CPU reads it, it exists in plaintext in RAM, in CPU caches, in registers. Anything with sufficient privilege on the same machine can potentially observe it: the operating system, the hypervisor, another process with the right permissions, and in a cloud environment, the provider’s administrators and infrastructure tools.

This is not a flaw in the design of computers. It is how computation works. But it creates an exposure window that shows the limits of encryption at rest, covered in an earlier article: the point where plaintext exists inside the provider’s compute environment, regardless of how well the storage and transit layers are protected.

Confidential computing is the attempt to close that window at the hardware level, by extending cryptographic protections beyond storage and transport to the execution environment itself.

To see why this matters, consider a workload running in a typical cloud VM. The data is encrypted at rest, the VM’s disks are protected by a KMS, the network traffic is encrypted in transit. The provider has strong operational controls, audit logs, and trained staff.

And yet, when the application is running, the plaintext data lives in memory. The hypervisor, which runs the VM, has visibility into the guest’s memory. The host operating system, which runs the hypervisor, has even more. A system administrator with the right privileges, a misconfigured debugging tool, a compromise of the hypervisor itself: any of these creates a path to plaintext that no amount of storage-side encryption can prevent.

This is the scenario where encryption at rest, even configured with HYOK, stops helping. The keys are safe. The data on disk is unreadable without them. But the moment the VM fetches it, decrypts it, and loads it into memory to process a request, that data potentially becomes accessible to anyone with sufficient privilege on the host.

For many workloads, this exposure is considered acceptable. The provider is considered trusted, the operational controls are deemed sufficient, and the threat model does not include the provider’s infrastructure. But for workloads where the provider is part of the threat model, whether because of legal compulsion, sovereignty concerns, insider risk, or sophisticated breach scenarios, this exposure is exactly the problem that needs solving.

What confidential computing actually is

Confidential computing is a family of hardware-based technologies that create isolated execution environments, commonly referred to as Trusted Execution Environments (TEEs). These environments protect code and data from other software running on the same machine, including the operating system and the hypervisor, using isolation mechanisms enforced by the processor and underlying hardware.

Two broad families of TEEs are commonly used in current cloud deployments, along with a third class of enclave-style isolation that does not map directly to CPU-native TEEs:

Process-level enclaves protect a specific region of memory within a process. The most prominent example is Intel SGX, which was the first widely available technology of this kind. Applications are rewritten to place their sensitive code and data inside an enclave, and the hardware enforces that software outside the enclave, including the kernel, cannot directly access its memory. The model is precise but demanding: developers have to partition their applications explicitly, and the ecosystem of libraries that work inside enclaves is limited.

Confidential VMs take a different approach. Instead of protecting a small region within a process, the memory of the virtual machine is encrypted and isolated from the hypervisor. AMD SEV-SNP, Intel TDX, and ARM CCA all follow this pattern. The operating system and applications inside the VM do not need to be modified in any meaningful way, which makes adoption dramatically easier. The trade-off is a larger trusted computing base: everything inside the VM is included in the security boundary.

Enclave-style isolated execution (hypervisor-based) represents a third model, where isolation is enforced primarily through a hardened virtualization layer rather than a CPU-native enclave or full confidential VM architecture. AWS Nitro Enclaves are the primary example: they carve out isolated execution environments from EC2 instances using the Nitro hypervisor and dedicated resource partitioning. While they are often grouped under confidential computing, they differ architecturally from CPU TEEs such as SGX, SEV-SNP, or TDX because the security boundary is not solely defined by processor-enforced memory encryption of a guest environment.

The direction of the market is clear. Process-level enclaves have proven difficult to adopt at scale outside specialized use cases. Confidential VMs based on CPU-enforced memory isolation (such as AMD SEV-SNP and Intel TDX) have become the dominant general-purpose model for confidential computing across cloud providers. AWS follows this trend for confidential VMs, while also positioning its Nitro Enclaves architecture as a mainstream platform-integrated approach to isolated execution within the AWS ecosystem.

In all cases, sensitive data is protected while in use, either through hardware memory encryption or through strongly isolated execution enforced by the underlying platform. In addition, cryptographic keys derived from hardware- or platform-rooted secrets are used to establish identity and support attestation, binding execution state to a verifiable trust anchor.

The central role of attestation

Hardware isolation alone is not sufficient. If a workload sends sensitive data into a TEE, it needs a way to verify before doing so that the enclave or confidential VM is genuine, that it is running the expected code, and that it has started in a known-good state. Without this, confidential computing would be little more than an assertion: the machine claims it is running in a trusted execution environment, but there is no external way to validate it.

Attestation is the mechanism that closes this loop. When a TEE starts, the CPU (or more generally the platform’s hardware root of trust) produces a cryptographic measurement of what is loaded: the code, the configuration, and the initial state of the environment. This measurement is signed using a hardware-rooted attestation key embedded in the processor and anchored in a manufacturer-provisioned trust hierarchy. A remote party can request this signed report, verify its authenticity, and compare the measurement against an expected value.

The practical consequence is significant. An external system, for example a key management service holding a secret that should only be released to a specific workload, can verify that the workload is really running in a genuine TEE of a known model, with the expected code, before releasing the key. If any of these conditions fail, the secret never leaves.

This is what distinguishes confidential computing from ordinary cloud workloads. It is not merely that data in use is protected at the memory level. It is that a relying party can cryptographically verify key properties of the execution environment (identity, integrity, and initial state). Trust is grounded in hardware and in the chip vendor’s PKI, rather than in assertions made by the cloud provider.

Without attestation, confidential computing is unverifiable. With it, it becomes a meaningful security boundary.

Offerings from the major providers

All three major cloud providers now offer confidential computing, with different emphases and histories.

AWS took an early and somewhat distinctive path with Nitro Enclaves. Rather than adopting Intel SGX as the industry did initially, AWS built its own abstraction on top of the Nitro hypervisor, providing isolated enclaves that sit alongside EC2 instances. Although often grouped under the broader umbrella of confidential computing, Nitro Enclaves represent a distinct enclave-style model built on top of AWS’s Nitro hypervisor rather than a CPU-native TEE architecture. The model is tightly integrated with AWS’s own infrastructure and works well for specific use cases like key management and secrets processing. AWS has since added support for AMD SEV-SNP in EC2 for broader confidential VM workloads.

Azure has invested heavily in the full spectrum. It supports Intel SGX for legacy enclave workloads, AMD SEV-SNP and Intel TDX for confidential VMs, and has built an ecosystem around confidential containers and confidential VMs. Azure’s positioning reflects its enterprise and regulated-industry focus, with particular attention to attestation services and integration with Azure Key Vault.

GCP offers Confidential VMs based on AMD SEV-SNP and Intel TDX, and has developed Confidential Space, a service specifically designed for multi-party data collaboration scenarios where two or more organizations want to run joint computations on their combined data without exposing it to each other or to Google.

Functionally, at a high level, provider offerings cover similar ground. In most cases, the differences that really matter to a decision maker are less about raw capability and more about integration with the rest of the platform, the maturity of the attestation tooling, and the specific use cases each provider has optimized for. From a cryptographic perspective, however, not all approaches are equivalent: SEV-SNP and TDX protect whole virtual machines through processor-enforced memory encryption, SGX applies similar protections at the level of individual application enclaves, while systems such as Nitro Enclaves rely primarily on hardware-isolated virtualization boundaries and a reduced trusted computing base.

What is true across all three is that confidential computing is no longer experimental. It is a production-grade option in every major cloud, with real workloads running on it today.

Where confidential computing actually fits

A few categories of workload benefit clearly from confidential computing, and they share a common pattern: the data must be processed server-side, and the threat model genuinely includes the infrastructure operator.

Multi-party computation and clean rooms. Two or more organizations, often competitors or regulated parties, need to run joint analytics on their combined datasets without exposing their raw data to each other or to the platform operator. Financial consortiums detecting fraud across institutions, healthcare networks pooling clinical data for research, advertising clean rooms matching audiences without sharing underlying identifiers: these scenarios all require a neutral execution environment that none of the participants, including the cloud provider, can inspect.

AI workloads on sensitive data. As touched on in the E2EE collaboration article, many AI features are fundamentally incompatible with end-to-end encryption because the server needs to read the content to process it. Confidential computing offers a middle path. An organization can run inference on sensitive data, or fine-tune a model on proprietary information, inside a TEE. The provider hosts the workload but cannot see the inputs, the outputs, or the model weights. This matters both for customers who want to use AI on data they cannot expose, and for model providers who want to protect their weights from the infrastructure that runs them. This is increasingly extending beyond CPUs to accelerators themselves: newer confidential GPU architectures, particularly around NVIDIA H100 deployments in Azure, GCP, and parts of the AWS ecosystem, aim to extend attested execution and protected memory boundaries into GPU-based AI workloads as well.

Key management and cryptographic operations. Running sensitive cryptographic services inside a TEE allows an organization to hold signing keys, perform cryptographic operations, and manage secrets in a way that is isolated from the host environment. This is the category AWS targeted early with Nitro Enclaves, particularly through integrations with KMS and enclave-isolated signing workflows, and it remains one of the most mature use cases.

Regulated data processing. Healthcare analytics, financial risk modeling, processing of personal data under strict regulatory regimes. When the data is too sensitive to expose to the provider but too voluminous or computation-heavy to process client-side, confidential computing provides a credible middle ground.

These use cases share a structural feature. In each of them, client-side processing is either impossible or impractical, which rules out the strongest form of end-to-end encryption. Confidential computing is not a replacement for E2EE in the cases where E2EE applies. It is a response to the cases where E2EE does not.

What confidential computing protects against

Positioned within a clear threat model, the guarantees provided by confidential computing are meaningful.

For instance, in hardware-based confidential computing systems such as AMD SEV-SNP or Intel SGX/TDX, administrators with access to the hypervisor or host operating system cannot directly inspect a protected workload’s memory. From the host’s perspective, the memory contents remain cryptographically protected.

Other tenants sharing the same physical hardware are isolated by the same mechanisms, preventing a compromised neighboring VM from directly accessing a confidential VM’s memory.

A compromise of the hypervisor, which in a traditional cloud model would expose all guest VMs, does not automatically expose confidential VMs, because the hypervisor is explicitly outside the trust boundary.

Physical memory attacks, such as cold boot attacks or bus snooping, are mitigated in architectures that use hardware memory encryption, since memory contents are not directly readable in plaintext form outside the protected boundary.

In contrast, enclave-style systems such as AWS Nitro Enclaves achieve a similar security objective through tightly controlled platform isolation rather than full CPU memory encryption of a virtual machine. In this model, execution is partitioned away from the parent instance and the surrounding cloud infrastructure, so that even privileged operators of the host system cannot directly access the enclave’s execution state.

Combined with attestation, these properties let an external party gain cryptographic assurance that a specific workload is running in a specific environment, before trusting it with sensitive data.

What confidential computing does not protect against, and what it asks you to trust

As with every other layer covered in this series, the honest evaluation requires naming the limits clearly.

Trust shifts to the hardware and platform vendors. Confidential computing does not eliminate trust. It relocates it. Where encryption at rest with HYOK ultimately depends on trusting the provider’s KMS, confidential computing depends on trusting the underlying TEE implementation and attestation infrastructure. This includes trusting hardware vendors such as Intel, AMD, or ARM to design TEEs correctly, manufacture chips faithfully, and securely manage the master keys and PKI used for attestation, as well as trusting cloud providers to correctly operate platform-level attestation and integration services. For many threat models this is an acceptable trade, but it should be named explicitly. A compromise of the relevant attestation root would undermine every system relying on it.

Side-channel attacks have a real history. Intel SGX, the most scrutinized TEE technology, has been compromised multiple times over its lifetime. Foreshadow, Plundervolt, SGAxe, ÆPIC Leak, and others have shown that the isolation provided by TEEs is not absolute. These attacks are typically complex and require specific conditions, but they are not theoretical. The pattern has also appeared in AMD’s ecosystem, with attacks like CacheWarp and various SEV-SNP weaknesses being disclosed over time. The appropriate posture is not to dismiss the technology, but to recognize that TEEs are subject to an ongoing research cycle of attacks and patches, and to factor this into operational decisions, particularly around patching discipline and the acceptable lag between a vulnerability being disclosed and remediated.

The application inside the TEE is not magically safe. If the code running in the enclave has vulnerabilities, the hardware protection does not help. A buffer overflow in an enclaved application can still be exploited. Confidential computing protects the execution environment from the outside; it does not protect the application from itself. The usual disciplines of secure development apply unchanged.

Attestation depends on a working PKI. The attestation mechanism relies on trusted signing infrastructure being trustworthy and available, whether operated by a chip vendor or by the platform provider. A compromise of that PKI, or a failure in the attestation service, has systemic consequences. This is not a common failure mode, but it introduces a centralized trust dependency that did not previously exist.

Metadata and side effects remain visible. Even when the contents of memory are protected, patterns can leak. Memory access patterns, timing of operations, network traffic volumes, cache usage: all of these can reveal information about what the workload is doing, even if not what the data contains. For highly adversarial threat models, these residual signals matter.

Confidential computing does not replace E2EE where E2EE applies. This is the comparison that matters most for this series. When data can be processed client-side, end-to-end encryption keeps plaintext entirely out of the provider’s environment. The trusted computing base is narrower: just the user’s device, not a chip vendor’s supply chain and an attestation service. The two approaches address different situations, and the choice between them follows from the workload itself. Confidential computing is the relevant answer when the use case requires server-side processing; end-to-end encryption is the relevant answer when it does not.

Positioning: three answers to “data in use”

Stepping back, the landscape of options for protecting data during processing can be organized around three approaches, each with a different trust profile.

Process client-side when the workload allows it. This is what end-to-end encryption enables. Data is processed on the client, and the server only handles ciphertext. When this model fits the use case, it keeps the trusted computing base as narrow as possible: no server-side trusted zone is required, because no plaintext ever exists on the server to begin with. The E2EE collaboration article covered the categories of workload where this is achievable.

Process server-side in a hardware-isolated execution environment. This is confidential computing. The server processes plaintext, but only within a trusted execution boundary enforced either through CPU-based memory isolation or through tightly controlled platform isolation mechanisms. In both cases, the hypervisor, host operating system, and cloud provider infrastructure are prevented from directly accessing data in use. The trusted base shifts toward the underlying hardware and platform security components (such as CPU TEEs or systems like AWS Nitro Enclaves), along with attestation infrastructure, while the cloud provider remains in control of system resources (compute, scheduling, I/O, and availability) but is excluded from direct access to plaintext application state.

Process server-side on ciphertext directly. This is where homomorphic encryption lives, and it is worth a short mention even though it warrants its own article. Fully Homomorphic Encryption (FHE) allows computations to be performed directly on encrypted data, producing encrypted results that decrypt to what the equivalent plaintext computation would have produced. The conceptual appeal is striking: no hardware trust, no attestation, no vendor PKI, the server sees ciphertext from end to end, including during computation. The practical limit today is performance. Despite major scientific progress over the past decade and with GPU acceleration, FHE remains several orders of magnitude slower than plaintext computation for most general-purpose workloads. Where it is deployed in production today, it is typically for targeted operations: encrypted search, simple aggregations, specific privacy-preserving ML inference patterns. It is not, at least for the moment, a replacement for general-purpose compute.

Confidential computing and FHE are not mutually exclusive. Some architectures combine them, using TEEs for workloads that need full performance and FHE for narrow operations where cryptographic guarantees matter most. A future article in this series will cover FHE in depth.

For now, the operational landscape is roughly this: E2EE when possible, confidential computing when server-side processing is required, and FHE on the horizon for specific operations where its current constraints are acceptable.

Approach Data accessible to the provider during processing? Primary trust base
Encryption at rest (including BYOK/HYOK) Yes Cloud provider infrastructure, KMS, platform administrators
Confidential computing Not directly, within the protected execution boundary TEE hardware/platform implementation, attestation infrastructure, workload/application
End-to-end encryption No Client devices and endpoint software
Fully Homomorphic Encryption No, including during computation Client devices and underlying cryptographic assumptions

Governance perspective: matching the tool to the threat model

As the governance article in this series argued, the unit of analysis should be the workload, not a blanket classification. Confidential computing is one more tool in the toolbox, not a default answer.

It becomes the right choice when three conditions typically align. First, the workload genuinely requires server-side processing, which rules out the strongest form of E2EE. Second, the threat model includes the provider in some form, whether legal compulsion, insider risk, or sovereignty concerns. Third, the operational and cost overhead of confidential computing is acceptable for the value it provides. If any of these conditions are absent, simpler approaches often suffice.

When a vendor claims to offer confidential computing, the questions worth asking are specific. Is attestation exposed to the customer, or is it used only internally by the provider? What measurements are published, and can they be verified independently? What is the patching policy for hardware vulnerabilities in the underlying TEE, and how quickly are customers notified? Which workloads run inside the TEE, and which still see plaintext in the conventional infrastructure? Vague answers to these questions suggest that the marketing has moved faster than the engineering.

As with every control discussed in this series, the value of confidential computing depends on the threat model it is matched against. When deployed against the risks it is actually designed to address, it closes a gap that no other currently practical technology closes as effectively. Used as a generic label, however, it risks providing the illusion of protection without the substance.

Conclusion

Confidential computing does not eliminate trust; it redistributes it from cloud operators toward hardware and platform roots of trust. In exchange, it reduces the cloud provider’s ability to access data during computation. For workloads where end-to-end encryption is not feasible and where the provider is part of the threat model, this can be a meaningful architectural win.

It also comes with real limits. “Confidential computing” should not be treated as a uniform security property. Different implementations make different assumptions about trusted hardware, attestation, physical access, and adversarial capabilities. At a high level they may all reduce exposure to cloud administrators, but their guarantees can diverge substantially once sophisticated or state-level attackers enter the threat model. In addition, hardware vendors must be trusted, side-channel attacks continue to surface, the application itself still has to be secure, and the metadata gap that affects E2EE affects confidential computing too. Treating it as a silver bullet is exactly the kind of mistake the governance article warned against.

That said, in the end, the right question, as always, is not “is confidential computing secure?” but “which threat model does it address, and is that my threat model?” For many regulated, sovereign, or high-value workloads where server-side processing is unavoidable, the answer increasingly is yes. For workloads where client-side processing is a natural fit, end-to-end encryption remains the more appropriate answer, because it removes the need for a trusted execution zone on the server altogether. And for the narrow set of operations where cryptographic processing of ciphertext is viable, fully homomorphic encryption is starting to offer a third path, one that a future article in this series will explore in depth.

The broader arc of this series should be clear by now. There is no single answer to data confidentiality in the cloud. There are tools, each with a scope and a set of assumptions, and there is the governance work of matching them to the actual threats an organization faces. Confidential computing has earned its place in that toolbox. What remains is using it where it fits, and being precise about what it does and does not do.

Continue the Series

All Resources

Want to discuss these topics?

Get in touch with our team to explore how advanced cryptography can address your security challenges.