← Essays /Post · 17 of 28 · Methods

The CRA Begins: Embedded Software's Center of Gravity Moves

September 11, 2026: the EU Cyber Resilience Act's first duty applies. I see it less as compliance than as embedded engineering's center of gravity moving.

·8 min read · · · #cra#sbom#security#compliance#embedded-linux
The CRA Begins: Embedded Software's Center of Gravity Moves
On this page

Five months left.

On September 11, 2026, the first obligation of the EU Cyber Resilience Act (CRA) takes effect. From that day, every manufacturer shipping digital products into the EU market must file an early warning to ENISA and national CSIRTs within 24 hours of learning about an actively exploited vulnerability (followed by a full notification within 72 hours and a final report within 14 days, in a three-stage obligation). On December 11, 2027, the CRA itself comes into full force. From then on, products that don’t meet the essential cybersecurity requirements in Annex I cannot be sold in the EU market. A violation can cost up to €15M or 2.5% of global annual revenue, whichever is greater.

At first it looks like one more regulation. Most places are handling it that way. I think that is the most expensive misreading. There is an answer to how embedded software should be built, one engineers have known and put off for the past decade. The CRA turns that answer into law.

What Actually Changed

If I compress the core of the CRA into one sentence, it comes out like this:

Security responsibility has shifted from “the moment of product launch” to “the product’s entire lifetime.”

In the old model, security was a checkpoint. You got certified, you shipped, you pushed the occasional patch. The moment of certification was the peak of security work. After the CRA, that moment becomes the starting line. Every device in the wild, for every day it’s alive, sits under a cybersecurity obligation.

So what exactly does it force? CRA Annex I, Part I defines 11 “Essential Cybersecurity Requirements.” One of them is very short: “Products shall be designed and manufactured to reduce the attack surface.” I would like this to be a recommendation. It is a mandatory requirement. If you can’t answer the market surveillance authority when it asks “why is this package in here,” you are in violation. “Debugging convenience” does not work as an excuse.

Annex I, Part II requires SBOMs in machine-readable format (SPDX, CycloneDX, etc.) as part of the product’s technical documentation. Every single package becomes an item in a permanent legal record. Each library we add to a BSP is treated, from that moment on, like an asset entered in a public registry.

Article 13 forces the support period to match the product’s expected use period. The minimum is five years. But a product whose catalog says “15-year operation” carries a legal 15-year support obligation. A number a PM wrote as marketing copy ends up deciding how long the BSP team is bound. And for that whole period, security updates must be free.

Article 14 defines the reporting obligation: 24-hour early warning, 72-hour detailed report, 14-day final report. The clock starts the moment you find out.

Put these four provisions on top of each other and a new equation appears.

One package in our BSP = one tracking, patching, and reporting obligation for the next N years.

A thousand packages means a thousand obligations. Free of charge, within 24 hours. And all of it in an environment where 131 new CVEs land every day.

The Numbers Are 10x

Why now? The numbers answer that.

48,174 new CVEs were filed in the 2025 NVD. That’s 131 a day on average. The Linux kernel alone accounts for 5,530, which works out to 8 to 9 new kernel CVEs every day. The median time from exploit disclosure to actual exploitation has dropped below five days. Industry data shows that more than half of breaches happen through known vulnerabilities that already had a patch.

The assumptions that held the old model up are gone.

Ten years ago, annual CVEs ran 5,000 to 7,000. A small security team could triage by hand, and you could pack 1,000 packages into a BSP without the operating cost showing. Yocto’s default images inherited desktop-Linux assumptions and grew to match, and nobody counted that growth as a cost.

The volume is now 10x. There is no way to match, evaluate, and decide on 100+ new vulnerabilities a day by hand. For automation to keep up, the number of components you track has to fit inside what automation can handle.

This, as I see it, is the core of the situation the CRA created. The 24-hour report is tied directly to BSP size. With few things to track, it can be done; with many, it can’t. “Keep the attack surface small” sounds like an aesthetic recommendation. In practice it is the precondition that lets the legal obligation be met at all.

The Cloud World Already Answered This

There is a thread embedded engineers tend to miss. The cloud and container world met this same problem 5 to 7 years earlier, and it has already answered it. Embedded is the only one that is late.

That answer is called distroless.

A company called Chainguard built Wolfi, a “non-distribution,” and uses it to package container images with only the application and its runtime dependencies. No shell, no package manager, no debugging utilities. The result shows up in numbers: Chainguard images cut CVEs by an average of 97.6% versus their OSS equivalents. The gap does not come from better patching. It comes from having less in there to begin with.

There is a more important principle behind it: don’t update, replace. Chainguard never runs apk update inside a container. When a new version is needed, they build a new image and swap the whole thing. Every base image is rebuilt automatically every night. This is Google’s internal “build horizon” thinking: even microservices whose code hasn’t changed get rebuilt on a fresh base on a regular cadence.

Minimize and replace. Those two principles are how the cloud holds up under the CVE flood.

You can’t carry this over to embedded as it is. There is no way to make a whole BSP distroless. The boot chain, the kernel, and the HAL have to stay where they are. The idea, though, can come across.

Physically separate the slow-changing layer from the fast-changing one. BSP gets the boot chain, the kernel, and a minimal OS. Anything that needs frequent updates (security libraries, communication stacks, applications) goes into containers or a separately statically-linked channel. Then the BSP itself takes one big upgrade every five years, and the CVEs that turn up weekly get handled in the fast layer. As long as two regions on different rebuild cadences live inside the same image, the CRA’s 24-hour reporting is impossible.

LLMs Widen the Asymmetry

At the same moment the CRA takes effect, another change is under way. LLMs reached attackers first.

On April 22, 2026, a week before this post, Deutsche Telekom’s Red Team disclosed a 12-year-old TOCTOU bug in PackageKit (CVE-2026-41651, “Pack2TheRoot”). PackageKit is a daemon shipped on nearly every major Linux distribution. The finding came out of AI-assisted research with Claude Opus. They steered the model in a specific direction and turned up an exploitable vulnerability.

The cost of finding new CVEs is falling. Quickly.

From the defender’s side, this is asymmetric. Attackers turn “LLM × time” into vulnerabilities. We have to track and respond to those findings across every single component inside our BSP. The attacker’s cost falls with time, while ours scales with BSP size. As time passes, the gap widens.

The defensive side is in worse shape than it looks. When I benchmarked LLMs on 233 embedded firmware cases, the best model cleared 68.0%, and the categories it failed hardest on were DMA, ISR, and threading. Those are the same places where a defect turns into a CVE instead of staying a bug report.

Suppose that gap keeps widening across a 15-year support window. On that assumption, the only way to survive is to shrink our own surface. Patching faster has limits, and 24 hours is already the limit. What remains is having less to patch.

Three Mindset Shifts

Within the next five years, I expect teams that treat the CRA as compliance work to part ways with teams that treat it as a change to the game itself. Becoming the second kind of team takes, I think, three shifts in mindset.

See packages as contracts, not assets.

Adding a line to IMAGE_INSTALL is signing a contract for that package’s CVE tracking, backporting, verification, and reporting for the next N years. Once this view settles in, decisions change on their own. The default question stops being “why remove it?” and becomes “why add it?” Debugging tools left behind in production (which happens more often than you’d think) become rarer too, because anything that goes in is hard to take out.

In day-to-day operation, every package addition should carry a name. Who added it, and why. Who will justify it at the next LTS migration. A package without a name does not go in.

Translate BSP size into compliance opex.

Suppose your BSP has N packages today. SBOM entries for the next 15 years: N. Daily new CVE matches: proportional to N. Some of those will fall in scope for 24-hour reporting. For each one, you have to produce a patch, a backport, or a mitigation, for free. At conformity assessment, a Notified Body audits N items.

When N is large, everything is large. No other single decision shapes 15-year operating cost as much as BSP size does. That makes BSP slimming closer to a compliance opex reduction line than a security R&D line. The message that goes up to leadership has to change to match.

Adopt “rebuild speed” as a security KPI.

In the CRA era, I think the single metric that best stands for security capability is how long it takes to rebuild the entire firmware from scratch. When a CVE drops on one critical dependency, it is the lead time from “build a new image from zero” to “OTA deployed.” When this is short, 24-hour reporting is possible, 15-year support is possible, and swapping Yocto LTS releases is possible. When it’s long, none of it is.

This time is roughly linear in BSP size. Build time, regression test time, QA time, OTA verification time: all of them grow with the package count. A small BSP makes a fast rebuild, and a fast rebuild makes compliance possible.

Closing

I don’t see the CRA as compliance work. It is engineering that has been right for the past decade finally getting a way to be enforced with penalties.

Build small, replace fast, own it forever. The cloud world worked out five years earlier that this is the only way embedded software survives the CVE flood, and it proved the answer. The CRA only extends that answer, by law, to every device maker selling into the EU.

Seen that way, the five-month countdown reads less like a burden and more like a signal of direction. Everything the CRA forces (smaller attack surface, SBOMs, 24-hour reports, free patches) is what good embedded software should have had anyway. It was put off only because the cost could not be seen. Now the cost is visible. The penalty is set, and the operating cost can be computed.

You can’t change everything in five months. But where to go is clear: small, modular, fast rebuild. In the game that starts September 11, those three things are what it takes to survive.

ecro
Written by ecro

Created an LLM benchmark for firmware. EmbedEval →

Building a project-shaped agent harness for Claude Code, Cursor, and Codex. harness-maker →

Building a serial and SSH terminal where coding agents work on the board beside you. NeuroTerm →

Comments

Loading comments...