Is Spectre Dead Yet? Eight Years In, Hypervisors Still Pwnable

Johannes Wikner (Security Researcher · RISE)

SEC-T 2026 · Day 3 · Main hall

Overview

Eight years after the initial disclosure of Spectre, one of the most significant microarchitectural vulnerabilities in modern computing, the question of its demise remains pertinent. In this compelling talk at SEC-T, Johannes Wikner, a security researcher from RISE, unequivocally answers: "No, Spectre is not dead." Wikner's presentation unveils novel exploits targeting popular hypervisors, specifically FreeBSD Bhyve and Oracle VirtualBox, demonstrating that these critical virtualization layers remain susceptible to Spectre variant 2 (branch target injection) attacks. The research highlights a critical gap in the security posture of widely used hypervisors, enabling an unprivileged guest VM to leak arbitrary memory from the host system or even from other co-located guest VMs.

Watch on YouTube

Visual summary for Is Spectre Dead Yet? Eight Years In, Hypervisors Still Pwnable by Johannes Wikner
Visual summary for Is Spectre Dead Yet? Eight Years In, Hypervisors Still Pwnable by Johannes Wikner

Key moments

  1. 0:00 Introduction: Is Spectre Dead Yet?
  2. 5:30 Branch prediction: The CPU's 'secret sauce'
  3. 10:00 How Spectre attacks work: Mis-speculation and leaking secrets
  4. 18:00 Hypervisor mitigations: KVM vs. FreeBSD Bhyve & VirtualBox
  5. 27:00 Demo: Identifying host kernel memory (ASLR bypass)
  6. 37:00 Demo: Leaking arbitrary host memory (VirtualBox)
  7. 40:00 Demo: Cross-VM memory leak (FreeBSD Bhyve)
  8. 43:30 Conclusion: Spectre isn't dead, Oracle's response

Is Spectre Dead Yet? Eight Years In, Hypervisors Still Pwnable

Speakers: Johannes Wikner, Security Researcher, RISE

Conference: SEC-T

YouTube: https://www.youtube.com/watch?v=SN4RmcJlT5Q

Overview

Eight years after the initial disclosure of Spectre, one of the most significant microarchitectural vulnerabilities in modern computing, the question of its demise remains pertinent. In this compelling talk at SEC-T, Johannes Wikner, a security researcher from RISE, unequivocally answers: "No, Spectre is not dead." Wikner's presentation unveils novel exploits targeting popular hypervisors, specifically FreeBSD Bhyve and Oracle VirtualBox, demonstrating that these critical virtualization layers remain susceptible to Spectre variant 2 (branch target injection) attacks. The research highlights a critical gap in the security posture of widely used hypervisors, enabling an unprivileged guest VM to leak arbitrary memory from the host system or even from other co-located guest VMs.

This talk is not merely an academic exercise; it's a stark reminder of the persistent and evolving threat posed by microarchitectural side-channel attacks. Wikner's work, which includes exploits developed exclusively for this presentation, underscores that despite years of mitigation efforts, fundamental design flaws in modern processors continue to expose systems to severe confidentiality breaches. The implications are far-reaching, especially for cloud environments where hypervisors form the bedrock of tenant isolation, making the ability to compromise them a direct path to cross-VM information leakage and host compromise.

Background

▶ Watch: Introduction: Is Spectre Dead Yet? (0:00)

Microarchitectural security gained widespread attention around 2018 with the discovery of Spectre and Meltdown. These vulnerabilities exposed that while software enforces strict isolation between different privilege levels (e.g., user applications, operating systems, hypervisors), the underlying hardware's performance optimizations, particularly speculative execution, can inadvertently leak sensitive data. The microarchitecture is the specific implementation of an Instruction Set Architecture (ISA), and it includes components like branch predictors and caches that operate decoupled from the core execution logic to maximize CPU utilization.

The core of Spectre attacks lies in branch prediction. Modern CPUs predict the outcome of branches (conditional jumps, indirect calls, returns) to keep their pipelines full. If a prediction is wrong, the CPU discards the speculatively executed instructions, but their transient effects, such as modifications to the cache state, can still be observed. An attacker can mis-train a branch predictor to direct speculative execution to an arbitrary, attacker-controlled location within the victim's address space. This transient execution can then be combined with a disclosure gadget (a few instructions that perform a secret-dependent memory access) to transmit secrets via observable microarchitectural state changes, typically cache side channels (like flush+reload). Spectre variant 2, or Branch Target Injection (BTI), specifically focuses on manipulating the Branch Target Buffer (BTB) or Return Stack Buffer (RSB) to redirect indirect branches or returns.

Wikner elaborates on the complexity of branch prediction, especially for returns. The Return Stack Buffer (RSB) is a small, purely microarchitectural buffer (16-32 targets) that stores return addresses, analogous to the program stack but for performance. The Branch Target Buffer (BTB), with more targets (e.g., 1024 sets, 12 ways), stores branch targets and, crucially, branch type information. Mispredictions can occur in various forms: phantom branching (predicting a branch where none exists), straight-line speculation (predicting no branch where one exists), and red bleed (predicting an indirect branch where a return exists). The latter, where a return is mispredicted as an indirect branch, is a key focus of Wikner's exploit.

Addressing these issues has led to complex and often performance-impacting mitigations. In the Linux Kernel-based Virtual Machine (KVM), for instance, significant effort has been invested. When a guest VM exits to the host (e.g., due to an interrupt or a VM exit instruction), KVM performs several mitigations:

  • RSB Overwriting: The RSB is filled with dummy targets (e.g., 16 times) to prevent guest-injected predictions from affecting the host.
  • Return Untraining: Specific return instructions in the host are "untrained" to remove potential attacker-injected predictions.
  • Retpolines: Indirect branches are replaced with sequences of indirect jumps that are difficult to mis-train, effectively "bouncing" speculative execution away from attacker-controlled targets.
  • SRSO Thunks: Special "return thunks" are used instead of direct returns to mitigate SRSO (Spectre-RSB-Stack-Overflow), a vulnerability where return addresses can be leaked or corrupted.

However, Wikner's research reveals that other hypervisors have not adopted such comprehensive measures. FreeBSD Bhyve, for example, attempts some RSB clearing but still uses direct ret instructions that are vulnerable. Oracle VirtualBox is highlighted as having virtually no mitigations, presenting readily exploitable ret instructions. This disparity in mitigation strategies creates exploitable attack surfaces, even years after the initial Spectre disclosures.

Key Findings

▶ Watch: How Spectre attacks work: Mis-speculation and leaking secrets (10:00)

Johannes Wikner's research definitively demonstrates that Spectre variant 2 (Branch Target Injection) remains a potent threat to hypervisor security, specifically identifying critical vulnerabilities in FreeBSD Bhyve and Oracle VirtualBox. The primary findings are:

  • Persistent Vulnerability of Hypervisors: Despite years of awareness and mitigation efforts, popular hypervisors like FreeBSD Bhyve and Oracle VirtualBox exhibit insufficient or absent defenses against Spectre V2 attacks. This contrasts sharply with more robust mitigations found in KVM.
  • Exploitable Return Instructions: Both targeted hypervisors contain direct ret instructions in their VM exit paths that are susceptible to red bleed (misprediction of a return as an indirect branch), allowing an attacker to hijack speculative control flow.
  • Arbitrary Memory Leakage: The demonstrated exploits allow an unprivileged guest VM to leak arbitrary memory from the host system. This includes kernel memory, process arguments, environment variables, and even the contents of the host's page cache.
  • Cross-VM Data Exfiltration: The research further shows the ability to leak data from other co-located guest VMs, breaking fundamental isolation guarantees crucial for multi-tenant environments like cloud computing.
  • Novel ASLR Bypass Technique: A new method for bypassing Kernel ASLR (Address Space Layout Randomization) on the host was developed, leveraging the RSB to leak host kernel addresses from within the guest.
  • Practical Exploitability: The talk includes live demonstrations of the exploits on AMD Zen 2 processors, showcasing their practical feasibility and effectiveness.

These findings highlight that the "Spectre problem" is far from solved, especially outside of highly scrutinized environments like the Linux kernel. The discrepancy in mitigation adoption across different hypervisor implementations leaves a significant attack surface open for sophisticated attackers.

Technical Deep Dive

▶ Watch: Demo: Identifying host kernel memory (ASLR bypass) (27:00)

The technical core of Wikner's presentation revolves around a multi-stage exploit chain designed to achieve arbitrary memory leakage from the host or other guest VMs. The attack leverages the fundamental principles of Spectre V2, focusing on manipulating the Return Stack Buffer (RSB) and Branch Target Buffer (BTB) to hijack speculative execution. The exploits were developed for AMD Zen 2 processors, but the underlying vulnerabilities are microarchitectural and generally applicable to other architectures.

The exploitation process is broken down into three distinct stages:

Stage 1: Identifying the Host (Kernel ASLR Bypass)

The first challenge for any hypervisor exploit is bypassing Kernel Address Space Layout Randomization (KASLR) to locate the target code within the host's memory. Wikner introduces a novel technique for this, leveraging the RSB:

  1. Host RSB Population: The guest VM repeatedly triggers a VM exit (e.g., by executing a CPUID instruction). Each VM exit involves the hypervisor saving guest state, handling the intercept, and then returning to the guest. During this process, the host's call/return sequence pushes its own return addresses onto the RSB.
  2. Guest RSB Leakage: After the host has populated the RSB with its internal return addresses, the guest executes a ret instruction. Due to the nature of the RSB, this ret will speculatively fetch an address from the top of the RSB, which is now a host kernel address.
  3. Instruction Fetch and TLB Side Channel: The CPU's instruction fetch unit attempts to fetch code from this speculatively predicted host address. Crucially, this fetch occurs within the guest's virtual address space. If this host address maps to a region that the guest has mapped, a cache hit would occur. However, with 35 bits of entropy for kernel addresses, directly mapping and checking every possible address is infeasible.
  4. MMU/Page Table Leakage: Instead of directly observing cache hits on the code itself, the exploit targets the Memory Management Unit (MMU) and its Translation Lookaside Buffer (TLB). If the speculatively fetched host address does not have a TLB entry in the guest's context, the MMU performs a page table walk to translate the virtual address to a physical one. This page table walk involves accessing various levels of page tables (e.g., PML4, PDPT, PD, PT). Each access to a page table entry causes a cache line to be loaded. By observing cache hits on guest-controlled page table entries, the attacker can infer chunks (e.g., 9 bits at a time) of the host's virtual address. This significantly reduces the entropy, making KASLR bypass practical and fast.
  5. Target Identification: By leaking these host return addresses, the guest can identify the base address of the hypervisor's Virtual Machine Manager (VMM) module and the host kernel's base address. For FreeBSD Bhyve, which lacks KASLR, this stage primarily identifies the VMM module's load address. For VirtualBox, it successfully leaks both the VMM ring zero address and the kernel base.

Stage 2: Setting Up the Covert Channel

Once the host's memory layout is known, the next step is to establish a reliable covert channel for data exfiltration. This requires finding a way for the host's speculative execution to write into or otherwise affect guest-controlled memory, making its state observable by the guest via a cache side channel.

  1. Vulnerable Host Return: The exploit targets a specific ret instruction in the VM exit path of the hypervisor (e.g., in VirtualBox's VM exit stub). At this point, the RCX register holds a pointer to a struct containing the guest's general-purpose registers (GPRs). While RCX itself isn't directly attacker-controlled, its dereferenced content is.
  2. Transient ROP Chain (VirtualBox Example): A transient Return-Oriented Programming (ROP) chain is injected into the BTB. When the vulnerable ret is mispredicted, speculative execution is hijacked to this ROP chain:
  • MOV RAX, RCX: Moves the pointer to guest GPRs into RAX.
  • RET: Jumps to the next gadget.
  • MOV RDX, [RAX + offset_R12]: Dereferences RAX to read the guest's R12 register into RDX.
  • RET: Jumps to the next gadget.
  • ADD RAX, page_offset_base: Adds the physmap (Linux) or direct map (FreeBSD) base address to RAX. This is crucial as it converts a physical address (from guest R12) into a host kernel virtual address that directly maps physical RAM.
  • MOV [RAX], RDX (or similar dependent load): Performs a memory operation where the address is derived from the guest's R12 (now a physical address mapped in the host's virtual space) and the value might be RDX. This access will cause a cache line to be loaded.
  1. Physical Address Discovery: The guest manipulates its R12 register to contain different physical addresses. By observing cache hits/misses on a flush and reload buffer (a guest-controlled memory region), the attacker can determine which R12 values correspond to the physical address of this buffer. This effectively maps the guest's physical memory into the host's virtual address space for observation.
  2. physmap/direct map Discovery: Once a guest physical address is linked to a host virtual address, the offset to the physmap/direct map base can be calculated, providing the final component for arbitrarily addressing guest physical memory from the host's perspective.

Stage 3: Leaking Arbitrary Memory

With KASLR bypassed and a covert channel established, the final stage is to read arbitrary memory from the host or other guests.

  1. Another Vulnerable Return: The exploit targets a different vulnerable ret instruction in VirtualBox where RCX is completely attacker-controlled (i.e., its value can be set directly by the guest) and RSI points to the guest GPRs.
  2. Advanced Transient ROP Chain:
  • MOV RAX, [RCX]: Dereferences the attacker-controlled RCX, loading the target secret byte/word into RAX.
  • RET: Jumps to the next gadget.
  • MOV RDX, [RSI + offset_flush_reload_buffer]: Loads the base address of the guest's flush and reload buffer into RDX from the guest GPRs.
  • RET: Jumps to the next gadget.
  • MOV AL, [RAX + RDX]: This is the crucial disclosure gadget. It loads a byte from the secret address (RAX) and uses it as an offset into the flush and reload buffer (RDX). The resulting memory access leaves a cache trace.
  1. Byte-by-Byte Exfiltration: By iterating through possible byte values (0-255) and observing which offset in the flush and reload buffer experiences a cache hit, the attacker can infer the value of the secret byte. This process is repeated byte-by-byte to leak arbitrary amounts of data.
  2. Targeted Data Acquisition: To demonstrate impact, the exploit doesn't just dump random memory. It leverages known kernel structures (e.g., the init_task struct) and walks kernel pointers to find interesting data.
  • Host Data: By walking task_struct pointers, the exploit can find recently opened files from the host's page cache (e.g., /etc/shadow, browser history).
  • Cross-VM Data (FreeBSD Bhyve): For cross-VM leakage, the exploit walks the nested page tables of another guest VM (e.g., "Bob") to find its task_structs. From there, it can dump process arguments and environment variables of processes running inside the victim VM. This involves complex page table translations to map victim guest virtual addresses to host physical addresses, and then back to host virtual addresses for the covert channel.

The entire process, while effective, is slow due to the byte-by-byte leakage and the need to repeatedly flush and reload caches. However, its ability to bypass ASLR and exfiltrate arbitrary data fundamentally breaks the confidentiality guarantees of the hypervisor.

Demo / Proof of Concept

▶ Watch: Demo: Leaking arbitrary host memory (VirtualBox) (37:00)

Johannes Wikner provided live demonstrations of the Spectre V2 exploits targeting both FreeBSD Bhyve and Oracle VirtualBox, running on an AMD Zen 2 processor. The demos showcased the practical feasibility of the multi-stage attack and its ability to leak sensitive information.

The first part of the demo focused on identifying the host and bypassing KASLR.

  • For FreeBSD Bhyve, the exploit quickly identified the base address of the Virtual Machine Manager (VMM) module, demonstrating that FreeBSD Bhyve lacks robust KASLR for its VMM.
  • For Oracle VirtualBox, the exploit successfully extracted both the dynamically allocated VMM ring zero address and the kernel base address from the host using the RSB leakage technique, proving the effectiveness of the KASLR bypass.

The second part established the covert channel by identifying the physical address of the guest's flush and reload buffer as seen from the host's perspective, necessary for the cache side channel. This stage involved scanning the host's memory for specific cache hits, confirming the ability to map guest physical memory into the host's address space.

The final and most impactful part of the demo was arbitrary memory leakage:

  • Oracle VirtualBox Host Leakage: The exploit demonstrated leaking contents from the host's page cache. By walking kernel pointers from the init_task struct, it traversed task_structs and identified recently accessed files on the host system. The demo showed parts of the /etc/shadow file, illustrating a critical compromise of host confidentiality.
  • FreeBSD Bhyve Cross-VM Leakage: This demonstration targeted a second guest VM, "Bob," running on the same Bhyve hypervisor. The attacker VM ("Eve") successfully walked the nested page tables of Bob to find its task_structs. It then proceeded to dump the environment variables of a Python process running inside Bob, revealing a "decrypted environment" message. This conclusively showed that cross-VM isolation could be broken, enabling one guest to spy on another.

Despite a brief moment where the "demo gods" seemed uncooperative (requiring a restart of one of the stages), the demonstrations ultimately succeeded, providing compelling evidence of the vulnerabilities. Wikner acknowledged the slowness of the byte-by-byte leakage but emphasized that by intelligently walking pointers, an attacker can pinpoint and extract specific, high-value information rather than dumping the entire memory.

Defensive Implications

▶ Watch: Conclusion: Spectre isn't dead, Oracle's response (43:30)

The findings presented by Johannes Wikner carry significant defensive implications for hypervisor developers, cloud providers, and system administrators. The central message is clear: Spectre, particularly variant 2 (Branch Target Injection), is not a solved problem, and its mitigations are far from universally applied.

  1. Inconsistent Mitigation Adoption: The stark contrast between KVM's extensive mitigation strategies (RSB overwriting, retpolines, SRSO thunks) and the incomplete or absent defenses in FreeBSD Bhyve and Oracle VirtualBox is alarming. This highlights a fragmented security landscape where basic microarchitectural protections are not consistently implemented across all hypervisor platforms. Defenders should be aware that not all virtualization solutions offer the same level of Spectre protection.
  2. Hypervisor Vulnerability is Host Compromise: The ability of an unprivileged guest VM to leak arbitrary host kernel memory or cross-VM data represents a critical security failure. In cloud environments, this directly translates to a potential breach of tenant isolation, allowing one customer's VM to spy on the host infrastructure or other customers' data. This undermines the fundamental security guarantees of cloud computing.
  3. Complexity of Mitigations: The mitigations themselves (RSB clearing, retpolines, SRSO thunks) are complex, often performance-intensive, and require deep architectural understanding. This complexity contributes to inconsistent adoption and potential for new bypasses or incomplete fixes. The speaker notes that Oracle's description of the vulnerability as "difficult to exploit" and affecting "low privilege attacker to log on with the infrastructure" is a dismissive way of describing a guest-to-host arbitrary memory leak, indicating a potential lack of commitment to comprehensive fixes.
  4. Persistent Microarchitectural Threat: The research reaffirms that microarchitectural side-channel attacks exploit fundamental design characteristics of modern CPUs. As long as speculative execution and shared microarchitectural resources exist, these vulnerabilities will persist, requiring continuous vigilance and research.
  5. Need for Comprehensive Security Audits: Hypervisor developers and maintainers must conduct thorough security audits specifically focused on microarchitectural vulnerabilities, adopting and rigorously testing all available mitigations. Relying on "spot mitigations" or assuming issues are fixed elsewhere is insufficient.
  6. Address Space Isolation (ASI): While mentioned as a potential future solution, Address Space Isolation (ASI) is itself a complex endeavor with its own set of challenges and potential vulnerabilities. It's not a silver bullet, but rather another layer in the ongoing architectural battle against side channels.
  7. Performance vs. Security Trade-off: The performance overhead associated with comprehensive Spectre mitigations is a known challenge. However, as demonstrated, neglecting these mitigations leads to severe security risks. Organizations deploying virtualization solutions must carefully evaluate this trade-off and prioritize security for sensitive workloads.

In essence, defenders should assume that Spectre is not dead, especially when using hypervisors that have not explicitly demonstrated robust, KVM-level mitigations. Regular patching, staying informed about the latest research, and advocating for comprehensive hardware and software defenses remain paramount.

Key Takeaways

  • Spectre Lives On: Eight years post-disclosure, Spectre variant 2 (Branch Target Injection) is still a critical threat, demonstrably capable of bypassing security in widely used hypervisors.
  • Hypervisor Vulnerability Gap: FreeBSD Bhyve and Oracle VirtualBox exhibit significant gaps in Spectre V2 mitigations, making them vulnerable to arbitrary host and cross-VM memory leakage, unlike more robustly mitigated platforms like KVM.
  • Novel ASLR Bypass: A new, practical technique for bypassing Kernel ASLR was demonstrated, leveraging RSB leakage and MMU/TLB side channels to infer host kernel addresses.
  • Arbitrary Data Exfiltration: Attackers can achieve arbitrary memory leakage from the host or other guest VMs by chaining speculative execution with ROP gadgets and cache side channels.
  • Incomplete Industry Response: The inconsistent adoption of comprehensive mitigations across hypervisor vendors, coupled with dismissive vulnerability descriptions, indicates a persistent challenge in addressing fundamental microarchitectural security flaws.
  • Continuous Vigilance Required: Microarchitectural security is an ongoing battle; defenders must remain aware of these threats, prioritize comprehensive mitigations, and not assume that older vulnerabilities are "dead."

About the Speaker(s)

Johannes Wikner is a Security Researcher at RISE (Research Institutes of Sweden), specializing in offensive security research, particularly in the realm of microarchitectural attacks. He holds a PhD in Spectre attacks, having dedicated several years to this complex field and authoring multiple papers on the topic. Wikner is known for his contributions to understanding and exploiting transient execution vulnerabilities, including "Red Pill," "SRSO" (Spectre-RSB-Stack-Overflow, also known as Inception), and new findings related to Spectre variant 2. His expertise lies in uncovering the "crazy parts of x86" and how they can be manipulated for security exploitation. Johannes's background includes working as a software engineer in Germany, pursuing a Master's degree in the VUSec group in the Netherlands, and conducting research in the ComSec group in Switzerland, before returning to Sweden to continue his groundbreaking work.

Reviews

Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT

Wikner just proved that outside the KVM bubble, hypervisor developers are still burying their heads in the sand regarding Spectre V2. He drops an elegant RSB-based ASLR bypass and live-demos a cross-VM memory leak on AMD Zen 2 against FreeBSD Bhyve and Oracle VirtualBox. This is exactly what microarchitectural exploitation should look like.

Heather Calloway (CISO) — SOLID

Wikner proves that eight years after Spectre's disclosure, it still breaks tenant isolation in VirtualBox and FreeBSD Bhyve. While the exploit mechanics are for researchers, the implication is for infrastructure leaders: if your workloads share physical hardware on these hypervisors, your isolation boundary is compromised.

→ Top-rated talks at SEC-T 2026

All talks from SEC-T 2026