Modern high-performance chips are increasingly assembled from chiplets — separately manufactured silicon dies placed side by side on a package and wired together. The dies stay consistent with each other through a hardware cache-coherence protocol: a message-passing scheme that lets one die ask for exclusive ownership of a piece of memory before writing it. That protocol is built for speed, not security — it never consults the operating system's permission tables. A recent demonstration shows that a malicious chiplet can therefore corrupt another die's memory with two perfectly legal messages: first a request for exclusive ownership of a victim's cache line, then a write-back carrying altered data, all without triggering any software fault (Hardware Trojan Threats to Cache Coherence in Modern 2.5D Chiplet Systems). Crucially, these two messages are separated in time by a window — the cycles between the grant of exclusive ownership and the corrupted write-back — and nothing in the literature measures that window or asks whether a defense could act inside it.
This proposal treats that window the way epidemiologists treat the early phase of an outbreak. The intervention-timing literature shows that when a process compounds exponentially, when you act dominates how hard you act: in a modeled avian influenza epidemic, reporting delays of just two to three days made quarantine protocols ineffective, and aggressive over-response (an 18.75 km culling radius) wasted resources without improving containment over a targeted 11 km radius (Multi-agent modeling of the South Korean avian influenza epidemic). We hypothesize the same structure holds in hardware: the probability that a coherence-forging attack succeeds collapses non-linearly as interposer intervention latency shrinks, and the right defense is a small, fast, targeted action rather than a blunt one. The obstacle is that deciding which targeted action is best normally requires cycle-accurate simulation (gem5), which is far too slow to run inside a millisecond-scale attack window — so we borrow multi-fidelity simulation, which has cut expensive simulation calls by 10x–100x in other domains (Multifidelity Simulation-based Inference for Computationally Inexpensive-Expensive Simulators), and deploy it for the first time on a microarchitectural state machine.
Core Claim
The forging attack on 2.5D cache coherence has a measurable, load-dependent vulnerability window, and a monitor inside the interposer — the package substrate wiring the chiplets together — can neutralize the attack within that window if it selects interventions using a cheap coarse model of coherence traffic that is calibrated and periodically validated against a cycle-accurate simulator. Formally, we will estimate the dose-response curve
$$ P_{\text{corrupt}}(\ell) \;=\; \Pr\{\text{victim line modified} \mid \text{detection-to-intervention latency } \ell \text{ cycles}\}, $$
where $\ell$ spans from the moment a statistical anomaly is flagged to the moment a corrective coherence message (a forced invalidation, a targeted throttle, or a reroute) takes effect. We expect this curve to show a sharp threshold at some window length $W$ — the hardware analogue of the two-to-three-day cliff in epidemic containment — and we expect a multi-fidelity decision policy to operate comfortably below $W$ where any gem5-in-the-loop approach cannot.
No existing work does this. The forging-attack paper simulates offline in gem5 and leaves "the precise temporal window of vulnerability between the GETX grant and the PUTX write-back" explicitly open, along with any runtime mitigation. The closest methodological relatives operate in other domains entirely: AT-UCB prunes intervention choices using a coarse abstract model of an epidemic, but treats intervention as a one-time arm pull with a statically known abstraction error (Using causal abstractions to accelerate decision-making in complex bandit problems); MF-NPE accelerates offline parameter inference for biological simulators, not closed-loop control (Multifidelity Simulation-based Inference for Computationally Expensive Simulators); SAVME picks simulator fidelities under a compute budget for autonomous-vehicle safety validation, not for microarchitecture (SAVME: Efficient Safety Validation for Autonomous Systems Using Meta-Learning). On the security side, SIMCom detects hardware Trojans at run time via bus-traffic statistics but stops at raising a flag — it neither models nor executes a mitigation (SIMCom: Statistical Sniffing of Inter-Module Communications for Run-time Hardware Trojan Detection). Our proposal sits precisely in that gap: detection exists, the attack exists, the timing mathematics exists, and the multi-fidelity machinery exists — nobody has connected them.
Research Program
The work has three strands. First, we reproduce the forging attack on the published configuration — a 64-core Rocket-64 system across eight chiplets running the MOESI Hammer protocol in gem5, where the original authors silently changed a victim array entry from 1 to 5 (Hardware Trojan Threats to Cache Coherence in Modern 2.5D Chiplet Systems) — and instrument it to measure the grant-to-write-back window under varying load, using PARSEC 2.1 workloads, the same suite used to stress coherence traffic at scale in related gem5 studies (Learning Cache Coherence Traffic for NoC Routing Design). This yields $P_{\text{corrupt}}(\ell)$ and the threshold $W$. In the same strand we confront an open tension in the literature: the forging attack is fully protocol-compliant, so protocol checkers will never flag it, while SIMCom claims any activating Trojan perturbs traffic statistics. We will sweep attack frequency from continuous forging down to one corrupted word per millions of cycles and measure whether Hurst-exponent-style statistics still separate attack from noise — if a stealthy regime exists, the case for timing-aware intervention (acting on weak, ambiguous signals quickly rather than waiting for certainty) becomes even stronger, mirroring the detection-delay findings in epidemic control.
Second, we build a two-tier simulation stack. The low-fidelity tier is a coarse event-driven model of the coherence directory and inter-chiplet message flows, with per-die aggregate state instead of per-line detail, calibrated against gem5 traces; the high-fidelity tier is the full gem5/Garnet slice. The decision policy runs on the low-fidelity tier during an attack window, prunes the intervention space in the spirit of AT-UCB, and commits the surviving candidate — but unlike AT-UCB, which requires the abstraction error $\epsilon$ to be known in advance, we estimate the abstraction discrepancy online by periodically replaying recent low-fidelity predictions against high-fidelity ground truth, directly attacking the limitation its authors flag. Interventions under consideration are deliberately conservative and surgical: revoking a granted exclusive ownership, throttling a suspect die's outstanding coherence requests, or rerouting around a suspect link — adaptations in the same family as the deep-RL routing work that cut execution time by up to 55.51% and packet latency by up to 10.52% on PARSEC (Learning Cache Coherence Traffic for NoC Routing Design), but repurposed for security rather than throughput. Offline, we express the safety requirement in Metric Temporal Logic — the formalism that synthesized intervention schedules for non-linear epidemic models in under 6 seconds on a laptop (Control strategies for COVID-19 epidemic with vaccination, shield immunity and quarantine: A metric temporal logic approach) — to constrain which interventions the online policy may ever select.
Third, we integrate the policy into a simulated interposer monitor with a hardware budget matched to SIMCom's demonstrated envelope of less than 1% area and power (SIMCom), and run the head-to-head evaluation described below.
Baselines
The naive reference point is the undefended Rocket-64 system under the forging attack, where the original paper demonstrates silent corruption of victim data with no MMU fault or software alert; this gives the attack-success floor (effectively 100% for unopposed attacks) and, importantly, no reported result found on Lacuna for any runtime mitigation of coherence-forging attacks — the entire mitigation space is unmeasured. The strongest existing competitor is a SIMCom-style statistical monitor wired to the obvious response: on any alarm, immediately quarantine the suspect chiplet by severing its coherence participation. This is the strongest simple baseline because its detection half is proven — 100% detection of TrustHub Trojans on MC8051 and LEON3 with under 1% area and power overhead — and maximal isolation is what a deployer would do today in the absence of any smarter policy. We will implement it with the same traffic statistics, the same monitor hardware budget, on the same gem5 configuration, attack schedule, and PARSEC workloads as our policy, with an equal wall-clock tuning budget. A second baseline is static hypervisor mediation in the style of the NAILGUN defense, which intercepts memory-mapped debug-register accesses through ARM Stage 2 translation at under 1.1% overhead on Unixbench and Sysbench (Revisiting ARM Debugging Features: Nailgun and its Defense); we include it to quantify, not assume, its blindness to sub-OS coherence traffic. Finally, two ablations isolate our key ingredients: the same policy with the low-fidelity tier removed (interventions chosen by fixed heuristics, no simulation in the loop), and the same multi-fidelity machinery with timing-awareness removed (a fixed intervention applied at a fixed delay regardless of the measured window). Beating the strongest baseline means matching its attack-prevention rate while reducing its collateral cost — PARSEC execution-time and packet-latency degradation caused by isolating an entire die — by a substantial margin, and demonstrating that prevention holds across the load conditions under which the window $W$ is shortest.
Why not just…?
Why not just trap the attack at the hypervisor, like the NAILGUN defense? Because the two attacks live on different planes. The NAILGUN defense works by intercepting an operating-system core's memory-mapped accesses to debug registers, which flow through address translation the hypervisor controls; coherence messages cross the interposer on physical addresses and never touch an MMU or Stage 2 table, so the same defense mechanism is structurally blind to forging (Hardware Trojan Threats to Cache Coherence in Modern 2.5D Chiplet Systems). We will verify this empirically by running the hypervisor baseline against the attack, and we expect zero interceptions — a result that itself sharpens the field's understanding of where defenses must physically sit.
Why not just eliminate Trojans before fabrication, with pre-silicon whitelisting? HaTCh achieves 100% detection of TrustHub and DeTrust Trojans at 4.18% average area overhead (HaTCh: Hardware Trojan Catcher), and if all silicon were auditable this would be the right answer. But 2.5D integration exists precisely to mix dies from multiple vendors, and third-party chiplets arrive as proprietary black boxes without netlists, which whitelisting requires; HaTCh also does not cover always-on architectural protocol misuse, which is exactly what the forging attack is. Pre-silicon verification constrains the trusted-die supply chain; it cannot police the package, so a runtime layer remains necessary.
Why not just isolate the whole suspicious chiplet on any alarm? This is the most serious alternative, and we treat it as the baseline to beat rather than an argument to dismiss. The epidemic evidence warns that maximal response is often wasteful without being more effective: aggressive 18.75 km culling radiuses over-culled healthy flocks without improving containment over a targeted 11 km radius (Multi-agent modeling of the South Korean avian influenza epidemic), and uncoordinated routing interventions in NoC settings cause severe degradation where adaptive ones yield gains (Learning Cache Coherence Traffic for NoC Routing Design). Severing a die's coherence participation can also deadlock the directory if victims hold pending dependencies on it. That said, if attacks turn out to be rare and quarantining one die of eight costs little average throughput, maximal isolation may be good enough — and our evaluation is designed to settle exactly this: we measure PARSEC execution time, packet latency, and energy under both policies across attack-free and attack-laden runs, so the cost of bluntness is quantified rather than asserted.
Why not just run standard single-fidelity simulation or a plain bandit in the loop? Because the window is measured in cycles, and cycle-accurate simulation of a 64-core system is orders of magnitude too slow to complete even one evaluation inside it. The file's evidence is consistent on the speedup available from abstraction: MF-NPE reduces expensive high-fidelity simulation calls by 10x to 100x and overall cost by roughly 4.4x on its hardest benchmark, single-fidelity neural posterior estimation needing $10^4$–$10^5$ runs (Multifidelity Simulation-based Inference for Computationally Expensive Simulators); SAVME achieves an 18x speedup in failure discovery under a 0.3 compute budget where single-fidelity search fails to find edge cases at all (SAVME); and standard UCB accumulates markedly higher regret than AT-UCB on the abstracted epidemic bandit (Using causal abstractions...). The honest caveat is the converse risk: multi-fidelity transfer collapses when the coarse model is misaligned with the fine one — the "similarity trap" that MF-NPE's own authors document. This is a real threat to our design, which is why the online abstraction-error estimator is a core deliverable rather than an afterthought, and why strand one calibrates the coarse model per workload before any policy evaluation.
Proposed Experiments and Decisive Checks
Experiment one measures the window and the dose-response curve on the published 64-core, eight-chiplet Rocket-64 MOESI Hammer gem5 configuration, sweeping PARSEC 2.1 workloads and system load, and separately sweeps attack frequency to map the stealth-detectability frontier against Hurst-statistic monitors. Its decisive output is $W$ and the shape of $P_{\text{corrupt}}(\ell)$: a sharp threshold validates the timing-sensitivity premise; a flat curve over cycle-scale latencies would mean the window is too tight for any in-package policy and would redirect the work toward prediction-before-grant — we state this falsification condition up front. Experiment two validates the coarse coherence model's predictive fidelity against gem5 traces per workload, reporting calibration error and the online estimator's ability to detect when the abstraction degrades, with the quantitative bar being that low-fidelity-guided intervention choices match high-fidelity-guided choices on the vast majority of attack episodes at a small fraction of the decision latency. Experiment three is the head-to-head: repeated forging attacks interleaved with PARSEC execution, comparing the multi-fidelity timing-aware policy against the SIMCom-plus-isolation baseline, the hypervisor baseline, and both ablations, on attack success rate, detection-to-neutralization latency in cycles, execution-time and packet-latency overhead, and energy, with all methods given identical hardware budgets and tuning time. The claim succeeds if the policy holds attack success near zero at materially lower performance cost than whole-die isolation, and specifically if its neutralization latency sits below the measured threshold $W$ in every load regime where the baseline's does not.
References
- Hardware Trojan Threats to Cache Coherence in Modern 2.5D Chiplet Systems
- Multi-agent modeling of the South Korean avian influenza epidemic
- Multifidelity Simulation-based Inference for Computationally Expensive Simulators
- Using causal abstractions to accelerate decision-making in complex bandit problems
- SAVME: Efficient Safety Validation for Autonomous Systems Using Meta-Learning
- SIMCom: Statistical Sniffing of Inter-Module Communications for Run-time Hardware Trojan Detection
- Learning Cache Coherence Traffic for NoC Routing Design
- Control strategies for COVID-19 epidemic with vaccination, shield immunity and quarantine: A metric temporal logic approach
- Revisiting ARM Debugging Features: Nailgun and its Defense
- HaTCh: Hardware Trojan Catcher