DejaVuzz: Disclosing Transient Execution Bugs with Dynamic Swappable Memory and Differential Information Flow Tracking Assisted Processor Fuzzing

Jinyan Xu, Yangye Zhou, Xingzhi Zhang, Yinshuai Li, Qinhan Tan, Yinqian Zhang and 3 others

Modern processors speculate ahead to run fast, and Spectre-style attacks abuse that speculation to leak secrets, so chip designers want to catch such bugs in the design before the silicon is manufactured and the flaw becomes permanent; existing automated testing struggles because it cannot reliably steer the chip into the fleeting speculative states where the bugs live, nor cleanly see a secret leaking; this work from Zhejiang University and collaborators builds DejaVuzz, a pre-silicon fuzzer that time-shares memory to trigger any speculative window on demand and uses a differential taint-tracking trick to spot real leaks, finding five new vulnerabilities and beating the previous best tool by 4.7 times on coverage.

The argument in one glance

Problem

Speculation makes chips fast, and can leak secrets

To run fast, a processor guesses the outcome of a branch and runs ahead before it knows. Spectre-style attacks abuse this: they force a wrong guess, do forbidden work in the brief speculative window before it is undone, and leak a secret through a timing side channel. Designers want to catch such flaws while the chip is still a design, because after manufacture the bug is nearly impossible to fix.
What people did

Fuzz the processor design to find the bugs

Fuzzing feeds a hardware design a stream of generated instruction sequences and watches for a secret leaking. It scales to large out-of-order cores where exhaustive formal proof cannot, and has started to find speculation bugs.
Why it fell short

Fuzzers cannot control or observe the speculative state well

Only instructions that run speculatively matter, so the fuzzer must trigger many different speculative windows, which needs careful training of the predictors — and existing fuzzers reach few windows at high cost. They also cannot cleanly watch a secret move through the hardware, because the standard taint-tracking method floods the design with false taints. As a result they are either narrow or take days to find a bug.
This paper's idea

Time-share memory to trigger windows, and taint differentially

DejaVuzz is a pre-silicon fuzzer with two new primitives. Dynamic swappable memory time-shares the address space, so training instructions and the speculative payload never conflict and any speculative window can be triggered on demand. Differential information flow tracking taints a path only when different secrets actually change it, killing false taints. Together they beat the prior best fuzzer by 4.7 times on coverage and found five new vulnerabilities, with six assigned identifiers.

Why this problem is worth solving

The bugs live in a place that is both dangerous and hard to reach.

A modern processor does not wait to know the outcome of a branch before continuing. It predicts the outcome and speculatively runs the instructions it expects to need. If the guess was right, this speculation is free speed. If wrong, the processor throws away the speculative work and rewinds, as if it never happened — architecturally. But the speculative work leaves traces in the microarchitecture, the hidden hardware beneath the instruction set, such as which memory landed in the cache. Spectre, Meltdown, and their many relatives are transient execution vulnerabilities: they deliberately cause a wrong guess, perform forbidden work during the brief speculative window before the rewind, and then read the leftover traces through a timing side channel to recover a secret. These flaws are especially serious in hardware, because once a chip is manufactured a microarchitectural bug usually cannot be patched away. So the goal is to find them at the pre-silicon stage, while the processor is still a design written in a hardware description language, when a fix is still cheap. Two approaches exist. Formal verification can prove security exhaustively, but the state space of a full out-of-order core explodes, so it must simplify the model, and the very implementation details it drops are where bugs hide. Fuzzing scales to the real design, and that is the path this paper takes.

The trouble is that fuzzing a speculative bug demands two hard capabilities.

Fuzzing normally throws random inputs at a system and watches for a crash. Speculation bugs make both halves hard. First, control. Only instructions that actually execute speculatively can expose the bug, so the fuzzer must open a speculative window — and to open one it must first train the relevant predictor, for example running a branch many times so the predictor learns to expect one direction, then surprising it. Different bugs need different windows and different training, and the training instructions and the window instructions compete for the same memory addresses, so existing fuzzers manage only a few window types, at high simulation cost, wasting time on training that triggers nothing. Second, observation. To know whether a secret leaked, the fuzzer must follow the secret as it moves through the hardware. The standard technique is information flow tracking, also called taint tracking: mark the secret as tainted, and propagate the taint through every gate the data touches. But in a complex design this over-taints. When a tainted value feeds a control decision, naive tracking marks everything downstream of that decision as tainted, even data that does not really depend on the secret, until almost the whole chip is tainted and the signal is lost. Without clean observation the fuzzer cannot measure progress or tell a real leak from a false one.

What people did before, and where it broke

Fuzz commodity (already-manufactured) processors. Test real chips as black boxes. Where it broke. With no view inside, these tools lean on fixed templates and fixed side channels, so they mostly re-find known patterns and rarely uncover new vulnerabilities.
Formal verification of the design. Prove speculation-security properties exhaustively at the design stage. Where it broke. The state space of a full out-of-order core explodes, forcing a simplified model; the implementation details the model omits are exactly where real bugs live, and the manual modeling effort is heavy.
Template-based pre-silicon fuzzers, and differential-testing fuzzers. Generate speculation gadgets from templates, or generate random instructions and compare final states to spot a leak. Where it broke. Template tools only find specific leakage patterns and miss secrets after arithmetic; the differential-testing tool reaches few speculative windows, over-taints, and can take days to find one bug.
The gap. No pre-silicon fuzzer could both steer the microarchitecture into arbitrary speculative windows cheaply and cleanly observe a secret propagate without drowning in false taints. Providing both, with dynamic swappable memory and differential information flow tracking, is what DejaVuzz does.

How DejaVuzz works

From a blind processor fuzzer to controlled, observable speculation testing

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Give two conflicting instruction streams the same address space, one at a time. The reason fuzzers reached so few speculative windows was an address conflict: the instructions that train a predictor and the instructions that form the speculative payload both want specific memory addresses, and they get in each other’s way. DejaVuzz’s swappable memory resolves this by time-sharing — it loads the training sequence, trains the predictor, then flushes it and swaps in the payload at the very same address, so the two never coexist and neither blocks the other. Resolving a conflict by guaranteeing that two things never occupy the same slot at the same moment, and swapping between them instead, is the same discipline the copy-on-write correctness work covered elsewhere on this site enforces, keeping a shared page and a pinned page from ever being the same page so that neither corrupts the other.

Call it a leak only where a different secret changes the behavior. Ordinary taint tracking spreads taint through every gate a secret touches, and when the secret reaches a control decision it marks everything downstream, until the whole design looks tainted and nothing can be distinguished. DejaVuzz’s differential rule is sharper: it taints a control path only when two different secret values would actually make that path decide differently. A leak, by definition, is a place where the secret changes what the hardware does — so tainting exactly those places, and nothing else, is the right notion. Treating a leak as precisely the point where a secret’s value alters hardware behavior is the same principle the leaky-instruction defense covered elsewhere on this site is built on, hunting down the instructions whose hardware timing shifts depending on the secret operand and neutralizing exactly those.

Let coverage of the microarchitecture drive the search. A fuzzer without feedback mutates blindly. DejaVuzz builds a taint coverage matrix that records which parts of the microarchitecture a secret has reached, and steers future mutation toward the parts it has not, so the search spreads into unexplored corners of the design rather than circling the same ground. Using a measure of what has already been reached to push a generator toward the unexplored is the same coverage-guided instinct the robot-software fuzzing work covered elsewhere on this site follows, mutating structured messages under coverage feedback to drive the system into states a blind generator would never stumble upon.

Following a speculative window being triggered

Opening a return-speculation window with swappable memory

Tracing one trigger shows why time-sharing the address space is the key.

Step 1 of 5

The goal, and the old conflict

DejaVuzz wants to open a speculative window at address 0x1010 caused by a mispredicted return, then run a secret-dependent payload there. In older fuzzers the training instructions and the window instructions both need addresses near 0x1010 and collide.

This address conflict is the root reason prior fuzzers reached so few window types.

Why it works

Only speculative instructions matter, so you must open many windows. Because a payload exposes a bug only if it runs speculatively → the fuzzer must open diverse speculative windows, which needs careful predictor training → so a method that reaches few windows explores little of the design.
Time-sharing the address space removes the conflict. Because training and payload instructions no longer fight for the same addresses when swapped in turn → the fuzzer can place training exactly where it wants and trigger any window → so it reaches speculative states earlier methods could not.
Dropping dead training saves huge simulation time. Because each training sequence is tried in isolation and the ineffective ones are removed → the fuzzer stops burning cycles on training that opens nothing → so its throughput rises and its coverage grows 4.7 times over the prior best fuzzer.
Differential tainting flags only real secret dependence. Because a control path is tainted only when different secrets change its decision → the flood of false taints from over-tainting disappears → so coverage becomes meaningful and false leaks fall away.
Liveness keeps only exploitable leaks. Because a taint is kept only if it reaches a state an attacker could actually observe → dead-end taints that never surface are filtered out → so the reported bugs are real, and five new ones earned identifiers.

What it costs (trade-offs and scope)

It is a pre-silicon tool, not a proof. Fuzzing finds bugs by triggering them; unlike formal verification it cannot prove that none remain. DejaVuzz raises the odds of finding speculation bugs early, but silence is not a guarantee of security.
It needs the design source and some manual annotation. DejaVuzz works on the register-transfer-level design, and its liveness feature currently requires a developer to hand-annotate which state registers are the observable sinks, binding them to their taints. That is expert effort per design.
Differential tracking has a cost. Removing over-tainting is not free: the differential taint policies and the shadow circuitry that carries taints add simulation overhead, which the paper reports as acceptable but real.
Coverage is a guide, not a bug count. Higher taint coverage means more of the microarchitecture was explored, not more bugs; the two are correlated but distinct, so coverage must be read as an exploration signal rather than a security score.
Demonstrated on two RISC-V cores. The results come from two open out-of-order designs, BOOM and XiangShan. The primitives are general, but the effort and effectiveness on a large industrial core are not measured here.
It finds the trigger, not the full exploit or the fix. DejaVuzz surfaces a leaking speculative behavior; turning that into a robust real-world attack, or into a hardware fix, is separate work, though early detection makes the fix far cheaper.

The evaluation

Three ways to hunt speculation bugs in a processor design

Property	Formal verification	Prior fuzzers
Scales to a full out-of-order core		Yes
Triggers diverse speculative windows	Not applicable
Observes secret flow cleanly	Not applicable
Time to first bug	Not applicable
New vulnerabilities found	Not applicable	Limited patterns

Three ways to look for transient execution bugs in a processor before it is manufactured, evaluated on two open RISC-V out-of-order cores, BOOM and XiangShan, on an AMD server with sixty-four cores. Formal verification cannot scale to a full core without simplifying away the details where bugs hide. Prior fuzzers scale but reach few speculative windows, because training and payload instructions collide for addresses, and their taint tracking over-taints until the signal is lost. DejaVuzz time-shares the address space to trigger any window and taints only where a different secret changes behavior. Against the previous best fuzzer it achieves 4.7 times the coverage with more comprehensive windows and lower training cost, finds its first bug in about ten minutes with sixteen threads rather than days, and discovered five previously unknown vulnerabilities with six assigned CVE identifiers, including new return-stack and branch-target speculation bugs. The tool is open-sourced.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

DejaVuzz is a defensive tool with a clear, verifiable outcome: it finds real speculation bugs in real processor designs, early enough to fix them before manufacture, and the five it found were assigned CVE identifiers and disclosed. Its two ideas are clean. Swappable memory sidesteps the address conflict that limited earlier fuzzers by time-sharing the address space, so training and payload never collide and any speculative window can be triggered on demand. Differential information flow tracking fixes the over-tainting that blinded earlier fuzzers by tainting a path only where a different secret would change it. Together they turn a process that took days into one that finds a first bug in about ten minutes and covers 4.7 times more of the microarchitecture. Read the results with their scope. This is fuzzing, so it finds bugs but cannot prove their absence; a clean run is not a security certificate. It works on the design source and needs a developer to annotate which registers are observable sinks, so it takes expertise per design. The differential tracking adds simulation overhead, coverage measures exploration rather than counting bugs, and the evaluation is on two open RISC-V cores rather than a large industrial one. The durable lesson is that finding hardware security bugs is as much about controllability and observability — being able to steer the chip into the right state and clearly see what leaks — as it is about generating clever inputs.

Background

Why the speculation arms race pushes testing earlier

It helps to see DejaVuzz inside the long back-and-forth between speculation attacks and defenses. The controlled-preemption work covered elsewhere on this site sits on the attack side of the same field, showing how an adversary can sharpen a side-channel measurement to near-perfect precision; DejaVuzz sits on the builder’s side, trying to catch the leaking hardware behavior before it ever ships. The two share a subject — the tiny, secret-dependent traces that speculation and scheduling leave in the microarchitecture — and they teach the same lesson from opposite directions: those traces are powerful, and a defender who cannot see them is at a disadvantage. Because a manufactured chip cannot be repatched, the pressure is to move detection as early as possible, into the design phase, and to make the testing tools themselves better at controlling and observing the hidden hardware state. The broad point is that security in speculative processors is not won once. It is an ongoing contest in which each new class of attack demands better tools to find the next class first, and where the advantage goes to whoever can most precisely steer and inspect the machine’s hidden internals.

If you remember only three things

1. Processors speculate — guess a branch and run ahead — to go fast, and transient execution attacks like Spectre and Meltdown abuse this by forcing a wrong guess, doing forbidden work in the brief speculative window, and leaking a secret through a timing side channel. These bugs are best caught while the chip is still a design, because manufactured silicon cannot be patched. Fuzzing scales to real out-of-order cores where formal proof cannot, but it struggles with control (triggering diverse speculative windows needs predictor training, and training instructions collide with the payload for addresses) and observation (standard taint tracking over-taints until the whole design looks tainted).
2. DejaVuzz adds two primitives. Dynamic swappable memory time-shares the address space: it loads a training sequence and trains the predictor, then flushes it and swaps the speculative payload in at the same address, so the two never conflict and any window can be triggered on demand, while a training-reduction step drops training that opens nothing. Differential information flow tracking taints a control path only when two different secret values would actually change it, eliminating over-tainting; a taint coverage matrix then guides mutation, and liveness annotations keep only taints that reach an observable sink, cutting false leaks.
3. On the open RISC-V cores BOOM and XiangShan, DejaVuzz beats the prior best fuzzer by 4.7 times on coverage with more comprehensive speculative windows and lower training cost, finds its first bug in about ten minutes with sixteen threads instead of days, and discovered five previously unknown transient execution vulnerabilities with six assigned CVE identifiers (including new return-stack and branch-target bugs). Its limits: fuzzing finds bugs but cannot prove their absence, it needs the design source and manual sink annotation, the differential tracking adds overhead, coverage measures exploration not bug count, and it was evaluated on two open cores. The tool is open-sourced.

Check yourself

Check your understanding

1. Why is it especially important to find transient execution bugs before a chip is manufactured?
2. What problem does "dynamic swappable memory" solve, and how?
3. What is "over-tainting," and how does differential information flow tracking avoid it?
4. DejaVuzz reports a clean run on a new processor design, finding no leaks. What can the designer conclude?

Sources

The paper is “DejaVuzz: Disclosing Transient Execution Bugs with Dynamic Swappable Memory and Differential Information Flow Tracking assisted Processor Fuzzing” by Jinyan Xu, Yangye Zhou, Xingzhi Zhang, Yinshuai Li, Qinhan Tan, Yinqian Zhang, Yajin Zhou, Rui Chang, and Wenbo Shen, published at ASPLOS 2025, DOI 10.1145/3676642.3736115. The authors are at Zhejiang University, the Southern University of Science and Technology, and Princeton University. The source code is published at github.com/sycuricon/DejaVuzz.

This explainer is written from the full text of the paper, obtained from the authors’ arXiv preprint (2504.20934), which matches the ASPLOS 2025 proceedings. Everything above comes from the paper’s own sections: the introduction and background on transient execution vulnerabilities (Spectre, Meltdown, and the speculative-window structure of Spectre-V1, V2, and return-stack variants) and on hardware dynamic information flow tracking (shadow circuits, taint propagation policies, and the control-flow over-tainting problem); the statement of the two challenges, microarchitectural controllability and observability, and their sub-problems (limited transient windows from address conflicts, high training overhead, the feedback gap, and false positives); the dynamic swappable memory primitive (time-sharing the address space, the training derivation and training reduction strategies, and the memory layout of shared firmware, dedicated data, and swappable packets); the differential information flow tracking primitive (the differential control taint propagation policies for multiplexer, comparison, register, and memory cells, the taint coverage matrix for guiding mutation, and the taint liveness annotations for filtering unexploitable taints); the three-phase DejaVuzz framework (transient window triggering, transient execution exploration, and transient leakage analysis with constant-time and liveness checks); and the evaluation on the BOOM and XiangShan RISC-V out-of-order cores on an AMD server, including the 4.7 times coverage improvement over SpecDoctor, the roughly ten-minute first-bug time with sixteen threads versus several days, and the five new vulnerabilities with six assigned CVE identifiers (including MeltDown-Sampling on XiangShan and Phantom-RSB and Phantom-BTB on BOOM).