Blog / Taxonomy & Classification

Spectre Is Not a Physical Attack

We classified transient execution as #8 Physical Attack and shipped it. The post-mortem is not about our mistake — it is about how four authoritative sources describe one vulnerability, and why nothing in the ecosystem records which question each of them answered.

Opus 5 Extended Thinking • • Loading...
Abstract

Our CWE mapping classified Spectre as #8 Physical Attack. It was wrong, we shipped it, and we have now fixed it. This article is the post-mortem. The interesting part is not our error — it is why the error was so easy to make. Following the same vulnerability through MITRE’s Hardware Design view, MITRE’s Research view, NVD’s actual CVE assignment, and CVSS yields four different implied causes, which map onto three different TLCTC clusters. Nobody reconciles them, because nothing in the ecosystem records which question a weakness ID is answering. Rowhammer shows why the obvious fix — gating on whether the attacker needs physical access — is also wrong. We propose the distinction that does work: is the physical property the vulnerability, or the readout channel?

Start with the confession.

Until this week, the TLCTC CWE mapping classified CWE-1420 — Exposure of Sensitive Information during Transient Execution, the Spectre family — as #8 Physical Attack. The machine-readable rationale we published said, in as many words:

“Microarchitectural side-channel — sensitive information exposed during transient (speculative) execution via cache-state, branch predictor, or other shared microarchitectural structures. Spectre-class. Decision tree Q7 -> #8.”

Spectre can be mounted from JavaScript, in a browser tab, against a machine the attacker has never physically touched. That fact is vivid, and it is not the argument — we will come back to why, because getting this wrong is how we got here in the first place.

The argument is what Spectre attacks. A processor speculatively crosses an isolation boundary it was designed to enforce. That is implemented logic failing. The physical layer supplies the readout channel; it is not the thing being exploited. We had it filed under the cluster whose generic vulnerability is “the physical accessibility of infrastructure and the exploitability of physical-layer properties” — and neither limb applies.

So how did a cause-oriented taxonomy, with an axiom explicitly forbidding classification by anything other than cause, end up here?

Q7, and the Damage One Word Does

Our CWE decision tree asked, at question seven:

Q7: Is this a PHYSICAL LAYER weakness?
(hardware debug interfaces, physical signal leakage, insufficient physical protection)

The intent was physical-layer phenomena. What the parenthetical actually communicated was hardware. And so the mapper — which was, we should say plainly, AI-generated and human-reviewed — answered a subtly different question than the one we meant to ask: not “does the attacker exploit a physical property?” but “is this CWE about hardware?”

Ninety entries landed in #8. Sixteen of them belonged there — voltage and clock glitching, electromagnetic fault injection, power side-channels, data remanence, thermal manipulation. Those genuinely abuse a physical property.

The other seventy-four arrived because they were about silicon. Including three covert-channel entries that are not even hardware.

The Failure Mode, Named

We classified the substrate — where the flaw lives — instead of the cause — what the attacker abuses. It is precisely the same error shape as classifying “ransomware” as a threat because that is what the incident looked like, which Axiom III already forbids. Axiom III catches classification by outcome. Nothing in the framework caught classification by location.

The Obvious Fix Is Also Wrong

The tempting correction is to gate #8 on attacker access: if exploitation needs proximity or possession, it is physical; otherwise it is not. It is crisp, it is testable, and it disposes of Spectre immediately.

It is also wrong, and Rowhammer is why.

Rowhammer repeatedly activates a DRAM row until charge leaks into adjacent cells and flips bits the attacker was never permitted to write. It can be mounted from JavaScript. No proximity, no possession — and it is unambiguously an attack on physical properties. The access test files it as “not physical,” which is plainly absurd.

MITRE says this outright, in the CWE that covers the category. CWE-1256 lists Rowhammer among its examples (citing CVE-2015-0565, where NaCl permitted the CLFLUSH instruction) and frames the entire weakness class as software-controllable mechanisms that “enable attackers to mount fault injection and side-channel attacks without having physical access to the device.”

So access cannot be the test. Compare the two attacks on what they actually exploit:

RowhammerSpectre
Does anything logical fail?No. Legal reads, legal addresses, correct permissions throughout.Yes. Speculation crosses an isolation boundary the design was meant to enforce.
Role of the physical layerThe vulnerability. Charge migrates between adjacent capacitors.The readout channel. Timing reveals residue left by a logical failure.
Remove the physics — is there still a flaw?No. Nothing remains.Yes. A design that speculatively crosses a privilege boundary.
Cluster#8#2
The Test

Is the physical property the vulnerability, or merely the readout channel? Put another way: is the attack against the implemented logic, or against the physical representation that logic runs on? Rowhammer attacks the representation. Spectre attacks the logic and reads the answer off the representation. Attacker proximity never enters into it.

This also fixes something the access test gets wrong in the other direction. Power side-channel analysis (CWE-1300) involves no logical error whatsoever — the cryptography is correct, it simply emits. The emission is the vulnerability. It stays #8 whether the attacker is holding an oscilloscope or reading a software-accessible power meter.

And notation-wise, Rowhammer is a two-step path, not one: #7 → #8. The attacker’s hammering code executing is the environment’s designed capacity to run foreign code being abused. The bit flip is a physical property being abused. Two generic vulnerabilities, so two steps — TLCTC’s single-cluster rule does not let you merge them.

MITRE Is Not the Culprit Here

It would be convenient to blame the source data. That would be unfair, and the truth is more interesting.

CWE-1194 “Hardware Design” is a View, and MITRE labels it honestly. Its stated objective is to organize “weaknesses around concepts that are frequently used or encountered in hardware design,” and its stated audience is hardware designers, manufacturers, educators, and assessment vendors. It is a location-based organization, by design and by declaration, and MITRE is explicit that this differs from threat-model or attack-vector approaches.

More striking: CWE’s own Research view — the cause-oriented one, CWE-1000 — places CWE-1420 under CWE-669, Incorrect Resource Transfer Between Spheres. That is an information-flow parent. It is, we would argue, very nearly the right answer. It is certainly not a physical one.

So CWE already contains the correct classification. It simply also contains another one, in a different view, for a different audience — and nothing in the identifier CWE-1420 records which of the two you arrived through.

Four Answers to One Question

Now follow Spectre — one vulnerability, CVE-2017-5753 — through the ecosystem, and run each waypoint through the TLCTC mapping to see what cause it implies:

ArtifactWhat it saysImplied causeTLCTC cluster
CWE Hardware Design view (1194)CWE-1420, hardware weaknessFlaw in silicon#8 (as we mapped it)
CWE Research view (1000)ChildOf CWE-669Resource crosses a sphere boundary#1
NVD’s assignment for CVE-2017-5753CWE-203, Observable DiscrepancyObservable behavioural difference#2 | #3
CVSS v3.1 base vectorAV:L — LocalExploitation is local, not remote— (answers a different question)

Four authoritative artifacts describing one vulnerability. Three distinct TLCTC clusters. And note what the fourth row does not do: CVSS looks like it should settle the dispute — it even has an AV:P value for physical attacks — but Rowhammer is also AV:L, and Rowhammer is physical. The one field that appears authoritative is answering a question about access, not about mechanism. It cannot adjudicate, and it was never built to.

This is not a case of one party being wrong. Every one of these is defensible for the question it was built to answer. CWE-1194 answers “where in a hardware design does this live?” CWE-1000 answers “what kind of weakness is this?” NVD answers “what weakness does this specific CVE instantiate?” CVSS answers “what access does exploitation require?”

The problem is that all four emit into the same pipelines, wearing the same kind of identifier, with no field recording which question they answered. Downstream, a consumer walking the tree cannot tell. We know, because we are that consumer, and we could not tell.

What We Would Ask of MITRE

CWE records Modes of Introduction — the lifecycle phase where a weakness enters. It records Applicable Platforms. It records Likelihood of Exploit. These are all properties of the weakness as an artifact.

It does not record the one property a threat taxonomy most needs: what the attacker must abuse to exploit it.

We nearly asked for the wrong attribute here, and the near-miss is instructive. The intuitive request is a boolean for “does exploitation require physical access?” — which would indeed have stopped us filing Spectre under #8. It would also have filed Rowhammer as not-physical, because Rowhammer needs no access either. We would have traded one systematic error for another.

The attribute worth having is about mechanism, not access:

Does exploitation abuse a physical-layer property of the substrate — charge, voltage, timing-as-emission, temperature, wear — as opposed to a defect in implemented logic?

That is the field nothing in the ecosystem currently carries. CVSS answers access. CWE answers structure and location. Nobody answers mechanism, which is precisely the question a cause-oriented taxonomy has to ask first. Rowhammer would answer yes, Spectre no, and both would land correctly — which is the minimum bar for a distinction worth adding.

What We Would Ask of NIST

NVD publishes both the CWE assignment and the CVSS vector for every CVE. For CVE-2017-5753 it publishes CWE-203 and AV:L. Nothing checks them against each other, and nothing needs to, because they are understood to be independent fields.

But a consumer reading both fields cannot answer the question that matters. CWE-203 plus AV:L tells you the weakness is an observable discrepancy exploitable locally. It does not tell you whether the defender is facing a logic defect to be patched in microcode or a physical property of the silicon that cannot be patched at all. For Spectre and for Rowhammer, those two fields look nearly identical — and the remediations could not be more different.

That gap is a prioritisation problem at national scale. A vulnerability database that cannot distinguish “fixable in software” from “inherent to the substrate” is withholding the single most decision-relevant fact it has. Surfacing the mechanism attribute above — once MITRE records it — would cost NVD nothing and change how a great many patch-versus-mitigate calls get made.

What We Changed

The first pass moved nine entries. The covert channels — CWE-385 timing, CWE-515 storage — became #1 Abuse of Functions: a covert channel abuses a path that exists by design but was never intended to carry data. CWE-514, the abstract parent, became N/A and Discouraged. The six transient-execution entries became #2 Exploiting Server.

That left about fifty-five entries — register and lock-bit weaknesses, fabric and SoC access control, debug and test interfaces, security-identifier handling — which we parked, because they seemed to depend on a question we could not answer by assertion. TLCTC defines #2 and #3 in terms of “source code implementation.” Is RTL source code? If yes, a hardware access-control flaw reachable from software is #2 and much of CWE’s hardware branch is not #8 at all. If no, TLCTC owed an account of where hardware implementation flaws live that was not simply “#8, because hardware.”

We never had to answer it.

The Question Dissolved

“Is RTL source code?” is a question about where the defect lives. R-SUBSTRATE does not ask that. It asks what the attacker exploits. Run the removal test on a register access-control flaw — if every physical property of the silicon behaved ideally, would the flaw remain? Yes: the permission check is still wrong. So it is a logic defect, and whether we call its source RTL or C never enters the reasoning. A good discriminator does not merely answer the hard question; it shows the hard question was the wrong one.

So the re-audit ran all eighty-one entries through that single test, and #8 came out at sixteen:

OutcomeCountWhat they are
Confirmed #816Glitching, EM fault injection, power side-channel, semiconductor defects, single event upsets, wear, remanence, decommissioned media, IC imaging, thermal, environmental, physical access control
Moved to #252Register/lock-bit/fuse, fabric/SoC/bus/NoC, security identifiers, sequencing, state machines, address decoding — access-control and configuration logic that happens to be implemented in silicon
Moved to #2 | #34Blocks that consume data a lower-privileged entity can influence, rather than servicing its requests
Moved to #2 | #87Debug/test interfaces and trace data — genuinely context-dependent
Moved to #12Unmasked password field; undocumented features and chicken bits

The four #2 | #3 entries are a second-order correction we nearly missed. Our first pass sent all fifty-six to #2 on one blanket argument: hardware services software, so it is in server role. True for fifty-two. But four of them — assumed-immutable data read back from writable memory, a verifier trusting mutable attestation data, state restored after a power transition, a boot chain with no immutable anchor — do not service a request at all. They consume something a less-privileged entity can influence, which is client role. Same class of mistake as the one this article is about, one level down: a plausible generalisation applied without checking each case against it.

The seven we left as #2 | #8 are worth dwelling on, because they are where the rule stops being mechanical. #8’s definition covers “physical interaction with … interfaces.” A JTAG port with no access control, reached by soldering onto a board, really is a physical attack — the exposed interface is the accessibility being abused. The identical weakness, reached from a software-visible debug register, is an access-control defect. Same CWE, two different attacks, and no honest way to collapse them into one cluster. They resolve at the CVE.

One entry outside the bucket needed fixing too. CWE-1256 was mapped #1 | #8, and its stated justification for the #8 branch was that “physical-vector exploitation requires hardware access.” That is the access criterion, in our own file, defended in prose. The branch survives — but on the correct ground, which is that a physical property is what gets abused. It is a small entry and an instructive one: the wrong test does not announce itself. It reads perfectly reasonably right up until Rowhammer walks past.

Axiom III Needs a Sibling

Axiom III says threats are causes, not outcomes. It is the axiom that stops “ransomware” and “data breach” from becoming threat categories, and it has done that job well enough that we assumed it covered the general case.

It does not. “Ransomware” is a classification by consequence — downstream of the cause. “Physical Attack, because the flaw is in silicon” is a classification by location — orthogonal to the cause. Axiom III has nothing to say about the second, which is why our own mapping walked straight into it while the axiom looked on.

So we would state the sibling explicitly, and we would offer it beyond TLCTC, because the failure mode is not ours alone:

Substrate is not cause. Where a weakness resides — hardware, kernel, browser, protocol, cloud control plane — constrains who can reach it. It does not determine what the attacker abuses. A taxonomy that permits classification by location will eventually be used that way, and the resulting categories will look rigorous while carrying no causal content at all.

The inverse deserves stating too, or the correction overshoots. Physical properties are perfectly good causes when they are what gets abused. Rowhammer belongs in a physical cluster, and so does power analysis, and so does electromagnetic fault injection — not because they involve hardware, but because charge migration and emission and glitch susceptibility are the exploited thing itself. The error was never “hardware got classified as physical.” It was that everything in hardware got classified as physical, which drained the category of meaning in both directions: it swallowed logic defects that happened to ship in silicon, and it offered no way to say what the genuinely physical entries had in common.

Every taxonomy that offers a location-shaped view offers this trapdoor. CWE labels its view honestly and still got walked through the wrong door by a careful consumer. That is worth knowing before the next one builds a hardware branch.

The test now sits in the framework as R-SUBSTRATE, alongside R-FLOOD (#6) and R-CHANNEL (#5) — three rules with one shape, each preferring a specific generic vulnerability over the residual “it was a code defect” answer. We put it there rather than leaving it in this article deliberately. A classification principle that lives only in prose gets re-derived, badly, by the next person who needs it; the whole reason our mapping went wrong is that the reasoning behind Q7 was never written down anywhere a reader could check it.

Our error is fixed and published, with the reasoning recorded in the audit history — including the seven entries we could not honestly collapse into one cluster, and the fact that a sixty-five-entry correction traces back to one imprecise parenthetical in a decision tree. We would rather be the worked example than the cautionary tale, but we will take either, provided the distinction gets made somewhere more durable than a decision tree in one project’s repository.