Architecture Agnostic Confidential Computing

This direction is split into other directions: hardware-dependent security. Its last version stays readable and citable here.

Version 1 of 1134 papers135 conceptsfrozen 2026-10-04

Modern security relies on a "root of trust"—a foundational piece of hardware or software that is assumed to be secure. In the last decade, this has largely meant Trusted Execution Environments (TEEs) like Intel SGX, ARM TrustZone, and AMD SEV. However, as research across 109 papers reveals, the field is hitting a "portability wall." Because these security features are tied to specific hardware instructions, a system built for one processor cannot easily move to another.

The current research direction focuses on breaking this hardware lock-in to create Architecture-Agnostic Confidential Computing: security frameworks that provide the same high-level guarantees regardless of whether they are running on an Intel server, an ARM-based IoT device, or a custom AI accelerator.

The Portability Wall

The core problem is that hardware-anchored security is currently "siloed." As Xusheng Chen and colleagues note in their work on GEEC, protocols that rely on specific secure enclaves are restricted to narrow CPU ecosystems. This limits adoption in heterogeneous environments like the cloud, where a single application might need to scale across different hardware vendors.

This dependency creates three primary challenges:

  1. Vendor Lock-in: Systems like BFS, developed by Quinn Burke and others, are often optimized for a single implementation (e.g., Intel SGX), making porting to AMD SEV or ARM TrustZone a matter of significant re-engineering.
  2. Hardware Obsolescence: As proprietary technologies face deprecation or limited availability, systems relying on them become fragile.
  3. The Heterogeneity Gap: Low-end microcontrollers often lack the hardware-based isolation primitives found in server CPUs. As Zhichuang Sun points out in OEI, this prevents high-assurance security from reaching the full spectrum of embedded devices.

Strategy 1: Minimizing the Trusted Computing Base

One way to solve the portability problem is to use hardware as little as possible. Instead of running an entire application inside a TEE, researchers are developing hybrid architectures that use the enclave only for a tiny, critical "root" task.

A prime example is Otak, a system for private machine learning inference. Muqsit Nawaz and his team use TEEs only for a small preprocessing step, combining it with cryptographic multi-party computation (2PC). This reduces the Trusted Computing Base (TCB) by 15-30x. By shrinking the amount of code that must run on specific hardware, these systems become easier to port and more resilient to hardware-specific flaws.

Similarly, NNSplitter, proposed by Tong Zhou, protects deep learning models by obfuscating a tiny fraction (0.001%) of weights and storing only those "secrets" in secure hardware. This "active defense" minimizes the hardware dependency while maintaining high security.

Strategy 2: Software-Based Roots of Trust

If hardware is the bottleneck, why not replace it with software? This is the intuition behind SAGE, developed by Andrei Ivanov and Torsten Hoefler. SAGE provides a software-based attestation mechanism for GPUs, establishing a dynamic root-of-trust through precise timing and optimized verification functions rather than specialized silicon.

While software-based methods often face their own portability issues—such as relying on undocumented instruction sets—they offer a path toward securing "legacy" hardware. Josep Torrellas explores this in Maya, using operating system-level control theory to mask power side-channels, protecting billions of existing devices that lack built-in hardware defenses.

Strategy 3: Abstraction Layers and Runtime Logic

The most direct approach to the portability wall is the creation of custom runtimes that "shield" the application from the underlying hardware. Guangmin Hu and the team behind SeSeMI introduced a custom enclave runtime and model-packing scheduler. This layer acts as a translator, allowing secure model inference to run efficiently across different cloud providers without requiring the developer to rewrite the attestation logic for every new environment.

The Path Forward

The research indicates a shift away from "Intel-only" or "ARM-only" security toward a unified trust model. Whether through hybrid cryptographic-hardware systems like Otak or software-based attestation like SAGE, the goal is to make confidentiality a property of the software architecture rather than a feature of the chip. As Aritra Dhar suggests in the context of NPUs in Ascend-CC, the future of the field lies in developing vendor-neutral security standards that can survive the rapid evolution of heterogeneous computing.

Papers in this version

Showing 60 of 134 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_architecture_agnostic_confidential_compu_b31b7096,
  title = {Architecture Agnostic Confidential Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/architecture-agnostic-confidential-computing/rdr_b31b7096a6d54dbf95465d2949c372b1},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_architecture_agnostic_confidential_compu_b31b7096_v1,
  title = {Architecture Agnostic Confidential Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/architecture-agnostic-confidential-computing/rdr_b31b7096a6d54dbf95465d2949c372b1/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}