Engineers with a laptop at automation test rigs in a bright production hall

SBOM

OWASP SCVS: the Software Component Verification Standard, explained

Last updated:

OWASP's Software Component Verification Standard (SCVS) is a framework of 87 controls across six families, for assessing and maturing how an organisation inventories, builds, analyses and tracks the provenance of the third-party and open-source components inside its software. Version 1.0, released 25 June 2020 under project lead Steve Springett, describes itself as "a community-driven effort to establish a framework for identifying activities, controls, and best practices, which can help in identifying and reducing risk in a software supply chain," and is explicitly "inspired by the OWASP Application Security Verification Standard." Unlike ASVS, which verifies a specific application's own security controls, SCVS verifies the process that produced the components that application depends on.

Key takeaways

  • Level 1 — "for low-assurance requirements where basic forms of analysis would suffice," covering baseline practices like producing a complete component inventory and using CI for repeatable builds.
  • SCVS was written with application builds in mind, where a package manager knows every dependency.
  • A team already producing SCVS evidence for a given requirement can point to the SSDF task it supports, rather than re-deriving the mapping.
  • Fix the scope. Name the product, the firmware release and the build pipeline you are assessing.

What are the three verification levels?

SCVS's "Using the SCVS" chapter defines three levels of increasing rigor, where "higher levels include additional controls":

  • Level 1 — "for low-assurance requirements where basic forms of analysis would suffice," covering baseline practices like producing a complete component inventory and using CI for repeatable builds. The standard notes "adoption of level 1 can be achieved with modern software engineering practices."
  • Level 2 — "for moderately sensitive software where additional analysis or due diligence is required," aimed at "software intensive enterprises and organizations with existing risk management frameworks and regulatory and/or contractual requirements," and may need "additional resources and domain expertise to achieve."
  • Level 3 — "for high-assurance requirements due to the sensitivity of data or use of the software," naming "critical infrastructure and systems with safety requirements" specifically, where "auditability and end-to-end transparency in the supply chain is required to maintain a high security posture."

Counted directly from OWASP's own machine-readable release data (OWASP_SCVS-1.0.json): 36 of the 87 total requirements apply at Level 1, 62 at Level 2, and all 87 at Level 3 — confirming the standard's own description of each level as a strict superset of the one below it.

What are the six control families?

Family Requirements Control objective (standard's own wording)
V1: Inventory 10 An accurate inventory of all components, "a foundational requirement for further analysis"
V2: Software Bill of Materials 18 "Automatically creating accurate... SBOM in the build pipeline is one indicator of mature development processes"
V3: Build Environment 21 Hardening source, package, CI/CD and test infrastructure, since "every system in the pipeline may provide an entry-point" for compromise
V4: Package Management 19 Securing the package managers and repositories that "are often targets for adversaries"
V5: Component Analysis 12 Identifying risk from third-party/open-source components via known-vulnerability and version-currency checks
V6: Pedigree and Provenance 7 "Identify point of origin and chain of custody in order to manage system risk" if either is compromised

Example Level-1 controls, quoted directly from their chapters: V1.1 "All direct and transitive components and their versions are known at completion of a build"; V2.1 "A structured, machine readable software bill of materials (SBOM) format is present"; V3.1 "Application uses a repeatable build"; V6.3 "Provenance of modified components is known and documented." Higher-level-only examples include V2.4/V2.5 (SBOM signing and signature verification, Level 2+) and V6.2 ("Chain of custody if auditable for source code and binary components," Level 3 only).

Which SCVS requirements are hardest for a firmware image?

SCVS was written with application builds in mind, where a package manager knows every dependency. A firmware image mixes package-managed code with vendored source, patched forks of upstream projects, prebuilt vendor blobs and a bootloader. These requirements, quoted from the V2, V3, V5 and V6 chapters, are where embedded teams usually find their gaps:

ID Level Requirement Why firmware makes it hard
1.1 1 "All direct and transitive components and their versions are known at completion of a build" Vendored C code and SDK blobs carry no package metadata
2.12 1 "Component identifiers are derived from their native ecosystems (if applicable)" Many C libraries have no package ecosystem; a PURL or CPE has to be chosen deliberately
2.18 3 Components in the SBOM "have one or more file hashes" Hashes of the source tarball differ from what ends up compiled into the image
3.18 1 "Checksums of all first-party and third-party components are documented for every build" Needs your build system to record fetch hashes, not only versions
3.21 3 "Unused direct and transitive components have been removed from the application" Board-support packages often ship whole toolkits of which a few binaries are used
5.8 3 "An automated process of identifying end-of-life / end-of-support components is used" Old kernels and libraries live on in long-support products
6.5 2 "Modified components are uniquely identified and distinct from origin component" A vendor-patched kernel reported as plain upstream gets the wrong vulnerability matches
6.6 1 "Modified components are analyzed with the same level of precision as unmodified components" Patched forks are often skipped by scanners that only know upstream versions

Is there an official SCVS certification?

The standard's "Assessment and Certification" chapter is unusually direct: "OWASP, as a vendor-neutral not-for-profit organization, does not certify any vendors, verifiers or software," and "all such assurance assertions, trust marks, or certifications are not officially vetted, registered, or certified by OWASP." Organisations may still offer SCVS-based assessment services, but "should not claim official OWASP certification." The recommended verification method is an "open book" review — auditors given access to legal, procurement, build-engineering, development, repository and build-environment resources — with any resulting report required to disclose its scope and the specific control levels assessed, so a "SCVS certified" claim from a third party is always a self-declared assessment against a disclosed scope, not an OWASP-issued credential.

How does it crosswalk to NIST SSDF?

NIST's own Secure Software Development Framework, SP 800-218, lists "OWASP Software Component Verification Standard (2020)" in its references and cites numbered SCVS sections and requirements inside its practice-to-reference tables, attached to individual SSDF tasks. Read from the SP 800-218 PDF:

SSDF task What the task asks SCVS reference
PO.3.2 Deploy, operate and maintain tools and toolchains securely 3, 5
PS.2.1 Make software integrity verification information available to acquirers 4
PS.3.1 Securely archive the files and supporting data for each release 1, 3.18, 3.19, 6.3
PS.3.2 Collect, safeguard, maintain and share provenance data for all components (for example in an SBOM) 1.4, 2
PW.4.1 Acquire and maintain well-secured third-party components 4
PW.4.4 Verify that acquired third-party components comply with requirements 4, 5, 6

A team already producing SCVS evidence for a given requirement can point to the SSDF task it supports, rather than re-deriving the mapping.

How do you run an SCVS self-assessment?

  1. Fix the scopeName the product, the firmware release and the build pipeline you are assessing. The certification chapter requires any report to state its scope.
  2. Pick a target levelLevel 1 for most products; Level 3 if the device sits in critical infrastructure or has safety functions, which is the case the standard names.
  3. Load the requirements as dataThe JSON export has one object per requirement with l1, l2 and l3 flags; filter it to your level and you have the checklist (36 rows at Level 1).
  4. Attach evidence to each row:a build log, an SBOM file, a pipeline configuration, a policy document. "We do this" without an artefact is a gap.
  5. Mark each row met, partly met or not met,and write the compensating measure or the fix for each gap.
  6. Repeat per releaseSBOM and inventory requirements describe a specific build, so the evidence ages with every firmware version.

Worked example: checking a gateway SBOM against Level 1

Synthetic example. The product, the SBOM contents and the findings are invented to show the method and describe no real device.

A maker of an industrial gateway checks the SBOM of firmware release 4.2 against the Level 1 SBOM requirements in V2:

Requirement Finding in the synthetic SBOM Result Action
2.1 Machine-readable SBOM format present CycloneDX JSON Met —
2.3 Each SBOM has a unique identifier serialNumber set Met —
2.7 SBOM is timestamped metadata.timestamp set Met —
2.8 SBOM is analyzed for risk Matched against public vulnerability data at release Met Keep the dated result with the release
2.9 Complete and accurate inventory Package-managed userland listed; vendored Wi-Fi driver and bootloader missing Not met Add both by hand from the build manifest
2.12 Identifiers from native ecosystems PURLs for packaged components; nothing for vendored code Partly met Assign CPEs where they exist
2.14 Accurate license information Licence fields empty Not met Fill from the build system's licence manifest

Four of seven rows are met, and they cover format and process; the partial and failed rows are about content. That pattern is typical: producing a valid SBOM file is easy, making it describe everything in the image is the real work.

How does SCVS fit with OSPS Baseline and Scorecard?

All three deal with open-source supply-chain hygiene, but they look at different parties:

OWASP SCVS OSPS Baseline OpenSSF Scorecard
Who it assesses Your organisation's own component processes An upstream open-source project An upstream repository, from outside
Who does the work You, or an auditor you hire The project's maintainers An automated tool
Output Requirement-by-requirement result at a level Self-attested level per version 0-10 check scores

A device maker uses Scorecard and the Baseline to judge the projects it takes code from, and SCVS to judge how well it inventories, builds and analyses that code once it is inside the product. OWASP also publishes a BOM Maturity Model (v1.0 RC 1) under the SCVS project, a format-neutral taxonomy for judging what data an incoming bill of materials actually carries.

What should an open-source policy cover?

SCVS ships a guidance appendix on open-source policy, marked "not part of SCVS." It suggests the policy should address, among other points: the acceptable age of a component and how many revisions behind is tolerable; exclusion criteria for components with known vulnerabilities; mean-time-to-remediate criteria; restrictions on end-of-life or end-of-support components; supplier selection criteria; acceptable licences; a prohibited-components list; and how modifications are contributed back upstream. For a device maker, the last point lines up with the CRA duty to share fixes for vulnerable components with their maintainers.

What are the common pitfalls?

  • Treating 1.0 as current guidance on every topic. The latest tagged release is still 1.0 from June 2020; pair it with newer SBOM guidance such as SBOM minimum elements.
  • Accepting "SCVS certified." OWASP certifies nothing; ask for the scope and level instead.
  • Counting a valid file as an accurate inventory. 2.1 and 2.9 are separate requirements for a reason.
  • Reporting patched forks as upstream. V6 exists because modified components carry different risk.
  • Confusing SCVS depth with the CRA minimum. Annex I Part II(1) of the CRA asks for an SBOM covering "at the very least the top-level dependencies"; SCVS 1.1 asks for all direct and transitive components. Meeting one does not mean meeting the other.

What is a workable adoption order?

  1. Start with V1 Inventory and V2 SBOM at Level 1— an accurate, machine-readable component list is the prerequisite every other family builds on.
  2. Harden V3 Build Environment next— repeatable, documented CI builds are both a Level-1 requirement in their own right and what makes an accurate SBOM possible to regenerate.
  3. Add V4 Package Management and V5 Component Analysis once the build is stable— trusted-repository sourcing and known-vulnerability checks assume there's already a reliable inventory to check against.
  4. Treat V6 Pedigree and Provenance as the Level-3 tier— chain-of-custody auditability is realistic mainly for organisations already operating at the first five families' Level 2.
  5. Use the SSDF crosswalk to avoid duplicate evidence— if an SSDF assessment is already underway, map produced SCVS evidence to the specific SSDF tasks above instead of running two unrelated assessments.

SoftWSP's firmware analysis covers part of the Level 1 evidence in V1, V2 and V5: it extracts the components inside a firmware image into a CycloneDX 1.6 SBOM with a unique serial number and a timestamp, and matches them against NVD, CISA KEV, FIRST EPSS and CISA CSAF ICS advisories, with an AI-drafted, cited report for engineer review. It writes component hashes and licences only when the extracted data already carries them, does not sign SBOMs, and does not perform the dataflow exploitability analysis of requirement 5.5. See device & firmware security, the firmware SBOM guide, or open an SBOM in the free SBOM viewer.

This guide summarises the public OWASP SCVS v1.0 standard (chapters and JSON export) and the related NIST SP 800-218 publication, read on 11 November 2026; it is not a substitute for the full text and does not constitute compliance or legal advice.

Put this guide to work

Frequently asked questions

What is OWASP SCVS?

The Software Component Verification Standard (SCVS) is an OWASP framework described in its own README as "a community-driven effort to establish a framework for identifying activities, controls, and best practices, which can help in identifying and reducing risk in a software supply chain." Version 1.0 was released 25 June 2020 (preceded by a 1.0.0-RC.1 public preview release), led by project lead Steve Springett, and is licensed under Creative Commons Attribution ShareAlike 4.0 (CC BY-SA 4.0). Its own Frontispiece states it "is inspired by the OWASP Application Security Verification Standard" (see our [OWASP ASVS guide](/guides/owasp-asvs/)) "and the work of their contributors." As of November 2026, 1.0 remains the latest tagged release on the project's GitHub repository.

What are SCVS's three verification levels?

Per the standard's own "Using the SCVS" chapter: "SCVS Level 1 is for low-assurance requirements where basic forms of analysis would suffice," focused on practices "achieved with modern software engineering practices" such as building an accurate SBOM and using continuous integration for repeatable builds. "SCVS Level 2 is for moderately sensitive software where additional analysis or due diligence is required," appropriate for "software intensive enterprises" with existing risk-management frameworks, and may need "additional resources and domain expertise." "SCVS Level 3 is for high-assurance requirements due to the sensitivity of data or use of the software," explicitly naming "critical infrastructure and systems with safety requirements" where "auditability and end-to-end transparency in the supply chain is required." Levels are cumulative — each higher level includes all controls from the level below.

What are SCVS's six control families, and how many requirements does each have?

Counted directly from OWASP's own machine-readable SCVS 1.0 data export (OWASP_SCVS-1.0.json), the standard defines 87 total requirements across six control families: V1 Inventory (10 requirements — e.g. "all direct and transitive components and their versions are known at completion of a build"), V2 Software Bill of Materials (18 — covering SBOM format, automation, and signature verification), V3 Build Environment (21 — covering repeatable builds and build-pipeline integrity), V4 Package Management (19 — covering trusted repositories and package-manager hardening), V5 Component Analysis (12 — covering known-vulnerability and component-currency checks), and V6 Pedigree and Provenance (7 — covering point-of-origin and chain-of-custody for modified components). Of the 87, 36 apply at Level 1, 62 apply at Level 2, and all 87 apply at Level 3.

Is there an official OWASP SCVS certification?

No. The standard's "Assessment and Certification" chapter states plainly: "OWASP, as a vendor-neutral not-for-profit organization, does not certify any vendors, verifiers or software," and that "all such assurance assertions, trust marks, or certifications are not officially vetted, registered, or certified by OWASP." It recommends an "open book" review model — auditors given access to legal, procurement, build engineering, development, repository, documentation and build-environment resources — and requires any certifying report to disclose its verification scope and the specific control levels assessed, rather than making a blanket compliance claim.

How does SCVS relate to NIST's Secure Software Development Framework (SSDF) and OWASP ASVS?

NIST SP 800-218 (the SSDF) lists "OWASP Software Component Verification Standard" in its own references section and cites specific SCVS requirement IDs directly in several of its practice-mapping tables — for example mapping PW.4.1 (acquiring third-party software) to "OWASPSCVS: 1.4, 2" and mapping PW.4.4 (verifying third-party components meet expectations) to "OWASPSCVS: 1, 3.18, 3.19, 6.3" — meaning specific numbered SCVS controls are referenced from inside the SSDF's own crosswalk, not just listed as a related reading. Structurally, SCVS and ASVS are sibling OWASP verification standards aimed at different targets: ASVS verifies a specific application's security controls, while SCVS verifies the supply-chain processes and tooling that produce and assemble third-party components used by that application.

Sources

  1. OWASP: Software Component Verification Standard — project README (GitHub)
  2. OWASP SCVS v1.0 release (25 June 2020) — tag, assets and release notes
  3. OWASP SCVS v1.0 — full-text PDF
  4. OWASP SCVS v1.0 — machine-readable requirement data (JSON)
  5. scvs.owasp.org — SCVS project landing page
  6. NIST SP 800-218, Secure Software Development Framework (SSDF) Version 1.1 — full-text PDF (OWASPSCVS crosswalk references)
  7. Creative Commons: Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license text
  8. OWASP SCVS v1.0 — V2 Software Bill of Materials requirements
  9. OWASP SCVS v1.0 — V3 Build Environment requirements
  10. OWASP SCVS v1.0 — V5 Component Analysis requirements
  11. OWASP SCVS v1.0 — V6 Pedigree and Provenance requirements
  12. OWASP SCVS — Guidance: Open Source Policy (appendix, not part of SCVS)
  13. OWASP SCVS — BOM Maturity Model
  14. Regulation (EU) 2024/2847 (Cyber Resilience Act), Official Journal text
Was this guide helpful?

In this cluster

OWASP SCVS: the Software Component Verification Standard, explained