A usable firmware SBOM is a merge of what your build can report and what only your team knows: a generator that reads the build (for Zephyr, west spdx), a hand-kept manifest for the vendor SDK code, binary blobs and copied C files that no tool can name, any SBOMs your vendors supply, and a check of the linked image against all of them. Publish one machine-readable SBOM per firmware image and release, in SPDX or CycloneDX, giving each component’s producer, version, identifiers, hash and license, and write “unknown” wherever you do not know. The EU Cyber Resilience Act asks for an SBOM covering at least top-level dependencies, and FDA asks sponsors of cyber devices for commercial, open-source and off-the-shelf components plus each component’s support status, so one SBOM built this way can serve both.
This guide is for the firmware engineer or CTO who has been asked for “the SBOM” by a regulatory lead, an EU distributor or a hospital buyer, ran a scanner over the repository and got back a nearly empty list. It covers what the 2026 minimum elements ask for, why microcontroller code defeats package scanners, how to generate and complete the SBOM, which format to choose, and what the CRA and FDA expect it to cover. Nothing here is legal or regulatory advice; which rules apply depends on your product and where you sell it.
What a firmware SBOM has to contain in 2026
A software bill of materials (SBOM) is a machine-readable inventory of the components in a piece of software and how they relate to each other. The current reference for what it should contain is the 2026 Minimum Elements for a Software Bill of Materials, published on July 29, 2026 by CISA, the NSA, the FBI and international partners, which replaces the minimum elements NTIA published in 2021.
The EU’s Cyber Resilience Act (CRA) uses a compatible definition. Article 3(39) of Regulation (EU) 2024/2847 calls an SBOM “a formal record containing details and supply chain relationships of components included in the software elements of a product with digital elements”.
The 17 data fields
The 2026 document lists 17 data fields in two groups: nine describe the SBOM itself and eight describe each component. Several are new since 2021, including the hash, the license and a signature over the SBOM. Here is what each means for a microcontroller image.
| Element | What to record for a firmware image |
|---|---|
| SBOM Author | The entity that generated the SBOM, usually your company, written out in full |
| SBOM Author Signature | A digital signature over the SBOM file |
| SBOM Data Format Name and Version | For example SPDX 2.3 or CycloneDX 1.6 |
| SBOM Generation Context | “Build” for a generator run on the build, “after build” for binary analysis |
| SBOM Timestamp | When the SBOM data last changed, formatted per RFC 9557 |
| SBOM Tool Name and Version | The generator, for example west spdx and the Zephyr version it came from |
| SBOM Version | Raised when you correct the SBOM for the same firmware version |
| Component Producer | Who made the component, or an explicit “unknown provenance” |
| Component Name and Version | As the producer names and numbers it, or “unknown” |
| Component Identifiers | At least one common identifier, such as a CPE or a PURL |
| Component Hash Value and Algorithm | A hash of the component artifact, with the algorithm named |
| Component License | SPDX license identifiers, including any proprietary terms |
| Component Dependency Relationship | Which component includes or links which |
Two renamed fields matter for firmware. Component Producer replaces the 2021 “Supplier Name”, which CISA says proved ambiguous around distributors; that is exactly the case of a chip vendor redistributing someone else’s library. Component Identifiers now asks for at least one common identifier, naming CPE (Common Platform Enumeration, the naming scheme the US National Vulnerability Database uses) and PURL (Package URL, now standardized as ECMA-427), and allows commit hashes as well.
The six practices
The document also sets six practices: Accommodation of Updates to SBOM Data, Coverage, Distribution and Delivery, Explicitly Identifying Unknown Information, Frequency, and Machine-Processable Data. Three change how a firmware team works.
- Coverage. The 2021 “Depth” element asked for top-level dependencies only. Coverage now asks for “all components that make up the target software, including transitive dependencies”, and states “There is no minimum depth.”
- Frequency. “Each software version or update should have an associated SBOM.” A new build or release gets a new SBOM.
- Explicitly identifying unknown information. If you do not know a field, say so, and distinguish information you do not know from information you are withholding.
The document is guidance. It says it does not create new requirements and is not compliance, regulatory or legal advice. Regulators set their own expectations, covered later in this article, but the 2026 elements are what an informed customer will check your file against.
Why package scanners miss most of a microcontroller image
Most software composition tools find components by reading package manifests and lockfiles, and a C firmware repository usually has neither. Its components arrive as directories of copied source, as prebuilt archives and as code produced by configuration tools, so a manifest-based scan of a typical microcontroller project reports little or nothing. That is not a tool defect. The information the tool needs was never written down.
Here are the usual places components hide in firmware:
- Vendored source trees. The HAL, the USB stack and the file system arrive in a vendor SDK archive and get copied into a
third_party/folder. The version lives in a README, in a header comment, or nowhere. - Vendor forks. Chip vendors often ship their own forks of open-source projects. The nRF Connect SDK’s SBOM tool documentation, for example, uses an Mbed TLS fork in its sample output: the package is
nrfconnect/sdk-mbedtlsat versionv3.6.3-ncs1, with an upstream CPE and PURL for Mbed TLS 3.6.3 added so vulnerability databases can match it. - Prebuilt libraries and blobs. Bluetooth LE controllers, Wi-Fi firmware and DSP libraries often ship as
.afiles or images without source and sometimes without a readable version string. - Copied snippets. A CRC routine from an application note or a ring buffer from a blog post becomes part of your code. The 2026 CISA document notes that copied code “is effectively a dependency that is better tracked as a fork and a dependency relationship.”
- Generated code. Pin and clock configuration tools, devicetree processing and protocol code generators write C files at build time. The generator and its version are the component.
- Build configuration. Kconfig options and
#ifdefblocks decide what is compiled. A scan of the repository lists code that never reaches the image, and a scan of the SDK lists the whole SDK. - The toolchain. The C library and compiler runtime are linked statically into the image, so they are components of the shipped firmware even though they live in the toolchain.
- More than one image. A product can ship a bootloader, an application, a radio-core image and a cellular module’s own firmware. Each is software in the product.
The conclusion for firmware is that the build, not the repository, is the source of truth for what is in the image. The build tells you which files were compiled and which archives were linked. It cannot tell you who made a copied file or which SDK release a blob came from, and that is the part your team writes down by hand.
Four sources that together describe a firmware image
Treat the SBOM as a merge of four inputs: the build graph, the SBOMs your vendors supply, a manifest your team keeps by hand, and a cross-check of the linked image. Each covers a gap in the others, and the merge step is where unknowns get marked instead of silently dropped.
- Build graph. A generator reads the build system’s own record of sources, targets and link steps. It is precise about what was compiled and weak on provenance for anything without metadata.
- Vendor SBOMs. Some SDKs and module makers can supply an SBOM for their release. Where one exists, it is better than anything you can reconstruct.
- Hand-kept manifest. A small file in the repository, reviewed like code, describes blobs, copied code, generated code and anything else the generator cannot name.
- Binary cross-check. The linker map file lists every object and archive member placed in the image. Checking it against the first three inputs catches what they missed. CISA’s 2026 document likewise suggests binary analysis tools to detect components not listed in an SBOM.
Which input supplies which entry depends on the kind of component. The table below is the decision rule we would start from for a Zephyr or vendor-SDK project.
| Component class | Examples | Where the entry comes from | What usually goes missing |
|---|---|---|---|
| Your application | Application sources, board files | Build generator | Version tied to your release tag |
| RTOS and its modules | Zephyr kernel, MCUboot, Mbed TLS module | Build generator (Zephyr records PURL and CPE) | Upstream identity of a vendor fork |
| Vendor SDK in source form | HAL, drivers, middleware | The SDK's own SBOM tool, else the manifest | Which SDK release each library came from |
| Prebuilt libraries and blobs | Radio controller, Wi-Fi firmware, DSP library | Link command and blob metadata, plus the manifest | Version, license, support status |
| Copied C code | Sensor driver from a maker's repository, CRC from an app note | Manifest, recorded as a fork | Origin, upstream commit, local changes |
| Generated code | Pin configuration output, protocol code | Manifest entry for the generator | Generator version |
| Toolchain runtime | C library, compiler runtime | Link line, then the manifest if the generator omits it | The whole entry |
| Other images | Bootloader, radio core, cellular module firmware | A separate SBOM per image, or the module maker's SBOM | Module firmware version |
How to generate the build SBOM for Zephyr, vendor SDKs and bare metal
Use the generator your platform already ships before writing your own. Zephyr has west spdx, ESP-IDF has esp-idf-sbom, and the nRF Connect SDK has west ncs-sbom; for FreeRTOS and bare-metal projects you will usually build the list from the linker map and your manifest.
Zephyr: west spdx
The Zephyr 4.5.0 documentation describes west spdx as generating an SBOM for a Zephyr build “as a set of SPDX documents” that record the source files, the build artifacts and the relationships between them. On 4.5 the procedure is three steps:
# prj.conf
CONFIG_BUILD_OUTPUT_META=y
west build -b <board> -d build app
west spdx -d build --spdx-version 3.0
SPDX 2.3 tag-value is the default; SPDX 2.2, 3.0 and 3.1 can be selected, and the documentation marks 3.1 support as experimental. The tool writes four documents to build/spdx/: app for your application sources, zephyr for the Zephyr files used, build for the output files and modules-deps for module dependencies.
Several details make the 4.5 output closer to the 2026 elements than older versions:
- Hashes and licenses. Every file gets SHA512, SHA256 and SHA1 hashes. Licenses and copyright are read with the REUSE tool, so an
SPDX-License-Identifiercomment, a.licensefile or aREUSE.tomlat the repository root all count. The documentation notes thatREUSE.tomlis the only way to license a file that cannot hold a comment, binary blobs in particular, and that copyright extraction is best-effort. - Identifiers. Each package records a supplier, a PURL pinned to the release tag or the exact revision, and for Zephyr itself a CPE such as
cpe:2.3:o:zephyrproject:zephyr:4.4.0:-:*:*:*:*:*:*. - Prebuilt libraries. Libraries linked into the image, “such as the binary blobs of a vendor HAL”, are read from each target’s link command and tied to the output with a
STATIC_LINKrelationship. For blobs declared in a module and fetched withwest blobs, the entry carries the blob’s version and download URL, and the tool warns when the file’s SHA256 differs from the declared one. - Several images. With sysbuild, run the command against the application’s own build directory, for example
west spdx -d build/hello_world. Run it again for the bootloader image if you ship MCUboot, because that is a separate image with its own components.
If your product is on the 3.7 long-term support release, the Zephyr 3.7.0 documentation describes an older flow. You run west spdx --init -d build before configuring the build, the output is SPDX 2.3 tag-value only, files get SHA256 and SHA1 hashes, and licenses come only from SPDX-License-Identifier comments. That page does not describe the handling of prebuilt libraries, so plan to list blobs in your manifest. In 4.5 the --init option is deprecated and is to be removed in Zephyr 5.0. The documentation also notes that SBOM generation is not supported for the native_sim platform.
Zephyr modules can describe themselves for vulnerability tracking. The modules documentation lets a module’s zephyr/module.yml carry a security: external-references: list of CPEs and PURLs, which is how a fork can point back at the upstream project. If you maintain a private module, such as a sensor library shared across products, give it this block.
For how the RTOS choice itself affects long-term maintenance, see Zephyr vs FreeRTOS vs bare metal.
Vendor SDK generators
Espressif’s esp-idf-sbom creates an SBOM from the project_description.json file the ESP-IDF build writes. As of November 2026 its README lists SPDX 2.2 tag-value as the default, plus SPDX 2.2 JSON, SPDX 3.0 JSON-LD and CycloneDX 1.6 JSON. It reads sbom.yml manifest files placed in a project, component or subdirectory, with fields such as name, version, repository, CPE and PURL, which is the same hand-kept manifest idea applied to ESP-IDF components. Its check command looks up vulnerabilities in the National Vulnerability Database by CPE, and by default it only examines packages reachable from the project package, to avoid reporting code that was compiled but not linked.
Nordic’s nRF Connect SDK ships west ncs-sbom. Its README describes a list of the licenses used in a build or in chosen files, and marks generating that list from a build as experimental. It can write SPDX 2.3 or 3.0, records PURLs and the upstream references from each module’s module.yml, and can sign the report.
If your chip vendor offers no generator, ask. The questions to send are in the next section.
FreeRTOS and bare metal
Without a generator, the linker map is your build graph. It lists every object file and archive member placed in the image, with the path it came from. A short CI script can turn it into an SBOM:
- Parse the map file into the set of linked objects and archive members.
- Map each one to a manifest entry by path prefix, for example
third_party/fatfs/to the FatFs entry. - Fail the build if any linked object maps to no entry, so new code cannot slip in unlisted.
- Emit SPDX or CycloneDX from the matched entries with a library for your chosen format, and validate the output against the format’s schema.
This gives you Coverage by construction: anything in the image is either in the SBOM or stops the build.
For embedded Linux the picture is different. The Yocto Project manual says the OpenEmbedded build system generates an SPDX SBOM by default through the create-spdx class, written as IMAGE-MACHINE.spdx.json next to the image. If you are weighing a Linux processor against a microcontroller, that difference in tooling is one of the maintenance costs covered in microcontroller or embedded Linux.
How to describe vendor SDKs and binary blobs you cannot scan
For every component no tool can identify, write the entry yourself from the vendor’s release package and say plainly what you do not know. A short manifest kept next to the code, changed in the same pull request as the code it describes, is enough for most startups.
What each manifest entry needs
Each entry should carry the fields the 2026 elements ask for, plus two that FDA asks for:
- name and version, as the producer gives them;
- producer, written in full, or “unknown provenance”;
- where it came from: the SDK release name, a download URL or a repository and commit;
- SHA-256 of the artifact as received, for blobs and archives;
- license, as an SPDX identifier or a
LicenseRef-naming the vendor’s license file; - identifiers: the vendor’s CPE if one exists, otherwise a PURL;
- local changes, if you modified it, so it is recorded as a fork;
- the paths it occupies in your repository, so the map-file check can match it;
- level of support and end-of-support date, for FDA submissions.
A blob entry might look like this:
- name: ble-controller
producer: <chip vendor, full name>
version: unknown
source: <SDK release archive URL>
sha256: <hash of the .a file>
license: LicenseRef-vendor-sdk
support: maintained; end of support unknown
paths: [third_party/vendor/ble/lib/]
Handling unknowns honestly
Vendors do not always print a version inside a blob. When that happens, record the version as unknown and keep the hash, which identifies the exact bytes even without a version. The 2026 elements ask authors to state whether information is unknown or deliberately withheld, and to give recipients a way to ask about redacted security information. An SBOM that says “unknown” in three places is more useful than one that guesses, because a recipient can see exactly where the risk sits.
Copied code is handled the same way. Name it as if it were a local fork, record the URL and the upstream commit or version you copied, and note your changes. When a vulnerability is published against that upstream project, the entry tells you that you carry an affected copy.
What to ask your chip and module vendors
Send these questions when you choose a part, and again before production:
- Do you publish an SBOM for this SDK release, and in which format?
- Which open-source projects does the SDK include, at which upstream versions, and which are forks?
- For each prebuilt library or firmware image, what is its version string, hash and license?
- What is the support period for this SDK release, and where do you publish security advisories?
- For a radio module, what firmware does the module run, can we read its version at runtime, and how are its updates delivered?
These questions line up with the CRA’s due-diligence duty. Article 13(5) requires manufacturers to “exercise due diligence when integrating components sourced from third parties”. The Commission’s CRA FAQs, in the entry on the appropriate level of due diligence, list example actions including “performing software composition analysis on components”, “when available, reviewing the SBOM of that component” and “checking the support period of the component”. Recital 34 adds that vulnerability handling applies to products “in their entirety, including to all integrated components”, which is why a module’s own firmware belongs in your inventory.
Choosing SPDX or CycloneDX for firmware
Either format works. Pick the one your generator emits natively and your recipients can read, keep the generated original, and convert only when a recipient asks for the other format. CISA’s 2026 document names SPDX and CycloneDX as “the two data formats currently widely used” and asks producers to avoid versions the format maintainers have deprecated.
| Question | SPDX | CycloneDX |
|---|---|---|
| Standard | ISO/IEC 5962:2021 | ECMA-424; 2nd edition, December 2025, defines CycloneDX 1.7 |
| Current version (November 2026) | 3.0 listed as current on spdx.dev; 2.3 still widely emitted | 1.7, released October 21, 2025 |
| Maintained by | SPDX project, Linux Foundation | OWASP Foundation and Ecma TC54 |
| Firmware generators checked | west spdx (2.2, 2.3, 3.0, 3.1), ncs-sbom (2.3, 3.0), esp-idf-sbom (2.2, 3.0) |
esp-idf-sbom (1.6) |
| Vulnerability status | Separate VEX documents, such as OpenVEX or CSAF | VEX can be carried in CycloneDX itself |
Sources: SPDX specifications, CycloneDX specification overview and ECMA-424, each checked November 2026.
For a Zephyr team the practical default is SPDX: west spdx writes it with the most detail, and SPDX 3.0 adds a Build profile that records the toolchain and how each artifact was produced. If a customer’s tooling only reads CycloneDX, convert and validate the result, and expect some fields to be lost in translation. Whatever you choose, keep the format and version stable across releases so that the recipient’s tools and your own monitoring do not have to change each time.
What the CRA and FDA expect the SBOM to cover
The CRA requires an SBOM in “a commonly used and machine-readable format covering at the very least the top-level dependencies”, kept in the technical documentation and shown to market surveillance authorities on reasoned request. FDA’s section 524B requires sponsors of cyber devices to provide an SBOM covering “commercial, open-source, and off-the-shelf software components”, and its February 2026 guidance asks for support status and known vulnerabilities as well. This section is a summary of the texts as checked in November 2026, not legal or regulatory advice.
EU Cyber Resilience Act
Annex I, Part II, point (1) of the CRA requires manufacturers to “identify and document vulnerabilities and components contained in products with digital elements, including by drawing up a software bill of materials in a commonly used and machine-readable format covering at the very least the top-level dependencies of the products”. The other SBOM provisions are short:
- Technical documentation. Annex VII, point 2(b) lists the SBOM among the information on vulnerability handling processes that the technical documentation must contain.
- Authorities. Annex VII, point 8 covers providing the SBOM “further to a reasoned request from a market surveillance authority” where needed to check compliance with Annex I.
- Publication. Recital 77 says “Manufacturers should not be obliged to make the SBOM public.” If you do choose to share it with users, Annex II, point 9 asks you to say where it can be accessed.
- Format rules. Article 13(24) lets the Commission specify “the format and elements of the software bill of materials” by implementing act. The Commission’s implementation timeline, last updated July 27, 2026, lists no such act as of November 2026.
- Upstream reporting. Article 13(6) requires a manufacturer that identifies a vulnerability in an integrated component, including an open-source one, to report it to whoever manufactures or maintains that component.
Timing matters. Most CRA obligations, including Annex I, apply from December 11, 2027, but Article 14’s reporting of actively exploited vulnerabilities and severe incidents has applied since September 11, 2026. The Commission’s reporting page describes an early warning within 24 hours of becoming aware, and a current SBOM is what lets you answer inside that window whether a newly exploited flaw is in your firmware. The full timeline and the reporting duties are in our Cyber Resilience Act guide for device makers.
“At the very least the top-level dependencies” is a floor, not a target. The vulnerability handling duties apply to the product in its entirety, so a flaw in a library that your vendor’s SDK pulls in is still your problem. Building to the 2026 Coverage element meets the CRA floor with room to spare.
FDA and section 524B
Section 524B(b)(3) of the FD&C Act (21 U.S.C. 360n-2) requires the sponsor of a cyber device to “provide to the Secretary a software bill of materials, including commercial, open-source, and off-the-shelf software components”. A cyber device is one that includes sponsor-validated software, can connect to the internet, and has characteristics that could be vulnerable to cybersecurity threats. FDA states the authority took effect on March 29, 2023.
FDA’s current premarket cybersecurity guidance, issued in February 2026, adds detail. It recommends machine-readable SBOMs consistent with the minimum elements in NTIA’s October 2021 “Framing Software Component Transparency” document, and for each component:
- “the software level of support provided through monitoring and maintenance from the software component manufacturer”, such as actively maintained, no longer maintained or abandoned;
- “the software component’s end-of-support date”.
These may go in the SBOM or in an addendum. FDA also asks manufacturers to identify all known vulnerabilities in the device and its components, “including those identified in CISA’s Known Exploited Vulnerabilities Catalog”, to describe how they were found, and to give a risk assessment and risk controls for each. If you cannot provide SBOM information, the guidance asks for a justification.
The guidance still points to NTIA’s 2021 baseline rather than the 2026 elements. An SBOM built to the 2026 list carries the NTIA fields under updated names, so it should cover that baseline; add the two support fields as custom properties or an addendum. The wider premarket picture is in FDA cybersecurity for device startups, and our medical devices page describes the firmware evidence we prepare for a regulatory team.
The three references side by side
| Question | EU CRA | FDA, cyber devices | CISA 2026 elements |
|---|---|---|---|
| Status | Law; Annex I applies from December 11, 2027 | Statute since March 29, 2023, plus February 2026 guidance | Guidance |
| Depth | At least top-level dependencies | Commercial, open-source and off-the-shelf components | All components, including transitive |
| Format | Commonly used, machine-readable | Machine-readable, industry-accepted formats encouraged | SPDX or CycloneDX named as widely used |
| Who receives it | Technical documentation; authorities on reasoned request | FDA, in the premarket submission | As agreed between the parties |
| Extra content | None specified yet | Support level, end-of-support date, known vulnerabilities | Hash, license, signature, generation context |
A worked example: the LW-1 probe’s first SBOM
The fastest way to see the gaps is to build one SBOM for a real release and read it line by line. The example below follows the site’s fictional soil-probe startup through its first attempt.
Example (fictional). Loamwick prepares release 1.1.0 of its LW-1 soil probe firmware, the release that fixes moisture readings drifting upward in wet clay. The probe runs Zephyr with MCUboot in a 48 KB bootloader partition and a 412 KB application image. The team, assumed here to be on Zephyr 4.4.0, adds CONFIG_BUILD_OUTPUT_META=y, runs west spdx in CI, and then compares the result with the linker map.
| Component | How it entered the SBOM | Gap found and fix |
|---|---|---|
| LW-1 application 1.1.0 | app document |
None |
| Zephyr 4.4.0 | zephyr and modules-deps, with PURL and CPE |
End of support 2027-04-12 added for the FDA fields |
| MCUboot | Second west spdx run on the bootloader build |
The first CI job skipped this image |
| Vendor HAL module | modules-deps |
SDK release name added from the vendor’s notes |
| BLE controller library | Prebuilt library with STATIC_LINK |
No license file; vendor asked, version recorded as unknown |
| Moisture sensor driver | Manifest, as a fork | Copied from the sensor maker’s repository; upstream commit recorded |
| CRC-16 routine | Manifest | Found only by the map-file check; origin traced to an application note |
The map-file check flagged one object that matched no entry, the CRC routine, and the build failed until it was listed. The vendor answered the license question a week later, so the team issued SBOM version 1.1 for the same firmware, with a new timestamp. The end-of-support date for Zephyr 4.4.0 was the most useful line: it showed the probes would outlive their RTOS release within months, so the team added a move to a long-term support release to the plan for the next maintenance release.
The full fictional project, from first boards to the staged rollout of 1.1.0, is on the example project page.
How to keep the SBOM useful after the release ships
An SBOM is a snapshot of one image. It stays useful only if it is generated with every release, stored with the image it describes, signed, and checked against new advisories for as long as the product is supported. Under the CRA that support period is at least five years unless the product is expected to be in use for less, per Article 13(8).
Generate, sign and store it with the release
Generate the SBOM in CI from the same build that produced the signed firmware image, and store it under the same version tag. Record the image’s own hash in the SBOM so anyone can confirm the file describes the bytes on the device. The firmware release checklist is a good place to make “SBOM generated and stored” a release gate.
The 2026 elements add an SBOM Author Signature, and CISA’s document says implementation “should use existing software signing infrastructure, tools, and key management”. Use a separate key from the one that signs firmware images, so the CI job that signs SBOMs never needs the key that devices trust. Key custody, rotation and revocation are covered in firmware signing key management.
Monitor it against advisories
Monitoring is where the identifiers pay off. CPEs let you query the National Vulnerability Database, PURLs match advisories from open-source projects, and hashes identify blobs that have neither. For each new advisory that matches a component, record a triage decision:
- Is the affected code in our image, or only in the repository?
- Is the affected function compiled in our configuration, and can an attacker reach it?
- How severe would exploitation be on this device, given its interfaces?
- What do we do: ship a fix, add a compensating control, or record “not affected” with the reason?
Write “not affected” decisions as VEX (Vulnerability Exploitability eXchange) statements, which CISA’s 2026 document describes alongside CSAF advisories as a way to narrow the scope of at-risk components. Customers and auditors read these instead of asking you the same question twice. If you find a flaw in a component, the CRA expects you to report it upstream to its maintainer.
Update it when you learn something
When the vendor answers a question or you correct an entry, issue a revised SBOM with a new SBOM Version and timestamp for the same firmware. FDA’s guidance asks that the SBOM be maintained as part of the device’s configuration management and updated to reflect software changes in marketed devices. The same habit serves the CRA’s technical documentation. A sustaining releases arrangement is one way to keep that review on a schedule after the first product ships.
A checklist for your first firmware SBOM
Start with one image and one release, and get the process right before you scale it to every product. Work through the steps in this order.
- List your images. Bootloader, application, radio core, module firmware. Each gets its own SBOM.
- Turn on the generator. For Zephyr, set
CONFIG_BUILD_OUTPUT_META=yand runwest spdxper image in CI. For ESP-IDF or the nRF Connect SDK, try the vendor tool first. - Write the manifest. One entry per blob, copied file, generated file and vendored library, with producer, version, source, hash, license and identifiers.
- Add the map-file check. Fail the build on any linked object that matches no SBOM entry.
- Mark unknowns. Write “unknown” or “unknown provenance” instead of leaving fields empty or guessing.
- Add support fields if you sell to US healthcare. Level of support and end-of-support date for every component.
- Pick and freeze a format. SPDX 2.3 or 3.0 for Zephyr, or CycloneDX if your recipients require it; validate against the schema in CI.
- Sign and store. Sign the SBOM with a dedicated key and store it with the release under the same tag.
- Set up monitoring and a triage log. Check advisories against CPEs, PURLs and hashes, and record each decision, using VEX for “not affected”.
- Send the vendor questions. Ask each chip and module vendor the five questions above, and file the answers.
Fumbar is a Denver company that writes embedded firmware and over-the-air update systems for hardware startups. In our engagements the SBOM is generated by CI with every signed release and handed over with the code and the triage log; the security page describes how we handle it, and firmware security services covers secure boot, keys and vulnerability handling around it. If you want a second pair of eyes on your build, your blobs and your SBOM plan, request a firmware review.
