FLOSS Best Practices Criteria (Silver Badge)

This is the set of best practices for Free/Libre and Open Source Software (FLOSS) projects to achieve the Open Source Security Foundation (OpenSSF) Best Practices silver badge. You can show this list with just the criteria or with additional information. The full set of criteria are also available.

See criteria discussion for more information about these criteria.




Basic project website content

  • The information on how to contribute MUST include the requirements for acceptable contributions (e.g., a reference to any required coding standard). {Met URL} [contribution_requirements]

Project oversight

  • The project SHOULD have a legal mechanism where all developers of non-trivial amounts of project software assert that they are legally authorized to make these contributions. The most common and easily-implemented approach for doing this is by using a Developer Certificate of Origin (DCO), where users add "signed-off-by" in their commits and the project links to the DCO website. However, this MAY be implemented as a Contributor License Agreement (CLA), or other legal mechanism. {Met URL} [dco]
    The DCO is the recommended mechanism because it's easy to implement, tracked in the source code, and git directly supports a "signed-off" feature using "commit -s". To be most effective it is best if the project documentation explains what "signed-off" means for that project. A CLA is a legal agreement that defines the terms under which intellectual works have been licensed to an organization or project. A contributor assignment agreement (CAA) is a legal agreement that transfers rights in an intellectual work to another party; projects are not required to have CAAs, since having CAA increases the risk that potential contributors will not contribute, especially if the receiver is a for-profit organization. The Apache Software Foundation CLAs (the individual contributor license and the corporate CLA) are examples of CLAs, for projects which determine that the risks of these kinds of CLAs to the project are less than their benefits.
  • The project MUST clearly define and document its project governance model (the way it makes decisions, including key roles). {Met URL} [governance]
    There needs to be some well-established documented way to make decisions and resolve disputes. In small projects, this may be as simple as "the project owner and lead makes all final decisions". There are various governance models, including benevolent dictator and formal meritocracy; for more details, see Governance models. Both centralized (e.g., single-maintainer) and decentralized (e.g., group maintainers) approaches have been successfully used in projects. The governance information does not need to document the possibility of creating a project fork, since that is always possible for FLOSS projects.
    There are many different governance models used by a wide array of successful projects. Therefore, we do not believe that we should specify a particular governance model. However, we do think it is important to have a governance model, and clearly define it, so that all participants and potential participants will know how decisions will be made. This was inspired by the OW2 Open-source Maturity Model, in particular RDMP-1 and STK-1.
  • The project MUST adopt a code of conduct and post it in a standard location. {Met URL} [code_of_conduct]
    Projects may be able to improve the civility of their community and to set expectations about acceptable conduct by adopting a code of conduct. This can help avoid problems before they occur and make the project a more welcoming place to encourage contributions. This should focus only on behavior within the community/workplace of the project. Example codes of conduct are the Linux kernel code of conduct, the Contributor Covenant Code of Conduct, the Debian Code of Conduct, the Ubuntu Code of Conduct, the Fedora Code of Conduct, the GNOME Code Of Conduct, the KDE Community Code of Conduct, the Python Community Code of Conduct, The Ruby Community Conduct Guideline, and The Rust Code of Conduct.
    Suggested in issue#608 by Dan Kohn and in the NYC 2016 brainstorm session.
  • The project MUST clearly define and publicly document the key roles in the project and their responsibilities, including any tasks those roles must perform. It MUST be clear who has which role(s), though this might not be documented in the same way. {Met URL} [roles_responsibilities]
    The documentation for governance and roles and responsibilities may be in one place.
    Much knowledge about the project roles builds up over the years, and is not sufficiently passed down to new people. Documenting the roles can help recruit, train, and mentor new project members. Projects may choose document the roles and responsibilities in one place, and identify who has the roles separately, so that the project doesn't need to update the role information when people change roles. The goal is to make underlying assumptions clear.
  • The project MUST be able to continue with minimal interruption if any one person dies, is incapacitated, or is otherwise unable or unwilling to continue support of the project. In particular, the project MUST be able to create and close issues, accept proposed changes, and release versions of software, within a week of confirmation of the loss of support from any one individual. This MAY be done by ensuring someone else has any necessary keys, passwords, and legal rights to continue the project. Individuals who run a FLOSS project MAY do this by providing keys in a lockbox and a will providing any needed legal rights (e.g., for DNS names). {Met URL} [access_continuity]
  • The project SHOULD have a "bus factor" of 2 or more. {Met URL} [bus_factor]
    A "bus factor" (aka "truck factor") is the minimum number of project members that have to suddenly disappear from a project ("hit by a bus") before the project stalls due to lack of knowledgeable or competent personnel. The truck-factor tool can estimate this for projects on GitHub. For more information, see Assessing the Bus Factor of Git Repositories by Cosentino et al.


  • The project MUST have a documented roadmap that describes what the project intends to do and not do for at least the next year. {Met URL} [documentation_roadmap]
    The project might not achieve the roadmap, and that's fine; the purpose of the roadmap is to help potential users and constributors understand the intended direction of the project. It need not be detailed.
  • The project MUST include documentation of the architecture (aka high-level design) of the software produced by the project. If the project does not produce software, select "not applicable" (N/A). {N/A justification} {Met URL} [documentation_architecture]
    A software architecture explains a program's fundamental structures, i.e., the program's major components, the relationships among them, and the key properties of these components and relationships.
    Documenting the basic design makes it easier for potential new developers to understand its basics. This is related to know_secure_design, as well as implement_secure_design and proposed documentation_security.
  • The project MUST document what the user can and cannot expect in terms of security from the software produced by the project (its "security requirements"). {N/A allowed} {Met URL} [documentation_security]
    These are the security requirements that the software is intended to meet.
    Writing the specification helps the developers think about the interface (including the API) the developers are providing, as well letting any user or researcher know what to expect.
  • The project MUST provide a "quick start" guide for new users to help them quickly do something with the software. {N/A justification} {Met URL} [documentation_quick_start]
    The idea is to show users how to get started and make the software do anything at all. This is critically important for potential users to get started.
    This is based on a conversation with Mike Milinkovich, Executive Director of the Eclipse Foundation, about the OSS project criteria and "what is important". He believes, based on his long experience, that it is critically important that any project have some sort of "quick start" guide to help someone get started and do something with the software; this feeling of accomplishment and demonstration that it works builds understanding and confidence in the user. See issue#645.
  • The project MUST make an effort to keep the documentation consistent with the current version of the project results (including software produced by the project). Any known documentation defects making it inconsistent MUST be fixed. If the documentation is generally current, but erroneously includes some older information that is no longer true, just treat that as a defect, then track and fix as usual. {N/A justification} {Met justification} [documentation_current]
    The documentation MAY include information about differences or changes between versions of the software and/or link to older versions of the documentation. The intent of this criterion is that an effort is made to keep the documentation consistent, not that the documentation must be perfect.
    It's difficult to keep documentation up-to-date, so the criterion is worded this way to make it more practical. Information on differences or changes between versions of the software helps users of older versions and users who are transitioning from older versions.
  • The project repository front page and/or website MUST identify and hyperlink to any achievements, including this best practices badge, within 48 hours of public recognition that the achievement has been attained. {Met URL} [documentation_achievements]
    An achievement is any set of external criteria that the project has specifically worked to meet, including some badges. This information does not need to be on the project website front page. A project using GitHub can put achievements on the repository front page by adding them to the README file.
    Users and potential co-developers need to be able to see what achievements have been attained by a project they are considering using or contributing to. This information can help them determine if they should. In addition, if projects identify their achievements, other projects will be encouraged to follow suit and also make those achievements, benefitting everyone.

Accessibility and internationalization

  • The project (both project sites and project results) SHOULD follow accessibility best practices so that persons with disabilities can still participate in the project and use the project results where it is reasonable to do so. {N/A justification} {Met justification} [accessibility_best_practices]
    For web applications, see the Web Content Accessibility Guidelines (WCAG 2.0) and its supporting document Understanding WCAG 2.0; see also W3C accessibility information. For GUI applications, consider using the environment-specific accessibility guidelines (such as Gnome, KDE, XFCE, Android, iOS, Mac, and Windows). Some TUI applications (e.g. `ncurses` programs) can do certain things to make themselves more accessible (such as `alpine`'s `force-arrow-cursor` setting). Most command-line applications are fairly accessible as-is. This criterion is often N/A, e.g., for program libraries. Here are some examples of actions to take or issues to consider:
    • Provide text alternatives for any non-text content so that it can be changed into other forms people need, such as large print, braille, speech, symbols or simpler language ( WCAG 2.0 guideline 1.1)
    • Color is not used as the only visual means of conveying information, indicating an action, prompting a response, or distinguishing a visual element. ( WCAG 2.0 guideline 1.4.1)
    • The visual presentation of text and images of text has a contrast ratio of at least 4.5:1, except for large text, incidental text, and logotypes ( WCAG 2.0 guideline 1.4.3)
    • Make all functionality available from a keyboard (WCAG guideline 2.1)
    • A GUI or web-based project SHOULD test with at least one screen-reader on the target platform(s) (e.g. NVDA, Jaws, or WindowEyes on Windows; VoiceOver on Mac & iOS; Orca on Linux/BSD; TalkBack on Android). TUI programs MAY work to reduce overdraw to prevent redundant reading by screen-readers.
  • The software produced by the project SHOULD be internationalized to enable easy localization for the target audience's culture, region, or language. If internationalization (i18n) does not apply (e.g., the software doesn't generate text intended for end-users and doesn't sort human-readable text), select "not applicable" (N/A). {N/A justification} {Met justification} [internationalization]
    Localization "refers to the adaptation of a product, application or document content to meet the language, cultural and other requirements of a specific target market (a locale)." Internationalization is the "design and development of a product, application or document content that enables easy localization for target audiences that vary in culture, region, or language." (See W3C's "Localization vs. Internationalization".) Software meets this criterion simply by being internationalized. No localization for another specific language is required, since once software has been internationalized it's possible for others to work on localization.
    When software is internationalized, the software can be used by far more people. By itself, that's valuable. In addition, software that can be used by far more people is more likely to lead to larger communities, which increases the likelihood of contributions and reviews.


  • If the project sites (website, repository, and download URLs) store passwords for authentication of external users, the passwords MUST be stored as iterated hashes with a per-user salt by using a key stretching (iterated) algorithm (e.g., Argon2id, Bcrypt, Scrypt, or PBKDF2). If the project sites do not store passwords for this purpose, select "not applicable" (N/A). {N/A justification} {Met justification} [sites_password_security]
    Note that the use of GitHub meets this criterion. This criterion only applies to passwords used for authentication of external users into the project sites (aka inbound authentication). If the project sites must log in to other sites (aka outbound authentication), they may need to store authorization tokens for that purpose differently (since storing a hash would be useless). This applies criterion crypto_password_storage to the project sites, similar to sites_https.

Change Control

Previous versions

  • The project MUST maintain the most often used older versions of the product or provide an upgrade path to newer versions. If the upgrade path is difficult, the project MUST document how to perform the upgrade (e.g., the interfaces that have changed and detailed suggested steps to help upgrade). {N/A justification} {Met justification} [maintenance_or_update]
    This was inspired by DFCT-1.2


Bug-reporting process

  • The project MUST use an issue tracker for tracking individual issues. {N/A justification} {Met justification} [report_tracker]

Vulnerability report process

  • The project MUST give credit to the reporter(s) of all vulnerability reports resolved in the last 12 months, except for the reporter(s) who request anonymity. If there have been no vulnerabilities resolved in the last 12 months, select "not applicable" (N/A). {N/A justification} {Met URL} [vulnerability_report_credit]
    It is only fair to credit those who provide vulnerability reports. In many cases, the only reporter requirement is that they receive credit. This is also important long-term, because giving credit encourages additional reporting. This was recommended in the NYC 2016 brainstorming session.
  • The project MUST have a documented process for responding to vulnerability reports. {Met URL} [vulnerability_response_process]
    This is strongly related to vulnerability_report_process, which requires that there be a documented way to report vulnerabilities. It also related to vulnerability_report_response, which requires response to vulnerability reports within a certain time frame.
    This is inspired by Apache Project Maturity Model QU30.


Coding standards

  • The project MUST identify the specific coding style guides for the primary languages it uses, and require that contributions generally comply with it. {N/A justification} {Met URL} [coding_standards]
    In most cases this is done by referring to some existing style guide(s), possibly listing differences. These style guides can include ways to improve readability and ways to reduce the likelihood of defects (including vulnerabilities). Many programming languages have one or more widely-used style guides. Examples of style guides include Google's style guides and SEI CERT Coding Standards.
  • The project MUST automatically enforce its selected coding style(s) if there is at least one FLOSS tool that can do so in the selected language(s). {N/A justification} {Met justification} [coding_standards_enforced]
    This MAY be implemented using static analysis tool(s) and/or by forcing the code through code reformatters. In many cases the tool configuration is included in the project's repository (since different projects may choose different configurations). Projects MAY allow style exceptions (and typically will); where exceptions occur, they MUST be rare and documented in the code at their locations, so that these exceptions can be reviewed and so that tools can automatically handle them in the future. Examples of such tools include ESLint (JavaScript), Rubocop (Ruby), and devtools check (R).

Working build system

  • Build systems for native binaries MUST honor the relevant compiler and linker (environment) variables passed in to them (e.g., CC, CFLAGS, CXX, CXXFLAGS, and LDFLAGS) and pass them to compiler and linker invocations. A build system MAY extend them with additional flags; it MUST NOT simply replace provided values with its own. If no native binaries are being generated, select "not applicable" (N/A). {N/A justification} {Met justification} [build_standard_variables]
    It should be easy to enable special build features like Address Sanitizer (ASAN), or to comply with distribution hardening best practices (e.g., by easily turning on compiler flags to do so).
    See Build system should honor CC, CFLAGS, CXX, CXXFLAGS
  • The build and installation system SHOULD preserve debugging information if they are requested in the relevant flags (e.g., "install -s" is not used). If there is no build or installation system (e.g., typical JavaScript libraries), select "not applicable" (N/A). {N/A justification} {Met justification} [build_preserve_debug]
    E.G., setting CFLAGS (C) or CXXFLAGS (C++) should create the relevant debugging information if those languages are used, and they should not be stripped during installation. Debugging information is needed for support and analysis, and also useful for measuring the presence of hardening features in the compiled binaries.
  • The build system for the software produced by the project MUST NOT recursively build subdirectories if there are cross-dependencies in the subdirectories. If there is no build or installation system (e.g., typical JavaScript libraries), select "not applicable" (N/A). {N/A justification} {Met justification} [build_non_recursive]
    The project build system's internal dependency information needs to be accurate, otherwise, changes to the project may not build correctly. Incorrect builds can lead to defects (including vulnerabilities). A common mistake in large build systems is to use a "recursive build" or "recursive make", that is, a hierarchy of subdirectories containing source files, where each subdirectory is independently built. Unless each subdirectory is fully independent, this is a mistake, because the dependency information is incorrect.
    For more information, see "Recursive Make Considered Harmful" by Peter Miller (note that this incorrect approach can be used in any build system, not just make). Note that "Non-recursive Make Considered Harmful" agrees that recursive builds are bad; its argument is that for large projects you should use a tool other than make. In many cases it is better to automatically determine the dependencies, but this is not always accurate or practical, so we did not require that dependencies be automatically generated.
  • The project MUST be able to repeat the process of generating information from source files and get exactly the same bit-for-bit result. If no building occurs (e.g., scripting languages where the source code is used directly instead of being compiled), select "not applicable" (N/A). {N/A justification} {Met justification} [build_repeatable]
    GCC and clang users may find the -frandom-seed option useful; in some cases, this can be resolved by forcing some sort order. More suggestions can be found at the reproducible build site.
    This is a step towards having a reproducible build. This criterion is much easier to meet, because it does not require that external parties be able to reproduce the results - merely that the project can. Supporting full reproducible builds requires that projects provide external parties enough information about their build environment(s), which can be harder to do - so we have split this requirement up.

Installation system

  • The project MUST provide a way to easily install and uninstall the software produced by the project using a commonly-used convention. {N/A justification} {Met justification} [installation_common]
    Examples include using a package manager (at the system or language level), "make install/uninstall" (supporting DESTDIR), a container in a standard format, or a virtual machine image in a standard format. The installation and uninstallation process (e.g., its packaging) MAY be implemented by a third party as long as it is FLOSS.
  • The installation system for end-users MUST honor standard conventions for selecting the location where built artifacts are written to at installation time. For example, if it installs files on a POSIX system it MUST honor the DESTDIR environment variable. If there is no installation system or no standard convention, select "not applicable" (N/A). {N/A justification} {Met justification} [installation_standard_variables]
    This supports capturing the artifacts (e.g., for analysis) without interfering with the build or installation system due to system-wide changes. See DESTDIR honored at install time This doesn't apply when there's no "installation" process, or when POSIX filesystems aren't supported during installation (e.g., Windows-only programs). See Build system should honor CC, CFLAGS, CXX, CXXFLAGS
  • The project MUST provide a way for potential developers to quickly install all the project results and support environment necessary to make changes, including the tests and test environment. This MUST be performed with a commonly-used convention. {N/A justification} {Met justification} [installation_development_quick]
    This MAY be implemented using a generated container and/or installation script(s). External dependencies would typically be installed by invoking system and/or language package manager(s), per external_dependencies.
    Recommended in the NYC 2016 brainstorming session.

Externally-maintained components

  • The project MUST list external dependencies in a computer-processable way. {N/A justification} {Met URL} [external_dependencies]
    Typically this is done using the conventions of package manager and/or build system. Note that this helps implement installation_development_quick.
    Inspired by the NYC 2016 brainstorming session.
  • Projects MUST monitor or periodically check their external dependencies (including convenience copies) to detect known vulnerabilities, and fix exploitable vulnerabilities or verify them as unexploitable. {N/A justification} {Met justification} [dependency_monitoring]
    This can be done using an origin analyzer / dependency checking tool / software composition analysis tool such as OWASP's Dependency-Check, Sonatype's Nexus Auditor, Synopsys' Black Duck Software Composition Analysis, and Bundler-audit (for Ruby). Some package managers include mechanisms to do this. It is acceptable if the components' vulnerability cannot be exploited, but this analysis is difficult and it is sometimes easier to simply update or fix the part.
    This must be monitored or periodically checked, because new vulnerabilities are continuously being discovered.
  • The project MUST either:
    1. make it easy to identify and update reused externally-maintained components; or
    2. use the standard components provided by the system or programming language.
    Then, if a vulnerability is found in a reused component, it will be easy to update that component. {N/A justification} {Met justification} [updateable_reused_components]
    A typical way to meet this criterion is to use system and programming language package management systems. Many FLOSS programs are distributed with "convenience libraries" that are local copies of standard libraries (possibly forked). By itself, that's fine. However, if the program *must* use these local (forked) copies, then updating the "standard" libraries as a security update will leave these additional copies still vulnerable. This is especially an issue for cloud-based systems; if the cloud provider updates their "standard" libaries but the program won't use them, then the updates don't actually help. See, e.g., "Chromium: Why it isn't in Fedora yet as a proper package" by Tom Callaway.
    A very common problem is to have obsolete components with known vulnerabilities. This is OWASP Top 10 (2013) number A9 (using known vulnerable components). See also The Unfortunate Reality of Insecure Libraries.
  • The project SHOULD avoid using deprecated or obsolete functions and APIs where FLOSS alternatives are available in the set of technology it uses (its "technology stack") and to a supermajority of the users the project supports (so that users have ready access to the alternative). {N/A justification} {Met justification} [interfaces_current]

Automated test suite

  • An automated test suite MUST be applied on each check-in to a shared repository for at least one branch. This test suite MUST produce a report on test success or failure. {Met justification} [automated_integration_testing]
    This requirement can be viewed as a subset of test_continuous_integration, but focused on just testing, without requiring continuous integration.
    This is inspired by continuous integration. Continuous integration provides much more rapid feedback on whether or not changes will cause test failures, including regressions. The term "continuous integration" (CI) is defined in Wikipedia as "merging all developer working copies to a shared mainline several times a day". Martin Fowler says that "Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including ) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly." However, while merging all developer working copies at this pace can be very useful, in practice many projects do not or cannot always do this. In practice, many developers maintain at least some branches that are not merged for longer than a day.
  • The project MUST add regression tests to an automated test suite for at least 50% of the bugs fixed within the last six months. {N/A justification} {Met justification} [regression_tests_added50]
    Regression tests prevent undetected resurfacing of defects. If a defect has happened before, there is an increased likelihood that it will happen again. We only require 50% of bugs to have regression tests; not all bugs are equally likely to recur, and in some cases it is extremely difficult to build robust tests for them. Thus, there is a diminishing point of return for adding regression tests. The 50% value could be argued as being arbitrary, however, requiring less than 50% would mean that projects could get the badge even if a majority of their bugs in the time frame would not have regression tests. Projects may, of course, choose to have much larger percentages. We choose six months, as with other requirements, so that projects that have done nothing in the past (or recorded nothing in the past) can catch up in a reasonable period of time.
  • The project MUST have FLOSS automated test suite(s) that provide at least 80% statement coverage if there is at least one FLOSS tool that can measure this criterion in the selected language. {N/A justification} {Met justification} [test_statement_coverage80]
    Many FLOSS tools are available to measure test coverage, including gcov/lcov, Blanket.js, Istanbul, JCov, and covr (R). Note that meeting this criterion is not a guarantee that the test suite is thorough, instead, failing to meet this criterion is a strong indicator of a poor test suite.
    Statement coverage is widely used as a test quality measure; it's often a first "starter" measure for test quality. It's well-supported, including by gcov/lcov and codecov.io. Bad test suites could also meet this requirement, but it's generally agreed that any good test suite will meet this requirement, so it provides a useful way to filter out clearly-bad test suites. After all, if your tests aren't even *running* many of the program's statements, you don't have very good tests. Only FLOSS test suites are considered, to ensure that the test suite can be examined and improved over time. A good automated test suite enables rapid response to vulnerability reports. If a vulnerability is reported to a project, the project may be able to quickly repair it, but that is not enough. A good automated test suite is necessary so the project can rapidly gain confidence that the repair doesn't break anything else so it can field the update. It could be argued that anything less than 100% is unacceptable, but this is not a widely held belief. There are many ways to determine if a program is correct - testing is only one of them. Some conditions are hard to create during testing, and the return-on-investment to get those last few percentages is arguably not worth it. The time working to get 100% statement coverage might be much better spent on checking the results more thoroughly (which statement coverage does *not* measure). The 80% suggested here is supported by various sources. The defaults of codecov.io. They define 70% and below as red, 100% as perfectly green, and anything between 70..100 as a range between red and green. This renders ~80% as yellow, and somewhere between ~85% and 90% it starts looking pretty green. The paper "Minimum Acceptable Code Coverage" by Steve Cornett claims, "Code coverage of 70-80% is a reasonable goal for system test of most projects with most coverage metrics. Use a higher goal for projects specifically organized for high testability or that have high failure costs. Minimum code coverage for unit testing can be 10-20% higher than for system testing... Empirical studies of real projects found that increasing code coverage above 70-80% is time consuming and therefore leads to a relatively slow bug detection rate. Your goal should depend on the risk assessment and economics of the project... Although 100% code coverage may appear like a best possible effort, even 100% code coverage is estimated to only expose about half the faults in a system. Low code coverage indicates inadequate testing, but high code coverage guarantees nothing." "TestCoverage" by Martin Fowler (17 April 2012) points out the problems with coverage measures. he states that "Test coverage is a useful tool for finding untested parts of a codebase. Test coverage is of little use as a numeric statement of how good your tests are... The trouble is that high coverage numbers are too easy to reach with low quality testing... If you are testing thoughtfully and well, I would expect a coverage percentage in the upper 80s or 90s. I would be suspicious of anything like 100%... Certainly low coverage numbers, say below half, are a sign of trouble. But high numbers don't necessarily mean much, and lead to ignorance-promoting dashboards."

New functionality testing

  • The project MUST have a formal written policy that as major new functionality is added, tests for the new functionality MUST be added to an automated test suite. {N/A justification} {Met justification} [test_policy_mandated]
    This ensures that major new functionality is tested. This is related to the criterion test_policy, but is rewritten to be stronger.
  • The project MUST include, in its documented instructions for change proposals, the policy that tests are to be added for major new functionality. {N/A justification} {Met justification} [tests_documented_added]

Warning flags

  • Projects MUST be maximally strict with warnings in the software produced by the project, where practical. {N/A justification} {Met justification} [warnings_strict]


Secure development knowledge

  • The project MUST implement secure design principles (from "know_secure_design"), where applicable. If the project is not producing software, select "not applicable" (N/A). {N/A justification} {Met justification} [implement_secure_design]
    For example, the project results should have fail-safe defaults (access decisions should deny by default, and projects' installation should be secure by default). They should also have complete mediation (every access that might be limited must be checked for authority and be non-bypassable). Note that in some cases principles will conflict, in which case a choice must be made (e.g., many mechanisms can make things more complex, contravening "economy of mechanism" / keep it simple).
    This was inspired by the NYC 2016 brainstorming session.

Use basic good cryptographic practices

  • The default security mechanisms within the software produced by the project MUST NOT depend on cryptographic algorithms or modes with known serious weaknesses (e.g., the SHA-1 cryptographic hash algorithm or the CBC mode in SSH). {N/A allowed} {Met justification} [crypto_weaknesses]
    SHA-1 has been known to be weak for many years; In February 2017 Google demonstrated a SHA-1 collision. There are a number of alternatives to SHA-1 that are not patent-encumbered, such as the SHA-2 suite (including SHA-256 and SHA-512) and SHA-3. There is some disagreement on how important it is to avoid CBC mode in SSH. The OpenSSH cbc.adv page argues that the attack on SSH CBC is not a practical attack. However, others clearly think it's more important; CERT notes it, as does FAQ: Disable CBC in SSH. It is also easy to use a different mode than CBC; generally when there are safer widely-available options, you should use the safe ones instead. This is a SHOULD, not a MUST; sometimes these weaker mechanisms need to be used for backwards compatibility.
  • The project SHOULD support multiple cryptographic algorithms, so users can quickly switch if one is broken. Common symmetric key algorithms include AES, Twofish, and Serpent. Common cryptographic hash algorithm alternatives include SHA-2 (including SHA-224, SHA-256, SHA-384 AND SHA-512) and SHA-3. {N/A allowed} {Met justification} [crypto_algorithm_agility]
    The advantage of crypto agility is that if one crypto algorithm is broken, other algorithms can be used instead. Many protocols, including TLS and IPSEC, are specifically designed to support crypto agility. There is disagreement by some experts who argue that this negotiation can itself be a point of attack, and that people should instead simply choose and stay with with one good algorithm. The problem with this position is that no one can be certain about what that "one good algorithm" is; a new attack could be found at any time. See the discussion at Remove requirement for supporting alternative crypto algorithms (crypto_alternatives)?
  • The project MUST support storing authentication credentials (such as passwords and dynamic tokens) and private cryptographic keys in files that are separate from other information (such as configuration files, databases, and logs), and permit users to update and replace them without code recompilation. If the project never processes authentication credentials and private cryptographic keys, select "not applicable" (N/A). {N/A allowed} {Met justification} [crypto_credential_agility]
  • The software produced by the project SHOULD support secure protocols for all of its network communications, such as SSHv2 or later, TLS1.2 or later (HTTPS), IPsec, SFTP, and SNMPv3. Insecure protocols such as FTP, HTTP, telnet, SSLv3 or earlier, and SSHv1 SHOULD be disabled by default, and only enabled if the user specifically configures it. If the software produced by the project does not support network communications, select "not applicable" (N/A). {N/A allowed} {Met justification} [crypto_used_network]
  • The software produced by the project SHOULD, if it supports or uses TLS, support at least TLS version 1.2. Note that the predecessor of TLS was called SSL. If the software does not use TLS, select "not applicable" (N/A). {N/A allowed} {Met justification} [crypto_tls12]
  • The software produced by the project MUST, if it supports TLS, perform TLS certificate verification by default when using TLS, including on subresources. If the software does not use TLS, select "not applicable" (N/A). {N/A allowed} {Met justification} [crypto_certificate_verification]
    Note that incorrect TLS certificate verification is a common mistake. For more information, see "The Most Dangerous Code in the World: Validating SSL Certificates in Non-Browser Software" by Martin Georgiev et al. and "Do you trust this application?" by Michael Catanzaro.
  • The software produced by the project MUST, if it supports TLS, perform certificate verification before sending HTTP headers with private information (such as secure cookies). If the software does not use TLS, select "not applicable" (N/A). {N/A allowed} {Met justification} [crypto_verification_private]

Secure release

  • The project MUST cryptographically sign releases of the project results intended for widespread use, and there MUST be a documented process explaining to users how they can obtain the public signing keys and verify the signature(s). The private key for these signature(s) MUST NOT be on site(s) used to directly distribute the software to the public. If releases are not intended for widespread use, select "not applicable" (N/A). {N/A justification} {Met justification} [signed_releases]
    The project results include both source code and any generated deliverables where applicable (e.g., executables, packages, and containers). Generated deliverables MAY be signed separately from source code. These MAY be implemented as signed git tags (using cryptographic digital signatures). Projects MAY provide generated results separately from tools like git, but in those cases, the separate results MUST be separately signed.
    This provides protection from compromised distribution systems. The public key must be accessible so that recipients can check the signature. The private key must not be on sites(s) distributing the software to the public; that way, even if those sites are compromised, the signature cannot be altered. This is sometimes called "code signing". A common way to implement this is by using GPG to sign the code, for example, the GPG keys of every person who signs releases could be in the project README. Node.js implements this via GPG keys in the README, but note that in the criterion we are intentionally more general: Node.js Release Team
  • It is SUGGESTED that in the version control system, each important version tag (a tag that is part of a major release, minor release, or fixes publicly noted vulnerabilities) be cryptographically signed and verifiable as described in signed_releases. {Met justification} [version_tags_signed]
    This was suggested by Kevin W. Wall (@kwwall)in issue #709.

Other security issues

  • The project results MUST check all inputs from potentially untrusted sources to ensure they are valid (an *allowlist*), and reject invalid inputs, if there are any restrictions on the data at all. {N/A justification} {Met justification} [input_validation]
    Note that comparing input against a list of "bad formats" (aka a *denylist*) is normally not enough, because attackers can often work around a denylist. In particular, numbers are converted into internal formats and then checked if they are between their minimum and maximum (inclusive), and text strings are checked to ensure that they are valid text patterns (e.g., valid UTF-8, length, syntax, etc.). Some data may need to be "anything at all" (e.g., a file uploader), but these would typically be rare.
  • Hardening mechanisms SHOULD be used in the software produced by the project so that software defects are less likely to result in security vulnerabilities. {N/A justification} {Met justification} [hardening]
    Hardening mechanisms may include HTTP headers like Content Security Policy (CSP), compiler flags to mitigate attacks (such as -fstack-protector), or compiler flags to eliminate undefined behavior. For our purposes least privilege is not considered a hardening mechanism (least privilege is important, but separate).
  • The project MUST provide an assurance case that justifies why its security requirements are met. The assurance case MUST include: a description of the threat model, clear identification of trust boundaries, an argument that secure design principles have been applied, and an argument that common implementation security weaknesses have been countered. {Met URL} [assurance_case]
    An assurance case is "a documented body of evidence that provides a convincing and valid argument that a specified set of critical claims regarding a system’s properties are adequately justified for a given application in a given environment" ("Software Assurance Using Structured Assurance Case Models", Thomas Rhodes et al, NIST Interagency Report 7608). Trust boundaries are boundaries where data or execution changes its level of trust, e.g., a server's boundaries in a typical web application. It's common to list secure design principles (such as Saltzer and Schroeer) and common implementation security weaknesses (such as the OWASP top 10 or CWE/SANS top 25), and show how each are countered. The BadgeApp assurance case may be a useful example. This is related to documentation_security, documentation_architecture, and implement_secure_design.
    Many sources discuss the rationale for an "assurance case". This was inspired by Security specification and facilitation of bug bounties and by the NYC 2016 brainstorming session.


Static code analysis

  • The project MUST use at least one static analysis tool with rules or approaches to look for common vulnerabilities in the analyzed language or environment, if there is at least one FLOSS tool that can implement this criterion in the selected language. {N/A justification} {Met justification} [static_analysis_common_vulnerabilities]
    We'd like all projects to use this kind of static analysis tool, but there may not be one in the chosen language, or it may only be proprietary (and some developers will therefore not use it).

Dynamic code analysis

  • If the software produced by the project includes software written using a memory-unsafe language (e.g., C or C++), then at least one dynamic tool (e.g., a fuzzer or web application scanner) MUST be routinely used in combination with a mechanism to detect memory safety problems such as buffer overwrites. If the project does not produce software written in a memory-unsafe language, choose "not applicable" (N/A). {N/A justification} {Met justification} [dynamic_analysis_unsafe]
    This would mean that C/C++ would be required to use something like ASAN during some testing and/or fuzz testing. See: consider giving links to asan/msan/tsan/ubsan and libFuzzer