SBOM tools for C/C++ and embedded firmware compared by what they read: the package manifest, the build, or the shipped binary.

Overview

C and C++ projects can be difficult to inventory accurately. Dependencies are often copied directly into source trees, pulled in through Git submodules, or linked from prebuilt libraries. Some projects use package managers, but many embedded teams still rely on a mix of vendor SDKs, internal libraries, and manually maintained code.

That creates a problem for SBOM generation. A package manifest can describe the dependencies it manages, but it may leave out code that was added through other routes. A source scan has its own limitations, particularly when the final firmware is built with custom toolchains and configurations.

The tools available today approach this problem differently. Some read package manifests, others collect information during the build, and some inspect the firmware image itself. This guide compares the main options for C/C++ and embedded development, including what each tool can see, where it fits, and what to check before adopting it. For a broader comparison across software categories, see our guide to the best SBOM tools.

Why generating SBOMs for C/C++ is different

Consider a firmware project that includes FreeRTOS and mbedTLS in a third_party/ directory, pulls lwIP through a Git submodule, and links a prebuilt libgcc.a. A Conan or vcpkg manifest may describe some of these dependencies. It won't necessarily describe all of them.

The same issue comes up with vendor SDKs, internally maintained libraries, and code that has been copied from another project. Static linking makes things more complicated, because the final executable may contain code from several libraries without preserving their original boundaries.

Build environments add another layer of complexity. Embedded teams work with Make, CMake, IAR, TI Code Composer, and other toolchains. They also cross-compile for different architectures and maintain product-specific build configurations. A useful SBOM needs to account for these realities.

There are three common sources of information:

  • Package metadata: shows dependencies resolved through package managers such as Conan and vcpkg.

  • Build information: records what the compiler and linker processed for a particular configuration.

  • Firmware analysis: examines the resulting binary and identifies components that can be recognized.

The catch is that these approaches can produce very different inventories of the same project.

The same firmware, three views

That difference is easiest to see on one real build. We ran Trusted Firmware-M on an STM32H573I-DK, a CMake project that vendors its crypto, MCUboot, and CMSIS code under lib/ext, with no Conan or vcpkg manifest covering those parts.

  • A package-manifest scan has little to resolve here, because those components never pass through a package manager.

  • A whole-tree source scan can identify components across the repository, but it may not distinguish what belongs to the bootloader versus the secure image, or establish what the linker actually retained.

  • A build-aware run, reconciled with each image's linker map, produced two image-specific SBOMs: 10 components for the bootloader and 20 for the secure image, with libgcc.a recorded as a linked runtime archive and build tools such as cmake and ninja left out because they are not linked into the firmware.

Same project, three inventories. Which one is right depends on the question you are asking, and the rest of this guide is about matching the tool to that question. The full run is in the STM32H5 case study.

SBOM tools for C/C++ and embedded firmware compared

The table covers open-source generators, commercial embedded security products, and SBOM management platforms.

Tool

Model

What it reads

Output formats

Where it fits

Conan

Open source

Resolved Conan dependency graph

CycloneDX 1.4 and 1.6

Projects using Conan. Native SBOM functionality is experimental.

vcpkg

Open source

Installed vcpkg packages, organized by triplet

SPDX JSON; CycloneDX conversion available

Projects using Microsoft's C/C++ package manager.

Syft

Open source

Filesystems, container images, and recognized package and binary data

CycloneDX and SPDX

General software inventory, including selected C/C++ discovery.

Trivy

Open source

Filesystems, repositories, container images, and supported package ecosystems

CycloneDX and SPDX

Convenient for teams already using Trivy. Validate coverage against actual firmware.

cdxgen

Open source

Project files, manifests, source trees, compile databases, and selected binaries

CycloneDX, with SPDX export

C/C++ projects using CMake, Conan, vcpkg, or other supported inputs.

CMake native SBOM

Built into CMake; experimental

Modeled project targets and linked libraries

SPDX 3.0.1 JSON-LD

CMake projects that use its target and installation model.

Microsoft SBOM Tool

Open source

Source and artifact information through supported component-detection workflows

SPDX 2.2 and 3.0

SPDX-oriented CI/CD workflows. Embedded toolchain coverage needs validation.

bomtique (Interlynk)

Open source

User-authored component manifests

CycloneDX and SPDX

Manually documenting components that automated discovery misses.

RunSafe Identify

Commercial

Build-time information from supported embedded workflows

CycloneDX

Build-time C/C++ and embedded SBOM generation without a package manager.

lynkctl (Interlynk)

Proprietary, commercial

Compiler and linker invocations, reconciled with linker map data

CycloneDX 1.6+ and SPDX 3+

Post-build SBOM generation for supported embedded toolchains.

Finite State

Commercial

Firmware images and other supported inputs

CycloneDX and SPDX

Firmware and product-security analysis across the supply chain.

ONEKEY

Commercial

Firmware images and device software

CycloneDX and SPDX

Firmware analysis with multiple detection methods and vulnerability assessment.

Black Duck Binary Analysis

Commercial

Compiled binaries and supported artifacts

CycloneDX and SPDX

Binary analysis inside a broader SCA and application-security portfolio.

OWASP Dependency-Track

Open source

Uploaded CycloneDX SBOMs

CycloneDX

SBOM ingestion, vulnerability analysis, and ongoing management. It is not a generator.

Tool capabilities and supported formats change. Check the current documentation and run each candidate against a representative firmware build before making a decision.

When dependencies are managed through Conan or vcpkg

If your team uses a C/C++ package manager, start with the information it already maintains.

Conan. Conan 2 includes experimental SBOM helpers that generate CycloneDX 1.4 and 1.6 documents from a resolved dependency graph. You can include build and test dependencies through optional settings, and those settings matter, because they are not automatically included in every generated SBOM. This is a useful starting point for teams that manage most of their dependencies through Conan. Code introduced outside the Conan dependency graph will need another source of inventory information. See Conan's SBOM documentation.

vcpkg. Microsoft's vcpkg generates SPDX JSON files for installed packages. The files are organized by target triplet, which is useful when the same project produces firmware for different architectures. vcpkg does not generate CycloneDX directly; Microsoft documents conversion through the CycloneDX CLI, with a warning that some dependency information may be lost. Like Conan, vcpkg covers the dependencies it manages well. Vendored source, separate SDKs, and libraries introduced through other build mechanisms still need to be accounted for. See Microsoft's vcpkg SBOM documentation.

General-purpose scanners: Syft and Trivy

Syft and Trivy are widely used inventory tools that read filesystems, container images, and the package ecosystems they recognize. Both can surface C/C++ components that arrive as recognized packages, and both include catalogers that inspect some binaries. What neither does is follow an embedded build, so a repository or image scan can still miss vendored source and static archives that no package metadata describes. They are a reasonable first pass for recognized dependencies and a sensible choice when one of them already runs in your pipeline. Test either against a real firmware image before relying on its C/C++ coverage, rather than treating it as an embedded firmware generator.

Build-aware SBOM generation

For embedded teams that control their build environment, the build itself can provide valuable information. A build-aware generator can collect compiler invocations, source files, include paths, compiler options, and linker inputs. This creates a connection between the software components and the configuration used to produce a particular release.

That distinction matters. A firmware project may have several configurations, each with different libraries, features, and target architectures. An SBOM that describes the repository without accounting for the actual build can include components that never ship or miss components that do.

CMake's native SBOM support. CMake includes experimental native SBOM generation through install(SBOM), present since the 4.3 series and still gated behind CMAKE_EXPERIMENTAL_GENERATE_SBOM in current releases such as 4.5. It generates SPDX 3.0.1 JSON-LD documents describing modeled project targets, linked libraries, and associated metadata. This is a useful development for teams already using CMake's target and installation model. The feature is still experimental, and its output reflects the information modeled in CMake, so it should not be treated as a complete inventory of every vendored file or SDK component in a repository. See the CMake installation documentation and our guide to CMake SBOM generation.

cdxgen. cdxgen supports C/C++ projects and recognizes inputs such as CMake files, Conan and vcpkg manifests, Meson files, and compile databases. Its support varies by input. A CMake project without version information may produce best-effort dependency results, while a compile database provides additional context about the files and compiler settings used in a build. cdxgen also accepts binary inputs, which can help identify recognizable components, though binary analysis does not provide the same evidence as records captured during compilation. See cdxgen project types, its CLI documentation, and our cdxgen and lynkctl comparison.

Microsoft SBOM Tool. Microsoft SBOM Tool generates SPDX documents and integrates with GitHub Actions and Azure DevOps pipelines. Producing SPDX is not the same as discovering every embedded dependency, so the question for firmware teams is what it detects, not what it can serialize. It is worth evaluating for teams already on Microsoft development infrastructure that need SPDX output. Test its component detection against the actual compiler, build system, and artifact types in your environment before adopting it for embedded work.

RunSafe Identify. RunSafe focuses on embedded software and generates SBOMs at build time, without relying on a package manager. The practical difference from a post-build collector like lynkctl is where it hooks into your pipeline: RunSafe gathers information as the build runs, while a post-build approach reads the compiler and linker records after the build completes. Both aim at the same gap, the C/C++ dependencies a manifest never sees. RunSafe documents CycloneDX output and CI/CD integration, which makes it a relevant option for teams working with embedded operating systems and complex C/C++ codebases. See RunSafe Identify.

lynkctl. Interlynk's lynkctl takes a post-build approach. It collects compiler and linker invocations and reconciles that information with linker map data to generate an SBOM. This lets teams generate an SBOM from their existing build process without having to reorganize their source tree or adopt another build system. It supports Make, CMake, IAR, and TI Code Composer, and for each component it records the decision path it followed to identify it, so a reviewer can see why a component is in the SBOM. lynkctl runs in air-gapped environments: its open-source component database needs network access to obtain and update, and for an isolated setup that database is copied in manually so the analysis itself runs offline. The approach targets embedded teams that rely on copied-in libraries, vendor SDKs, and static archives, which are hard to account for using package manifests alone. As with any build-integrated tool, check support for your compiler version, linker-map format, build configuration, and deployment environment before relying on the output.

Interlynk also maintains several open-source SBOM tools. bomtique supports manually curated component inventories, sbomqs evaluates SBOM quality, and sbomasm assembles and edits SBOMs, with pylynk, sbomgr, and sbommv covering related workflows. These are community open-source projects, separate from lynkctl, which is proprietary and commercial. See the Interlynk C/C++ embedded software page.

Build-aware generation and binary analysis answer different questions. Build-aware establishes what a particular build used and ties it to a configuration. Binary analysis independently identifies what ended up in the shipped image. Neither is universally more accurate, and teams that both build the firmware and need to check the released artifact often run both and reconcile the results.

When you only have the firmware image

Sometimes the source code and original build environment are unavailable. This is common when assessing third-party firmware, inherited products, or devices that have been in production for years. In these situations, binary analysis can provide an inventory without access to the original source code.

These tools inspect firmware images and look for recognizable components using package metadata, signatures, strings, binary patterns, and other identification techniques. The results depend on the firmware format, architecture, compiler, optimization settings, and whether the code has been stripped or statically linked. Component identification can be particularly challenging when a library has been modified, backported, or incorporated into a larger binary, where a scanner may recognize a component without establishing its exact version.

Several commercial products cover this work from different angles. ONEKEY documents multiple detection methods, including package enumeration, binary analysis rules, package metadata, and RTOS component detection, and exports in CycloneDX and SPDX. Finite State covers firmware and product security more broadly, across the device and its supply chain. Black Duck Binary Analysis sits inside a larger SCA and application-security portfolio, which suits teams that want firmware analysis alongside their existing Black Duck tooling. cdxgen also accepts selected binary inputs. Their inputs and methods differ, so compare them on firmware from your own products rather than assuming all binary scanners return equivalent component detail.

When evaluating these tools, look at component identification, version confidence, architecture coverage, and the evidence provided for each finding. If you have access to the original build records, those records can help validate what the binary scanner identifies.

Managing SBOMs after generation

Generating an SBOM is the first step. Teams also need to associate it with product versions, track changes between releases, identify vulnerabilities, and share relevant information with customers and suppliers. This is where SBOM management platforms become useful.

OWASP Dependency-Track is an open-source platform that consumes CycloneDX SBOMs and continuously analyzes their components. It provides vulnerability and policy management, but it does not generate the original SBOM. Commercial platforms offer different combinations of SBOM generation, vulnerability analysis, VEX management, compliance evidence, and reporting. When comparing platforms, look beyond whether they can import an SBOM, and check how they handle product versions, multiple release branches, vulnerability triage, VEX, and communication with downstream stakeholders. Our broader best SBOM tools guide covers this part of the market.

Regulations and SBOM formats

Regulatory requirements are another reason embedded teams are investing in SBOM generation. The requirements differ across frameworks, and the format of an SBOM is only one part of the picture. It also helps to separate what is law, what is regulatory guidance, and what is a voluntary recommendation, because the three carry different weight.

CISA 2026 Minimum Elements (voluntary baseline guidance). On July 29, 2026, CISA, NSA, FBI, and international partners released the 2026 Minimum Elements for a Software Bill of Materials, updating the NTIA's 2021 minimum elements. It introduces additional data fields, including component hashes, license information, SBOM tool name, and SBOM generation context, and places greater emphasis on machine-processable formats. One practical implication for embedded teams is that recording what actually went into a release, rather than only what sits in the repository, is the kind of detail build evidence is well suited to capture. The guidance is a baseline for SBOM practices, not a law that every product use a particular generator or format. Read the CISA announcement and our CISA 2026 Minimum Elements overview.

FDA Section 524B (statute plus guidance). Section 524B of the FD&C Act requires certain cybersecurity information in premarket submissions for devices that meet the statutory definition of a cyber device. That information includes an SBOM, processes for managing cybersecurity vulnerabilities, and plans for postmarket updates and patches. FDA guidance adds recommendations on SBOM content and documentation. The law does not impose a blanket requirement to generate SBOMs in both CycloneDX and SPDX. Manufacturers should determine whether their device and submission fall within the applicable requirements. See the FDA cybersecurity resources and FAQs and our FDA 524B overview.

EU Cyber Resilience Act (regulation). The EU Cyber Resilience Act requires manufacturers to identify and document vulnerabilities and components in products with digital elements. Annex I specifies an SBOM in a commonly used, machine-readable format, covering at least the product's top-level dependencies. The regulation does not prescribe CycloneDX or SPDX as the only acceptable formats. For embedded manufacturers, the practical challenge is maintaining an inventory that reflects the software shipped in the product and supports vulnerability handling throughout its lifecycle. See Regulation (EU) 2024/2847 and our Cyber Resilience Act overview.

Across these frameworks, the important question is whether the SBOM provides useful, accurate information about the product. A format that passes validation does not automatically mean the underlying inventory is complete.

How to choose an SBOM tool

Before choosing a tool, look at how your team actually builds and ships firmware.

  • You use Conan or vcpkg: start with the package manager's SBOM output, then identify dependencies introduced outside its package graph.

  • You build and control the firmware: evaluate build-aware generation against an actual release configuration, and check whether the tool captures the compiler and linker information needed to identify shipped components.

  • You use CMake: consider its native SBOM functionality, keeping its experimental status and target-model limitations in mind.

  • You only have the firmware image: evaluate binary analysis tools that support your image format and architecture, and check how they establish component names and versions.

  • You need ongoing vulnerability monitoring: look for a platform that can ingest SBOMs, maintain product and release history, analyze vulnerabilities, and support VEX workflows.

  • You operate in an air-gapped environment: verify that installation, licensing, updates, and analysis can all work within your security requirements.

  • You have FDA or CRA obligations: map the generated SBOM and supporting processes to the requirements applicable to your product, and confirm regulatory interpretations with qualified counsel.

Many embedded teams will use more than one approach. A build-aware generator can provide evidence about a release, while binary analysis can help validate the shipped image or assess software received from a supplier.

Where Interlynk fits

The comparison table says what lynkctl does and the build-aware section explains how it works, so the point here is where it leads. Once an SBOM exists, the Interlynk platform carries it into the rest of the lifecycle: SBOM and CBOM ingestion, management across releases, component risk assessment, VEX, and notifications. That is the difference between generating a file and maintaining a defensible inventory over the years a device stays in the field.

For embedded teams, the practical question is whether a tool can capture the components in your actual firmware build and produce evidence your security and compliance teams can use. See the C/C++ SBOM generator for embedded software, or for the wider market, our guide to the best SBOM tools.

Frequently asked questions

What is the best SBOM tool for C/C++? It depends on how your software is built and what information is available. Conan and vcpkg are useful for package-managed dependencies. Build-aware tools can capture information from the compilation and linking process. Binary analysis is useful when you only have the firmware image.

What is the difference between build-aware and binary SBOM generation? Build-aware generation uses information from the build process to identify components and their relationships to a particular configuration. Binary analysis examines the finished artifact and identifies components it recognizes. They answer different questions, and teams that control the build often use both: build-aware for provenance, binary analysis to check the shipped image.

Can SBOM tools find statically linked C/C++ libraries? Some can. Build-aware tools can capture linker inputs when their integration supports the relevant toolchain. Binary analysis can recognize some statically linked libraries, although identifying exact versions can be difficult in optimized or stripped binaries.

How do I create an SBOM for firmware when I have no source access? Use a firmware analysis tool that supports your image format and processor architecture. Review the evidence behind identified components and validate versions against supplier records where possible.

Which SBOM format is required by FDA 524B or the EU CRA? Neither establishes a blanket requirement to generate both CycloneDX and SPDX. FDA guidance addresses SBOM content and documentation, while the CRA calls for a commonly used, machine-readable format covering at least top-level dependencies. Check the applicable requirements for your product.

Are Conan or vcpkg enough to generate a complete embedded SBOM? They can provide useful information about dependencies managed through their respective workflows. Code copied into a repository, vendor SDKs, and libraries introduced outside the package manager may require additional inventory methods.

Related resources

Next step: Start free or book a demo.

Trusted by security and compliance teams at 100+ regulated companies

Audit-ready SBOM. With every build.

Interlynk automates SBOMs, manages open source risks, monitors suppliers, and prepares you for the post-quantum era, all in one trusted platform.

Trusted by security and compliance teams at 100+ regulated companies

Audit-ready SBOM. With every build.

Interlynk automates SBOMs, manages open source risks, monitors suppliers, and prepares you for the post-quantum era, all in one trusted platform.

Trusted by security and compliance teams at 100+ regulated companies

Audit-ready SBOM. With every build.

Interlynk automates SBOMs, manages open source risks, monitors suppliers, and prepares you for the post-quantum era, all in one trusted platform.