Firmware SBOMs: SPDX, CycloneDX and Publication Workflows
Practical comparison of SPDX and CycloneDX for firmware SBOMs, covering what to include, automation approaches, tooling, and publication strategies for embedded Linux products.

Choose the firmware software bill of materials (SBOM) format your recipient and validator can read. Start with SPDX if your build already generates it and the recipient accepts that version. Use CycloneDX if the recipient's inventory or vulnerability workflow requires it. In either case, tie the SBOM to the exact firmware image and check which components the generator misses.
The EU Cyber Resilience Act calls for a machine-readable SBOM covering at least top-level dependencies for products in scope. The regulation generally applies from 11 December 2027. Earlier reporting duties have a separate timetable. In US federal procurement, agencies can include terms requiring an SBOM on request. Check the actual contract against OMB memorandum M-26-05.
SPDX vs CycloneDX: format comparison
The table compares SPDX 3.0 and CycloneDX 1.6. Record the exact version in your release workflow, since a tool that accepts one version of a format may reject another.
SPDX
SPDX originated in the Linux Foundation. ISO/IEC 5962:2021 covers SPDX 2.2.1. The SPDX 3.0 model and serialisation need their own version checks.
Strengths:
- A versioned standard provides a common interchange reference
- Rich license expression support (SPDX license identifiers are the industry standard)
- SPDX 3.0 includes security (VEX), build, and AI profiles
- Yocto generates SPDX natively
- Deep integration with Linux kernel and open-source compliance workflows
Format options: SPDX 2.x has tag-value and JSON serialisations, among others. SPDX 3.0 uses a different model with a JSON-LD serialisation.
CycloneDX
CycloneDX is an OWASP standard focused on security use cases. It originated in the application security community and has strong integration with vulnerability scanning tools.
Strengths:
- Designed for security workflows (VEX, vulnerability references, services)
- Simpler schema for common use cases
- Strong tooling ecosystem (Grype, Syft, Trivy)
- XML and JSON formats with clear schemas
- Good support for hardware component inventory (BOM for devices)
Format options: XML, JSON, Protocol Buffers
Comparison matrix
| Feature | SPDX 3.0 | CycloneDX 1.6 |
|---|---|---|
| Specification | SPDX Project 3.0 | OWASP CycloneDX 1.6, ECMA-424 first edition |
| Licence information | SPDX licence expressions | SPDX identifiers and expressions supported |
| Vulnerability data | Via Security profile | Native VEX support |
| Build provenance | Via Build profile | Via formulation |
| File-level detail | Check whether generation includes file records | Check whether generation includes file components |
| Yocto integration | Use the selected release's SPDX generator | Check whether your chosen exporter preserves relationships |
| Receiving workflow | Confirm accepted schema version | Confirm accepted schema version |
Choose the format and version your downstream tools support. Schema validity and format selection cannot establish compliance, component accuracy or vulnerability absence.
What to include in a firmware SBOM
Inventory starting point
- Shipped open-source and proprietary components with versions
- Licence information per package
- Supplier (upstream project) for each package
- The firmware image as the top-level component
- Dependency relationships
Recommended (useful for security)
Everything above, plus:
- File-level checksums for key binaries
- Build tool versions (GCC, binutils, kernel version)
- Known vulnerability status (or reference to VEX document)
- Source repository URLs for each package
Advanced (full supply chain transparency)
Everything above, plus:
- Build configuration (compiler flags, enabled features)
- Link to SLSA provenance document
- Transitive dependency tree (not just direct dependencies)
- Patch metadata (which upstream patches were applied)
Automation approaches
From Yocto
Yocto generates SPDX documents as part of the build process. Enable it in local.conf:
INHERIT += "create-spdx"
Check whether the distribution already inherits this class before adding it. Verify the serialisation and schema version of the generated image document. See the Yocto 5.2 highlights for release context.
From Buildroot
Buildroot's make legal-info collects licensing information. On a release that includes utils/generate-cyclonedx, use the package metadata from the configured build to generate a separate CycloneDX file:
make show-info | utils/generate-cyclonedx > sbom.cdx.json
Check the selected release's Buildroot manual for availability and options. Compare the generated inventory with the shipped image to catch firmware blobs or files copied in by a post-build script.
From container/image scanning
Tools like Syft can scan a filesystem or container image and generate an SBOM:
syft dir:output/rootfs -o spdx-json > sbom.spdx.json
syft dir:output/rootfs -o cyclonedx-json > sbom.cdx.json
An image scan sees only what the scanner can identify from the files it receives. Reconcile its output with your build manifest to spot stripped binaries or copied files with missing package metadata. Keep build dependencies in the build record even when they never reach the device.
From ProteanOS
ProteanOS package metadata includes the information needed for SBOM generation. The packaging system records component names, versions, licenses, and upstream sources in control files. Check the selected ProKit source and validate any exporter before relying on its output.
Publication strategies
Embed in firmware
Include the SBOM in the firmware image itself, accessible via a well-known path (e.g., /usr/share/sbom/). This ensures the SBOM always accompanies the firmware.
Publish alongside releases
Host SBOMs on your release infrastructure, named to match the firmware version:
firmware-v2.1.0.bin
firmware-v2.1.0.spdx.json
firmware-v2.1.0.vex.json
API access
For fleet-managed devices, provide SBOM access through a device management API. This allows automated compliance scanning across your deployed fleet.
Validation
Before publishing, validate your SBOM:
SPDX validation
The following command applies to a supported SPDX 2.x document with spdx-tools installed:
# Using SPDX tools
pyspdxtools -i sbom.spdx.json
For SPDX 3.0, use a validator that explicitly supports the producer's JSON-LD model and patch level. The SPDX tools discussion on Yocto-generated JSON-LD shows how validator support can be mistaken for a defect in the document. Keep one known file from your own build as a fixture for tool upgrades, and test that the recipient can ingest it.
Check for:
- Valid SPDX license expressions
- All required fields present
- Consistent package identifiers
- Correct relationship types
CycloneDX validation
# Using CycloneDX CLI
cyclonedx validate --input-file sbom.cdx.json
Content validation
Automated validation catches format errors but not content errors. Manual checks:
- Are all packages in the firmware represented in the SBOM?
- Are versions accurate (not just "latest")?
- Are licenses correct (not just "unknown")?
- Does the dependency tree match the actual build?
Maintaining SBOMs over time
An SBOM is a snapshot. Maintain them by:
- Generating fresh SBOMs with every release: Automated in CI.
- Storing historical SBOMs: Set retention from the product's legal and support obligations, including any longer documentation-retention requirement.
- Monitoring for new vulnerabilities: Run vulnerability scans against published SBOMs periodically.
- Updating VEX statements: When new CVEs are published, update VEX documents. The VEX guide covers this workflow.
Integration with the broader compliance stack
SBOMs are one piece of the compliance puzzle:
- SBOM → What is in the firmware?
- VEX → Which vulnerabilities apply?
- Provenance → How was it built? (SLSA guide)
- Evidence pack → Complete compliance documentation (CRA guide)
Together, these artifacts provide full supply chain transparency for your firmware.
The SPDX 3.0 guide covers the specifics of SPDX 3.0's package and relationship model for embedded Linux images.
Summary
Produce SBOMs for every firmware release. Choose SPDX if your ecosystem is Yocto-centric and license-focused. Choose CycloneDX if your ecosystem is security-tool-centric. Automate generation in CI, validate before publication, and maintain historical SBOMs for the product's lifetime. Budget validation and ownership alongside generation, including packages that the selected exporter cannot identify.