Two-Way Confidential VMs (2cVM): Collaborative Confidential Computing for Mutually Distrustful Parties
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 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. 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. 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
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 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. 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. 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.Where the paper says it
Where the paper says it
Where the paper says it
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 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. 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 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.Where the paper says it
Where the paper says it
Where the paper says it
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 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. 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.Where the paper says it
Where the paper says it
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 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. 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. 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. : 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.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
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 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.Where the paper says it
REFERENCE
arXiv:2606.10615v2,cs. p. 0 Even with extensive algorithmic and hardware acceleration,
VOLUME 0, 2025 1
arXiv:2606. 10615v2 [cs.Where the paper says it
--- 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
-
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. -
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 toverify and audit compliance
independently. -
The AI system can securely collaborate across organizations by enabling
collaborative computation among mutually distrusting parties
wheretrust between participants is no longer a prerequisite.
This is achieved through the dual-layer isolation design protecting against both host infiltration and guest exfiltration. -
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 forselective and attestable enforcement of data and code boundaries inside the 2cVM.
-
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
- Constant-Time Wasmtime, for Real This Time: End-to-End Verified Zero-Overhead Constant-Time Programming for the Web and Beyond
- Integrating Remote Attestation with Transport Layer Security
- Comprehensive Performance Analysis of Homomorphic Cryptosystems for Practical Data Processing
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data