CPUs guess. They execute instructions speculatively along a predicted branch or as if a permission check passed, then roll back architectural state if the guess was wrong. Kocher et al. (Spectre) and Lipp et al. (Meltdown) showed that microarchitectural state — cache lines, BTB, fill buffers — is not always rolled back. A victim's secret can modulate which cache line is hot; an attacker times access and reconstructs the bit.
Meltdown versus Spectre, operationally
Meltdown (rogue data cache load) let user code speculatively read kernel-mapped physical memory on some Intel designs because the permission check was ordered late. KPTI (kernel page-table isolation) and later silicon were the answers. If your fleet is unpatched 2017 silicon, this is still a CVE; if it is current, Meltdown-class holes are mostly in the "applied mitigations" column.
Spectre is a family. Variant 1: bounds-check bypass — speculate past if (i < len), read arr[i], then use that value to index a second array the attacker times. Variant 2: branch target injection — poison indirect branch prediction so the victim speculatively jumps to a gadget. Later variants use other predictors and buffers. Software mitigations include lfence, retpolines, restricted speculation, and compiler pass options. They cost cycles. Cloud vendors toggle them per CPU generation.
speculative: read secret → touch probe[secret*256]
architecturally: squash
microarch: probe line still warm → attacker timesWhat application developers still own
You cannot "code around" every Spectre gadget in a JIT. Browsers site-isolated processes, reduced timer resolution, and disabled shared memory in some contexts because JavaScript was a practical Spectre remote. JITs (V8, JVM) shipped mitigations; keep runtimes current. Constant-time crypto still matters: speculative execution is one more way control flow and data-dependent addressing leak.
Shared-hardware multi-tenancy is the threat that made these papers existential for cloud. If two VMs share a core, speculative leakage is in scope. If you run a single-tenant box, priority drops relative to SQL injection — but CI runners that execute untrusted code on the same kernel as secrets are closer to the paper's world.
How to talk about this without theater
List CPU microcode, kernel, hypervisor, and runtime versions in the security baseline. Know which mitigations are on (lscpu speculation flags, cloud CPU feature docs) and what latency they cost. Do not disable mitigations "for Java benchmarks" on a multi-tenant host.
Read the two original papers' diagrams of the probe array. They are still the clearest explanation. Then treat isolation as a stack: process, kernel, hypervisor, and silicon, each with a leaky abstraction. Speculative execution was supposed to be invisible. The 2018 papers are why we no longer write that in threat models.