Quick Answer — On August 10, 2023, two research teams independently went public with Downfall (Intel) and Inception (Intel) — side-channel attacks that leak privileged memory data across privilege boundaries via transient-execution quirks in modern CPUs. Neither could be fixed in silicon; both relied on the fundamental speculation bet that makes CPUs fast. The lesson for defenders: speculative execution is permanent attack surface, and microcode updates are the tax you pay for speed.
What happened
- Downfall (CVE-2022-40982): A flaw in Intel’s AVX gather instruction implementation lets a malicious userspace process sniff data from other processes, kernels, and VMs on the same core through speculative execution of vector instructions.
- Inception (CVE-2023-20569): Affecting Zen 1/2 AMD CPUs — privileged data leakage via branch-prediction training poisoning where an attacker pushes poisoned entries into shared predictors to steer speculation at privileged data.
- The dual-reveal symmetry: Both advisories landed within 24 hours of each other in August 2023, pushing transient-execution attack research from “Spectre-era relic” back into current-news cycle relevance.
Why speculation keeps breaking things
| Factor | What it does |
|---|---|
| Speculative execution | CPU guesses ahead; wrong guesses leave microarchitectural traces (cache timing, port contention) |
| Shared hardware state | Buffers, predictors, and caches shared across privilege boundaries leak via side channels |
| Microcode vs silicon | Flaws baked into shipped silicon can only be patched by microcode workarounds — usually with performance cost |
| Non-extinction of the class | Spectre-class issues categorically cannot be “fully fixed” — only made harder, bug by bug |
| Cloud multi-tenancy | Co-tenant VMs on the same physical core become attack surface for each other |
Timeline
| Date | Event |
|---|---|
| 2018-01 | Spectre/Meltdown disclosures establish the transient-execution attack class |
| 2022-08 → 2023-08 | Coordinated research windows: Downfall reported to Intel (Aug 2022), Inception to AMD (late 2022 → coordinated 2023 disclosure) |
| 2023-08-10 (our peg week) | Public reveal of Downfall (independent academic write-ups) and Inception within the same cycle; Intel and AMD ship microcode updates |
| 2023-08 → 09 | Rollout of microcode + OS mitigations across cloud fleets; measured perf hits on gather-heavy workloads (some HPC/vector cases hit hardest) |
| 2023-Q4 → | Cloud providers disclose mitigation completion; the class quietly becomes a standing line item in every CPU generation’s threat model |
Defensive lessons
- Treat CPU side channels as infrastructure weather. Not a fire drill: a recurring operational condition. Track microcode update channels like you track CVE feeds, because your CPU vendor will keep finding these.
- Count the perf cost honestly. Mitigations tax vector-heavy and syscall-heavy workloads differently; measure before and after every microcode wave, or you’ll discover the cost in production slowdowns you can’t attribute.
- Segment co-tenancy where it matters. If your threat model includes hostile co-tenants (public cloud, shared CI), place high-value secrets — keys, tokens, DRAM-level crown jewels — on dedicated or isolated hardware.
- Minimize predictor-poisoning upside. Fewer reachable gadgets and less cross-privilege code reuse shrinks what speculation can leak; hardened JIT configs and eIBRS-era controls help at the margins.
The performance apology problem
Every transient-execution cycle produces the same awkward apology tour: vendors ship fixes, then quietly publish performance-regression tables showing which workloads lose 2%, 8%, or 20%. Downfall’s gather-based leak was particularly annoying because AVX gather instructions sit inside hot loops of crypto and data-processing code — exactly where slowdowns hurt. The industry’s real defense wasn’t heroics; it was already-having measurement baselines so regression tables could be acted on in days instead of argued about for months. Teams without baselines spent Q4 2023 guessing whether their latency regression was microcode, the cloud provider, or imagination.
Why it still matters in 2026
Downfall and Inception closed the era’s argument: transient execution is a permanent tax, not a bug family that gets solved. Since then every CPU generation ships with the class in its threat model, cloud providers publish standing side-channel isolation tiers, and “gather instruction” became a phrase security architects know on sight. The 2023 dual-reveal also normalized the disclosure rhythm you now see yearly: research window → coordinated microcode → measured fleet rollout → quiet acceptance. Your budget line for “CPU weather” is permanent. Pretending otherwise is how production latency mysteries get born.
Was anyone exploited in the wild?
No public evidence of in-the-wild exploitation for either flaw as of the disclosure window — typical for this class, since transient-execution attacks are difficult, noisy, and better suited to research than to criminal ROI. Absence of evidence isn’t evidence of absence, but the practical risk tier was always nation-state adjacent snooping, not commodity malware.
Do I need to do anything in 2026?
If your fleet is current on microcode and OS mitigations, no action beyond keeping it that way. The standing risks are unmanaged bare metal and ancient cloud images — both of which keep shipping vulnerable microcode years after fixes exist.
Why can’t these bugs be fixed properly?
Because the flaw is the feature. Speculation is why your CPU is fast; removing it entirely means removing performance. Vendors instead serialize or flush the specific instruction patterns that leak, case by case, generation by generation.
AMD and Intel both? Whose fault is this?
Neither vendor’s “fault” uniquely — the class emerges from shared industry-wide bets on speculative execution made in the 1990s-2000s, before anyone modeled them as attack surface. Downfall and Inception landing together simply proved the problem is architectural, not vendor-specific negligence.
Part of the hmmnm.com security-timeline series — one event per month, 2021–2024, indexed here.
Detection and response playbook
CPU speculation bugs like Downfall (CVE-2022-40982) and Inception (CVE-2023-20569) break the boundary between processes on the same core, letting attacker-controlled code infer secrets from victim execution. Response differs from every other vulnerability class because the patch is microcode that costs performance and the exploit leaves almost no log.
- Risk-rank by co-tenancy, not by CVSS. The threat model requires attacker and victim code on the same physical core with shared resources. Multi-tenant hosts running untrusted workloads next to secret-handling processes are the exposure; dedicated single-tenant fleets mostly are not. Rank remediation by scheduler adjacency, and document the decision — auditors will ask why you accepted a documented CPU bug.
- Measure the microcode patch cost before fleet-wide rollout. The fixes slow specific instruction sequences (gather-heavy code, crypto loops). Benchmark your real workloads — encryption throughput, data-processing pipelines — on a canary group first, then decide per-fleet. Some clouds chose to keep vulnerable microcode with hypervisor-level scheduling isolation instead; that is a legitimate answer if written down.
- Detect the exploitation pattern where it must surface. In-process secret theft via speculation produces high-resolution timing loops: cache-thrash signatures, repeated rdtsc-style instruction patterns, abnormal scheduling requests pinning threads to specific cores. EDR rules for side-channel primitives exist for exactly this family — enable them rather than assuming signature-based detection covers it.
- Segment the crown jewels out of the blast radius. The architectural fix is older than the bugs: key material and secret-handling processes on dedicated cores or separate nodes, cgroup-isolated from tenant workloads. This is the same defense that survived Spectre, Meltdown, and every successor — and it survives the next one too.
- Track the disclosure rhythm. These bugs arrive in families with embargoes and codenames (MDS, LVI, Retbleed, Downfall, Inception). When one lands, assume siblings exist for adjacent silicon generations and pre-book the benchmark and decision process so the next advisory is a checklist run, not a new fire drill.
Where this sits in the broader pattern
Downfall and Inception are sequels in the longest-running franchise in hardware security. Spectre and Meltdown (2018) established the genre: performance optimizations that speculate past architectural boundaries leak microarchitectural state. The successors — Foreshadow, MDS, LVI, Retbleed, and then Downfall and Inception in 2023 — varied the mechanism (branch prediction, store buffers, return predictors, gather sampling) without changing the plot: code that should be isolated shares silicon, and sharing is observable.
The industry response matured along the way. Early waves produced panic patching and measurable performance hits; by the Downfall era, the process was risk-ranked — cloud providers patched multi-tenant fleets first, applied hypervisor scheduling mitigations where microcode costs were unacceptable, and documented the tradeoffs. That maturation is the real story: speculative-execution bugs moved from existential event to managed risk category within five years, and organizations that internalized the co-tenancy threat model now treat each new entry as a checklist run.
The strategic lesson for defenders mirrors the xz backdoor postmortem in an important way: the most durable risks live in components everyone assumed were safe — the CPU itself, the boring compression library — and the only sustainable defense is architectural isolation of what matters most, applied generically enough to cover the bugs you do not yet know about.
The bottom line. Speculation bugs tax trust in the silicon itself, and the tax recurs. You cannot patch a CPU generation out of existence, but you can control what shares cores with your secrets. Risk-rank by co-tenancy, benchmark before fleet-wide microcode, isolate key-handling processes, and keep the decision documented. The next name in this family will arrive; whether it is an emergency or a checklist item was decided by the architecture you run today.
One practical note for vulnerability-management teams: silicon vendors now ship these fixes through both OS-level microcode updates and firmware channels, and fleets routinely apply one and not the other. Verify both delivery paths during your next patch cycle, and record per-generation microcode versions in your asset inventory — when the next family member is announced, the first question every vendor asks is which microcode you run, and most teams cannot answer. The audit is cheap; the absence of the answer is not.
Frequently Asked Questions
{“@context”:”https://schema.org”,”@type”:”FAQPage”,”mainEntity”:[{“@type”:”Question”,”name”:”What are the Downfall and Inception CPU vulnerabilities?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Downfall (CVE-2022-40982, Intel) and Inception (CVE-2023-20569, AMD) are speculative-execution flaws letting malicious code on the same core infer data from other processes or the kernel via CPU internal buffers, leaking secrets like encryption keys.”}},{“@type”:”Question”,”name”:”Do Downfall and Inception require attacker code on the machine?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Yes — exploitation requires running attacker-controlled code on the same physical core as the victim, so multi-tenant servers and shared-hosting environments are the main risk; remote exploitation is not practical.”}},{“@type”:”Question”,”name”:”Should you apply the microcode patches immediately?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Apply by risk: prioritize multi-tenant and untrusted-workload hosts, benchmark performance-sensitive fleets first (the fixes measurably slow certain instruction sequences), and document acceptance decisions for low-risk fleets.”}}]}
Related Reading
- What Studying 33 Historic Cyberattacks Taught Me About Defending Systems Today
- Passwordless in 2026: Why Passkeys Are Finally Killing the Password (and How Attackers Are Adapting)
- 2022–2024: Lapsus$, Change Healthcare & the XZ Backdoor
- Authoritative reference: CISA Known Exploited Vulnerabilities
- CurveBall CVE-2020-0601: Forging Trust With One Elliptic Curve Paramet
- DST Root CA X3 Expiry: The Scheduled Outage That Mostly Wasn’t
- Snowflake-Related Arrests: UNC5537’s Kitchener Pinch
