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

SBOM

OpenSSF Best Practices Badge: the passing, silver and gold criteria, explained

Last updated:

The OpenSSF Best Practices Badge is a free, self-certification programme in which a Free/Libre and Open Source Software (FLOSS) project answers a structured questionnaire against 67 specific, published criteria — organised into 6 categories — to earn a "passing" badge, with Silver and Gold tiers layered sequentially on top for projects that go further. Originally the Core Infrastructure Initiative (CII) Best Practices Badge, it is now run by the Open Source Security Foundation (OpenSSF) under the Linux Foundation, and its own stated purpose is that "consumers of the badge can quickly assess which FLOSS projects are following best practices." Unlike an automated scanner, the badge reflects what a maintainer has reported about their own project's process — which is also why OpenSSF Scorecard checks for it directly rather than treating it as redundant with Scorecard's own automated checks.

Key takeaways

  • Source: OpenSSF Best Practices Badge criteria, level 0.
  • Basics (floss_license, MUST): "The software produced by the project MUST be released as FLOSS," meeting Open Source Initiative, Free Software Foundation, Debian, or Fedora approval standards.
  • Silver adds 55 criteria and gold 23, per the same criteria.yml; at gold, 21 of the 23 are MUST.
  • Because the badge is explicitly designed as a maturity ladder rather than three independent certificates.

What problem does the badge solve?

A downstream team evaluating an open-source dependency usually cannot tell, from the code alone, whether the maintainers follow a defined release process, handle vulnerability reports responsibly, or require code review before merging — practices that matter for supply-chain risk but rarely show up in a quick repository browse. The Best Practices Badge turns those practices into an explicit, answerable questionnaire a maintainer completes once and keeps current, giving any downstream consumer a structured signal without needing to read the project's entire history or contact its maintainers directly. The programme site notes that automated analysis fills in many answers and prevents "obviously incorrect answers," and that the programme was formally renamed from "CII Best Practices badge" on 2021-12-24.

How are the 67 passing-level criteria organised?

Counting directly from the project's own criteria files, and checked against the live passing criteria page on 2026-11-12, the 67 passing-level criteria fall into 6 categories:

Category Criteria count Covers
Basics 13 Project website content, FLOSS licensing
Change Control 9 Version-controlled repository, unique version numbering, release notes
Reporting 8 Bug reporting process, vulnerability report handling
Quality 13 Build process, automated test suite, coding standards, warning flags
Security 16 Secure-development knowledge, cryptographic practices, secure delivery
Analysis 8 Static and dynamic code analysis

Source: OpenSSF Best Practices Badge criteria, level 0.

Each criterion is tagged MUST, SHOULD or SUGGESTED; at the passing level that is 43 MUST, 10 SHOULD and 14 SUGGESTED. The terms follow RFC 2119 language with one addition. Quoted directly from the project's own document: "MUST is an absolute requirement," "SHOULD indicates a criterion that is normally required, but there may exist valid reasons in particular circumstances to ignore it," and "SUGGESTED is used instead of SHOULD when the criterion must be considered, but valid reasons to not do so are even more common than for SHOULD." The same document also defines MAY, but only to show "one way something can be done" inside a criterion's text; it is not a criterion tag. To earn a passing badge, every MUST criterion must actually be met, every SHOULD criterion must be met or its exception documented, and every SUGGESTED criterion must at least be explicitly considered — a project cannot simply skip an item.

What does a real criterion look like, word for word?

Three examples, quoted directly from the project's own criteria document, show the range from simple to technically specific:

  • Basics (floss_license, MUST): "The software produced by the project MUST be released as FLOSS," meeting Open Source Initiative, Free Software Foundation, Debian, or Fedora approval standards.
  • Security (know_secure_design, MUST): "The project MUST have at least one primary developer who knows how to design secure software" — and the criterion's own detail text requires familiarity with Saltzer and Schroeder's eight named design principles: economy of mechanism, fail-safe defaults, complete mediation, open design, separation of privilege, least privilege, least common mechanism, and psychological acceptability.
  • Security (crypto_keylength, MUST, N/A allowed): default security mechanisms "MUST use default keylengths that at least meet the NIST minimum requirements through the year 2030 (as stated in 2012)" — a specific, dated technical floor, not a vague instruction to use "strong" cryptography.

What do silver and gold add on top of passing?

Silver adds 55 criteria and gold 23, per the same criteria.yml; at gold, 21 of the 23 are MUST. Silver is mostly about documentation, governance and quality discipline; gold is about people and verification. Selected criteria, quoted from the all-levels criteria page:

Tier Criteria Examples (criterion ID: requirement)
Passing 67 (43 MUST) vulnerability_report_response: initial response to any vulnerability report in the last 6 months "MUST be less than or equal to 14 days"
Silver 55 (44 MUST) governance: a documented governance model; assurance_case: an assurance case including a threat model and trust boundaries; dependency_monitoring: monitor dependencies "to detect known vulnerabilities"; signed_releases: cryptographically signed releases with a documented way to verify them; test_statement_coverage80: at least 80% statement coverage
Gold 23 (21 MUST) two_person_review: "at least 50% of all proposed modifications reviewed before release by a person other than the author"; require_2FA: two-factor authentication for changing a central repository; build_reproducible; test_statement_coverage90 and test_branch_coverage80; security_review: "a security review within the last 5 years"

Source: OpenSSF Best Practices Badge criteria, levels 1 and 2, criterion text from the live criteria page, read 2026-11-12.

The gold criteria contributors_unassociated ("at least two unassociated significant contributors") and bus_factor are the reason Scorecard's own documentation says gold "requires multiple developers in the project." A small single-maintainer library can be well run and still never reach gold.

Why does Silver require Passing, and Gold require Silver?

Because the badge is explicitly designed as a maturity ladder rather than three independent certificates. The project's own higher-level criteria document states plainly: "You must achieve the 'passing' criteria before you can achieve silver or gold," and the criteria encode it directly as achieve_passing (a silver MUST) and achieve_silver (a gold MUST). Each higher tier both strengthens some existing criteria and adds criteria of its own. Three items move from SHOULD at silver to MUST at gold: bus_factor (two or more), crypto_used_network (secure protocols for all network communications) and hardening. Silver also adds items absent at passing, such as following accessibility best practices. A project cannot skip ahead; the ladder enforces that foundational practices are in place before more demanding ones are assessed.

Which criteria matter most when the dependency ships in firmware?

A library compiled into a device image is often updated far less frequently than a web dependency, so the criteria about vulnerability handling and release integrity carry more weight. The passing-level ones worth reading first:

Criterion (level) What it requires Why a device maker cares
vulnerability_report_process (passing, MUST) Publish the process for reporting vulnerabilities You need a route to report a flaw you find in your own testing
vulnerabilities_fixed_60_days (passing, MUST) No unpatched medium-or-higher vulnerabilities publicly known for more than 60 days Bounds how long a known flaw can sit in the code you ship
release_notes_vulns (passing, MUST) Release notes identify every publicly known run-time vulnerability fixed in the release that already had a CVE or similar Lets your SBOM matching and changelog review line up
delivery_mitm (passing, MUST) A delivery mechanism that counters MITM attacks, such as https or ssh+scp Protects the source you pull into your build
dynamic_analysis_unsafe (passing, SUGGESTED) For C/C++ code, a dynamic tool such as a fuzzer combined with memory-safety detection Most embedded libraries are C
signed_releases (silver, MUST) Signed releases and a documented way to verify them Lets your build verify what it ingests

Source: criterion text from bestpractices.dev, read 2026-11-12.

release_notes_vulns may be marked N/A where users "typically cannot practically update the software themselves," and it covers only the project's own results, not its dependencies — so a met answer says nothing about the libraries that project bundles in turn.

How do you read a project's badge answers instead of the icon?

Every project's answers are public. The project's API documentation describes a read-only JSON endpoint per project, and a search by repository URL:

  1. Find the projectwith https://www.bestpractices.dev/projects.json?url=<repository URL>; the result is an array of matches.
  2. Fetch its recordat https://www.bestpractices.dev/projects/<id>.json.
  3. Read `badge_level`(in_progress, passing, silver or gold) and tiered_percentage, which the API docs define as 100 for passing, 200 for silver and 300 for gold, plus progress toward the next level.
  4. Read the criteria you care about: each criterion has a <criterion>_status (Met, Unmet, N/A or ?) and a <criterion>_justification text field.
  5. Record the dateyou checked, because the answers are self-reported and can change.

A synthetic excerpt, labelled as such (a made-up embedded library, not a real record), shows what step 4 looks like:

{
  "name": "example-embedded-tls",
  "badge_level": "passing",
  "tiered_percentage": 131,
  "vulnerability_report_process_status": "Met",
  "vulnerability_report_response_status": "Met",
  "vulnerability_report_response_justification": "No external reports so far.",
  "dynamic_analysis_unsafe_status": "Unmet"
}

Here the badge is real but the justification for the 14-day response rule is vacuous, and the C library is not fuzzed — two facts the icon alone would hide.

How does OpenSSF Scorecard use this badge?

Directly, as one of its named automated checks. Scorecard's own CII-Best-Practices check documentation states that it "determines whether the project has earned an OpenSSF (formerly CII) Best Practices Badge at the passing, silver, or gold level," and assigns points by tier: 10 points for gold, 7 for silver, 5 for passing, and 2 for a badge that is under way but still unearned. The same page notes that Scorecard "can only report what it can automatically detect," while the badge "can report on claims and claim justifications from people." See OpenSSF Scorecard: what the automated checks actually measure for how this single check sits alongside Scorecard's other automated signals — a project with no badge at all simply scores 0 on this check rather than being flagged as actively unsafe, since the badge is opt-in and many well-run projects have simply never applied.

How does the badge relate to the OpenSSF Baseline?

The BadgeApp now hosts a second criteria set next to passing, silver and gold: the all-levels criteria page also lists Baseline Level 1, 2 and 3, drawn from the Open Source Project Security Baseline. The OSPS Baseline site describes it as "a minimum definition of requirements for a project relative to its maturity level" and lists v2026.08.28 as the current version on 2026-11-12. When you record a dependency's status, note which set the project answered. Our OpenSSF Security Baseline guide covers the controls themselves.

What should a device or firmware team actually check before trusting a dependency?

  1. Look up the specific badge tier, not just whether a badge existsA passing badge confirms baseline practices; it does not confirm silver or gold items such as signed releases, two-person review or a recent security review.
  2. Read the project's actual criteria answers, not just the badge iconThe BadgeApp publishes each project's specific met/unmet/N-A answer per criterion — useful for checking exactly which Security-category criteria (cryptography practices, secure-development knowledge) a given dependency claims to meet.
  3. Treat the absence of a badge as "unknown," not "unsafe."Many well-maintained FLOSS projects embedded in firmware (smaller libraries, vendor-contributed drivers) have simply never gone through the self-certification process; absence of a badge is a prompt for more manual review, not an automatic disqualification.

Common pitfalls when teams use the badge as evidence:

  • Checking the upstream project, not the copy you ship. A vendor SDK may carry a fork or an old release of a badged library.
  • Treating the badge as a vulnerability statement. It describes process; it does not say the version in your image is free of known CVEs.
  • Reusing an answer from last year. A badge can be lost as well as earned: each project record carries lost_passing_at, lost_silver_at and lost_gold_at dates next to the achieved_*_at ones. Re-check at each release.
  • Counting the badge as your own evidence. Article 13(5) of the Cyber Resilience Act requires manufacturers to "exercise due diligence when integrating components sourced from third parties", including free and open-source components; a badge can inform that due diligence but does not replace it. See our open-source steward guide for where open-source projects themselves fit.

A firmware image frequently bundles dozens of open-source components whose individual badge status, Scorecard score and licence terms are easy to lose track of once compiled into a binary. SoftWSP's device firmware security service unpacks the shipped image, builds a CycloneDX software bill of materials, and matches every identified open-source component against published CVE, CISA KEV and FIRST EPSS data — the component inventory a badge, Scorecard check or SLSA provenance review starts from. It does not look up badge or Scorecard results; that review stays with your engineers. See device firmware security, our firmware SBOM guide, or open an exported SBOM in the free SBOM viewer.

Criteria counts and quotes in this guide were checked on 2026-11-12 against the criteria definitions and English criterion text published in the ossf/best-practices-badge repository and against the live all-levels criteria page at bestpractices.dev, which the project names as the current criteria text. This guide is general information, not a substitute for reading a specific project's own badge answers.

Put this guide to work

Frequently asked questions

What is the OpenSSF Best Practices Badge?

A free, voluntary self-certification programme for Free/Libre and Open Source Software (FLOSS) projects, run by the Open Source Security Foundation (OpenSSF), part of the Linux Foundation. It was originally the Core Infrastructure Initiative (CII) Best Practices Badge, and its GitHub repository has since moved from `coreinfrastructure/best-practices-badge` to `ossf/best-practices-badge`. Per the programme's own stated purpose, it exists so that "consumers of the badge can quickly assess which FLOSS projects are following best practices and as a result are more likely to produce higher-quality secure software." A project earns a badge by answering a structured questionnaire (the BadgeApp) about its own practices, not through a third-party audit.

How many criteria are there, and how are they organised?

At the passing level — the entry tier — the project's own criteria document lists 67 individual criteria across 6 categories. Counting directly from that document: Basics (13 criteria, covering project website content and licensing), Change Control (9, version-controlled repository and release practices), Reporting (8, bug and vulnerability disclosure process), Quality (13, build systems, testing, coding standards), Security (16, secure-development knowledge and cryptographic practices), and Analysis (8, static/dynamic code analysis). Silver and Gold are higher tiers layered on top, documented separately, and per the project's own text, "you must achieve the 'passing' criteria before you can achieve silver or gold" — the three tiers are strictly sequential, not independent.

What do MUST, SHOULD and SUGGESTED mean in the criteria, exactly?

The project defines these using RFC 2119 language plus one addition, quoted directly from its criteria document: "MUST is an absolute requirement, and MUST NOT is an absolute prohibition." "SHOULD indicates a criterion that is normally required, but there may exist valid reasons in particular circumstances to ignore it" (with the exception documented). "SUGGESTED is used instead of SHOULD when the criterion must be considered, but valid reasons to not do so are even more common." To earn the passing badge, a project must meet every MUST/MUST NOT criterion, meet every SHOULD criterion or document why not, and have explicitly considered (met or unmet) every SUGGESTED criterion — nothing can simply be left unanswered.

What does a real passing-level criterion actually require?

Specific and checkable text, not vague principle. Two examples quoted directly from the project's own criteria document: the Basics category's `floss_license` criterion states "the software produced by the project MUST be released as FLOSS," meeting OSI, FSF, Debian or Fedora approval standards. The Security category's `know_secure_design` criterion states "the project MUST have at least one primary developer who knows how to design secure software," with the detail explicitly requiring familiarity with Saltzer and Schroeder's eight design principles (economy of mechanism, fail-safe defaults, complete mediation, open design, separation of privilege, least privilege, least common mechanism, and psychological acceptability) by name. Another Security criterion, `crypto_keylength`, requires default key lengths that "at least meet the NIST minimum requirements through the year 2030 (as stated in 2012)" — a specific, dated technical bar, not a general instruction to "use strong cryptography."

Does OpenSSF Scorecard check for this badge?

Yes, directly and by name. OpenSSF Scorecard's own `CII-Best-Practices` check documentation states that it "determines whether the project has earned an OpenSSF (formerly CII) Best Practices Badge at the passing, silver, or gold level," and assigns point values by tier: 10 points for gold, 7 for silver, 5 for passing, and 2 for a badge whose criteria are partly met (OpenSSF calls the state `in_progress`). See [OpenSSF Scorecard: what the automated checks actually measure](/guides/openssf-scorecard/) for how this fits into Scorecard's overall score — a project missing the badge entirely scores 0 on this specific check, not a penalty beyond that.

Is the badge the same thing as an OpenSSF Scorecard score or an SLSA level?

No — each measures something different, and they are complementary rather than overlapping. The Best Practices Badge is a self-reported questionnaire a maintainer fills in once (and should keep current) about process and practice; OpenSSF Scorecard is an automated tool that re-scans a repository's actual current state on every run, with the badge as just one of its many checks; SLSA grades the integrity of a specific build's provenance, not the project's general practices. See [SLSA: the Supply-chain Levels for Software Artifacts framework, explained](/guides/slsa-supply-chain-levels/) for the build-provenance model. A device or firmware team evaluating an open-source dependency reasonably checks all three rather than treating any single one as sufficient.

Sources

  1. OpenSSF Best Practices Badge: programme overview (bestpractices.dev)
  2. GitHub: ossf/best-practices-badge — the project's criteria document (passing-level criteria, categories, MUST/SHOULD/SUGGESTED definitions)
  3. GitHub: ossf/best-practices-badge repository
  4. GitHub: ossf/scorecard — Scorecard's checks documentation (CII-Best-Practices check, point values by tier)
  5. GitHub: ossf/best-practices-badge criteria.yml (criteria per level: passing 67, silver 55, gold 23; MUST/SHOULD/SUGGESTED)
  6. OpenSSF Best Practices Badge: all criteria (passing, silver, gold and Baseline levels)
  7. GitHub: ossf/best-practices-badge — silver and gold criteria document (tier order)
  8. GitHub: ossf/best-practices-badge — API documentation (JSON API, tiered_percentage)
  9. Open Source Project Security (OSPS) Baseline
  10. Regulation (EU) 2024/2847 (Cyber Resilience Act), Article 13(5)
Was this guide helpful?

In this cluster

OpenSSF Best Practices Badge: the passing, silver and gold criteria, explained