💻 computer science

Secure Scattered Memory: Rethinking Secure Enclave Memory with Secret Sharing

This paper introduces Secure Scattered Memory (SSM), a novel scheme that replaces counter-based encryption with polynomial-based secret sharing to achieve full data confidentiality, integrity, and freshness with significantly lower hardware overhead and performance costs compared to existing secure enclave memory solutions.

Original authors: Haoran Geng, Yuezhi Che, Dazhao Chen, Michael Niemier, Xiaobo Sharon Hu

Published 2026-02-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Haoran Geng, Yuezhi Che, Dazhao Chen, Michael Niemier, Xiaobo Sharon Hu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a incredibly valuable secret, like the master key to a bank vault. You need to store this key in a cloud server, but you don't trust the server owner. You know they might try to steal the key, swap it with a fake one, or even pretend they have the key from yesterday (a "replay attack") to trick the system.

This is the problem computer scientists face with Secure Memory. They need to protect data stored on remote servers so that even if a hacker controls the server, they can't read, steal, or trick the data.

The Old Way: The "Locked Diary" Problem

For years, the standard way to protect this data was like putting your diary in a locked box (encryption) and adding a wax seal (integrity check).

The Problem with Simple Locks: Some systems just use a lock (like AES-XTS). It's fast, but if a hacker steals the diary, they can swap it with a fake one, and the system won't know.
The Problem with Wax Seals: Other systems add a wax seal (like AES-GCM). This stops fakes, but it's still vulnerable to "replay attacks." Imagine a hacker recording you opening the door today, then playing that recording back tomorrow to trick the system into thinking it's still today.
The "Merkle Tree" Solution: The most secure systems (like SGXv1) use a massive, complex tree of wax seals. Every time you touch the diary, you have to climb up and down this tree to verify every seal.
- The Catch: It's incredibly slow. It's like having to check 20 different security cameras every time you want to read a single sentence. This slows down the computer significantly.

The New Idea: "Secure Scattered Memory" (SSM)

The authors of this paper, Haoran Geng and his team, asked a simple question: "Why do we need a separate lock and a separate seal? Why not make the data itself the lock and the seal?"

They invented a new system called Secure Scattered Memory (SSM). Here is how it works, using a simple analogy:

The "Jigsaw Puzzle" Analogy

Imagine your secret data is a beautiful, complete picture.

Old Method: You put the picture in a safe, write down a serial number, and keep a log of every time you open the safe.
SSM Method: You take that picture, cut it into 100 tiny, random pieces. But here's the magic: You don't just cut it; you mix in 100 pieces of "noise" (fake puzzle pieces) that look exactly like the real ones.

Now, you scatter these 200 pieces all over the floor (the memory).

Confidentiality (Secrecy): If a thief picks up 50 pieces, they see nothing but random noise. They can't see the picture. They need a specific number of pieces (say, 10) to even start guessing what the picture looks like.
Integrity (Truth): If a thief tries to swap one of your real pieces with a fake one, the puzzle won't fit together anymore. When you try to put the pieces back together, the picture comes out distorted, and the system knows, "Hey, someone tampered with this!"
Freshness (Anti-Replay): Every time you write new data, you don't just update the pieces; you move them to new locations on the floor and mix in new noise.
- If a hacker tries to use the old pieces they stole yesterday, they are looking in the wrong spots. The system says, "I'm looking at the new spots; those old pieces are useless now."

Why is this a Big Deal?

The paper shows that this "puzzle" method is actually faster than the old "climbing the tree" method, while being just as secure.

Speed: The old secure systems were like a delivery truck that had to stop at 20 different houses to drop off a package. SSM is like a drone that drops all the pieces at once. The experiments showed SSM is 40% faster than the best previous high-security methods.
Efficiency: It doesn't need a massive "logbook" (Merkle Tree) to keep track of everything. The data is the logbook.
Hardware: They built a physical chip prototype. It's tiny (smaller than a fingernail) and doesn't use much power.

The Bottom Line

Think of Secure Scattered Memory as a magic trick where the data is so well-hidden in a pile of junk that a thief can't find it, and if they try to mess with it, the whole pile falls apart.

It solves the age-old trade-off between speed and security. For a long time, you had to choose: "Fast but risky" or "Safe but slow." This new system says, "You can have both." It's a smarter, faster way to keep our digital secrets safe in the cloud.

1. Problem Statement

The migration of workloads to the cloud necessitates secure memory systems that guarantee confidentiality, integrity, and freshness (protection against replay attacks). Existing solutions face a critical trade-off between security and performance:

Weak Security, High Performance: Schemes like AES-XTS and AES-GCM offer low overhead but lack robust integrity protection or replay attack resistance (e.g., AES-XTS has no integrity check; AES-GCM lacks monotonic counters).
Strong Security, High Overhead: Schemes like SGXv1-like (using AES-CTR with Version Numbers, MACs, and Merkle Trees) provide comprehensive protection. However, they suffer from severe performance bottlenecks due to:
1. Version Number (VN) Updates: Frequent reads/writes of VN blocks increase memory bandwidth.
2. Merkle Tree (MT) Traversal: Verifying integrity requires traversing tree nodes, causing significant memory traffic (up to 20+ additional accesses per verification).
3. Cache Inefficiency: VNs often reside in the Last-Level Cache (LLC) or off-chip, leading to high miss rates, especially for irregular access patterns (e.g., graph algorithms).

Current optimizations (e.g., Morphable Counters, VN caching, hybrid designs) attempt to mitigate these issues but often introduce hardware complexity, require system modifications, or fail to provide uniform security against replay attacks.

2. Methodology: Secure Scattered Memory (SSM)

The authors propose Secure Scattered Memory (SSM), a novel architecture that replaces traditional encryption-based metadata management with Secret Sharing.

Core Concept

Instead of encrypting data and storing separate metadata (VNs, MACs, MT nodes), SSM decomposes a data block into multiple cryptographically independent shares using Shamir's Secret Sharing (SSS).

Data Segmentation: A 64-byte data block is split into segments and used as coefficients for a polynomial $f(x)$ . Random coefficients (seeds) are added for integrity.
Share Generation: The polynomial is evaluated at random points to generate $N$ shares.
Storage: These shares are scattered across memory. A single share reveals no information about the original data.
Reconstruction: To read data, the system retrieves $K$ shares (where $K > t$ , and $t$ is the threshold). It uses Lagrange Interpolation over a Galois Field to reconstruct the polynomial and recover the original data.

Key Architectural Components

Dynamic Share Regeneration (Freshness): To prevent replay attacks, SSM regenerates shares and remaps them to new physical locations on every write operation. This eliminates the need for explicit Version Numbers or Merkle Trees. An attacker replaying old shares fails because the system looks for shares at the new locations defined by the updated page table.
Address Mapping & Locality: SSM employs a specialized mapping strategy where consecutive virtual addresses map to the same set of physical memory blocks but select different share indices. This exploits spatial locality to improve cache hit rates.
Hardware Implementation:
- SSM TLB: Caches the mapping from data addresses to share locations to reduce page walks.
- Shares Cache: A dedicated cache within the memory controller stores recently fetched shares to avoid DRAM access.
- Data Processing Unit: Contains modules for polynomial generation, evaluation, reconstruction, and Lagrange interpolation.

3. Key Contributions

Paradigm Shift: Moves away from counter-based encryption to polynomial-based secret sharing, integrating confidentiality, integrity, and freshness into the data structure itself.
Elimination of Metadata Overhead: Removes the need for Version Numbers, MACs, and Merkle Trees, thereby eliminating the associated memory traffic and storage overhead.
Hardware Feasibility: Implemented and synthesized in a 28nm commercial PDK using Cadence Genus. The design occupies 0.27 mm² and consumes 284.53 mW.
Comprehensive Security: Provides information-theoretic confidentiality and integrity. It guarantees freshness through dynamic relocation, making replay attacks statistically infeasible without access to the on-chip mapping.

4. Experimental Results

The authors evaluated SSM using the Gem5 simulator with a 4-core X86 system and 32GB secure memory, comparing it against AES-XTS, AES-GCM, and state-of-the-art SGXv1-like optimizations (MorphCTR, EMCC, RMCC, COSMOS, etc.).

Performance Overhead:
- Compared to AES-XTS: Only 10% overhead.
- Compared to AES-GCM: Only 8% overhead.
- Compared to Morphable Counter (MorphCTR): Up to 40% better performance.
- Compared to EMCC/RMCC: 12% better performance.
- Compared to COSMOS: 3% better performance.
Memory Access Efficiency:
- SSM reduces memory access overhead significantly compared to SGXv1-like schemes. While SGXv1-like incurs >25x normalized memory access in graph benchmarks due to MT traversal, SSM stays under 5.5x.
- Cache Hit Rates: SSM's shares cache achieves significantly higher hit rates (reducing miss rates by ~30% on average) for irregular workloads (e.g., Graph BFS/DFS) compared to VN caches in SGXv1-like systems.
Security Analysis:
- With parameters $N=9$ and $K=56$ , the probability of an attacker successfully guessing the correct $t$ shares is negligible ( $P \approx 2.8 \times 10^{-11}$ ).
- The system provides AES-256 equivalent security while maintaining high performance.

5. Significance

This paper presents a fundamental rethinking of secure memory design. By leveraging secret sharing, SSM successfully breaks the traditional trade-off between strong security (replay resistance, integrity) and performance.

Scalability: Unlike SGXv1-like schemes which struggle with large memory capacities due to MT overhead, SSM scales efficiently to 32GB and beyond.
Versatility: It works effectively for both regular (ML) and irregular (Graph) workloads without requiring specialized hardware accelerators or software modifications.
Practicality: The 28nm synthesis results demonstrate that the complex mathematical operations (polynomial interpolation) can be implemented with minimal area and power cost, making it a viable candidate for next-generation secure enclaves.

In conclusion, SSM offers a robust, high-performance alternative to current secure memory standards, providing full protection against replay and tampering attacks while minimizing the performance penalties that have historically hindered widespread adoption of strong memory encryption.