VEX and CSAF for Embedded Vulnerability Status

How to produce and distribute VEX documents and CSAF advisories for embedded firmware, enabling downstream consumers to filter false positives from vulnerability scans.

VEX and CSAF for Embedded Vulnerability Status

Every embedded firmware image contains hundreds of open-source packages. When a CVE is published against one of those packages, the immediate question is: "Are we actually affected?" Investigate the affected code, configuration and reachable interfaces before assigning a status. VEX (Vulnerability Exploitability eXchange) and CSAF (Common Security Advisory Framework) provide standardized ways to communicate these "not affected" statements at scale.

The false positive problem

Scanner matches need product-specific investigation. Retain the matched component, version and vulnerability record with each triage decision.

Without VEX, human engineers must triage each CVE individually:

  1. Identify which package version is in the image
  2. Read the CVE description and affected versions
  3. Determine if the vulnerable code path is compiled in
  4. Determine if the exploitable interface is exposed
  5. Document the analysis
  6. Repeat for every image variant

Reuse an investigation only when component identity, configuration and execution context are equivalent across the affected products.

What VEX provides

VEX is a structured format for communicating the exploitability status of a vulnerability in a specific product. Each VEX statement ties together a CVE identifier, the affected product (your firmware image or specific package), a status (not_affected, affected, fixed, or under_investigation), and a justification for that status. The justification is what makes VEX useful: it is not just a status flag, it is a documented reason that downstream tools and customers can act on.

Illustrative status record

{
  "vulnerability": "EXAMPLE-UNASSIGNED",
  "product": "firmware-image-v2.1.0",
  "status": "not_affected",
  "justification": "vulnerable_code_not_present",
  "impact_statement": "The affected function (libxml2 XPath evaluation) is not compiled into the image. This synthetic example assumes the relevant function is excluded. Verify actual build evidence."
}

This synthetic fragment illustrates fields and is not a valid full OpenVEX or CSAF document. Validate a complete document against the selected format version before publication.

VEX formats

OpenVEX

OpenVEX is a minimal, JSON-based format focused exclusively on VEX statements. It is designed to be attached to SBOMs (SPDX or CycloneDX), integrates well with automated tooling, and is straightforward to generate from a build pipeline. If you are just starting with VEX, this is the right format.

CSAF VEX

CSAF is a broader advisory framework that includes VEX as one of its profiles. A CSAF VEX document is more verbose - it includes a product tree, advisory metadata, and a built-in distribution and trust model - which can support a formal advisory workflow. Verify the format and distribution requirements of the actual recipient.

Choose the representation accepted by your receiving tools and advisory process. Converting formats requires preserving product identity, status, justification and timestamps. A valid document does not establish that its vulnerability assessment is correct.

Generating VEX at build time

The most efficient approach is generating VEX statements during the build process, when you know exactly what is compiled and configured.

From Yocto

Treat build-generated CVE status as evidence to review. Verify the exporter and its status mapping in the selected Yocto revision before relying on a VEX artifact. A database version match or a patch marker alone does not demonstrate that a shipped product is unaffected. The Yocto 5.2 release context distinguishes historical components from current support.

From build configuration

For vulnerabilities that depend on compile-time configuration (e.g., a feature compiled out), generate VEX statements from your build configuration:

# Pseudocode: generate VEX from config
if not config.has("LIBXML2_XPATH"):
    vex.add_statement(
        cve="EXAMPLE-UNASSIGNED",
        status="not_affected",
        justification="vulnerable_code_not_present",
        detail="XPath support disabled at compile time"
    )

From runtime analysis

Some "not affected" determinations require runtime context (e.g., the vulnerable network service is not started). These are harder to automate but can be captured in VEX statements with appropriate justifications.

Justification categories

OpenVEX includes the following justification values for "not affected". Check the selected specification version and recipient requirements before generating a statement:

JustificationWhen to use
component_not_presentThe vulnerable package is not included in the image
vulnerable_code_not_presentThe package is present but the vulnerable code (function, module) is not compiled in
vulnerable_code_not_in_execute_pathThe code is compiled in but never executed in your product's configuration
inline_mitigations_already_existThe vulnerability is mitigated by other controls (sandboxing, network isolation, etc.)

Choose the most specific justification. vulnerable_code_not_present is stronger than vulnerable_code_not_in_execute_path because it is deterministic rather than depending on runtime configuration.

Distribution

Attach to SBOMs

The recommended approach is distributing VEX documents alongside your SBOM. The firmware SBOM guide covers SBOM generation and distribution.

SPDX 3.0 can embed VEX statements directly in the SBOM document using the Security profile. CycloneDX has a VEX extension.

CSAF distribution

CSAF advisories are published at well-known URLs following the CSAF provider specification:

https://example.com/.well-known/csaf/provider-metadata.json
https://example.com/.well-known/csaf/2026/csaf-2026-001.json

This allows automated tools to discover and consume your advisories.

Frequency

Publish VEX updates when:

  • A new firmware version is released (include VEX for all known CVEs)
  • A new CVE is published that affects a package in your image
  • Your triage determines a previously "under investigation" CVE is not affected

Scaling across product families

When you maintain multiple products sharing common packages, VEX statements for shared components can be reused:

  1. Generate per-package VEX statements at the build system level
  2. Aggregate per-product VEX documents by combining package-level statements
  3. Publish product-level VEX documents

This avoids duplicating triage work across products. Check that the affected library, compiled features, mitigations and execution paths match before carrying a decision to another product.

Integration with ProteanOS

ProteanOS's packaging metadata includes fields for security information. VEX statements can reference ProteanOS package identifiers directly.

The SLSA build provenance workflow produces the build evidence that supports VEX justifications. When you claim "vulnerable code not present," the build provenance proves which configuration flags were active.

For compliance with the EU Cyber Resilience Act, the EU CRA compliance guide covers how VEX fits into the broader evidence pack.

Where to start

If your team currently has no VEX process, the most useful first step is not picking a format - it is identifying the top 20 CVEs in your current scanner output and writing VEX statements for them manually. That exercise reveals which justification categories apply to your build, which packages need recurring attention, and where your build configuration can be made more precise. From there, automating statement generation from your build system is a natural next step. The format choice (OpenVEX or CSAF) matters less than having a repeatable process that produces statements with accurate, defensible justifications.