Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties

summary

The gist

Collaborative computation across organizations is often constrained by the need to process sensitive data and proprietary code without exposing them to untrusted infrastructure or participants.

In short

The two-way Confidential Virtual Machine (2cVM) enables secure collaborative computation between distrustful organizations. It uses a hardware trusted execution environment and a WebAssembly sandbox to isolate workloads. A central Commitment Manifest governs all interactions, ensuring participants only access authorized data and code, establishing trust through verifiable attestation.

Key concepts

Two-Way Confidential Machine (2cVM)
A two-layer architecture combining AMD SEV-SNP hardware protection with a WebAssembly sandbox. This setup isolates workloads from the untrusted host while allowing participants to control their own data and code, enabling secure collaboration among mutually distrustful parties.
Commitment Manifest
A locked policy that enumerates all participants, component compositions, permitted data channels, and authorized outputs for the VM. It is incorporated into attestation evidence to ensure the policy is immutable and independently verifiable by all involved parties.
WebAssembly Component Model
A language-agnostic sandbox used to isolate and compose code contributed by different participants. It enforces fine-grained sandboxing by restricting component interaction strictly to explicitly declared interfaces, ensuring selective enforcement of data and code boundaries.

Terminology used across episodes

This episode discusses

The paper

Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties · Read on arXiv

Ghent University - imec

Collaborative computation across organizations is often constrained by the need to process sensitive data and proprietary code without exposing them to untrusted infrastructure or participants. Cryptographic approaches such as fully homomorphic encryption and secure multi-party computation provide strong confidentiality but remain impractical for general workloads due to their extreme computational cost. We present the Two-Way Confidential Virtual Machine (2cVM), a two-layer architecture that pairs a hardware trusted execution environment with an intra-workload isolation layer. Unlike regular Confidential Virtual Machines, 2cVM enforces mutual isolation between co-resident workloads, ensuring that participants retain control over their data and code. All computation in 2cVM is governed by a Commitment Manifest that enumerates participants, component composition, permitted data channels, and authorized outputs; the manifest is locked to the VM and incorporated into attestation evidence, making the policy immutable and independently verifiable throughout the VM's lifetime. A proof-of-concept realization combines AMD SEV-SNP for hardware protection with the WebAssembly Component Model for fine-grained sandboxing of participant code. Evaluation on commodity hardware across four benchmark classes shows that the two isolation layers do not accumulate linearly: once a workload executes inside the WebAssembly sandbox, the marginal cost of enabling hardware memory protection is small. Overhead is workload-dependent, governed primarily by memory access pattern, ranging from negligible for sequential workloads to approximately 2x for irregular, pointer-chasing access patterns. These results indicate that 2cVM provides a practical and verifiable foundation for privacy-preserving collaborative computation.

DOI: 10.1109/ACCESS.2026.3702811

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: We're looking at the paper: "Two-Way Confidential VMs (2cVM)".

Elias: Here's the gist of the paper. Collaborative computation across organizations is often constrained by the need to process sensitive data and proprietary code without exposing them to untrusted infrastructure or participants.

Nadia: We present the Two-Way Confidential Virtual Machine (2cVM), a two-layer architecture that pairs a hardware trusted execution environment with an intra-workload isolation layer.

Elias: Unlike regular Confidential Virtual Machines, 2cVM enforces mutual isolation between co-resident workloads, ensuring that participants retain control over their data and code.

Nadia: All computation in 2cVM is governed by a Commitment Manifest that enumerates participants, component composition, permitted data channels, and authorized outputs; the manifest is locked to the VM and incorporated into attestation evidence, making the policy immutable and independently verifiable throughout the VM’s lifetime.

Title and authors: Nadia: We’re talking about "Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties" and the authors are Jordi Thijsman, Merlijn Sebrechts, Stefan Lefever, Filip De Turck, and Bruno Volckaert from Ghent University and imec <ref:2606.10615#pg1,Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties>.

Elias: They’re coming from a strong foundation in hardware security at imec. What this title really points to is moving beyond simple host isolation into actual multi-party collaboration where trust isn't assumed between the participants themselves.

Nadia: It suggests a system where you can have different groups compute together, but the system ensures that Group A can't see what Group B is doing, and vice versa.

Priya: From my side, I’m interested in how they handle this collaboration when the underlying hardware might be compromised or when we are dealing with complex codebases.

Elias: That’s where the architecture comes in—they use a two-layer isolation approach: one layer is the SEV SNP technology for protecting memory from an untrusted host, and on top of that is this intra-workload isolation layer.

Nadia: That second layer uses something called the WebAssembly Component Model to sandbox and compose the code contributed by each participant in a language agnostic way.

Priya: So it’s not just protecting the whole VM from the host, but also making sure the different pieces of code within that VM don't interfere with each other maliciously.

Elias: Right, and they have this Attestation Agent that acts as the central control point for all this setup, generating an ephemeral key pair inside the machine.

Nadia: And then it asks for a report called rho equal to AttestP mu H pkG to bind the measured launch state to that public key.

Elias: That whole process is designed so each participant can verify that the platform state was measured correctly before they even provision any data or code into the environment.

The paper's summary: Nadia: So, to summarize what this paper is doing, it introduces the 2cVM as a protected execution environment specifically for collaborative computation among mutually distrusting parties <ref:2606.10615#pg1>.

Elias: They are addressing the limitation of standard Confidential Virtual Machines where everything inside is assumed to be trusted, and the 2cVM actively removes that assumption by enforcing mutual isolation <ref:2606.10615#pg1>.

Priya: The key mechanism they propose is this Commitment Manifest, which cryptographically binds the permitted interactions between components to the VM’s attested state.

Nadia: This manifest acts like a contract for the environment, describing what behavior is allowed and it can't be altered once it's locked in place.

Elias: That lock allows participants to verify and audit compliance independently, which is a big step compared to conventional confidential computing where you just rely on the host’s claim about the VM state.

Priya: It means we can check if the code being run actually matches what was agreed upon in that manifest before we let any sensitive data flow through it.

Nadia: And they are extending this beyond just a standard confidential machine, including parts of the guest kernel and selected user-space components up to AL4.

Elias: The paper points out that for real zero-trust use, especially when you don't want to blindly trust the cloud provider, you need to reconstruct this chain of evidence yourself.

The paper's improvements: Nadia: They suggest a few key improvements on top of the basic setup. One major one is preventing leakage of sensitive data by strictly governing data sharing through that Commitment Manifest.

Elias: They say that if one participant doesn't have authorization in the manifest to access something, then that other participant has no program visible channel through which they can observe inputs or state.

Priya: That’s a strong security guarantee because it ties the data flow directly to the agreed-upon policy, making unauthorized observation impossible under those conditions.

Nadia: It also enhances verifiable governance by making that Commitment Manifest lock a conceptual state where the platform code is bound to that manifest in a way that it can only perform what’s described there.

Elias: So participants can verify and audit compliance independently against this locked policy, which is something conventional confidential computing simply doesn't offer.

Priya: That moves us toward a more auditable system where we can confirm the rules are being followed without needing to trust a central authority for every interaction.

Conclusion: Nadia: So, wrapping up, the 2cVM demonstrates that combining hardware attestation with modular, capability-based sandboxing lets us build secure and auditable multi-party computation environments <ref:2606.10615#pg1>.

Elias: It operationalizes zero-trust principles within confidential computing by making trust something that has to be continuously established through attestation and manifest governance rather than just assumed.

Priya: From a privacy standpoint, this architecture means we can finally enforce fine-grained boundaries on data and code exchange inside the 2cVM, which is crucial for complex workflows <ref:2606.10615#pg1>.

Nadia: It shows how you can secure collaborative computation among mutually distrusting parties effectively by focusing on continuous verification of the setup.

Elias: This work, Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties, really pushes the idea that trust between participants is no longer a prerequisite for running sensitive computations together <ref:2606.10615#pg1,Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties>.

Priya: It’s a solid piece of research showing how layered isolation and policy enforcement can combine to enable computation where traditional methods fall short due to their computational cost or lack of mutual trust guarantees.

More episodes

← Home