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

arXiv:2606.10615 · cs.CR · Submitted 2026-06-09 · Read on arXiv

Listen

Radio episode about this paper

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.

Ghent University - imec

cs.CR

Submitted: 2026-06-09

Updated: 2026-06-10

Comments: Accepted for publication in IEEE Access

Journal ref: IEEE Access, vol. 14, pp. 89461-89481, 2026

DOI: 10.1109/ACCESS.2026.3702811

Code: https://github.com/AMDESE/AMDSEV

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 91/100

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.

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

Summary

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. p. 0

Where the paper says it

thijsman@ugent. This research was partially supported by the imec AAA project 2cVM ABSTRACT 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.

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. p. 0
Where the paper says it

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. p. 0
Where the paper says it

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. p. 0
Where the paper says it

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.

System Architecture

The 2cVM architecture is built upon two complementary isolation layers. The first layer uses AMD’s SEV-SNP Confidential Virtual Machine technology as the confidential-computing substrate for protecting the 2cVM’s memory and execution state from the untrusted host. p. 6

Where the paper says it

COMPONENTS The implementation builds on two complementary isolation layers. The first layer uses AMD’s SEV-SNP Confidential Virtual Machine technology as the confidential-computing substrate for protecting the 2cVM’s memory and execution state from the untrusted host.

On top of this, the WebAssembly Component Model provides a language-agnostic sandbox for isolating and composing the code contributed by each participant. p. 6
Where the paper says it

The first layer uses AMD’s SEV-SNP Confidential Virtual Machine technology as the confidential-computing substrate for protecting the 2cVM’s memory and execution state from the untrusted host. On top of this, the WebAssembly Component Model provides a language-agnostic sandbox for isolating and composing the code contributed by each participant.

The Attestation Agent serves as the central control point for the 2cVM. p. 4
Where the paper says it

Any participant requesting attestation evidence after the commitment manifest lock goes into effect, will receive a cryptographically signed guarantee of both the current state and the future behavior of the platform. The Attestation Agent serves as the central control point for the 2cVM.

Security Model

The security model defines a system consisting of an untrusted host platform H, a secure confidential computing platform P, and a confidential virtual machine G instantiated from image I. The Attestation Agent generates an ephemeral key pair inside G and requests a report ρ = AttestP (µ, H(pkG), n) to bind the measured launch state µ to the public key pkG. p. 5

Where the paper says it

During attestation, A generates an ephemeral key pair (pkG, skG) inside G. It requests a report ρ = AttestP (µ, H(pkG), n), where n is a nonce supplied by Vn to ensure freshness.

Each participant verifies the attestation report and checks a signature over σ before provisioning data or code. p. 5
Where the paper says it

The agent then signs the commitment manifest σ using skG and provides (ρ, pkG, SigskG (σ)) to each connector Vn. Each Vn verifies the attestation report, checks freshness, verifies the signature over σ, and provisions Dn only if all checks succeed.

The security goals include Host Isolation, Measured Launch Integrity, Component Isolation and Policy Enforcement, and Attested Composition Agreement. p. 1
Where the paper says it

The following sections then detail our main Contributions: • Section IV: the Two-Way Confidential Virtual (2cVM) architecture1 , which extends existing confidential computing models through a dual-layer isolation design that protects against both host infiltration and guest exfiltration. It introduces the novel abstract concept of the Commitment Manifest as a verifiable link between attested hardware and component-level policy enforcement throughout the VM’s lifecycle, enabling mutual assurance between data owners and code providers.

Performance Evaluation

Experimental evaluation across four benchmark classes shows that the layered design achieves strong security without multiplicative performance penalties. The two isolation layers do not accumulate linearly. p. 0

Where the paper says it

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 workloaddependent rather than fixed: SEV-SNP remains modest across all tested workloads, while Wasm overhead is governed primarily by memory access pattern. p. 0
Where the paper says it

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 2× for irregular, pointer-chasing access patterns.

Limitations and Future Work

The prototype does not perform cryptographic verification of participant identifiers on artifact submission. A lack of vTPM support means the current prototype may not correctly attest AL4 when operating on systems that use vTPMs for AL4 attestation. p. 4

Where the paper says it

As part of this state, the Commitment Manifest is bound to the platform attestation, extending the TCB’s cryptographic coverage to encompass the defined trust and security parameters at AL4. Any participant requesting attestation evidence after the commitment manifest lock goes into effect, will receive a cryptographically signed guarantee of both the current state and the future behavior of the platform.

Furthermore, the security model does not include availability guarantees, meaning a malicious host can refuse to start the VM. p. 4
Where the paper says it

It first introduces the design goals, then provides an overview of the components that make up the 2cVM. DESIGN GOALS The Two-Way Confidential Virtual Machine architecture was designed with the following goals in mind: 1) Extend the default security model of Confidential VMs with protections against exfiltration by malicious code, provided by one of the parties, running inside the CVM.

Future work should investigate output-filter components to provide additional verifiable control over the content of released outputs. p. 0
Where the paper says it

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.

The integration of RA-TLS is another long-term goal to unify attestation and secure data exchange. p. 7
Where the paper says it

: 2cVM: Confidential Collaboration Among Distrustful Parties the agent would operate over TLS with identity-bound authentication such as OIDC. Integrating Remote Attestation– TLS (RA-TLS) [28] would allow attestation evidence to be embedded in the TLS handshake, creating verifiable, secure channels between participants.

Conclusion

Overall, 2cVM demonstrates that hardware attestation and modular, capability-based sandboxing can be combined to enable secure, auditable, and efficient multi-party computation. It operationalizes zero-trust principles within confidential computing environments by ensuring trust is never assumed but continuously established through attestation and manifest-based governance. p. 2

Where the paper says it

Recent policy work, including recommendations from national cybersecurity agencies, argues that open-source CVM firmware and standard attestation protocols are prerequisites for such independently verifiable, zero-trust use of confidential computing. WEBASSEMBLY WebAssembly (Wasm) is a portable binary instruction format that compiles high-level languages to a well-defined abstract machine, enabling execution across heterogeneous hardware and operating environments.

REFERENCE

arXiv:2606.10615v2,cs. p. 0

Where the paper says it

Even with extensive algorithmic and hardware acceleration, VOLUME 0, 2025 1 arXiv:2606. 10615v2 [cs.

CR 1 Jun 2026

--- Page 1 ---

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

--- Page 2 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 3 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 4 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 5 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 6 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 7 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 8 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 9 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 10 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 11 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 12 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 13 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 14 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 15 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 16 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 17 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 18 ---

Thijsman et al.: 2cVM: Confidential Collaboration Among Distrustful Parties

--- Page 19 ---

Thijsman et al.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. No leakage of sensitive data to untrusted components is prevented because If sigma does not authorize access from Ci to Cj, then Cj has no program-visible channel through which Ci may observe Ci’s state or inputs. This ensures that data sharing is strictly governed by the Commitment Manifest.

  2. The system can enforce verifiable governance by making the policy immutable, as the Commitment Manifest Lock is a conceptual state in which the platform code is bound to the commitment manifest in a way such that it can only perform the behavior described by the commitment manifest. This allows participants to verify and audit compliance independently.

  3. The AI system can securely collaborate across organizations by enabling collaborative computation among mutually distrusting parties where trust between participants is no longer a prerequisite. This is achieved through the dual-layer isolation design protecting against both host infiltration and guest exfiltration.

  4. The system provides fine-grained sandboxing of participant code using the WebAssembly Component Model, which restricts component interaction to explicitly declared interfaces. This capability allows for selective and attestable enforcement of data and code boundaries inside the 2cVM.

  5. The AI can ensure that the execution environment is authentic by requiring all honest parties to verify a report that binds the platform state to a signed Commitment Manifest, guaranteeing Attested Composition Agreement.

Abstract

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.

Sources

Related papers