The Blind Spot of Cache Security
Traditional cache side-channel defenses operate under a fundamental assumption: information only leaks when data is evicted. If an attacker can force a victim's data out of the cache (or vice versa), the resulting timing difference between a cache hit and a cache miss creates an observable side channel. To block this, modern secure architectures use techniques like cache partitioning or line locking to ensure a process's data cannot be displaced by an adversary.
However, this focus on data eviction creates a dangerous blind spot. Caches are not just passive arrays of data; they rely on complex internal metadata to manage performance, such as way predictors and replacement policy states (e.g., Least-Recently Used, or LRU). This metadata updates dynamically on every cache hit, creating a stealthy, high-speed side channel that completely bypasses eviction-based defenses.
Exploiting the LRU Stack via Cache Hits
To understand why this works, consider a standard set-associative cache using an LRU replacement policy. The cache must track the relative recency of accesses within a set to decide which line to evict next. When a process accesses a piece of data already in the cache, no eviction occurs—it is a clean cache hit. However, the hardware silently updates the internal LRU bits, promoting that specific cache line to the "Most Recently Used" position and shifting the relative priorities of all other lines in the set.
As Wenjie Xiong et al. (2019) discovered, this shared metadata state can be exploited as a covert channel. Even if an architecture implements strict partition-locking to prevent an attacker from evicting a victim's data, the underlying replacement priority logic often remains shared and mutable.
In a subsequent work, Wenjie Xiong et al. (2021) demonstrated that an attacker can infer a victim's access patterns simply by observing how the priority of their own locked lines changes over time. Because this technique relies entirely on cache hits, it does not trigger the hardware performance counters or elevated miss rates that traditional security monitors look for, making it exceptionally fast and stealthy.
Initial State (Set Priority Stack):
[ Attacker Line (MRU) ] -> [ Victim Line ] -> [ Shared/Other Line (LRU) ]
Victim Accesses Victim Line (Cache Hit, No Eviction):
[ Victim Line (MRU) ] -> [ Attacker Line ] -> [ Shared/Other Line (LRU) ]
^
|-- Attacker's relative priority has changed!
Non-Commutativity and Access Reordering
The vulnerability of replacement metadata stems from a core mathematical property: cache replacement policies are typically non-commutative. If an application performs Access A and then Access B, the final state of the cache's internal tracking metadata will look fundamentally different than if it had performed Access B and then Access A.
This property opens the door to sophisticated exploitation via speculative execution. In their work on speculative interference attacks, Josep Torrellas et al. showed that mis-speculated instructions can be used to subtly alter the execution timing of older, non-speculative memory loads. By shifting when these loads execute relative to other operations, the attacker forces a secret-dependent reordering of cache accesses.
Because the replacement policy is non-commutative, this reordering leaves a persistent, measurable footprint in the cache metadata state. This attack successfully dismantles "invisible speculation" defenses, proving that even if speculative data modifications are completely rolled back, the temporal disruption leaves a permanent scar in the metadata.
Beyond LRU: Way Predictors and Randomization
This paradigm of metadata leakage extends beyond LRU bits to other microarchitectural optimizations. For instance, modern processors use way predictors to guess which cache way contains the requested data, reducing power consumption by avoiding a full parallel search. Moritz Lipp et al. successfully reverse-engineered the internal hash functions of AMD's L1 data cache way predictors. They demonstrated that hash collisions within the predictor itself could be leveraged to monitor memory accesses via novel "Collide+Probe" and "Load+Reload" techniques, entirely bypassing the need for shared memory or physical addresses.
Even defenses designed to randomize cache mappings are forced to grapple with the nuances of metadata tracking. As Wei Song et al. observed, prominent randomized cache designs like CEASER-S and ScatterCache remain vulnerable because their remapping triggers are fundamentally tied to tracking internal eviction counts rather than total accesses. This highlights a broader architectural reality: as long as security mechanisms treat the cache as a static data store rather than a dynamic state machine, metadata will continue to leak information.
Designing Metadata-Isolated Architectures
To fully secure modern processors against these threats, the hardware community must rethink how internal state is managed. Simply isolating data lines is insufficient; the metadata tracking state must be isolated or eliminated entirely.
The authors of these studies point to two primary paths forward. First, hardware designers can transition away from highly stateful replacement policies like LRU to simpler, non-stateful alternatives. As Wenjie Xiong et al. (2021) note, implementing First-In-First-Out (FIFO) or random replacement policies completely eliminates hit-based metadata side channels because these policies do not update internal state upon a cache hit. Crucially, this architectural shift incurs only a negligible performance penalty, offering a practical and robust blueprint for securing next-generation processors.
Key Foundational Work
Leaking Information Through Cache LRU States (2019) — contributed 6 concept elements to this direction.
Take A Way: Exploring the Security Implications of AMD's Cache Way Predictors (2020) — contributed 1 concept elements to this direction.
Randomized Last-Level Caches Are Still Vulnerable to Cache Side-Channel Attacks! But We Can Fix It (2020) — contributed 1 concept elements to this direction.