RIDL: Rogue In-flight Data Load
Stephan van Schaik, Sebastian Österlund
Overview
In this insightful talk, Sebastian Österlund and Stephan van Schaik unveil RIDL (Rogue In-flight Data Load), a new and unsettling class of speculative execution attacks that fundamentally challenges the security paradigms established after previous vulnerabilities like Meltdown and Spectre. RIDL, also known by Intel as Microarchitectural Data Sampling (MDS), demonstrates the ability to leak sensitive data directly from various internal CPU buffers, rather than just the well-understood cache hierarchy. This distinction is critical, as it allows RIDL to bypass all existing software and hardware mitigations that primarily focus on isolating or masking memory addresses.

Key moments
- 4:20 RIDL leaks root password on mitigated system
- 5:30 RIDL's "no boundaries" and address-agnostic nature
- 7:25 RIDL affects all mainstream Intel CPUs since 2008
- 9:30 RIDL leaks from internal CPU buffers like Line Fill Buffers
- 18:15 Leaking root password hash from co-located cloud VMs
- 22:00 RIDL attacks in web browsers using demand paging
- 24:00 Intel's proposed mitigations and the need for fundamental fixes
- 29:00 Conclusion: RIDL's broad impact and future challenges
RIDL: Rogue In-flight Data Load
Speakers: Stephan van Schaik, Sebastian Österlund
Conference: OFFZONE
YouTube: https://www.youtube.com/watch?v=baXY8NezHE0
Overview
In this insightful talk, Sebastian Österlund and Stephan van Schaik unveil RIDL (Rogue In-flight Data Load), a new and unsettling class of speculative execution attacks that fundamentally challenges the security paradigms established after previous vulnerabilities like Meltdown and Spectre. RIDL, also known by Intel as Microarchitectural Data Sampling (MDS), demonstrates the ability to leak sensitive data directly from various internal CPU buffers, rather than just the well-understood cache hierarchy. This distinction is critical, as it allows RIDL to bypass all existing software and hardware mitigations that primarily focus on isolating or masking memory addresses.
The talk meticulously details how RIDL operates by exploiting the transient data present in these undocumented internal buffers, such as Line Fill Buffers (LFBs), during speculative execution. The speakers illustrate the profound implications of this attack, showing how data can be exfiltrated across nearly all security boundaries, including between hyper-threads, from the kernel, across virtual machines (VMs), from hypervisors, and even from Intel SGX enclaves. Furthermore, they demonstrate a practical attack within a web browser environment, highlighting the pervasive threat.
RIDL's significance lies in its broad impact: it affects all mainstream Intel CPUs manufactured since 2008, including the 9th generation processors that Intel had previously marketed as having "in-silicon mitigations" against certain speculative execution flaws. The research underscores that despite previous efforts, the underlying microarchitectural design flaws persist, demanding more fundamental, hardware-level redesigns rather than incremental software patches. The speakers not only present the technical intricacies of the attack but also delve into the challenging disclosure process with Intel and the complex, often incomplete, proposed mitigations.
Background
▶ Watch: RIDL leaks root password on mitigated system (4:20)
The evolution of modern CPU architectures, particularly the relentless pursuit of performance, has introduced complex features like speculative execution and caching. While these innovations significantly enhance speed, they have also opened doors to novel security vulnerabilities. To understand RIDL, it’s crucial to first grasp the principles of cache attacks and the preceding speculative execution vulnerabilities.
At its core, a CPU relies on a hierarchy of memory. Registers are incredibly fast but scarce, while main memory is vast but slow. Caches, smaller and faster memory units, bridge this gap. A cache hit (data found in cache) is fast, while a cache miss (data not in cache, requiring main memory access) is slow. Cache attacks, such as Flush+Reload, exploit this time difference. An attacker first flushes a shared memory region from the cache, forcing subsequent accesses to be slow. A victim then accesses data, potentially loading part of the shared region into the cache. Finally, the attacker reloads the region, timing each access. A fast reload reveals which specific data the victim accessed, thereby leaking information.
Building on cache attack principles, speculative execution attacks emerged, notably Meltdown and Spectre in 2018. Meltdown exploited a vulnerability where the CPU would speculatively execute instructions that accessed kernel memory, even if those instructions would eventually be deemed unauthorized and rolled back. During this transient execution window, the kernel data would be brought into the Level 1 Data Cache (L1 D-cache). An attacker could then use a Flush+Reload-like technique to infer the leaked kernel data. The primary mitigation for Meltdown was Kernel Page Table Isolation (KPTI), which separated the user and kernel address spaces, making kernel memory inaccessible from user mode during normal operation. Spectre, on the other hand, leveraged branch prediction units to trick the CPU into speculatively executing incorrect code paths, again leaking data through cache side channels. Its mitigations involved array index masking and other software-based defenses. Foreshadow, another related attack, extended these concepts to leak data from physical addresses and Intel SGX enclaves.
The common thread among these prior attacks is their reliance on addressing. Meltdown exploited virtual addresses, Spectre exploited out-of-band addresses, and Foreshadow exploited physical addresses. Consequently, mitigation efforts focused on isolating, unmapping, or masking these addresses to prevent unauthorized speculative access. However, as Sebastian Österlund and Stephan van Schaik reveal, RIDL operates on a fundamentally different principle: it does not depend on addressing at all. This crucial distinction renders all existing address-based security checks and mitigations ineffective against RIDL, opening up a new and largely unmitigated attack surface. The presenters highlight that while previous attacks were considered severe, RIDL bypasses the very foundations of their countermeasures.
The scope of RIDL's impact is also a significant concern. The researchers systematically tested a wide array of Intel and AMD CPUs across generations dating back to 2008. Their findings confirm that RIDL successfully exploits all mainstream Intel CPUs tested, including the latest 9th generation Coffee Lake Refresh processors like the Intel Core i9-9900K, which were supposed to include "in-silicon mitigations" against Meltdown and Foreshadow. This indicates that these hardware-level fixes were insufficient for the newly discovered class of vulnerabilities. Crucially, their extensive testing confirmed that AMD CPUs were not affected by RIDL, a fact corroborated by an official statement from AMD. Similarly, ARM CPUs were also found to be immune to this specific vulnerability. This highlights a particular architectural characteristic present in Intel CPUs that makes them susceptible to RIDL.
Key Findings
▶ Watch: RIDL affects all mainstream Intel CPUs since 2008 (7:25)
The research presented on RIDL uncovers several critical findings that reshape our understanding of speculative execution vulnerabilities and CPU security:
- New Class of Speculative Execution Attacks: RIDL introduces a novel class of speculative execution attacks, dubbed Microarchitectural Data Sampling (MDS) by Intel. Unlike previous attacks that primarily exploited data held in traditional caches, RIDL targets various internal CPU buffers, such as Line Fill Buffers (LFBs), store and forward buffers, and load ports. This shift in target location is fundamental to its ability to bypass existing defenses.
- Bypasses Existing Mitigations: A cornerstone finding is that RIDL does not rely on memory addressing. This means it completely bypasses all current address-based security checks and mitigations, including Kernel Page Table Isolation (KPTI), array index masking, and physical address invalidation, which were implemented to counter Meltdown, Spectre, and Foreshadow. This makes RIDL exceptionally difficult to mitigate using traditional software-based approaches.
- Cross-Domain Data Leakage: RIDL exhibits unprecedented capability to leak data across virtually all security domains. This includes leaking between hardware threads (hyper-threads), from the kernel, across different Virtual Machines (VMs), from the hypervisor itself, and even from isolated Intel SGX enclaves. This comprehensive breach of isolation underscores the severity of the vulnerability.
- Pervasive Intel CPU Vulnerability: The researchers conducted extensive testing across numerous CPU generations and confirmed that all mainstream Intel CPUs since 2008 are vulnerable to RIDL. This includes the latest 9th generation processors, such as the Intel Core i9-9900K, which were advertised with hardware-level mitigations against previous speculative execution attacks. This demonstrates that those "in-silicon" fixes were not sufficient for this new class of vulnerabilities.
- AMD and ARM Immunity: In contrast to Intel, extensive testing confirmed that AMD and ARM CPUs are not affected by RIDL. This was also officially acknowledged by AMD, indicating a specific microarchitectural design difference that provides resilience against this attack vector.
- Web Browser Exploitation: RIDL can be exploited even within highly constrained environments like web browsers. The speakers demonstrated successful data leakage from Mozilla Firefox using WebAssembly, requiring no special instructions like
CLFLUSHorTSXtransactions. This significantly expands the attack surface, making users vulnerable to malicious JavaScript or WebAssembly served via ads or compromised websites. - Fundamental Microarchitectural Flaw: The existence of RIDL points to a deep-seated, fundamental design flaw within Intel's microarchitecture where internal buffers are not properly sanitized or zeroed out after transient use. This suggests that the current approach of "spot mitigations" for individual vulnerabilities is unsustainable and that a more holistic, hardware-level redesign is necessary for long-term security.
Technical Deep Dive
▶ Watch: Leaking root password hash from co-located cloud VMs (18:15)
The technical core of RIDL lies in its exploitation of internal CPU buffers, specifically the Line Fill Buffers (LFBs), during speculative execution. Unlike traditional caches, these buffers are often undocumented and serve critical roles in optimizing CPU performance.
Understanding Line Fill Buffers (LFBs):
LFBs are essential, undocumented buffers situated between the CPU's execution units and its cache hierarchy. Their primary function is to improve memory throughput by handling asynchronous memory requests. When the CPU encounters a cache miss (i.e., requested data is not in any cache level), it doesn't immediately halt execution. Instead, it allocates an entry in an LFB to track the pending memory request. This allows the CPU to continue executing other instructions or serving other loads and stores while waiting for the data to return from main memory. Once the data arrives, it is written into the LFB and then typically moved to the L1 cache.
The RIDL Exploitation Mechanism:
The vulnerability arises from the fact that these LFB entries are not consistently zeroed out or sanitized after use. When a memory request completes and its data is consumed, the LFB entry might still retain "stale" data from that previous operation. RIDL exploits this by combining speculative execution with this LFB characteristic:
- Flush Caches: Similar to traditional cache attacks, the attacker first ensures that the probe array (a memory region used to detect cache hits) is evicted from all caches, forcing subsequent accesses to be slow.
- Triggering Speculative Execution with an Invalid Address: The attacker then attempts to read from an invalid or unmapped memory address (e.g., a null pointer dereference). Under normal circumstances, this would cause a fault and terminate the program. However, due to speculative execution, the CPU might proceed to execute subsequent instructions before the fault is fully resolved.
- Data Sampling from LFB: During this speculative window, because the CPU cannot retrieve data from the invalid address, it may transiently use "in-flight" data from an LFB entry. This LFB entry might contain sensitive, stale data from a previous operation (e.g., a kernel read, a password hash load) that was performed by a co-located process or even a different security domain on the same hyper-thread.
- Side-Channel Leakage: The CPU then speculatively uses this sampled LFB data as an offset to access the attacker's probe array. If the sampled data matches a specific value, it will cause a cache hit in a particular location of the probe array.
- Reload and Inference: Finally, the attacker performs a reload phase, timing accesses to the probe array. A faster access time indicates which offset was hit, thereby revealing one byte of the sensitive data that was transiently present in the LFB.
Practical Attack Program Flow:
The core RIDL attack program, as described, involves:
- Evicting the probe array from caches.
- Initiating a Transactional Synchronization Extensions (TSX) transaction. While not strictly necessary (demand paging can also be used, as shown in the browser attack), TSX allows suppressing faults when dereferencing an unmapped address. This enables the speculative execution to proceed further without immediately crashing.
- Performing a read from a null or unmapped pointer.
- Using the transiently leaked value (from the LFB) as an offset into the probe array.
- Timing accesses to the probe array to identify the leaked byte.
The "Firehose" Problem and Data Filtering:
A key challenge with RIDL is that it leaks a continuous stream of "in-flight" data from the LFB, akin to "drinking from a firehose." This means the attacker receives a lot of noise alongside the target sensitive data. To make this practical, the researchers employ post-processing and pattern matching:
- Repeated Measurements: The attack is performed multiple times to gather a large set of sampled data.
- Pattern Matching: For specific targets, like the root password hash from
/etc/shadow, attackers know the expected prefix (e.g.,root:followed by a semicolon). They filter the sampled data, retaining only measurements that are consistent with this known prefix. By iteratively matching and extending the known pattern with newly leaked bytes, the full sensitive string can be reconstructed over many measurements. This process effectively filters out the noise and isolates the desired information.
This detailed understanding of LFB behavior and the speculative execution pipeline is what allowed the researchers to craft RIDL, demonstrating a potent new avenue for microarchitectural attacks that sidesteps all existing address-centric defenses.
Demo / Proof of Concept
▶ Watch: RIDL attacks in web browsers using demand paging (22:00)
The speakers demonstrated the versatility and severity of RIDL through several compelling proof-of-concept attacks, progressively escalating in complexity and impact:
- Local Root Password Hash Leak:
- Goal: To leak the root user's password hash from the
/etc/shadowfile on a Linux system as an unprivileged user. - Mechanism: The attacker first ensures their process is co-located on the same hyper-thread as the
passwdutility usingtaskset. Thepasswdutility, when invoked to change a password, reads the/etc/shadowfile, which contains the hashed passwords for all users, including root. By repeatedly invokingpasswd, the sensitive data from/etc/shadowis continuously brought into the CPU's Line Fill Buffers (LFBs). The attacker then executes the RIDL attack program from the co-located hyper-thread, sampling the in-flight data from the shared LFBs. Through repeated measurements and pattern matching (looking for theroot:prefix), the full root password hash is reconstructed. This demonstrates a clear privilege escalation from an unprivileged local user.
- Cloud VM SSH Credential Leak:
- Goal: To leak the root password hash from a victim VM running in a cloud environment, from an attacker VM.
- Mechanism: This attack leverages the common practice in cloud environments where different VMs from different tenants might share physical CPU cores and thus hyper-threads and LFBs. The attacker provisions a VM and ensures it is co-located with a victim VM. The victim VM runs an SSH server, a common service. The attacker VM then repeatedly attempts to establish SSH connections to the victim. Each SSH connection attempt on the victim VM triggers a read of
/etc/shadowfor authentication, causing the root password hash to pass through the LFBs. The attacker VM, running the RIDL exploit on the shared hyper-thread, can then sample this in-flight data and reconstruct the password hash, effectively breaching the isolation between cloud tenants.
- Arbitrary Kernel Read (Spectre + RIDL Combination):
- Goal: To achieve an arbitrary kernel memory read, demonstrating how RIDL can be combined with other speculative execution techniques.
- Mechanism: This PoC combines elements of Spectre with RIDL. It exploits Spectre gadgets to force arbitrary kernel data into the LFBs. The attack involves branch predictor training:
- The attacker repeatedly calls a system function like
setrlimitwith a valid user pointer. This trains the CPU's branch predictor to follow a specific code path within the kernel (e.g., insidecopy_from_user). - Then, the attacker calls
setrlimitwith an invalid kernel pointer. Due to the trained branch predictor, the CPU speculatively takes the "expected" path, attempting to copy data from the invalid kernel pointer. - During this speculative execution, the arbitrary kernel data from the invalid address is transiently loaded into the LFBs. Although the speculative execution will eventually be rolled back due to the invalid address, the data has already passed through the LFBs.
- The RIDL attack then samples this in-flight data from the LFBs, effectively achieving an arbitrary kernel read.
- Web Browser Leak (Mozilla Firefox):
- Goal: To demonstrate data leakage from a web browser environment, highlighting the threat from malicious web content.
- Mechanism: This PoC adapts RIDL for a highly constrained environment where privileged instructions like
CLFLUSH(for cache eviction) andTSXtransactions (for fault suppression) are unavailable. - Cache Eviction: Instead of
CLFLUSH, an Evict+Reload technique is used, which floods the cache with attacker-controlled data to evict target data. - Fault Suppression: Instead of TSX, the attack leverages demand paging. The attacker attempts to read from a memory page that has been allocated but not yet mapped (i.e., accessed for the first time). When the CPU speculatively tries to access this "new page," it will temporarily use LFB data before the page fault is fully resolved.
- The attack code was generated from WebAssembly, demonstrating that malicious code embedded in web pages (e.g., through ads) could exploit this vulnerability to steal sensitive data from the browser's process. The speakers had an animation prepared for this, as the live demo could not be shown due to technical issues.
These demonstrations collectively illustrate RIDL's capability to breach isolation across various security domains, from local systems to cloud environments and even the web, affirming its status as a critical and pervasive vulnerability.
Defensive Implications
▶ Watch: Conclusion: RIDL's broad impact and future challenges (29:00)
The discovery of RIDL and the broader class of Microarchitectural Data Sampling (MDS) attacks presents significant challenges for system defenders and CPU manufacturers alike. The fact that RIDL bypasses existing address-based mitigations means a fundamental rethinking of security strategies is required.
Intel's Proposed Mitigations (and their limitations):
Intel has proposed different mitigation strategies depending on whether the RIDL attack occurs within the same hardware thread or across hyper-threads:
- Same-thread RIDL Mitigation:
- For attacks originating and executing on the same logical processor (i.e., not involving hyper-threading), Intel introduced the
VERWinstruction. This instruction, or specific assembly snippets that achieve similar functionality, aims to flush the affected internal CPU buffers (like LFBs). - Deployment: This mitigation requires microcode updates from Intel. Systems without the newest microcode can use software-based assembly snippets. While relatively straightforward, it still requires system administrators to apply updates and might incur some performance overhead due to the flushing operations.
- Cross-thread RIDL (Hyper-threading) Mitigation:
- This is significantly more complex because it involves coordinating security domains across two logical processors sharing the same physical core. The core challenge is that sensitive data from one hyper-thread can leak to another.
- Complex Scheduling Policies: Intel proposed intricate scheduling policies. The core idea is that hyper-threads should never be in different security domains simultaneously. For example, if one hyper-thread enters the kernel, the other must also be in the kernel or wait to leave its current security domain until the first one exits the kernel. This requires the operating system's scheduler to be aware of and actively manage the security domain of each hyper-thread.
- Overhead and Implementation Difficulty: The speakers emphasize that such complex scheduling policies are extremely difficult to implement correctly and efficiently. They anticipate significant performance overhead due to the forced synchronization and waiting periods. At the time of the talk, these policies were not fully implemented or deployed, with only preliminary Linux kernel patches observed.
- Immediate Recommendation: Given the complexity and incomplete deployment of cross-thread mitigations, the most immediate and effective defensive measure recommended by the speakers is to disable Hyper-threading entirely. While this comes with a performance penalty (typically 20-30% reduction in throughput), it completely eliminates the cross-thread leakage vector for RIDL.
Broader Implications and Long-Term Outlook:
- "Spot Mitigations" vs. Fundamental Fixes: The speakers critically point out that current mitigations, including those for RIDL, are essentially "spot mitigations." They address specific, discovered vulnerabilities in isolated buffers but do not tackle the underlying architectural design philosophy that allows such transient data leakage. The intricate diagrams of Intel's microarchitecture presented highlight the sheer complexity and the likelihood that many other internal buffers or transient execution pathways could harbor similar, undiscovered vulnerabilities.
- Need for Hardware Redesign: The ultimate solution, according to the researchers, requires a more fundamental, hardware-level redesign of CPUs to ensure that internal buffers are properly sanitized or zeroed out after use, preventing any transient data from being exposed. However, such hardware changes take years to design, validate, and deploy, meaning current systems will remain vulnerable to variations of these attacks for the foreseeable future.
- Risk of Exploitation in the Wild: While speculative execution attacks like Spectre and Meltdown were initially academic curiosities, the code for RIDL and its variants is now publicly available. The speakers warn that it is only a matter of time before malicious actors adapt these techniques to create real-world exploits, making proactive defense crucial.
- Verification Tools: To assist defenders, Stephan van Schaik developed a valuable tool that allows users to check their systems for vulnerability to Meltdown, Foreshadow, and RIDL. This empowers users and administrators to assess their risk and verify the effectiveness of applied mitigations.
In essence, RIDL serves as a stark reminder that the pursuit of performance in CPU design has inadvertently introduced deep-seated security challenges that require a paradigm shift in how microarchitectural security is approached.
Key Takeaways
- RIDL (Microarchitectural Data Sampling) is a new class of speculative execution attacks that leaks sensitive data from internal CPU buffers, not just traditional caches.
- It bypasses all existing address-based security mitigations (e.g., KPTI for Meltdown) because it does not rely on memory addressing for exploitation.
- All mainstream Intel CPUs since 2008 are vulnerable, including the 9th generation processors with "in-silicon mitigations"; AMD and ARM CPUs are not affected.
- RIDL can leak data across all security domains, including between hyper-threads, from the kernel, across VMs, from the hypervisor, from SGX enclaves, and even from within web browsers via WebAssembly.
- Mitigations are complex and often involve significant trade-offs, such as disabling Hyper-threading (recommended for cross-thread attacks) or incurring performance overhead from buffer flushing instructions.
- The vulnerability points to a fundamental microarchitectural design flaw that requires long-term hardware redesigns rather than continuous "spot mitigations" for individual buffer types.
About the Speaker(s)
Stephan van Schaik and Sebastian Österlund presented RIDL on behalf of the research group that discovered it, describing themselves in the talk as PhD students. Van Schaik is credited in the talk with writing a tool to check systems for speculative-execution vulnerabilities, including Meltdown, Foreshadow and RIDL.
Reviews
Dr. Zero (Offensive Security Researcher) — MUST SEE
This is foundational MDS research that broke Intel's post-Meltdown narrative and forced an entirely new class of mitigations. Van Schaik and Österlund demonstrated that address-based defenses were a category error — RIDL leaks from LFBs, not caches, and Intel's 9th-gen 'in-silicon fixes' didn't touch it. The cross-domain leakage demos are brutal and the browser PoC via WebAssembly closes the 'but it needs local code execution' escape hatch.
Heather Calloway (CISO) — STRONG ACCEPT
This is foundational CPU vulnerability research that every CISO with Intel infrastructure needs to understand. RIDL bypasses all prior speculative execution mitigations by targeting internal buffers rather than cache, affecting every Intel chip since 2008. The immediate decision point: disable hyper-threading on sensitive workloads until your microcode and OS patches are verified.