Spectre, Meltdown, and Hardware Vulnerabilities

Abstract

On January 3, 2018, the industry learned that the performance tricks inside nearly every processor made since the 1990s doubled as an attack surface. Meltdown let an ordinary program read kernel memory on most Intel CPUs; Spectre turned branch prediction itself into a way to leak secrets on Intel, AMD, and ARM alike. Both had been found independently by multiple teams within months of each other, kept under a seven-month embargo, and patched at the cost of measurable performance. Together with Rowhammer, the 2014 discovery that software can flip bits in DRAM by hammering memory rows, they ended an assumption computing had been built on: that hardware, unlike software, could be trusted to behave like its manual.

The Spectre logo by Natascha Eibl, released CC0. Both 2018 vulnerabilities came with names and logos, following the branding pattern Heartbleed started. Image: Natascha Eibl, CC0, via Wikimedia Commons.

The Contract

An instruction set architecture is a contract: the processor promises that programs behave as if instructions execute one at a time, in order, touching only the memory they are allowed to touch. Everything underneath (pipelines, caches, branch predictors, out-of-order engines) is microarchitecture, officially invisible. From the Pentium Pro (1995) onward, mainstream CPUs won their performance by speculating: guessing which way a branch will go and computing ahead on credit, throwing the work away if the guess was wrong. The results of discarded speculation never appear in any register. But they leave footprints, in cache timing above all, and cryptographers had known since Paul Kocher’s timing attacks (1996) that footprints leak secrets. What almost nobody had asked was whether the CPU’s own internal guesswork could be steered and then read through those side channels.

Rowhammer

The first crack in hardware’s reputation came from physics rather than logic. At ISCA 2014, Yoongu Kim and colleagues at Carnegie Mellon and Intel showed that repeatedly activating one row of a modern DRAM chip disturbs its neighbors: cells packed so densely that charge leaks between them, flipping bits in rows the attacker never touched. In their DDR3 tests up to one cell in 1,700 was vulnerable. In March 2015, Google’s Project Zero turned the curiosity into an exploit, using deliberate bit flips in page tables to escalate an unprivileged process to full memory access, and escaping a browser sandbox the same way. The industry answered with Target Row Refresh in DDR4; researchers answered back with TRRespass (2020), which defeated it, then Half-Double, ZenHammer, and by 2025 the Phoenix attack on DDR5. A decade of mitigation has raised the cost of Rowhammer without abolishing it, because the root cause is the density that makes cheap memory cheap.

Melting the Wall

Meltdown (CVE-2017-5754) broke the oldest boundary in operating systems, the wall between user programs and kernel memory. On most Intel processors since 1995, an out-of-order core would fetch a forbidden kernel byte and race ahead computing with it for a few nanoseconds before the privilege check caught up; the fault arrived, the results were discarded, but a cache footprint indexed by the secret byte survived to be timed. Read in a loop, the entire kernel (and through it, physical memory) became readable at hundreds of kilobytes per second. Three groups found it independently within months in 2017: Jann Horn at Google Project Zero; Werner Haas and Thomas Prescher at Cyberus Technology; and Daniel Gruss, Moritz Lipp, Michael Schwarz, and Stefan Mangard at TU Graz, whose team had, without knowing the bug existed, already built the defense: their KAISER patch for hiding kernel addresses became KPTI, the kernel page-table isolation now in every operating system. Vendors were notified on July 28, 2017. Itanium and early Atoms were immune (no out-of-order execution); so, for this bug, was AMD; some ARM cores, including the Cortex-A75, and IBM POWER were not.

The Ghost

Spectre was worse in a quieter way. Variant 1 (CVE-2017-5753, bounds check bypass) and Variant 2 (CVE-2017-5715, branch target injection) do not exploit an Intel privilege-check quirk; they exploit branch prediction itself. An attacker trains the predictor, and the victim’s own code speculatively executes down a path it never architecturally takes, touching secrets and leaving the cache footprint. That mechanism exists in essentially every high-performance CPU: Intel, AMD, ARM, IBM. Jann Horn reported it to vendors on June 1, 2017; Paul Kocher, working with Daniel Genkin, Mike Hamburg, Moritz Lipp, and Yuval Yarom, arrived independently. The researchers named it for its root cause in speculation, and for the prognosis: “it will haunt us for quite some time.” Where Meltdown had a clean fix, Spectre had only partial ones, because the flaw is the optimization.

Disclosure Week

The embargo, one of the largest coordinated disclosures ever attempted, was supposed to end January 9, 2018. It leaked out of the open: unexplained KPTI patches flowing into the Linux kernel, with comments carefully scrubbed, told anyone watching that something was wrong at the hardware level, and press speculation forced disclosure on January 3. The week that followed was chaotic. KPTI cost between 5 and 30 percent on system-call-heavy workloads (far less on typical desktops); Google published the retpoline compiler defense against Variant 2 on January 4; Intel shipped microcode that caused spontaneous reboots and was disabled by Microsoft; and Linus Torvalds reviewed early Spectre patches as “complete and utter garbage” in a thread aimed as much at Intel’s handling as at the code. Cloud providers, for whom one tenant reading another’s memory is an existential bug, mass-rebooted fleets worldwide.

The Family

The papers had described a class, and the class delivered: Foreshadow (August 2018) read Intel’s SGX enclaves through the L1 cache; the MDS attacks, ZombieLoad, RIDL, and Fallout (2019), leaked data from internal CPU buffers; Retbleed (July 2022) revived branch-target injection with mitigations costing up to 39 percent on affected Intel parts; 2023 alone brought AMD’s Zenbleed and Inception and Intel’s Downfall; Branch History Injection (2022) and Training Solo (2025) kept the Spectre lineage going. New cores now ship with hardware mitigations and the transient-execution family is a permanent research field, tracked in its own taxonomies. The count of variants across vendors long ago passed what any patch cycle could close out.

Dead End: The Invisible Microarchitecture

The dead end here is an assumption rather than a product: the belief, load-bearing for twenty years of CPU design, that whatever the microarchitecture does on the way to a correct result is security-irrelevant because it is architecturally invisible. Speculation was performance borrowed against a risk nobody had priced, and the bill arrived all at once in 2018, payable in performance (the mitigations), in silicon (redesigned cores), and in trust. Unlike a software flaw, a CPU vulnerability cannot be patched in place, only mitigated around, and the affected installed base was effectively the entire computing world (Cybersecurity: The Invisible War puts the episode in the longer arms-race arc). What ended was an era’s mental model. Since 2018, “the hardware behaves like the manual” is a claim that has to be argued, with side channels in the threat model, rather than assumed.