WorksComputer Science
CVM-Store: A Secure Storage System for Confidential Virtual Machines
Abstract
Stateful cloud workloads require high-performance persistent storage when running on untrusted cloud infrastructure. Confidential Virtual Machines (CVMs) promise to protect these workloads through hardware-enforced memory encryption and isolation without requiring application changes. However, they protect only data in use; persistent storage lies outside the CVM trust boundary, exposing all stateful data to the cloud provider. Extending the trust boundary to persistent storage presents inherent challenges. High-bandwidth workloads require near-raw NVMe throughput, yet the default kernel CVM I/O stacks are inadequate, and userspace I/O libraries are not designed with CVM use cases in mind. Access patterns and storage semantics vary between workloads, necessitating access-pattern-aware security abstractions rather than uniform block-level encryption. In order to mitigate against rollback, freshness is needed, but CVMs lack hardware primitives for this purpose, requiring alternative solutions. We present CVM-Store, a storage system that co-designs a high-throughput userspace I/O engine with CIF (confidentiality, integrity, freshness) data protection. The key insight is that neither authenticated encryption nor I/O is a bottleneck by itself, but their naive combination is. CVM-Store exploits this by interleaving them, eliminating redundant copies and OS/hypervisor mediation. CIF guarantees are provided as composable primitives that adapt protection to workload access patterns, from which we derive three concrete authenticated abstractions: a KVS, a log, and a filesystem. An asynchronous trusted counter service provides freshness guarantees with epoch-based batching, which enables rollback protection without dedicated hardware support. CVM-Store delivers full CIF guarantees within 1% (write) and 1-19% (read) of raw NVMe bandwidth for large objects.
Introduction
A broad range of sensitive workloads are increasingly deployed in public clouds and require performant persistent storage. These include [38, 83, 17], [46, 7], and HPC, AI training and inference pipelines [75, 48, 55, 82], spanning sensitive domains such as healthcare record management and financial transaction processing. In all cases, the cloud provider controls the entire workload lifecycle and may try to undermine the security guarantees such workloads depend on [53, 41].
Recently, Confidential Virtual Machines (CVMs) have become the dominant model for confidential computing [110] in the cloud. CVMs protect entire VMs with hardware-enforced memory encryption and isolation, enabling unmodified applications to run securely on untrusted infrastructure. Major cloud providers [86, 85, 87] have deployed CVMs, offered by various vendors (e.g., AMD SEV-SNP [5], Intel TDX [88], Arm CCA [89]), at scale, making them the de facto foundation for running security-sensitive workloads.
However, CVMs protect only data in use, leaving persistent storage outside their trust boundary. NVMe devices, storage controllers, and the I/O stack remain under full control of the untrusted cloud provider. Thus, a malicious operator can read, corrupt, or replay persistent data, exposing every workload that requires storage outside CVM memory and relies on local storage such as NVMe SSDs. Importantly, fully closing this threat requires not only cryptographic protection of stored data, but also a mechanism to bind that data to a verified, trusted identity. Therefore, designing such secure storage systems for CVMs is necessary but non-trivial.
Further, protecting persistent data requires ensuring three properties: confidentiality, integrity, and freshness (CIF). Existing solutions fall short, as generic block-level encryption [18, 15] protects only data uniformly across all access patterns, performing redundant cryptographic operations, and application-level schemes [9, 112] bind their guarantees to a single workload. Both remain vulnerable to rollback attacks where adversaries replay cryptographically valid but stale data after crashes or migrations. Although counter-based freshness mechanisms exist [16, 7], they rely on hardware primitives (e.g., Intel SGX monotonic counters) or external distributed systems [44] that suffer from limited write endurance [9, 112] or extreme latency, rendering them unsuitable for high-throughput CVM storage workloads.
we present CVM-Store, a storage system tailored for CVM deployments that delivers end-to-end CIF guarantees. Our key insight is that CVM storage security and I/O performance are fundamentally at odds. Neither encryption nor userspace I/O is the bottleneck in isolation, only their naive composition is.
We implement CVM-Store for AMD SEV-SNP, contributing upstream fixes to SPDK DMA handling and the SEV-SNP attestation pipeline. End-to-end attestation completes in 188 ms, and the trusted counter interval (1 ms–281 ms) allows applications to tune the performance-freshness trade-off according to their needs.
Overall, this paper makes four key contributions:
Background
Confidential Virtual Machines (CVMs)
CVMs [5, 88, 89] enable confidential computing in untrusted clouds through hardware-enforced isolation and memory encryption for entire VMs [47]. During launch, the hypervisor loads guest code, data, and state, but thereafter cannot access or modify guest memory or state Further, CVMs support generating attestation evidence to verify their initial state and platform integrity.
Sealing and provisioning. To enable secure data persistence and provisioning, sealing mechanisms bind encrypted data to specific evidence. Sealing is implemented by generating an ephemeral asymmetric key and including its public-key hash in the user-controllable portion of the attestation evidence. After verifying the evidence and public-key hash, the sealing party encrypts sensitive data (e.g., encryption keys) so only the CVM with the sealing key can decrypt it.
Figure 1. I/O mechanism comparison in normal VMs, CVMs with kernel I/O, and a strawman design of SPDK in CVMs.
CVM I/O Architecture
In CVMs, the hypervisor cannot directly access encrypted memory; thus, CVMs rely on an unencrypted shared buffer (bounce buffer [90]) for I/O communication. The typical I/O process involves [36]: (i) the guest kernel encrypts and copies data to a bounce buffer, (ii) the hypervisor or device (i.e., DMA) accesses data from this shared region, and (iii) for received data, the guest copies and decrypts it from the bounce buffer.
Userspace I/O frameworks. To reduce I/O overhead, kernel-bypass frameworks (e.g., SPDK [84], DPDK [92]) In virtualized environments, userspace I/O frameworks can be combined with device passthrough mechanisms (VFIO [97], iommufd [98]). In CVMs, userspace I/O still requires bounce buffers for DMA, and direct device access exposes the CVM to potentially malicious device behavior (Figure 1). While recent work has explored userspace I/O in CVMs [35, 80, 36, 37], these efforts focus on the network I/O path and do not explore combining the I/O layer with CIF properties
Trusted I/O devices. The recent TEE Device Interface Security Protocol (TDISP) [51, 93] extends the CVM trust boundary to include I/O devices. It provides device attestation and encrypts PCIe transactions, enabling devices to directly access encrypted memory. TDISP and is not yet widely commercially available. Furthermore, it does not ensure security properties for data at rest; it still depends on software or support from the storage medium (e.g., self-encrypting drives [68] or in-storage computing [31]).
Figure 2. Difference in throughput between host, VM, and CVM using the kernel libaio and the userspace SPDK driver.
Modern Cloud Storage Devices
Modern, high-performance NVMe SSDs communicate with the host via a queue-based interface comprising submission queues (SQs) and completion queues (CQs), enabling parallel processing and reduced latency compared to legacy storage protocols [95]. The host submits I/O commands to SQs. The controller fetches them, performs the requested DMA transfers, and posts completion entries to CQs.
Motivation and Key Ideas
Protecting persistent storage under the CVM threat model is essential for modern stateful cloud workloads.
Requirement #1: Secure, performant storage I/O. Container runtimes load multi-GB image layers before pod start, AI inference loads tens-of-GB model weights on every cold start, and ledger services require continuous append-only logging. However, standard CVM I/O stacks fail to meet such demands. To this end, we measure I/O throughput using fio [23] across virtualization architectures with varying access patterns (Figure 2). We observe that CVMs achieve only up to 90% of VM write throughput and 77% of read throughput via the kernel I/O stack. This is mainly because devices cannot perform DMA into protected CVM memory, making bounce buffers mandatory for I/O operations. As a result, each operation incurs at least two extra memory copies. Additional context switches across the trust boundary further increase the incurred overhead [47, 36].
Userspace I/O [84]
CVM-Store integrates protection into a hardened kernel-bypass I/O engine. CVM-aware DMA allocations keep sensitive driver state out of shared memory, while in-path encryption/decryption subsumes unnecessary bounce-buffer copies. On top of that, completion validation and bounds checks harden the device interface against untrusted infrastructure.
Figure 3. Disk encryption performance: LUKS overhead with different cipher suites vs. baseline kernel driver inside a VM.
| Application | Stored data | Pattern | Volume |
| Confidential AI | Model weights | Write-once | GB--TB |
| Cloud apps | Image layers | Write-once | MB--GB |
| Forensic media | Video, imaging | Write-once | GB--PB |
| Object caches | Cached objects | Keyed R/W | KB--GB |
| Event logs | Audit trails | Append-only | KB--MB |
Requirement #2: Workload-tailored abstractions. CVMs provide no built-in data-at-rest protection, and application-level encryption is error-prone and often incomplete.
| Scheme | Throughput (GB/s) [VM/CVM] | CPU util. (%) |
| No encryption | 13.41 / 6.56 | 26.30 / 43.78 |
| LUKS (AES-XTS) | 10.33 / 4.10 | 38.43 / 46.15 |
| LUKS (AES-XTS+sha256) | 5.94 / 4.11 | 73.51 / 68.24 |
| LUKS (AEGIS-128) | 8.14 / 5.07 | 46.38 / 52.95 |
| dm-verity | 3.42 / 2.53 | 54.89 / 50.23 |
Table 1. Block-level read encryption/integrity performance.
Generic block-level encryption [99] ignores access-pattern structure, incurring unnecessary overheads. For write-once files, dynamic Merkle tree updates on every write are redundant; a static tree computed at write time suffices. For append-only logs, Merkle tree integrity the access pattern; instead, counter-chained MACs provide integrity and ordering more efficiently. Sometimes, a simple KV store is sufficient to block-level storage overhead unnecessary. Figure 3 and Table 1 quantify this cost: authenticated block encryption with AES-XTS+sha256 reduces throughput by 37–56%, while AEGIS-128 achieves up to 8.14 s−1.
| Throughput (GB/s) [Kernel/OpenSSL] | |||
| Host | VM | CVM | |
| AES-256-GCM | 4.52 / 4.38 | 4.47 / 4.31 | 4.43 / 4.22 |
| AES-256-XTS | 6.15 / 7.97 | 6.19 / 7.83 | 5.98 / 7.77 |
| ChaCha20 | 1.83 / 3.20 | 1.79 / 3.14 | 1.73 / 3.13 |
| ChaCha20-Poly1305 | 1.18 / 2.24 | 1.12 / 2.21 | 1.09 / 2.20 |
| SHA3-256 | 0.14 / 0.30 | 0.13 / 0.29 | 0.13 / 0.29 |
| SHA-256 | 1.03 / 1.04 | 1.02 / 1.03 | 0.98 / 1.01 |
| AEGIS-128 | 4.19 / -- | 4.38 / -- | 3.90 / -- |
| AEGIS-128L | -- / 9.47 | -- / 9.33 | -- / 9.25 |
| AEGIS-128X2 | -- / 20.07 | -- / 19.76 | -- / 19.59 |
| AEGIS-128X4 | -- / 27.06 | -- / 26.70 | -- / 26.38 |
Table 2. Encryption throughput on 4k block size.
Beyond this, CIF enforcement must be lifted to the abstraction level to exploit per-pattern structure. Co-designing each storage API with the I/O engine reduces cryptographic overhead while preserving full CIF guarantees. CVM-Store provides composable CIF primitives that enable access-pattern-aware protection, with pattern-specific abstractions layered on top of a hardened I/O engine. We demonstrate this through three instantiations: a KV store, a shared log, and a filesystem, each composing these primitives into workload-specific CIF enforcement.
. Confidentiality and integrity alone do not protect against rollback attacks. A stale snapshot retains valid authentication tags: reverting an audit log violates non-repudiation [7, 16], and rolling back model weights can reintroduce known vulnerabilities (e.g., model backdoors). rollback defenses often require replication and synchronization, while host-level freshness mechanisms contradict the CVM threat model.
| Solution | Hardware | Scope | C | I | F | Perf. |
| Unprotected CVM I/O paths | ||||||
| Bounce buffer | CVM | Kernel | darkpastelred55 | darkpastelred55 | darkpastelred55 | Medium |
| SPDK f | CVM | Userspace | darkpastelred55 | darkpastelred55 | darkpastelred55 | High |
| Block-level protection | ||||||
| Kernel FDE | CVM | Kernel | darkpastelgreen51 | darkpastelgreen51 | darkpastelred55 | Medium |
| MlsDisk c | SGX, CVM | Kernel | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | Low |
| Rollbaccine c,g | CVM | Kernel | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | Medium |
| Shielded runtimes | ||||||
| Haven | SGX | Userspace | darkpastelgreen51 | darkpastelgreen51 | darkpastelred55 | Low |
| SCONE | SGX | Userspace | darkpastelgreen51b | darkpastelgreen51b | darkpastelred55 | Medium |
| rkt-io f | SGX | Userspace | darkpastelgreen51 | darkpastelred55 | darkpastelred55 | High |
| Application-specific secure storage | ||||||
| ShieldStore a | SGX | KV store | darkpastelgreen51 | darkpastelgreen51 | darkpastelred55 | Medium |
| Speicher | SGX | KV store | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | Low |
| Pesos d | SGX | Objects | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | Low |
| EnclaveDB a | SGX | SQL DB | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | Medium |
| NeXUS e | SGX | Files | darkpastelgreen51 | darkpastelgreen51 | darkpastelred55 | Low |
| Freshness and state-continuity services | ||||||
| Memoir | TPM | Module state | black!45-- | black!45-- | darkpastelgreen51 | Low |
| ROTE c | SGX | Counters (repl.) | black!45-- | black!45-- | darkpastelgreen51 | Medium |
| ADAM-CS c | SGX, TPM | Counters (async) | black!45-- | black!45-- | darkpastelgreen51 | Medium |
| Nimble c | SGX, CVM | Ledgers | black!45-- | black!45-- | darkpastelgreen51 | Medium |
| CVM-Storec | CVM | KV/Log/FS | darkpastelgreen51 | darkpastelgreen51 | darkpastelgreen51 | High |
Precisely, CVMs lack a local hardware freshness primitive, such as SGX monotonic counters. A prior work CVMs with SGX monotonic counters [42], but this incurs 60 ms–250 ms latencies and wears out within days [9]. Counter state must therefore be externalized to a trusted party, incurring a round trip on each freshness update.
Furthermore, external counters alone are insufficient: the trusted party must also verify which CVM instance may receive storage keys, initialize counters, and resume persistent state. Without this binding, an attacker can replay sealed state into a modified instance or bind a valid counter to the wrong identity. Attestation is therefore not an auxiliary feature but a foundational design requirement:
CVM-Store externalizes monotonic counter state and binds initialization, recovery, and key provisioning to its attestation flow. Per-abstraction counter chains embed values in persistent structures for read-time rollback detection. Epoch-based batching sets the performance/freshness trade-off: per-write synchronization . In contrast, batching lets a crash revert the store only to the last committed epoch.
Summary and problem statement. The three requirements highlighted above are interdependent. Secure high-throughput I/O requires integrating CIF protection directly into the I/O engine. Workload-tailored abstractions require lifting CIF enforcement to the abstraction level, where per-pattern properties can be exploited. Fresh, attested state requires embedding counter values in the persistent structures provided by those abstractions. Addressing any one requirement in isolation leaves the others unsolved. Unfortunately, existing approaches fail to simultaneously satisfy all three (tab:cvm-storage-comparison): This leads to our core research question: how can we co-design an attested CVM I/O engine and CIF storage abstractions to simultaneously achieve high-throughput secure I/O, access-pattern-aware protection, and freshness?
Overview
Figure 4. Overview of CVM-Store’s system architecture.
System Architecture
CVM-Store targets CVM deployments where applications demand high-performance storage access, and the underlying devices and storage stack are exposed to an untrusted cloud provider. Figure 4 depicts CVM-Store’s architecture, highlighting its key components, trusted entities, and workflow.
CVM-Store’s I/O engine provides general CIF building Unlike generic block-level protections, each abstraction exploits its specific access pattern to minimize cryptographic overhead while preserving full CIF guarantees.
At the core, CVM-Store implements an I/O engine built on SPDK Blobstore [96] for high-performance userspace storage access. It integrates an encryption engine that applies modern AEAD ciphers directly in the I/O path, optimizing bounce buffer copying with encryption and integrity checks. Further, the I/O engine hardens SPDK’s device-facing boundary against untrusted NVMe controllers (Figure 1).
The CVM-Store Service manages all control-path operations. It handles metadata for storage abstractions, ensures crash consistency via copy-on-write updates, and enforces CIF properties by integrating the I/O engine’s cryptographic primitives with an asynchronous Trusted counter mechanism. The trusted counter maintains monotonic values synchronized with an external trusted party to prevent rollback attacks. Beyond this, the Service provides remote attestation and sealing/unsealing primitives for secure provisioning.
System Deployment and Workflow
CVM-Store’s deployment involves the application user, and the trusted parties responsible for attestation, provisioning, and counter synchronization. CVM-Store’s cryptographic material includes the user-provided symmetric keys for blob encryption and the CVM-generated sealing key used to bind the provisioned configuration to the attested system identity.
Figure 4 illustrates the system workflow. During initialization (), the CVM boots, and the application selects CVM-Store as its storage backend. CVM-Store’s I/O engine then performs the device setup (), configuring the NVMe via SPDK and allocating untrusted DMA buffers for data transfers.
Next, the user uses the CVM-Store Service to run the attestation and provisioning protocol () (§ 5.4). The Service collects CVM attestation evidence, which the user verifies through an external verifier, and, upon success, the user provisions symmetric encryption keys and CVM-Store configuration sealed to the attested CVM. The Service unseals and applies this configuration. Then, it establishes trusted counter synchronization () with an external trusted party, retrieving or initializing monotonic counter values and periodically synchronizing them according to CVM-Store’s configuration.
At runtime, applications interact with CVM-Store via its storage abstractions (, Table 3). For each operation, CVM-Store transparently enforces CIF guarantees. The CVM-Store Service manages the blobs and metadata, while the I/O engine issues NVMe commands and performs DMA transfers using its untrusted DMA buffers (). On writes, CVM-Store encrypts data and adds integrity metadata and trusted counter values before writing it to the DMA buffer, ensuring that only CIF-protected data is written to storage (). On reads, CVM-Store decrypts the fetched data and performs CIF verification () by validating trusted counter values and cryptographic authentication tags before returning it to the application.
| Use case | API | Description |
| get(key) | Retrieve value of KV pair | |
| put(key, value) | Store/update value for KV pair | |
| exists(key) | Check the existence of a key | |
| delete(key) | Delete KV pair | |
| create(name) | Create named shared log | |
| append(data) | Append data to log end | |
| truncate(pos) | Truncate log to position | |
| read(pos) | Read data at position | |
| create(name) | Create named file | |
| open(name, op) | Open file for read/write | |
| close(fd) | Close file descriptor | |
| read(fd, pos, length) | Read data at position/length | |
| write(fd, data) | Write data to file | |
| load(blob) | Load keys & counter from blob | |
| store() | Export keys & counter as blob | |
| evidence(nonce) | Get evidence of CVM |
Table 3. CVM-Store application and provisioning APIs.
Programming Model and APIs
Table 3 lists CVM-Store’s APIs organized by storage abstraction. CVM-Store transparently provides CIF guarantees to the application each abstraction: confidentiality and integrity are guaranteed its authenticated encryption scheme, and freshness is ensured trusted counter validation.
Figure 5. Inner components of the I/O engine and the view of storage and shared memory region between CVM and host.
. CVM-Store adopts the standard confidential computing threat model [100, 102, 101]. TCB comprises the CVM firmware and hardware, and the software running in the CVM. The rest of the system software and infrastructure, including the hypervisor, host OS, and storage devices, is untrusted. We consider attackers who have full control over the host environment and can inspect, modify, or replay any data outside the CVM boundaries, including storage, DMA buffers, and I/O traffic. We assume that the confidential computing hardware functions correctly and that cryptographic primitives are secure. We assume all CVM components can be attested and that CVM-Store exclusively uses attestation primitives to prevent multi-protocol attacks [60]. Side-channel [103, 104, 105, 106, 107, 108, 109], denial-of-service, and physical attacks, including physical RAM attacks [64, 10], are considered out of scope.
CVM-Store Design
CVM-Store consists of five building blocks: the I/O engine (§ 5.1), the trusted counter (§ 5.2), the CVM-Store service (§ 5.3), and the attestation (§ 5.4) and sealing (§ 5.5) mechanisms, which form the basis of the CIF-protected abstractions (§ 6).
I/O Engine
CVM-Store’s I/O engine (Figure 5 (a)) builds on SPDK [84] and provides high-performance userspace NVMe access from within the CVM. It ensures confidentiality and integrity through authenticated data encryption. On writes, CVM-Store transparently handles the encryption from application memory to an unprotected shared memory ring buffer before NVMe DMA, and follows the same process in reverse on reads.
SPDK Blobstore. SPDK Blobstore [96] is a userspace, power-fail-safe data allocator designed for storage services without implementing a POSIX filesystem. It organizes NVMe device space into a four-level hierarchy (logical blocks, pages, clusters of 1 by default, and blobs), where a blob is an ordered list of clusters forming a variable-sized, contiguous device allocation. Blobstore manages all logical-to-physical block mappings and provides allocation, read, and write primitives via the SPDK NVMe driver. CVM-Store adopts blobs as its fundamental storage unit, delegating physical block management to Blobstore and focusing its own logic on CIF-protected blob layout.
On the control path, the I/O engine uses Blobstore to manage storage operations, and combines it with confidentiality and integrity checks. It organizes each blob on disk into three sections: unprotected metadata (nonces, MACs, file size), optional encrypted metadata, and encrypted data chunks.
Encryption and integrity protection.
Hardening. Each nvme_tracker embeds the PRP list, SGL descriptors, and metadata SGL in DMA memory, exposing request pointers, callback pointers and arguments, and queue links to a malicious host or NVMe controller. CVM-Store hardens this by splitting the nvme_trackers into private driver state and a separate per-tracker DMA buffer containing only the NVMe-required PRP/SGL descriptors. The device receives the physical address of the descriptor buffer, while the tracker array remains outside DMA-accessible memory. CVM-Store that the controller-supplied completion identifier (CID) falls within the allocated tracker range before using it to index the array. Invalid CIDs fail the queue, preventing a forged completion from turning an untrusted DMA field into an out-of-bounds access to SPDK’s internal tracker state.
Device passthrough. Therefore, CVM-Store VFIO without an IOMMU in the CVM. The VFIO PCI BAR space is mapped directly into guest memory (Figure 5 (b)), which the guest then maps to userspace. This direct mapping eliminates the need for expensive MMIO hypercalls for device access.
Trusted Counter
CVM-Store Services
The CVM-Store Service manages all control-path operations (i.e., metadata, crash consistency, CIF enforcement), handles the data lifecycle, and reclaims unused resources.
Metadata management. The CVM-Store Service maintains Blobstore metadata for low-level storage management and application-specific metadata for the storage abstractions. SPDK’s Blobstore handles blob allocation and its metadata on the physical disk. Application-specific metadata is persisted via the I/O engine with explicit synchronization control to balance consistency with performance. To ensure crash consistency, the Service employs writing modified metadata to new locations before swapping between them, ensuring atomic updates. Cleanup of stale blobs is deferred till a successful metadata synchronization to prevent inconsistencies after crashes. CVM-Store omits journaling-based recovery to maintain simplicity and minimize overhead.
Figure 6.
Figure 7. CVM-Store’s storage interface in-memory metadata and persistent data structure organization.
CIF enforcement. The CVM-Store Service ensures the CIF properties through two mechanisms: the I/O engine’s cryptographic primitives enforce confidentiality and integrity, while the trusted counter mechanism ensures freshness. Trusted counters are embedded in persistent data, binding each storage operation to a counter state, ensuring no stale data is replayed after crashes or restarts. Counter increments are batched with storage operations to minimize synchronization overhead. At startup, the Service validates all CIF properties, verifying counter values against the external trusted party and authenticating all metadata structures, before granting application access.
Attestation and provisioning service. The CVM-Store Service serves as the central authority for attestation evidence collection and provisioning, coordinating with external verifiers and trusted counter services. It implements sealing/unsealing primitives that enable the secure provisioning of secrets and configuration, allowing CVM-Store to bind persistent state to CVM instances via attestation-derived sealing keys.
Attestation and Provisioning
CVM-Store demonstrates a complete attestation and provisioning pipeline . Before deployment, the user collects platform endorsements and reference values [6], provides them to a verifier, and sets up the trusted counter service.
Attestation.
Provisioning.
Data Sealing and Unsealing
CVM-Store provides four operations for secure data management. User-to-CVM-Store sealing encrypts data with CVM-bound keys, ensuring only the attested CVM instance can access provisioned material. CVM-Store-to-user sealing encrypts internal state using the configuration-provisioned symmetric key, enabling the user to export and later restore system state. The corresponding unseal operations perform decryption and system setup or allow data processing as opaque blobs. For data provisioning, the trusted party runs a local CVM-Store with the target symmetric key and simulated counters. This allows the data to be written without any trusted counter round trips. The resulting counter value is then provisioned into the freshness service so that the receiving CVM can validate the data freshness and consistency.
CVM-Store Abstractions
To support diverse cloud workloads with high-performance I/O while remaining easy for applications to adopt, CVM-Store provides three storage abstractions: KVS, shared log, and filesystem.
Key-Value Store (KVS)
CVM-Store’s KVS (Figure 7 (a)) stores one KV pair per blob and models updates as object replacement, targeting large values that are read sequentially.
Data organization. CVM-Store’s KVS maintains a key map in memory along with CIF-protected on-disk blobs. The map stores keys, trusted counter values, and blob identifiers, enabling existence checks and freshness validation without keeping values in memory. This design trades memory proportional to the number of keys for fast lookup and rollback checks, targeting workloads with MB-to-GB objects rather than high-cardinality small records. Each KV blob has an encrypted metadata section (trusted counter value, key), and a data section for the value.
Crash consistency. On startup, CVM-Store reads the metadata blob to retrieve the trusted counter value and hash, then reconstructs the key mapping by walking all on-disk blobs, discarding those with counters exceeding the metadata counter and selecting the higher valid counter for duplicate keys. Integrity is verified by recomputing the hash over all reconstructed key-counter pairs and comparing it against the stored value.
Operations. The Put operation inserts or updates a KV pair. CVM-Store allocates a blob, obtains and increments the trusted counter, encrypts the metadata (trusted counter, key) and data section (value), writes them to the blob, and places the metadata in the in-memory map. Then, if requested, it atomically synchronizes the metadata blob.
The Get operation retrieves a value given a key. CVM-Store looks up the key in the in-memory map to obtain the blob identifier and expected trusted counter, reads and decrypts the blob, the encrypted metadata against the looked-up key
CVM-Store looks up the key in the map, marks the blob as deleted, removes the key from the in-memory map, and defers blob deallocation to the next metadata synchronization.
Shared Log
CVM-Store’s shared log (Figure 7 (b)) is suitable for append-heavy workloads,
Data organization. The inode stores the log name, entry count, flags, first/last-entry counters and direct references to the first and last extend nodes to avoid full list traversal on append and retrieval. The extend nodes form a doubly linked list of fixed-size . Each log entry blob stores (the current and previous entry’s counters) and ; the MAC covers both, preventing tampering with the counter chain or the entry data. CVM-Store caches expected counter values in memory to validate entries without full log traversal.
Crash consistency. CVM-Store updates the super metadata block atomically , it traverses all entries and builds the counter cache, verifying for each entry that the stored previous counter matches the predecessor’s counter value, with the authenticated encryption MAC protecting the binding between counters and entry data. Finally, CVM-Store confirms that the inode’s recorded first and last counter values match those encountered during traversal.
Operations. The Append operation adds new data at the end of the log. CVM-Store marks the inode with an append-in-progress flag to prevent concurrent modifications obtains the last log entry’s counter and the current counter from the CVM-Store service. encrypts the metadata and data sections, and updates the trusted counter cache before writing to the blob. The inode metadata is updated to reflect the new entry, including incrementing the entry count and updating the last entry’s trusted counter value. Finally, the append-in-progress flag is cleared, and the trusted counter is incremented.
The Retrieve operation reads a log entry by an entry number. CVM-Store uses the log descriptor to identify the inode, returns an error if an append is in progress, and from the inode’s last extend node reference to locate the retrieves the blob identifier, reads and decrypts the blob, and For the first and last entries, CVM-Store additionally validates counters against the inode’s boundary values. Only after CIF verification is the decrypted entry returned to the application.
The Truncate operation removes old log entries. An application specifies how many entries to retain to maintain ordering. CVM-Store traverses the extend node linked list from the beginning, marking the blobs for deletion and for deallocation. subsequent consistency and freshness checks, updates the entry count and in the inode to reflect the truncation. updates the cached trusted counter mapping to remove truncated entries. Under CVM-Store’s deferred cleanup policy, marked blobs are
Filesystem
CVM-Store’s filesystem (Figure 7 (c)) exposes file-oriented APIs (Table 3) for write-once, read-many workloads . CVM-Store therefore files as immutable, name-addressed objects in a flat namespace.
Data organization. CVM-Store’s filesystem reuses the shared log’s inode and node map, , but adapts the integrity mechanism to support Merkle tree verification for random access to file chunks. Each file consists of an encrypted blob for chunked file data and an unencrypted blob for its Merkle tree, computed over all the file’s data blob. The inode contains the Merkle tree root hash and direct references to the encrypted file data and the Merkle tree blob, enabling efficient integrity checks without exposing file contents. For newly created files, the inode is initialized with a file size of zero and no blob references.
Crash consistency.
Operations. The Write operation stores data to an empty file. CVM-Store marks the inode as write-in-progress to prevent concurrent accesses the data according to a configurable policy. encrypts each chunk using derived from a global file nonce and the chunk number. Because files are write-once, the global file nonce is generated once at creation and never reused, guaranteeing nonce uniqueness across As chunks are written, CVM-Store incrementally builds the Merkle tree using MAC-based leaf hashes and stores the tree in a separate blob. The root hash and Merkle tree blob identifier are stored in the inode. Upon completion, the file becomes read-only, and the inode is marked as available.
The Read operation retrieves data from a file at a specified position and length. CVM-Store uses the file descriptor to retrieve the inode, checks that no write is in progress, and verifies the requested range against the inode’s stored size. On the first read, loads and caches the Merkle tree from disk. It then identifies the chunks for the requested range, reads and decrypts them directly into an application-provided destination buffer, and verifies them against the cached Merkle tree, skipping already-verified nodes. Only after successful CIF verification does CVM-Store return control to the application.
Security Analysis
We analyze CVM-Store against attack vectors from an untrusted host under our considered threat model (§ 4.4). Table 4 summarizes these attacks and CVM-Store’s mitigations.
| Category | Attack Vector | Mitigation |
| Loading compromised instance | Attestation | |
| CVM memory access | CVM protection | |
| Storage data snooping | AEAD encryption | |
| Storage data tampering | AEAD authentication | |
| Device descriptor manipulation | Bounds checking on DMA | |
| Rollback of storage state | Trusted counter | |
| Copy-on-write & CIF revalidation on startup | ||
| Log entry splicing | Counter-chained MACs | |
| Log truncation (front/back) | Boundary counter validation | |
| Log entry reordering | Monotone counter chain | |
| Chunk/block replacement | Merkle tree leaf MAC | |
| Root hash in trusted-counter-protected metadata |
Table 4. Attack vectors and CVM-Store’s mitigations.
General Attack Vectors
Loading compromised instance. An attacker may try to bypass CVM-Store by loading a compromised instance; attestation detects this through invalid measurements.
CVM memory access. CVM protection blocks unauthorized reads or writes to private memory.
Storage data snooping. An attacker may observe storage or DMA-shared memory. The I/O engine encrypts data inside the CVM before it enters DMA-shared memory. Thus, (§ 5.1). Keys are provisioned through attestation and never leave the protected CVM memory (§ 5.4).
Storage data tampering. An attacker may alter an encrypted CVM-Store blob while preserving the storage layout. Each blob written through the I/O engine carries an AEAD authentication tag (§ 5.1), allowing CVM-Store to detect tampering on a subsequent read operation. For KVS and Shared Log, ciphertext, metadata, or tag changes lead to a failed decryption; filesystem cross-chunk replacement is handled by Merkle-tree checks, as explained in § 7.4.
Manipulating device descriptors. An attacker may manipulate device descriptors in the shared memory, injecting adversarial metadata (e.g., invalid descriptor offset) [29]. CVM-Store mitigates this by limiting DMA-shared state and performing bounds-checking when reading DMA-received fields (§ 5.1).
Rollback of storage state. An attacker may replay an older disk state with valid authentication tags. CVM-Store mitigates this by embedding trusted counters in persisted data and synchronizing them with an external trusted party (§ 5.2). These values are validated before returning data (§ 5.3). The asynchronous synchronization interval bounds freshness, as discussed in § 7.5.
Cross-instance key reuse. An attacker may replay sealed configuration or storage keys into another CVM. CVM-Store binds provisioned keys and configuration to the public sealing key in attested evidence in such a way that a different or compromised CVM cannot unseal them (§ 5.4).
State inconsistency exploitation. An attacker may crash a CVM to induce inconsistent CVM-Store state. CVM-Store’s copy-on-write metadata updates, deferred cleanup, and restart revalidation ensure each synchronized state is a valid snapshot, effectively eliminating inconsistent state (§ 5.3).
Attacks on KVS
CVM-Store in the CIF-protected metadata blob (§ 6.1),
. An attacker may replace a value with an older, valid blob for the same key. On every Get, CVM-Store compares the blob’s key and counter with the in-memory key map stale valid blobs from replacing current values (§ 6.1).
KV unauthorized deletion. An attacker may remove a valid blob while leaving others intact. Legitimate deletions atomically update the metadata hash and defer physical deallocation until the next synchronization.
Attacks on Shared Log
The Shared Log’s potential attack surface consists of rearrangements that leave individual entries valid. (§ 6.2).
Log entry splicing. An attacker may replace an entry in the middle of the log with another valid entry. However, CVM-Store maintains the trusted counter so that its values are unique across all log entries, including those from different logs. Successfully replacing an entry in the middle of the log would require mutually consistent counter values and MACs; specifically, the replacement must match its own counter, its predecessor counter, and the successor’s stored predecessor counter. Without access to the encryption key, the adversary cannot forge such an entry or modify neighboring entries accordingly.
Log truncation (front/back). An attacker may remove valid entries from either log end.
Log entry reordering. An attacker may swap valid entries. The monotonic counter chain commits each entry to its predecessor’s counter, so any swap breaks at least one predecessor relationship and exposes tampering to CVM-Store.
Attacks on Filesystem
The Filesystem attack surface consists of block-level and whole-file replacement. Our filesystem invariant is that immutable file chunks are verified against a static Merkle tree whose root is stored in CIF-protected filesystem metadata (§ 6.3).
Chunk/block replacement. An attacker may replace, reorder, or replay individual chunks within a file. At write time, CVM-Store commits the encrypted chunks to the file’s Merkle root; on read, it releases plaintext only after the requested chunks get verified against this root (§ 6.3). These operations ensure that replacing, reordering, or replaying a chunk invalidates the corresponding leaf and propagates to a root mismatch before plaintext is returned.
File replacement. Although an old data blob and a matching Merkle-tree blob can verify internally when replayed together, CVM-Store detects the file replacement as read operations check chunks against the current file root hash recorded in trusted-counter-protected filesystem metadata. Replaying the metadata, including the superblock state, is rejected during startup because its trusted counter value is detected as stale.
Figure 8.
Limitations
Metadata exposure. CVM-Store encrypts at the abstraction rather than the block level [81, 28, 13], metadata such as file sizes, blob counts, and I/O access patterns remain visible to the untrusted host.
Trusted counter service dependency. CVM-Store relies on an external trusted counter service for freshness. written since the last synchronization point may be lost after an adversarial restart.
Side-channel / physical attacks. Side-channel and physical attacks are
Denial-of-service. , CVM-Store does not prevent an adversarial host, hypervisor, or storage device from dropping requests, delaying completions, exhausting resources, or refusing to provide the NVMe device.
Implementation
We implement CVM-Store targeting AMD SEV-SNP, but our design is vendor-agnostic and applicable to other CVMs such as Intel TDX and Arm CCA. CVM-Store is implemented as a userspace library with SPDK, totaling example clients, modifications to the Linux guest kernel, and extended SPDK [84]/DPDK [92] components to support encrypted memory management, inspired by prior work [35, 80, 36, 37, 65].
Userspace I/O handling. We re-enable userspace MMIO handling in SEV-SNP CVMs, which is disabled to prevent hypervisor coordination attacks [19], which attestation of the entire usersapce mitigates. To enable userspace DMA memory allocation, we extend mmap with the VM_CVM_SHARED flag, which decrypts pages on fault for DMA access and re-encrypts them on unmapping.
DPDK integration. SPDK utilizes DPDK [92] for environment abstraction and memory management. Since CVMs protect memory by default, DPDK’s allocator must distinguish between regular and DMA-capable memory. We modify the Environment Abstraction Layer (EAL) memory allocation APIs to propagate memory type and maintain separate memzones, memseg lists, and heaps per type (1,500 LoC), and export APIs to manage distinct pools for encrypted and decrypted memory. This approach reuses existing DPDK allocation infrastructure while enabling memory-type awareness, avoiding the alternative of external allocation which would forgo integration with DPDK’s allocation logic.
SPDK integration. SPDK abstracts device handling and memory management via an environment layer. In its abstraction layer, SPDK distinguishes between normal and DMA memory allocations, requiring changes in fewer than 50 LoC to integrate with CVM-Store’s encrypted memory management. During development, we identified upstream SPDK code that did not properly use the allocation APIs and upstreamed fixes.
CVM-Store library. The I/O engine uses SPDK’s Blobstore [96] on top of NVMe bdev, getting its DMA buffers through its own iobuf modules using SPDK’s pools, which are allocated in CVM shared memory. Authenticated encryption uses AEGIS-128X4 from libaegis [1], and filesystem integrity is build on top of a Merkle tree from cryptsetup [18]. During development, we further identified that DMA buffers without 4K alignment slow down NVMe transfers, and CVMs without AES-NI and AVX512 enabled suffer a 50% reduction in AES performance [22].
Trusted counter. CVM-Store implements trusted counters as a pluggable library with a trusted third-party module.
Attestation. CVM-Store’s attestation follows the IETF RATS background check model [12]. We provision SEV-SNP-specific reference values generated by go-gen-ref [57] along with AMD trust anchors [5] into the verifier. The CVM generates a key pair and includes the key hash with a verifier nonce in the attestation evidence. CVM-Store uses ratsd [72] to collect CVM evidence via configfs-tsm [32] in RATS CMW format with an Entity Attestation Token (EAT) [11, 39], and forwards it to a relying party for verification. This party uses Veraison [71, 73] to validate the evidence and receives an EAT Attestation Result (EAR) [24], seals the CVM-Store configuration against the attested public key, and transmits it to the CVM. Deployment required backporting Linux kernel 7.0 patches [26] for certificate chain provisioning, patching QEMU, and extending sev-snp-measure-go [74] to support OVMF measurements; all applicable changes are sent upstream.
Evaluation
Experimental Setup
Testbed. We conduct our experiments on two AMD SEV-SNP servers with CPUs, and The host runs NixOS 25.11 with Linux 6.18, including patches for NVMe speed and backported SEV-SNP KVM certificate syscall [62, 59, 58]. (C)VMs run Linux 6.17 with our mmap patch, 64 RAM, .
Variants.
I/O Analysis
End-to-end Performance
Figure 9.
Read/Write Amplification
| Workload (R/W) | SPDK | MS | IO Meta | MT | Total () |
| KVS 64 | 80/70 | 0/0.2 | 20/53 | 0/0 | 0.10/0.13 |
| KVS 4 | 1.3/1.6 | 0/0 | 0.2/3.0 | 0/0 | 0.0015/0.0044 |
| Log 64 | 30/70 | 0/90 | 20/21 | 0/0 | 0.05/0.18 |
| Log 4 | 0/1.5 | 0/8.0 | 0.2/0.3 | 0/0 | 0.0002/0.0097 |
| FS 64 | 60/190 | 0/100 | 7.6/8.3 | 20/20 | 0.09/0.32 |
| FS 4 | 0/3.7 | 0/8.2 | 0.1/0.2 | 20/20 | 0.02/0.03 |
To measure CVM-Store’s read/write amplification we trace API-level operations and compare application-visible I/O against actual bytes written through the SPDK bdev layer, capturing overhead from SPDK metadata, CVM-Store metadata, and CIF structures. We do not measure physical write amplification on the NVMe, as it is NVMe- and internal-state-specific.
tab:evaluation:rw-amplification presents the results.
Figure 10.
| Evidence | Evidence | Attestation | Seal/ | Total | |
| collection | appraisal | appraisal | Unseal | ||
| CVM | 26.57 | — | — | 24.65 | 188.35 |
| Trusted party | — | 65.95 | 0.76 | 20.73 | 87.43 |
Table 5. \revnoref[rev1]{Breakdown of attestation and provisioning time.}
| Data Size | KVS (s) | Filesystem (s) | Shared log (s) |
| S / M / C | S / M / C | S / M / C | |
| 100 | 0.03 / 0.12 / -- | 0.06 / 0.25 / 0.13 | 0.03 / 0.05 / 0.08 |
| 1 | 0.16 / 0.32 / -- | 0.16 / 0.49 / 0.14 | 0.15 / 0.23 / 0.07 |
| 10 | 1.5 / 1.3 / -- | 1.5 / 1.3 / 0.15 | 1.5 / 0.9 / 0.08 |
| 100 | 15.5 / 7.9 / -- | 15.1 / 8.1 / 0.14 | 15.0 / 8.8 / 0.08 |
| 1000 | 150.1 / 75.2 / -- | 150.2 / 76.4 / 0.15 | 150.2 / 76.1 / 0.09 |
Attestation and Sealing
Trusted Counter
Figure 11.
Related Work
. However, and neither provides full integrity or freshness guarantees. CVM-Store provides optimized storage abstractions that support diverse access patterns within CVMs while maintaining strong CIF guarantees.
Userspace I/O in confidential computing. Userspace I/O frameworks (e.g., DPDK [92], SPDK [84]) reduce context switching overhead by directly interacting with devices [65, 92]. Bifrost [36] leverages the fact that application-level protocols (e.g., TLS) already provide end-to-end confidentiality, thereby avoiding unnecessary encryption at the I/O layer, other approaches demonstrate that careful software optimization can achieve near-optimal I/O performance [37]. CVM-Store builds upon these insights to design a secure userspace I/O engine tailored for storage workloads in CVMs.
Trusted counters. CVMs do not natively support trusted counters. AMD provides SecureTSC to protect time-source values from hypervisor manipulation, but it introduces new attack vectors [30, 4] and cannot be used as a replacement. Therefore, remote trusted services have been proposed [7, 43, 44] to restore the trusted counter functionality and build replication on top. CVM-Store addresses this by exposing a pluggable trusted counter interface through which it synchronizes with an external trusted party to provide its freshness guarantees.
Attestation. RATS [12] provides standardized frameworks used by Trustee KBS [69] and Veraison [71]. CVM-Store contributed to Veraison to attest evidence from the CVM before provisioning cryptographic materials.
Authenticated data structures. Recent work proposes skewed Merkle trees with shorter paths for frequently accessed addresses [63] and Bonsai Merkle Forests that split integrity trees to reduce overhead [25]. Additional optimizations adapt the tree layout at runtime [56, 66]. CVM-Store only requires a simple Merkle tree for filesystem integrity verification, while avoiding the complexity of dynamic restructuring through its immutable file design.
Conclusion
Artifact and appendix. CVM-Store’s source code is available at https://github.com/TUM-DSE/CVM-Store-NDSS27.
Acknowledgment
This work was supported in part by an ERC Starting Grant (ID: 101077577) and the Chips Joint Undertaking (JU), European Union (EU) HORIZON-JU-IA, under grant agreement No. 101140087 (SMARTY). We also thank the Veraison and SPDK open-source projects, whose work CVM-Store builds upon, for their input and help contributing fixes upstream.
Ethics Considerations
This paper does not introduce any new vulnerability and does not involve human subjects research. Our work aims to strengthen security in confidential cloud computing, and we therefore believe this work raises no ethical concerns.
| Cost | Description | |
| Local counter (in the CVM) | ||
| next() | none | Reserve and return the next value |
| read() | none | Last reserved value, without reserving |
| load/store | none | Import/export state for provisioning and sealing |
| External service (over the authenticated channel) | ||
| commit(v) | 1 RTT | Publish reserved value; asynchronous |
Table 6. \rev[rev1]{G.05, G.11}{CVM-Store{}'s trusted counter interface. Only commit leaves the CVM, and it is issued once per epoch rather than once per operation.}
| Setting | Semantics and rollback window | |
| Coupling | ordered | Blobcommitsuperblock: |
| parallel | Commit with the blob write: | |
| Trigger | shutdown | Epoch at close only |
| barrier | Epoch on an explicit barrier only | |
| every- | Epoch everymutations | |
| every- | Epoch everys | |
| per-op | Epoch per mutation | |
| Modifier | blocking | Admit further mutations only once the epoch is durable |
| metadata-only | Persist without committing freshness |
Table 7. \rev[rev1]{G.05, G.11}{Durability and freshness configuration.}
Figure 12.
SPDK hardening & DMA allocations
We list the key SPDK structures that require DMA-accessible memory in Table 8. They cover NVMe queue management, blobstore metadata, and I/O buffer pools. We identified these allocations by tracing SPDK memory allocations with GDB and manually cross-referencing the source code.
To harden the NVMe driver, we added bounds checks to the completion queues and split the nvme_tracker struct so that only the required data is allocated in DMA memory. CVM-Store uses SPDK’s iobuf sized accordingly and allocated in DMA shared memory with its own module.
| Structure | Frequency and description |
pqpair->cmd (spdk_nvme_cmd[]) | NVMe submission queue |
pqpair->cpl (spdk_nvme_cpl[]) | NVMe completion queue |
pqpair->dma_bufs (nvme_dma_prp_sgl_buffer[]) | PRP/SGL scatter-gather descriptors (4 , 4 -aligned), split from nvme_tracker, which is now private |
spdk_bs_super_block | Blobstore metadata (version, cluster size) |
spdk_bs_md_mask | Used-pages/blobids/clusters bitmasks (458 ea.) |
spdk_blob_md_page | Blob extent maps and cluster metadata (4 ) |
spdk_nvme_ctrlr_data / spdk_nvme_ns_data | Identify controller/namespace payload (4 ) |
small_pool_base / large_pool_base | SPDK’s modules with default names (unused), CVM-Store’s DMA buffers (resized based on configuration, e.g., 180 single-threaded w/ 1 chunks) |
g_bdev_mgr.zero_buffer | Zero buffer for write-zero ops (1 ) |
Table 8. Selection of SPDK main DMA memory allocations. All structures need to be allocated in DMA memory.
Artifact Appendix
This artifact contains the implementation and the scripts to reproduce the experiments, figures, and tables of the paper. It consists of the CVM-Store library and its example clients, the patched guest kernel, the CVM-enabled DPDK/SPDK forks, the applications ported to CVM-Store(Redis, MLPerf Storage), and the benchmarking framework. The framework builds the guest images, boots AMD SEV-SNP guests with NVMe passthrough, and automates the measurements: the fio and crypto motivation experiments, the CVM-Store evaluation against ext4 and Rollbaccine (I/O characteristics, ablation, amplification, epochs, seal/unseal recovery), and the end-to-end MLPerf Storage, Redis and attestation benchmarks.
Description & Requirements
How to access
The artifact is publicly available on GitHub at https://github.com/TUM-DSE/CVM-Store-NDSS27 . This repository is the evaluation harness and pins every other component (CVM-Store, DPDK/SPDK forks, guest kernel patches, MLPerf Storage and Redis forks, and the orchestration framework) as Nix flake inputs, so all components are built reproducibly.
Hardware dependencies
An AMD SEV-SNP enabled server (EPYC Zen 4 and up, we mainly used EPYC 9334)
At least 64 physical cores and 320 GB of DDR5 RAM.
A dedicated KIOXIA CM7-R PCIe Gen 5 NVMe SSD or similar with 3.8 TB or more. It is erased by the experiments and must not hold any data. A slower or Gen 4 NVMe can demonstrate the functionality, not the absolute numbers. NVMe NUMA and guest configuration should match.
Up to about 400 GB of free disk space for traces and build artifacts.
Software dependencies
A Linux host with SEV-SNP support (7.2 Linux kernel upstream, or older 6.18 with custom patches), IOMMU and
vfio-pciincluded. Hugepages should be allocatable on the host.Nix with flakes and ccache enabled. Everything else is built via Nix directly.
Docker on the host, for the MLPerf Storage container in the guest image and Veraison.
Root access, for booting VMs and binding the NVMe to VFIO.
Benchmarks
All workloads are included in the artifact repository or generated reproducibly.
Artifact Installation & Configuration
Install Nix with flakes on the host and clone
CVM-Store-NDSS27, then enter the shell withnix develop.Add the host to
config.tomlwith the correct NVMe.Build OVMF, QEMU, and the guest image with MLPerf:
oma-arvio build.allandoma-arvio accelstore.build-guest --mlperfSet up Veraison for attestation:
oma-arvio veraison.setup, then check withoma-arvio veraison.statusthat every service is up.Smoke test that boots a SEV-SNP guest with NVMe:
oma-arvio-root vm.start --type snp --size medium -u
Major Claims
The artifact supports the following claims of the paper. C1 covers the motivation, C2 to C7 correspond to the evaluation’s Takeaways 1 to 6, and each names the experiment and figure or table that it relates to.
(C1) CVM kernel I/O loses at least 10–23% of VM throughput, authenticated block-level encryption (AES-XTS+sha256) a further 37–56% of read bandwidth, while AEGIS exceeds NVMe bandwidth on one core. (E1), Figure 2–Figure 3, Table 1 and Table 2.
(C2) For large objects, one core with full CIF is within 1% (write) and 1–19% (read) of raw NVMe bandwidth, while single-threaded ext4 and Rollbaccine reach 18–30% on reads (Takeaway 1). (E2), Figure 8.
(C3) These characteristics carry through to applications: CVM-Store matches or outperforms both baselines on large-object workloads and trails only on small-object or high-thread-count ones (Takeaway 2). (E3), Figure 9.
(C4) Read/write amplification of the three abstractions stays below 1 (Takeaway 3). (E4), Table tab:evaluation:rw-amplification.
(C5) Full CIF costs 1% runtime, while naively implementing any one part costs up to 76% (Takeaway 4). (E4), Figure 10.
(C6) Attestation is a one-time overhead; sealing scales linearly with data (Takeaway 5). (E5), Table 5–tab:evaluation:api-recovery.
(C7) Widening the epoch takes filesystem and shared-log overhead from 8–10% down to 2.5% (Takeaway 6). (E6), Figure 11.
Evaluation
Every figure and table of the paper is tied to one paper.<name> task that runs its experiment, exports results into , and figures into . All runs are automated, with minimal human intervention required. oma-arvio-root paper.all --quick runs a representative subset of them in about a day. Without --quick, the full set may take several weeks, mainly because of the fio runs, which require the NVMe to reach steady state. The in the artifact repository lists the exact differences between the quick subset and the paper, and a runtime breakdown of the tasks. Quick runs use less data, so the absolute numbers may differ from those in the paper. However, the ratios between the arms and the shapes of the curves are expected to be similar on matching hardware. The following table shows the experiments and tasks that are part of it.
| Task paper.* | Output | Paper | |
| Motivation | |||
| E1 | crypto | / 0 1 2 3 4 5 6 7 8 9=/.:-crypto-summary.csv | Tab. |
| fio-iops | / 0 1 2 3 4 5 6 7 8 9=/.:-fio-iops_iops.pdf | Fig. | |
| fio-stacks | / 0 1 2 3 4 5 6 7 8 9=/.:-fio-luks_iops.pdf, / 0 1 2 3 4 5 6 7 8 9=/.:-fio-bandwidth.csv | Fig. , Tab. | |
| I/O analysis of the three abstractions | |||
| E2 | synthetic | / 0 1 2 3 4 5 6 7 8 9=/.:-synthetic.pdf | Fig. |
| End-to-end applications | |||
| E3 | apps | / 0 1 2 3 4 5 6 7 8 9=/.:-apps.pdf | Fig. |
| Ablation and amplification study | |||
| E4 | ablation | / 0 1 2 3 4 5 6 7 8 9=/.:-ablation.pdf | Fig. |
| amplification | / 0 1 2 3 4 5 6 7 8 9=/.:-amplification.csv | Tab. | |
| Attestation, sealing and recovery | |||
| E5 | attestation | / 0 1 2 3 4 5 6 7 8 9=/.:-attestation-summary.csv | Tab. |
| seal-unseal | / 0 1 2 3 4 5 6 7 8 9=/.:-seal-unseal-summary.csv | Tab. | |
| Trusted counter epochs | |||
| E6 | epoch | / 0 1 2 3 4 5 6 7 8 9=/.:-epoch-overhead.pdf | Fig. |
| included in paper.all --quick |
Prerequisites:
All: make sure the build steps are done and no one else is using the NVMe.
E1: the two fio tasks precondition the whole SSD (only run if time permits).
E3: requires MLPerf in the guest image. If the runs fail, rebuild the guest image.
E5:
paper.attestationrequires Veraison running on the host. Check withoma-arvio veraison.status.
Customization
The and of the artifact repository describe how to run every benchmark family manually, including how to customize the VM size, the storage backends, crypto variants, durability and freshness settings, and workloads.
References
- [1]Aegis-Aead/Libaegis. (2026). Aegis-Aead/Libaegis. In The AEGIS authenticated encryption algorithms.
- [4]AMD. (2024). AMD Security Bulletin AMD-SB-3007. In https://www.amd.com/en/resources/product-security/bulletin/amd-sb-3007.html. https://www.amd.com/en/resources/product-security/bulletin/amd-sb-3007.htmlamd.com/en/resources/product-security/bulletin/amd-sb-3007.html
- [5]AMD. (2020). AMD SEV-SNP: Strengthening VM Isolation with Integrity Protection and More. In AMD.
- [6]AMD. (2025). Versioned Chip Endorsement Key (VCEK) Certificate and KDS Interface Specification.
- [7]Angel, S., Basu, A., Cui, W., Jaeger, T., Lau, S., Setty, S., & Singanamalla, S. (2023). Nimble: Rollback Protection for Confidential Cloud Services. 17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23), 193–208.
- [9]Bailleu, M., Thalheim, J., Bhatotia, P., Fetzer, C., Honda, M., & Vaswani, K. (2019). SPEICHER: Securing LSM-based Key-Value Stores Using Shielded Execution. 17th USENIX Conference on File and Storage Technologies (FAST 19), 173–190.
- [10]Meulemeester, J. D., Oswald, D., Verbauwhede, I., & Van Bulck, J. (2026). Battering RAM: Low-Cost Interposer Attacks on Confidential Computing via Dynamic Memory Aliasing. 47th IEEE Symposium on Security and Privacy (IEEE S&P '26).
- [11]Birkholz, H., Smith, N., Fossati, T., Tschofenig, H., & Glaze, D. (2025). RATS Conceptual Messages Wrapper (CMW). In Internet Engineering Task Force (Number draft-ietf-rats-msg-wrap-23).
- [12]Birkholz, H., Thaler, D., Richardson, M., Smith, N., & Pan, W. (2023). Remote ATtestation procedureS (RATS) Architecture. In Internet Engineering Task Force (Number RFC 9334). https://doi.org/10.17487/RFC9334
- [13]Brož, M. (2018). Authenticated and Resilient Disk Encryption.
- [15]Chakraborti, A., Jain, B., Kasiak, J., Zhang, T., Porter, D., & Sion, R. (2017). Dm-x: Protecting Volume-level Integrity for Cloud Volumes and Local Block Devices. Proceedings of the 8th Asia-Pacific Workshop on Systems, 1–7. https://doi.org/10.1145/3124680.3124732
- [16]Chu, D., Balasubramanian, A., Bao, D., Crooks, N., Howard, H., Katahanas, L. E., & Ponnapalli, S. (2025). Rollbaccine : Herd Immunity against Storage Rollback Attacks in TEEs [Technical Report] (Numbers arXiv:2505.04014). https://doi.org/10.48550/arXiv.2505.04014
- [17]Confidential Containers. (n.d.). Confidential Containers - Secure Storage Documentation. In https://github.com/confidential-containers/guest-components/blob/main/confidential-data-hub/docs/SECURE_STORAGE.md. Retrieved https://github.com/confidential-containers/guest-components/blob/main/confidential-data-hub/docs/SECURE_STORAGE.mdgithub.com/confidential-containers/guest-components/blob/main/confidential-data-hub/docs/SECURE_STORAGE.md
- [18]cryptsetup / cryptsetup $ $ GitLab. (2026). cryptsetup / cryptsetup $ $ GitLab. In https://gitlab.com/cryptsetup/cryptsetup. https://gitlab.com/cryptsetup/cryptsetupgitlab.com/cryptsetup/cryptsetup
- [19]CVE-2023-46813. (n.d.). CVE-2023-46813. In https://www.cve.org/CVERecord?id=CVE-2023-46813. Retrieved https://www.cve.org/CVERecord?id=CVE-2023-46813cve.org/CVERecord?id=CVE-2023-46813
- [22]Enable AES and AVX Instructions for SEV-SNP CVMs $ $ Issue #12382 $ $ Kata-Containers/Kata-Containers. (n.d.). Enable AES and AVX Instructions for SEV-SNP CVMs $ $ Issue #12382 $ $ Kata-Containers/Kata-Containers. In https://github.com/kata-containers/kata-containers/issues/12382. Retrieved https://github.com/kata-containers/kata-containers/issues/12382github.com/kata-containers/kata-containers/issues/12382
- [23]Fio - Flexible I/O Tester Rev. 3.38 --- Fio 3.38-38-G3ee5 Documentation. (n.d.). Fio - Flexible I/O Tester Rev. 3.38 --- Fio 3.38-38-G3ee5 Documentation. In https://fio.readthedocs.io/en/latest/fio_doc.html. Retrieved https://fio.readthedocs.io/en/latest/fio_doc.htmlfio.readthedocs.io/en/latest/fio_doc.html
- [24]Fossati, T., Voit, E., Trofimov, S., & Birkholz, H. (2025). EAT Attestation Results. In Internet Engineering Task Force (Number draft-ietf-rats-ear-00).
- [25]Freij, A., Zhou, H., & Solihin, Y. (2021). Bonsai Merkle Forests: Efficiently Achieving Crash Consistency in Secure Persistent Memory. MICRO-54: 54th Annual IEEE/ACM International Symposium on Microarchitecture, 1227–1240. https://doi.org/10.1145/3466752.3480067
- [26][GIT PULL] KVM Changes for Linux 7.0 - Paolo Bonzini. (n.d.). [GIT PULL] KVM Changes for Linux 7.0 - Paolo Bonzini. In https://lore.kernel.org/all/[email protected]/. Retrieved https://lore.kernel.org/all/[email protected]/lore.kernel.org/all/[email protected]
- [28]Groß, T., Ahmadova, M., & Müller, T. (2019). Analyzing Android's File-Based Encryption: Information Leakage through Unencrypted Metadata. Proceedings of the 14th International Conference on Availability, Reliability and Security, 1–7. https://doi.org/10.1145/3339252.3340340
- [29]Hetzelt, F., Radev, M., Buhren, R., Morbitzer, M., & Seifert, J.-P. (2021). VIA: Analyzing Device Interfaces of Protected Virtual Machines. Proceedings of the 37th Annual Computer Security Applications Conference, 273–284. https://doi.org/10.1145/3485832.3488011
- [30]Juffinger, J., Neela, S. R., & Gruss, D. (2025). Not So Secure TSC. Applied Cryptography and Network Security, 3–23. https://doi.org/10.1007/978-3-031-95764-2_1
- [31]Kang, L., Xue, Y., Jia, W., Wang, X., Kim, J., Youn, C., Kang, M. J., Lim, H. J., Jacob, B., & Huang, J. (2021). IceClave: A Trusted Execution Environment for In-Storage Computing. MICRO-54: 54th Annual IEEE/ACM International Symposium on Microarchitecture, 199–211. https://doi.org/10.1145/3466752.3480109
- [32]Kernel.Org/Doc/Documentation/ABI/Testing/Configfs-Tsm. (n.d.). Kernel.Org/Doc/Documentation/ABI/Testing/Configfs-Tsm. In https://www.kernel.org/doc/Documentation/ABI/testing/configfs-tsm. Retrieved https://www.kernel.org/doc/Documentation/ABI/testing/configfs-tsmkernel.org/doc/Documentation/ABI/testing/configfs-tsm
- [35]Lam, W. (2024). Boosting the Network Performance of Confidential VM Using Userspace Stack.
- [36]Li, D., Mi, Z., Ji, C., Tan, Y., Zang, B., Guan, H., & Chen, H. (2023). Bifrost: Analysis and Optimization of Network I/O Tax in Confidential Virtual Machines. 2023 USENIX Annual Technical Conference (USENIX ATC 23), 1–15.
- [37]Li, M., Srivastava, S., & Yan, M. (2024). Bridge the Future: High-Performance Networks in Confidential VMs without Trusted I/O Devices (Numbers arXiv:2403.03360). https://doi.org/10.48550/arXiv.2403.03360
- [38]Lin, C., Nadi, S., & Khazaei, H. (2020). A Large-scale Data Set and an Empirical Study of Docker Images Hosted on Docker Hub. 2020 IEEE International Conference on Software Maintenance and Evolution (ICSME), 371–381. https://doi.org/10.1109/ICSME46990.2020.00043
- [39]Lundblade, L., Mandyam, G., O'Donoghue, J., & Wallace, C. (2025). The Entity Attestation Token (EAT). In Internet Engineering Task Force (Number RFC 9711). https://doi.org/10.17487/RFC9711
- [41]Mahajan, P., Setty, S., Lee, S., Clement, A., Alvisi, L., Dahlin, M., & Walfish, M. (2011). Depot: Cloud Storage with Minimal Trust. ACM Transactions on Computer Systems, 29(4), 1–38. https://doi.org/10.1145/2063509.2063512
- [42]Mahhouk, M. (2025). MoeMahhouk/Gramine-Sealing-Key-Provider. In Last accessed: July 2025.
- [43]Martin, A., Lian, C., Gregor, F., Krahn, R., Schiavoni, V., Felber, P., & Fetzer, C. (2021). ADAM-CS: Advanced Asynchronous Monotonic Counter Service. 2021 51st Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), 426–437. https://doi.org/10.1109/DSN48987.2021.00053
- [44]Matetic, S., Ahmed, M., Kostiainen, K., Dhar, A., Sommer, D., Gervais, A., Juels, A., & Capkun, S. (2017). ROTE: Rollback Protection for Trusted Execution. 26th USENIX Security Symposium (USENIX Security 17), 1289.
- [46]Michael, N., Mink, J., Liu, J., Gaur, S., Hassan, W. U., & Bates, A. (2020). On the Forensic Validity of Approximated Audit Logs. Annual Computer Security Applications Conference, 189–202. https://doi.org/10.1145/3427228.3427272
- [47]Misono, M., Stavrakakis, D., Santos, N., & Bhatotia, P. (2024). Confidential VMs Explained: An Empirical Analysis of AMD SEV-SNP and Intel TDX. Proceedings of the ACM on Measurement and Analysis of Computing Systems, 8(3), 1–42. https://doi.org/10.1145/3700418
- [48]Mohan, A., Walkup, R., Karacali, B., Chen, M.-. hung ., Kayi, A., Schour, L., Salaria, S., Wen, S., Chung, I.-. hsin ., Alim, A., Evangelinos, C., Luo, L., Dombrowa, M., Schares, L., Sydney, A., Maniotis, P., Koteshwara, S., Tang, B., Belog, J., … Seelam, S. (2025). Vela: A Virtualized LLM Training System with GPU Direct RoCE. Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, 1348–1364. https://doi.org/10.1145/3676641.3716280
- [51]PCI-SIG. (2024). PCI Express Base Specification Revision 6.3.
- [53]Popa, R. A., Lorch, J. R., Molnar, D., Wang, H. J., & Zhuang, L. (2011). Enabling Security in Cloud Storage SLAs with CloudProof. 2011 USENIX Annual Technical Conference (USENIX ATC 11).
- [55]Quoc, D. L., Gregor, F., Arnautov, S., Kunkel, R., Bhatotia, P., & Fetzer, C. (2020). secureTF: A Secure TensorFlow Framework. Proceedings of the 21st International Middleware Conference, 44–59. https://doi.org/10.1145/3423211.3425687
- [56]Rakshit, J., & Mohanram, K. (2017). ASSURE: Authentication Scheme for SecURE Energy Efficient Non-Volatile Memories. 2017 54th ACM/EDAC/IEEE Design Automation Conference (DAC), 1–6. https://doi.org/10.1145/3061639.3062205
- [57]Raman, J. (2025). Jraman567/Go-Gen-Ref. In Last accessed: February 2026.
- [58]Roth, M. (2026). KVM: Introduce KVM_EXIT_SNP_REQ_CERTS for SNP Certificate-Fetching. In Last accessed: February 2026.
- [59]Roth, M. (2026). KVM: SEV: Add KVM_SEV_SNP_ENABLE_REQ_CERTS Command. In Last accessed: February 2026.
- [60]Segall, A. (2012). Using the TPM: Machine Authentication and Attestation.
- [62]Sun, J. (2025). [PATCH v4 0/2] PCI: Fix the Issue of Failed Speed Limit Lifting. In Last accessed: February 2026.
- [63]Szefer, J., & Biedermann, S. (2014). Towards Fast Hardware Memory Integrity Checking with Skewed Merkle Trees. Proceedings of the Third Workshop on Hardware and Architectural Support for Security and Privacy, 1–8. https://doi.org/10.1145/2611765.2611774
- [64]Chuang, J., Seto, A., Berrios, N., van Schaik, S., Garman, C., & Genkin, D. (2026). TEE.Fail: Breaking Trusted Execution Environments via DDR5 Memory Bus Interposition. 47th IEEE Symposium on Security and Privacy (IEEE S&P '26).
- [65]Thalheim, J., Unnibhavi, H., Priebe, C., Bhatotia, P., & Pietzuch, P. (2021). Rkt-Io: A Direct I/O Stack for Shielded Execution. Proceedings of the Sixteenth European Conference on Computer Systems, 490–506. https://doi.org/10.1145/3447786.3456255
- [66]Thomas, S., Workneh, K., McCarty, J., Izraelevitz, J., Lehman, T., & Bahar, R. I. (2024). A Midsummer Night's Tree: Efficient and High Performance Secure SCM. Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3, 3, 22–37. https://doi.org/10.1145/3620666.3651354
- [68]Trusted Computing Group. (2025). TCG Storage Security Subsystem Class (SSC): Opal Version 2.30. In Trusted Computing Group.
- [69]Trustee. (2025). Trustee. In Confidential Containers.
- [71]Veraison. (n.d.). Veraison. In https://github.com/veraison. Retrieved https://github.com/veraisongithub.com/veraison
- [72]Veraison/Ratsd. (2026). Veraison/Ratsd. In Veraison.
- [73]Veraison/Services. (2026). Veraison/Services. In Veraison.
- [74]Virtee/Sev-Snp-Measure-Go. (2025). Virtee/Sev-Snp-Measure-Go. In VirTEE.
- [75]Wang, G., Ruwase, O., Xie, B., & He, Y. (2024). FastPersist: Accelerating Model Checkpointing in Deep Learning (Numbers arXiv:2406.13768). https://doi.org/10.48550/arXiv.2406.13768
- [80]Yang, Z. (2023). Fast and Secure: DPDK Meets Confidential Computing.
- [81]Zadok, E., Badulescu, I., & Shender, A. (1998). Cryptfs: A Stackable Vnode Level Encryption File System. https://doi.org/10.7916/D82N5935
- [82]Zhang, C., Xia, J., Yang, B., Puyang, H., Wang, W., Chen, R., Akkus, I. E., Aditya, P., & Yan, F. (2021). Citadel: Protecting Data Privacy and Model Confidentiality for Collaborative Learning. Proceedings of the ACM Symposium on Cloud Computing, 546–561. https://doi.org/10.1145/3472883.3486998
- [83]Zhao, N., Tarasov, V., Albahar, H., Anwar, A., Rupprecht, L., Skourtis, D., Warke, A. S., Mohamed, M., & Butt, A. R. (2019). Large-Scale Analysis of the Docker Hub Dataset. 2019 IEEE International Conference on Cluster Computing (CLUSTER), 1–10. https://doi.org/10.1109/CLUSTER.2019.8891000
- [84]Yang, Z., Harris, J. R., Walker, B., Verkamp, D., Liu, C., Chang, C., Cao, G., Stern, J., Verma, V., & Paul, L. E. (2017). SPDK: A development kit to build high performance storage applications. 2017 IEEE International Conference on Cloud Computing Technology and Science (CloudCom), 154–161. https://doi.org/10.1109/CloudCom.2017.14
- [85]Microsoft. (2019). Azure Confidential Computing. In Last accessed: March, 2025. https://azure.microsoft.com/en-us/solutions/confidential-computeazure.microsoft.com/en-us/solutions/confidential-compute
- [86]Google. (2019). Google Cloud Confidential Computing. In Last accessed: March, 2025. https://cloud.google.com/confidential-computing/cloud.google.com/confidential-computing
- [87]IBM. (2019). Confidential computing on IBM Cloud. In Last accessed: March, 2025. https://www.ibm.com/cloud/confidential-computingibm.com/cloud/confidential-computing
- [88]Intel. (n.d.). Intel® Trust Domain Extensions (Intel TDX). In Last accessed: March, 2025. Retrieved https://www.intel.com/content/www/us/en/developer/articles/technical/intel-trust-domain-extensions.htmlintel.com/content/www/us/en/developer/articles/technical/intel-trust-domain-extensions.html
- [89]ARM. (n.d.). Arm Confidential Compute Architecture. In Last accessed: March, 2025. Retrieved https://www.arm.com/architecture/security-features/arm-confidential-compute-architecturearm.com/architecture/security-features/arm-confidential-compute-architecture
- [90]Rybczyńska, M. (2019). Bounce Buffers for Untrusted Devices [LWN.net]. In Last accessed: March, 2025. https://lwn.net/Articles/786558/lwn.net/Articles/786558
- [92]DPDK Project. (2026). DPDK. In https://www.dpdk.org/. https://www.dpdk.org/dpdk.org
- [93]Ternullo, L. (2026). IDE and TDISP: An Overview of PCIe® Technology Security Features. In https://pcisig.com/blog/ide-and-tdisp-overview-pcie%C2%AE-technology-security-features. https://pcisig.com/blog/ide-and-tdisp-overview-pcie%C2%AE-technology-security-featurespcisig.com/blog/ide-and-tdisp-overview-pcie%C2%AE-technology-security-features
- [95]NVM Express®. (2026). NVM Express® Base Specification. In https://nvmexpress.org/specification/nvm-express-base-specification/. https://nvmexpress.org/specification/nvm-express-base-specification/nvmexpress.org/specification/nvm-express-base-specification
- [96]SPDK community. (2026). Blobstore Programmer's Guide. In https://spdk.io/doc/blob.html. https://spdk.io/doc/blob.htmlspdk.io/doc/blob.html
- [97]The kernel development community. (2026). VFIO - “Virtual Function I/O”. In https://docs.kernel.org/driver-api/vfio.html. https://docs.kernel.org/driver-api/vfio.htmldocs.kernel.org/driver-api/vfio.html
- [98]Gunthorpe, J., & Tian, K. (2026). IOMMUFD. In https://docs.kernel.org/userspace-api/iommufd.html. https://docs.kernel.org/userspace-api/iommufd.htmldocs.kernel.org/userspace-api/iommufd.html
- [99]The kernel development community. (2026). dm-crypt. In https://docs.kernel.org/admin-guide/device-mapper/dm-crypt.html. https://docs.kernel.org/admin-guide/device-mapper/dm-crypt.htmldocs.kernel.org/admin-guide/device-mapper/dm-crypt.html
- [100]Cheng, P.-C., Ozga, W., Valdez, E., Ahmed, S., Gu, Z., Jamjoom, H., Franke, H., & Bottomley, J. (2024). Intel TDX Demystified: A Top-Down Approach. ACM Comput. Surv., 56(9). https://doi.org/10.1145/3652597
- [101]Aktas, E., Cohen, C., Eads, J., Forshaw, J., & Wilhelm, F. (2023). Intel Trust Domain Extensions (TDX) Security Review April 2023. In Last accessed: March, 2025. https://services.google.com/fh/files/misc/intel_tdx_-_full_report_041423.pdfservices.google.com/fh/files/misc/intel_tdx_-_full_report_041423.pdf
- [102]Reshetova, E., & Bilbao, C. (2023). Confidential Computing in Linux for x86 virtualization. In Last accessed: March, 2025. https://docs.kernel.org/security/snp-tdx-threat-model.htmldocs.kernel.org/security/snp-tdx-threat-model.html
- [103]Alam, A. K. M. M., & Chen, K. (2023). Making Your Program Oblivious: A Comparative Study for Side-channel-Safe Confidential Computing. Proceedings of the IEEE 16th International Conference on Cloud Computing. https://doi.org/10.1109/CLOUD60044.2023.00040
- [104]Intel. (2022). Guidelines for Mitigating Timing Side Channels Against Cryptographic Implementations. In Last accessed: July, 2024. https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/secure-coding/mitigate-timing-side-channel-crypto-implementation.htmlintel.com/content/www/us/en/developer/articles/technical/software-security-guidance/secure-coding/mitigate-timing-side-channel-crypto-implementation.html
- [105]Wichelmann, J., Pätschke, A., Wilke, L., & Eisenbarth, T. (2023). Cipherfix: Mitigating Ciphertext Side-Channel Attacks in Software. Proceedings of the 32nd USENIX Security Symposium.
- [106]AMD. (2022). TECHNICAL GUIDANCE FOR MITIGATING EFFECTS OF CIPHERTEXT VISIBILITY UNDER AMD SEV REVISION 5.10.22. In Last accessed: July, 2024. https://www.amd.com/system/files/documents/221404394-a_security_wp_final.pdfamd.com/system/files/documents/221404394-a_security_wp_final.pdf
- [107]Deng, S., Li, M., Tang, Y., Wang, S., Yan, S., & Zhang, Y. (2023). CipherH: Automated Detection of Ciphertext Side-channel Vulnerabilities in Cryptographic Implementations. Proceedings of the 32nd USENIX Security Symposium.
- [108]Intel. (2018). Host Firmware Speculative Execution Side Channel Mitigation. In Last accessed: July, 2024. https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/technical-documentation/host-firmware-speculative-side-channel-mitigation.htmlintel.com/content/www/us/en/developer/articles/technical/software-security-guidance/technical-documentation/host-firmware-speculative-side-channel-mitigation.html
- [109]Wang, W., Li, M., Zhang, Y., & Lin, Z. (2023). PwrLeak: Exploiting Power Reporting Interface for Side-Channel Attacks on AMD SEV. Proceedings of the 20th International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment.
- [110]Confidential Computing Consortium. (2022). Confidential Computing: Hardware-Based Trusted Execution for Applications and Data: November 2022, V1.3. In Last accessed: September, 2025. https://confidentialcomputing.io/wp-content/uploads/sites/10/2023/03/CCC_outreach_whitepaper_updated_November_2022.pdfconfidentialcomputing.io/wp-content/uploads/sites/10/2023/03/CCC_outreach_whitepaper_updated_November_2022.pdf
- [112]Stavrakakis, D., Giantsidi, D., Bailleu, M., Sändig, P., Issa, S., & Bhatotia, P. (2023). Anchor: A Library for Building Secure Persistent Memory Systems. Proc. ACM Manag. Data, 1(4). https://doi.org/10.1145/3626718











