Critères des meilleures pratiques FLOSS (tous les niveaux)

Il s'agit de l'ensemble des meilleures pratiques pour les projets de logiciels libres et open source (FLOSS) pour obtenir les badges des meilleures pratiques de la Core Infrastructure Initiative (CII) aux niveaux basique, argent et or. Vous pouvez afficher cette liste avec uniquement les critères ou avec des informations supplémentaires. Vous pouvez également afficher uniquement les critères du niveau basique , argent et or, ainsi que les statistiques des critères.

Voir la discussion des critères pour plus d'informations sur ces critères.

Basique

Notions de base

Contenu basique du site Web du projet

  • Le site du projet DOIT décrire succinctement ce que le logiciel fait (quel problème résout-il ?). [description_good]
    Détails:
    Cela DOIT être dans un langage que les utilisateurs potentiels peuvent comprendre (par exemple, il utilise un jargon minimal).
  • Le site Web du projet DOIT fournir des informations sur la façon d'obtenir, de fournir des commentaires (comme des signalements de bogues ou des demandes d'amélioration) et de contribuer au logiciel. [interact]
  • L'information sur la façon de contribuer DOIT expliquer le processus de contribution (par exemple, les pull requests sont-ils utilisés ?) {Atteint URL} [contribution]
    Détails:
    Nous supposons que les projets sur GitHub utilisent les problèmes et les pull requests, sauf indication contraire. Cette information peut être courte, par exemple, en indiquant que le projet utilise les pull requests, un suivi des problèmes ou des messages dans une liste de diffusion (laquelle ?)
  • Les informations sur la façon de contribuer DEVRAIENT inclure les exigences pour des contributions acceptables (par exemple, une référence à toute norme de codage requise). {Atteint URL} [contribution_requirements]

Licence FLOSS

  • Le logiciel produit par le projet DOIT être distribué en tant que FLOSS. [floss_license]
    Détails:
    FLOSS est un logiciel distribué d'une manière qui répond à la Définition de l'Open Source ou à la Définition du Logiciel Libre. Des exemples de ces licences sont CC0, MIT, BSD 2-clause, BSD 3-clause révisée, Apache 2.0, Lesser GNU General Public License (LGPL), et GNU General Public License (GPL). Pour nos besoins, cela signifie que la licence DOIT être : Le logiciel PEUT également être distribué avec d'autres licences (par exemple, « GPLv2 ou propriétaire » est acceptable).
  • Il est PROPOSÉ que toute licence requise pour le logiciel produit par le projet soit approuvée par l'Open Source Initiative (OSI). [floss_license_osi]
    Détails:
    L'OSI utilise un processus d'approbation rigoureux pour déterminer quelles licences sont OSS.
  • Le projet DOIT afficher la ou les licences de ses résultats dans un emplacement standard dans leur dépôt source. {Atteint URL} [license_location]
    Détails:
    Une convention est de publier la licence sous la forme d'un fichier à la racine du dépôt appelé LICENSE ou COPYING, qui PEUT être suivi d'une extension telle que « .txt » ou « .md ». Une autre convention est d'avoir un réportoire nommé LICENSES contenant le(s) fichier(s) de licence ; ces fichiers sont généralement nommés comme leur identifiant de licence SPDX suivi d'une extension de fichier appropriée, comme décrit dans la Spécification REUSE. Notez que ce critère est requis uniquement pour le dépôt de sources. Vous n'avez PAS besoin d'inclure le fichier de licence lors de la génération d'un élément à partir du code source (tel qu'un exécutable, un paquet ou un conteneur). Par exemple, lors de la génération d'un paquet R pour le réseau d'archives complet R (CRAN), suivez la procédure standard CRAN : si la licence est une licence standard, utilisez la spécification de standard courte (pour éviter d'installer une autre copie du texte) et listez le fichier LICENSE dans un fichier d'exclusion tel que .Rbuildignore. De même, lors de la création d'un paquet Debian, vous pouvez mettre un lien dans le fichier de copyright vers le fichier de licence dans /usr/share/common-licenses, et exclure le fichier de licence du paquet créé (par exemple, en supprimant le fichier après avoir appelé dh_auto_install). Nous encourageons fortement l'inclusion d'informations de licence lisibles automatiquement dans des formats générés lorsque cela est possible.

Documentation

  • Le projet DOIT fournir une documentation de base pour le logiciel produit par le projet. {N/A justification} [documentation_basics]
    Détails:
    Cette documentation doit se trouver dans un certain format (comme le texte ou la vidéo) qui comprend : comment l'installer, comment le démarrer, comment l'utiliser (éventuellement avec un tutoriel à l'aide d'exemples) et comment l'utiliser en toute sécurité (par exemple, quoi faire et ne pas faire) si c'est un sujet approprié pour le logiciel. La documentation de sécurité n'a pas besoin d'être longue. Le projet PEUT utiliser des liens hypertextes vers du matériel hors projet en tant que documentation. Si le projet ne produit pas de logiciel, choisissez « non applicable » (N/A).
  • Le projet DOIT fournir une documentation de référence qui décrit l'interface externe (entrée et sortie) du logiciel produit par le projet. {N/A justification} [documentation_interface]
    Détails:
    La documentation d'une interface externe explique à un utilisateur final ou un développeur comment l'utiliser. Cela inclut son interface de programmation (API) si le logiciel en possède une. S'il s'agit d'une bibliothèque, documentez les principales classes / types et méthodes / fonctions pouvant être appelés. S'il s'agit d'une application Web, définissez son interface URL (souvent son interface REST). S'il s'agit d'une interface de ligne de commande, documentez les paramètres et les options qu'elle supporte. Dans de nombreux cas, il est préférable que la majorité de cette documentation soit générée automatiquement, de sorte que cette documentation reste synchronisée avec le logiciel au fur et à mesure qu'il change, mais cela n'est pas nécessaire. Le projet PEUT utiliser des liens hypertextes vers du matériel hors projet en tant que documentation. La documentation PEUT être générée automatiquement (quand c'est possible, c'est souvent la meilleure façon de le faire). La documentation d'une interface REST peut être générée à l'aide de Swagger / OpenAPI. La documentation de l'interface de code PEUT être générée à l'aide d'outils tels que JSDoc (JavaScript), ESDoc (JavaScript), pydoc (Python), devtools (R), pkgdown (R) et Doxygen (plusieurs). Le simple fait d'avoir des commentaires dans le code source n'est pas suffisant pour satisfaire ce critère ; il doit y avoir un moyen simple de voir l'information sans lire l'intégralité du code source. Si le projet ne produit pas de logiciel, choisissez « non applicable » (N/A).

Autre

  • Les sites du projet (site Web, dépôt et URLs de téléchargement) DOIVENT supporter HTTPS en utilisant TLS. [sites_https]
    Détails:
    Cela nécessite que l'URL de la page d'accueil du projet et l'URL du référentiel de contrôle de version commencent par « https: » et non par « http: ». Vous pouvez obtenir des certificats gratuits de Let's Encrypt. Les projets PEUVENT mettre en œuvre ce critère en utilisant (par exemple) des pages GitHub, des pages GitLab ou des pages de projet SourceForge. Si vous prenez en charge HTTP, nous vous invitons à rediriger le trafic HTTP vers HTTPS.
  • Le projet DOIT avoir un ou plusieurs mécanismes de discussion (y compris les changements et les problèmes proposés) qui peuvent être recherchés, permettent de désigner les messages et les sujets par une URL, permettent aux nouvelles personnes de participer à certaines des discussions et ne nécessitent pas d'installation côté client de logiciels propriétaires. [discussion]
    Détails:
    Parmi les exemples de mécanismes acceptables figurent les listes de diffusion archivées, les problèmes de GitHub et les discussions sur les pull requests, Bugzilla, Mantis et Trac. Les mécanismes de discussion asynchrones (comme IRC) sont acceptables s'ils répondent à ces critères ; assurez-vous qu'il existe un mécanisme d'archivage adressable par URL. Une solution propriétaire en JavaScript, tout en étant découragée, est autorisée.
  • Le projet DEVRAIT fournir de la documentation en anglais et être en mesure d'accepter les signalements de bogues et les commentaires sur le code en anglais. [english]
    Détails:
    L'anglais est actuellement la langue véhiculaire des technologies informatiques ; l'utilisation de l'anglais augmente le nombre de développeurs et de relecteurs potentiels dans le monde entier. Un projet peut répondre à ce critère même si la langue principale de ses principaux développeurs n'est pas l'anglais.
  • Le projet DOIT être maintenu. [maintained]
    Détails:
    Au minimum, le projet doit tenter de répondre aux rapports de problèmes et de vulnérabilités importants. Un projet qui poursuit activement un badge est probablement maintenu. Tous les projets et tous les individus ont des ressources limitées, et les projets typiques doivent rejeter certaines modifications proposées, de sorte que les ressources limitées et les rejets de propositions n'indiquent pas en eux-mêmes un projet non maintenu.

    Lorsqu'un projet sait qu'il ne sera plus maintenu, il doit définir ce critère comme « Non satisfait » et utiliser le(s) mécanisme(s) approprié(s) pour indiquer aux autres qu'il n'est pas maintenu. Par exemple, utiliser « DEPRECATED » comme premier en-tête de son fichier README, ajouter « DEPRECATED » au début de sa page d'accueil, ajouter « DEPRECATED » au début de la description de projet de son dépôt de code, ajouter un badge sans maintenance dans son README et/ou sa page d'accueil, le marquer comme obsolète dans tous les dépôts de paquets (par exemple, npm deprecate), et/ou utiliser le système de marquage du dépôt de code pour l'archiver (par exemple, le paramètre « archive » de GitHub, le marquage « archivé » de GitLab, le statut « lecture seule » de Gerrit ou le statut de projet « abandonné » de SourceForge). Une discussion supplémentaire peut être trouvée ici.

Contrôle des modifications

Dépôt source public sous contrôle de version

  • Le projet DOIT avoir un dépôt source sous contrôle de version qui est publiquement lisible et possède une URL. [repo_public]
    Détails:
    L'URL PEUT être identique à l'URL du projet. Le projet PEUT utiliser des branches privées (non publiques) dans des cas spécifiques alors que la modification n'est pas diffusée publiquement (par exemple, pour la correction d'une vulnérabilité avant qu'elle ne soit révélée au public).
  • Le dépôt source du projet DOIT suivre les changements apportés, qui a effectué les changements et quand les changements ont été effectués. [repo_track]
  • Pour permettre une analyse collaborative, le dépôt source du projet DOIT inclure des versions provisoires pour examen entre versions officielles ; Il NE DOIT PAS inclure que les dernières versions. [repo_interim]
    Détails:
    Les projets PEUVENT choisir d'omettre des versions intermédiaires spécifiques dans leurs dépôts source publics (par exemple, celles qui corrigent des vulnérabilités de sécurité non publiques spécifiques, ne peuvent jamais être rendues publiques ou incluent des éléments qui ne peuvent être légalement publiés et ne sont pas dans la version finale).
  • Il est PROPOSÉ qu'un logiciel reconnu de contrôle de version distribué soit utilisé (par exemple, git) pour le dépôt source du projet. [repo_distributed]
    Détails:
    Git n'est pas spécifiquement requis et les projets peuvent utiliser un logiciel de contrôle de version centralisé (comme subversion) avec justification.

Numérotation unique de la version

  • Les résultats du projet DOIVENT avoir un identifiant de version unique pour chaque version destinée à être utilisée par les utilisateurs. [version_unique]
    Détails:
    Cela PEUT être satisfait de diverses façons, y compris les identifiants de commit (comme git commit id ou mercure changeset id) ou un numéro de version (y compris les numéros de version qui utilisent la version sémantique ou les systèmes basés sur la date comme YYYYMMDD).
  • Il est PROPOSÉ d'utiliser le format de numérotation de version appelé Versionage Sémantique (SemVer) ou Versionage Calendaire (CalVer). Il est PROPOSÉ que ceux qui utilisent CalVer incluent une valeur de niveau micro. [version_semver]
    Détails:
    Les projets devraient généralement préférer le format attendu par leurs utilisateurs, par exemple, parce que c'est le format normal utilisé par leur écosystème. De nombreux écosystèmes préfèrent SemVer, et SemVer est généralement préféré pour les interfaces de programmation d'applications (API) et les kits de développement logiciel (SDK). CalVer a tendance à être utilisé par des projets de grande envergure, ayant un nombre inhabituellement élevé de dépendances développées indépendamment, ayant une portée en constante évolution ou étant sensibles au temps. Il est PROPOSÉ que ceux qui utilisent CalVer incluent une valeur de niveau micro, car l'inclusion d'un niveau micro prend en charge les branches maintenues simultanément chaque fois que cela devient nécessaire. D'autres formats de numérotation de version peuvent être utilisés, y compris les ID de commit git ou les ID de jeu de modifications mercurial, à condition qu'ils identifient de manière unique les versions. Cependant, certaines alternatives (telles que les ID de commit git) peuvent poser des problèmes en tant qu'identificateurs de version, car les utilisateurs peuvent ne pas être en mesure de déterminer facilement s'ils sont à jour. Le format de l'ID de version peut être sans importance pour l'identification des versions logicielles si tous les destinataires n'exécutent que la dernière version (par exemple, il s'agit du code d'un site Web ou d'un service Internet unique qui est constamment mis à jour par livraison continue).
  • Il est PROPOSÉ que les projets identifient chaque version dans leur système de contrôle de version. Par exemple, il est PROPOSÉ que ceux qui utilisent git identifient chaque version à l'aide des tags de git. [version_tags]

Notes de version

  • Le projet DOIT fournir, avec chaque distribution, des notes de version qui sont un résumé lisible par les humains des changements majeurs dans cette version afin d'aider les utilisateurs à déterminer s'ils doivent se mettre à niveau et quel sera l'impact de la mise à niveau. Les notes de version NE DOIVENT PAS être la sortie brute d'un journal de contrôle de version (par exemple, les résultats de la commande « git log » ne sont pas des notes de version). Les projets dont les résultats ne sont pas destinés à être réutilisés dans plusieurs emplacements (tels que le logiciel pour un site Web ou un service unique) ET qui utilisent la livraison continue PEUVENT sélectionner « N/A ». {N/A justification} {Atteint URL} [release_notes]
    Détails:
    Les notes de version PEUVENT être mises en œuvre de différentes façons. De nombreux projets les fournissent dans un fichier nommé « NEWS », « CHANGELOG » ou « ChangeLog », éventuellement avec des extensions telles que « .txt », « .md » ou « .html ». Historiquement, le terme « journal des modifications » signifiait un enregistrement de chaque changement, mais pour répondre à ces critères, il faut un résumé lisible par un humain. Les notes de version PEUVENT être fournies à la place par des mécanismes de système de contrôle de version tels que le GitHub Releases workflow.
  • Les notes de version DOIVENT identifier toutes les vulnérabilités connues du public corrigées dans cette version qui avaient déjà une affectation CVE ou similaire lors de la création de la version. Ce critère peut être marqué comme non applicable (N/A) si les utilisateurs ne peuvent pas en général mettre à jour le logiciel eux-mêmes (par exemple, comme c'est souvent le cas pour les mises à jour du noyau). Ce critère s'applique uniquement aux résultats du projet, pas à ses dépendances. S'il n'y a pas de notes de version ou qu'il n'y a pas eu de vulnérabilité publiquement connue, choisissez N/A. {N/A justification} [release_notes_vulns]
    Détails:
    Ce critère aide les utilisateurs à déterminer si une mise à jour donnée corrigera une vulnérabilité connue publiquement, pour aider les utilisateurs à prendre une décision éclairée concernant la mise à jour. Si les utilisateurs ne peuvent généralement pas mettre à jour le logiciel eux-mêmes sur leur ordinateur, mais doivent à la place dépendre d'un ou plusieurs intermédiaires pour effectuer la mise à niveau (comme c'est souvent le cas pour un noyau et un logiciel de bas niveau associé à un noyau), le projet peut choisir « non applicable » (N/A) à la place, car ces informations supplémentaires ne seront pas utiles à ces utilisateurs. De même, un projet peut choisir N/A si tous les destinataires n'exécutent que la dernière version (par exemple, il s'agit du code d'un site Web ou d'un service Internet unique qui est constamment mis à jour par livraison continue). Ce critère s'applique uniquement aux résultats du projet, pas à ses dépendances. Énumérer les vulnérabilités de toutes les dépendances transitives d'un projet devient ingérable à mesure que les dépendances augmentent et varient, et n'est pas nécessaire car les outils qui examinent et suivent les dépendances peuvent le faire de manière plus évolutive.

Compte-rendu

Procédure de signalement des bogues

  • Le projet DOIT fournir un processus permettant aux utilisateurs de soumettre des signalements de bogue (par exemple, en utilisant un suivi des problèmes ou une liste de diffusion). {Atteint URL} [report_process]
  • Le projet DEVRAIT utiliser un suivi des problèmes pour le suivi des problèmes individuels. [report_tracker]
  • Le projet DOIT confirmer une majorité des signalements de bogues soumis au cours des 2 à 12 derniers mois (inclus) ; la réponse ne doit pas nécessairement inclure une correction. [report_responses]
  • Le projet DEVRAIT répondre à une majorité (>50%) des demandes d'amélioration au cours des 2 à 12 derniers mois (inclus). [enhancement_responses]
    Détails:
    La réponse PEUT être « non » ou une discussion sur ses mérites. Le but est simplement qu'il y ait une réponse à certaines demandes, ce qui indique que le projet est toujours en vie. Aux fins de ce critère, les projets ne doivent pas compter les fausses demandes (par exemple, provenant de spammeurs ou de systèmes automatisés). Si un projet ne fait plus d'améliorations, sélectionnez « non satisfait » et incluez l'URL qui rend cette situation claire pour les utilisateurs. Si un projet tend à être submergé par le nombre de demandes d'amélioration, sélectionnez « non satisfait » et expliquez.
  • Le projet DOIT avoir une archive publique pour les signalements et les réponses pour une recherche ultérieure. {Atteint URL} [report_archive]

Processus de signalement de vulnérabilité

  • Le projet DOIT publier le processus de signalement des vulnérabilités sur le site du projet. {Atteint URL} [vulnerability_report_process]
    Détails:
    Par exemple, une adresse postale clairement désignée sur https://PROJECTSITE/security, souvent sous la forme security@example.org. Cela PEUT être identique à son processus de signalement des bogues. Les signalements de vulnérabilités PEUVENT toujours être publics, mais de nombreux projets disposent d'un mécanisme privé de signalement des vulnérabilités.
  • Si les signalements de vulnérabilités privés sont pris en charge, le projet DOIT inclure la façon d'envoyer l'information de manière confidentielle. {N/A autorisé} {Atteint URL} [vulnerability_report_private]
    Détails:
    Des exemples incluent un signalement de défaut privé envoyé sur le Web en utilisant HTTPS (TLS) ou un courrier électronique chiffré à l'aide d'OpenPGP. Si les signalements de vulnérabilités sont toujours publics (donc il n'y a jamais de signalements de vulnérabilités privés), choisissez « non applicable » (N/A).
  • Le temps de réponse initial du projet pour tout signalement de vulnérabilité reçu au cours des 6 derniers mois DOIT être inférieur ou égal à 14 jours. {N/A autorisé} [vulnerability_report_response]
    Détails:
    S'il n'y a pas eu de vulnérabilité signalée au cours des 6 derniers mois, choisissez « non applicable » (N/A).

Qualité

Système de construction opérationnel

  • Si le logiciel produit par le projet nécessite d'être construit pour être utilisé, le projet DOIT fournir un système de construction fonctionnel qui peut reconstruire automatiquement le logiciel à partir du code source. {N/A autorisé} [build]
    Détails:
    Un système de construction détermine quelles actions doivent se produire pour reconstruire le logiciel (et dans quel ordre), puis exécute ces étapes. Par exemple, il peut invoquer un compilateur pour compiler le code source. Si un exécutable est créé à partir du code source, il doit être possible de modifier le code source du projet, puis de générer un exécutable mis à jour avec ces modifications. Si le logiciel produit par le projet dépend de bibliothèques externes, le système de construction n'a pas besoin de construire ces bibliothèques externes. S'il n'est pas nécessaire de construire quoi que ce soit pour utiliser le logiciel après la modification de son code source, sélectionnez « non applicable » (N/A).
  • Il est PROPOSÉ d'utiliser des outils courants pour la construction du logiciel. {N/A autorisé} [build_common_tools]
    Détails:
    Par exemple, Maven, Ant, cmake, autotools, make, rake (Ruby) ou devtools (R).
  • Le projet DEVRAIT être constructible en utilisant uniquement des outils FLOSS. {N/A autorisé} [build_floss_tools]

Suite de tests automatisée

  • Le projet DOIT utiliser au moins une suite de tests automatisée publiée publiquement comme FLOSS (cette suite de tests peut être maintenue sous la forme d'un projet FLOSS distinct). Le projet DOIT clairement montrer ou documenter comment exécuter la ou les suites de tests (par exemple, via un script d'intégration continue (CI) ou via la documentation dans des fichiers tels que BUILD.md, README.md ou CONTRIBUTING.md). [test]
    Détails:
    Le projet PEUT utiliser plusieurs suites de tests automatisées (par exemple, une qui s'exécute rapidement, par rapport à une autre qui est plus approfondie, mais nécessite un équipement spécial). De nombreuses plate-formes de tests et environnements de tests sont disponibles, tels que Selenium (automatisation de navigateur Web), Junit (JVM, Java), RUnit (R), testthat (R).
  • Une suite de tests DEVRAIT être invocable d'une manière standard pour ce langage. [test_invocation]
    Détails:
    Par exemple, « make check », « mvn test » ou « rake test » (Ruby).
  • Il est PROPOSÉ que la suite de tests couvre la plupart (ou idéalement toutes) les branches du code, les champs de saisie et les fonctionnalités. [test_most]
  • Il est PROPOSÉ que le projet utilise une intégration continue (où le code nouveau ou modifié est fréquemment intégré dans un dépôt de code central et des tests automatisés sont exécutés sur le résultat). [test_continuous_integration]

Nouveau test de fonctionnalité

  • Le projet DOIT avoir une politique générale (formelle ou non) qui spécifie que, dès qu'une nouvelle fonctionnalité majeure est ajoutée au logiciel produit par le projet, des tests de cette fonctionnalité devraient être ajoutés à une suite de tests automatisée. [test_policy]
    Détails:
    Dès qu'une politique est en place, même par le bouche à oreille, qui spécifie que les développeurs devraient ajouter des tests à une suite de tests automatisée pour toute nouvelle fonctionnalité importante, sélectionnez « Atteint ».
  • Le projet DOIT avoir la preuve que la politique de test pour l'ajout de tests a été respectée dans les dernières modifications majeures apportées au logiciel produit par le projet. [tests_are_added]
    Détails:
    Les principales fonctionnalités sont généralement mentionnées dans les notes de version. La perfection n'est pas nécessaire, il suffit de prouver que les tests sont généralement ajoutés en pratique à la suite de tests automatisée lorsque de nouvelles fonctionnalités majeures sont ajoutées au logiciel produit par le projet.
  • Il est PROPOSÉ que cette politique sur l'ajout de tests (voir la politique de test) soit documentée dans les instructions pour les propositions de modification. [tests_documented_added]
    Détails:
    Cependant, même une règle informelle est acceptable tant que les tests sont ajoutés dans la pratique.

Options d'avertissement

  • Le projet DOIT activer une ou plusieurs options d'avertissement du compilateur, un mode du langage « sûr » ou utiliser un outil « linter » séparé pour rechercher des erreurs de qualité de code ou des erreurs simples courantes, s'il existe au moins un outil FLOSS qui peut implémenter ce critère dans le langage sélectionné. {N/A autorisé} [warnings]
    Détails:
    Des exemples d'options d'avertissement du compilateur incluent « -Wall » pour gcc/clang. Des exemples d'un mode de langage « sûr » incluent « use strict » en JavaScript et « use warnings » de perl5. Un outil « linter » distinct est simplement un outil qui examine le code source pour rechercher des erreurs de qualité de code ou des erreurs simples courantes. Ceux-ci sont généralement activés par le code source ou par les instructions de construction.
  • Le projet DOIT résoudre les avertissements. {N/A autorisé} [warnings_fixed]
    Détails:
    Ce sont les avertissements identifiés par la mise en œuvre du critère warnings. Le projet doit corriger les avertissements ou les marquer dans le code source comme faux positifs. Idéalement, il n'y aurait pas d'avertissement, mais un projet PEUT accepter certains avertissements (généralement moins de 1 avertissement pour 100 lignes ou moins de 10 avertissements).
  • Il est PROPOSÉ que les projets soient maximalement stricts avec les avertissements dans le logiciel produit par le projet, quand cela est approprié. {N/A autorisé} [warnings_strict]
    Détails:
    Certains avertissements ne peuvent être efficacement activés sur certains projets. Ce qui est nécessaire est la preuve que le projet s'efforce d'activer les options d'avertissements où il peut, de sorte que les erreurs soient détectées tôt.

Sécurité

Connaissance du développement sécurisé

  • Le projet DOIT avoir au moins un développeur principal qui sait comment concevoir un logiciel sécurisé. (Voir les « détails » pour les exigences exactes.) [know_secure_design]
    Détails:
    Cela nécessite de comprendre les principes de conception suivants, y compris les 8 principes de Saltzer et Schroeder :
    • économie de moyens (maintenez la conception aussi simple et petite que pratique, par exemple en adoptant des simplifications conséquentes)
    • valeurs sûres par défaut (les décisions d'accès par défaut devraient être de refuser l'accès et l'installation des projets devrait être sécurisée par défaut)
    • médiation complète (tous les accès qui pourraient être limités doivent être vérifiés pour l'autorité et ne pas être contournables)
    • conception ouverte (les mécanismes de sécurité ne doivent pas dépendre de l'ignorance par l'attaquant de sa conception, mais plutôt d'informations plus facilement protégées et modifiées comme des clés et des mots de passe)
    • séparation des privilèges (idéalement, l'accès aux objets importants devrait dépendre de plus d'une condition, de sorte que la défaillance d'un système de protection n'autorisera pas l'accès complet. Par exemple, l'authentification multi-facteurs, comme l'exigence d'un mot de passe et d'un jeton matériel, est plus forte qu'une authentification à un seul facteur)
    • principe de plus faible privilège (les processus doivent fonctionner avec le minimum de privilège requis)
    • mécanisme de partage minimal (la conception devrait minimiser les mécanismes communs à plus d'un utilisateur et nécessaires à tous les utilisateurs, par exemple, les répertoires pour les fichiers temporaires)
    • acceptabilité psychologique (l'interface humaine doit être conçue pour faciliter l'utilisation - la conception pour « l'étonnement minimal » peut aider)
    • surface d'attaque limitée (la surface d'attaque - l'ensemble des différents points où un attaquant peut essayer d'entrer ou d'extraire des données - devrait être limitée)
    • validation d'entrée avec des listes blanches (les entrées devraient généralement être vérifiées pour déterminer si elles sont valides avant qu'elles ne soient acceptées ; cette validation devrait utiliser des listes blanches (qui n'acceptent que des bonnes valeurs connues), et non des listes noires (qui tentent de répertorier les valeurs mauvaises connues)).
    Un « développeur principal » dans un projet est celui qui connaît la base de code du projet, est à l'aise pour faire des modifications et est reconnu comme tel par la plupart des autres participants au projet. Un développeur principal a effectué généralement un certain nombre de contributions au cours de l'année écoulée (du code, de la documentation ou des réponses aux questions). Des développeurs sont généralement considérés comme des développeurs principaux s'ils ont lancé le projet (et n'ont pas quitté le projet il y a plus de trois ans), ont la possibilité de recevoir des informations sur un canal privé de déclaration de vulnérabilités (s'il y en a un), peuvent accepter des contributions au nom du projet, ou effectuer les distributions finales du logiciel du projet. S'il n'y a qu'un seul développeur, cette personne est le développeur principal. De nombreux livres et cours sont disponibles pour vous aider à comprendre comment développer des logiciels plus sûrs et pour discuter de leur conception. Par exemple, le cours Bases du développement logiciel sécurisé est un ensemble gratuit de trois cours qui expliquent comment développer des logiciels plus sûrs.
  • Au moins l'un des principaux développeurs du projet DOIT connaître les types courants d'erreurs qui conduisent à des vulnérabilités dans ce genre de logiciel, ainsi qu'au moins une méthode pour contrer ou atténuer chacun d'eux. [know_common_errors]
    Détails:
    Des exemples (selon le type de logiciel) incluent l'injection SQL, l'injection OS, le débordement mémoire classique, le cross-site scripting, l'authentification manquante et l'autorisation manquante. Voir CWE/SANS top 25 ou OWASP Top 10 pour les listes couramment utilisées. De nombreux livres et cours sont disponibles pour vous aider à comprendre comment développer des logiciels plus sûrs et discuter des erreurs courantes de mise en œuvre qui conduisent à des vulnérabilités. Par exemple, le cours Bases du développement logiciel sécurisé est un ensemble gratuit de trois cours qui expliquent comment développer des logiciels plus sûrs.

Utiliser de bonnes pratiques de base de cryptographie

  • Le logiciel produit par le projet DOIT utiliser, par défaut, uniquement les protocoles cryptographiques et les algorithmes publiés publiquement et revus par des experts (si des protocoles et algorithmes cryptographiques sont utilisés). {N/A autorisé} [crypto_published]
    Détails:
    Ces critères cryptographiques ne s'appliquent pas toujours car certains logiciels n'ont pas besoin d'utiliser directement de capacités cryptographiques.
  • Si le logiciel produit par le projet est une application ou une bibliothèque, et si son objectif principal n'est pas d'implémenter de la cryptographie, alors il DEVRAIT simplement appeler un logiciel spécialement conçu pour implémenter des fonctions cryptographiques ; il ne DEVRAIT PAS ré-implémenter les siennes. {N/A autorisé} [crypto_call]
  • Toutes les fonctionnalités du logiciel produit par le projet qui dépendent de la cryptographie DOIVENT être réalisables à l'aide de FLOSS. {N/A autorisé} [crypto_floss]
    Détails:
    Consultez les Exigences des standards ouverts pour les logiciels par l'Open Source Initiative.
  • Les mécanismes de sécurité dans le logiciel produit par le projet DOIVENT utiliser des longueurs de clés par défaut qui satisfont au moins aux exigences minimales du NIST jusqu'à l'année 2030 (comme indiqué en 2012). Il DOIT être possible de configurer le logiciel afin que les plus petites longueurs de clés soient complètement désactivées. {N/A autorisé} [crypto_keylength]
    Détails:
    Ces longueurs de bit minimales sont : pour une clé symétrique 112, pour un modulo de factorisation 2048, pour une clé de logarithme discret 224, pour un groupe du logarithmique discret 2048, pour une courbe elliptique 224 et pour un hachage 224 (le hachage de mot de passe n'est pas couvert par cette longueur de bit, plus d'informations sur le hachage de mot de passe peuvent être trouvées dans le critère crypto_password_storage). Voir https://www.keylength.com pour une comparaison des recommandations sur les longueurs de clés de diverses organisations. Le logiciel PEUT permettre de plus petites longueurs de clés dans certaines configurations (idéalement non, car cela permet des attaques de dégradation, mais des longueurs de clés plus courtes sont parfois nécessaires pour l'interopérabilité).
  • Les mécanismes de sécurité par défaut dans le logiciel produit par le projet NE DOIVENT PAS dépendre d'algorithmes cryptographiques cassés (par exemple, MD4, MD5, DES unique, RC4, Dual_EC_DRBG) ou utiliser des modes de chiffrement inappropriés dans le contexte, sauf si ils sont nécessaires pour implémenter un protocole d'interopérabilité (où le protocole implémenté est la version la plus récente du standard supporté largement par l'écosystème du réseau, l'écosystème requiert l'utilisation de cet algorithme ou mode, et cet écosystème n'offre pas d'alternative plus sûre). La documentation DOIT décrire tous les risques de sécurité appropriés et les parades connues si ces algorithmes ou modes cassés sont nécessaires pour un protocole d'interopérabilité. {N/A autorisé} [crypto_working]
    Détails:
    Le mode ECB n'est presque jamais approprié car il révèle des blocs identiques dans le texte chiffré, comme le montre le pingouin ECB, et le mode CTR est souvent inapproprié car il n'effectue pas d'authentification et provoque des doublons si l'état d'entrée est dupliqué. Dans de nombreux cas, il est préférable de choisir un mode d'algorithme de chiffrement de bloc conçu pour combiner le secret et l'authentification, par exemple Galois/Counter Mode (GCM) et EAX. Les projets PEUVENT permettre aux utilisateurs d'activer les mécanismes cassés (par exemple pendant la configuration) si nécessaire pour la compatibilité, mais les utilisateurs savent alors qu'ils le font.
  • Les mécanismes de sécurité par défaut dans le logiciel produit par le projet NE DEVRAIENT PAS dépendre d'algorithmes ou de modes cryptographiques avec des faiblesses sérieuses connues (par exemple, l'algorithme de hachage cryptographique SHA-1 ou le mode CBC en SSH). {N/A autorisé} [crypto_weaknesses]
    Détails:
    Les préoccupations concernant le mode CBC en SSH sont discutées dans CERT : vulnérabilité SSH CBC.
  • Les mécanismes de sécurité dans le logiciel produit par le projet DEVRAIENT implémenter la confidentialité persistante pour les protocoles d'échange de clés afin qu'une clé de session dérivée d'un ensemble de clés à long terme ne soit pas compromise si l'une des clés à long terme est compromise dans le futur. {N/A autorisé} [crypto_pfs]
  • Si le logiciel produit par le projet entraîne la sauvegarde de mots de passe pour l'authentification d'utilisateurs externes, les mots de passe DOIVENT être sauvegardés comme hachages itérés avec un salage par utilisateur en utilisant un algorithme d'étirement de clé (itéré) (par exemple Argon2id, Bcrypt, Scrypt, ou PBKDF2). Voir également le pense-bête sur le stockage des clés d'OWASP. {N/A autorisé} [crypto_password_storage]
    Détails:
    Ce critère s'applique uniquement lorsque le logiciel applique l'authentification des utilisateurs utilisant des mots de passe pour les utilisateurs extérieurs (càd l'authentification entrante), telles que des applications Web côté serveur. Il ne s'applique pas dans les cas où le logiciel sauvegarde des mots de passe pour l'authentification dans d'autres systèmes (càd l'authentification sortante, par exemple, le logiciel implémente un client pour un autre système), car au moins certaines parties de ce logiciel doivent avoir souvent accès au mot de passe en clair.
  • Les mécanismes de sécurité dans le logiciel produit par le projet DOIVENT générer toutes les clés cryptographiques et les nonces en utilisant un générateur de nombres aléatoires cryptographiquement sécurisé, et NE DOIVENT PAS le faire en utilisant des générateurs qui ne seraient pas cryptographiquement sécurisés. {N/A autorisé} [crypto_random]
    Détails:
    Un générateur de nombres aléatoires cryptographiquement sécurisé peut être un générateur de nombres aléatoires matériel ou un générateur de nombres pseudo-aléatoires cryptographiquement sécurisé (CSPRNG) utilisant un algorithme tel que Hash_DRBG, HMAC_DRBG, CTR_DRBG, Yarrow ou Fortuna. Des exemples d'appels de générateurs de nombres aléatoires sûrs incluent java.security.SecureRandom en Java et window.crypto.getRandomValues ​​de JavaScript. Des exemples d'appels de générateurs de nombres aléatoires non sûrs incluent java.util.Random en Java et Math.random en JavaScript.

Livraison sécurisée contre les attaques man-in-the-middle (MITM)

  • Le projet DOIT utiliser un mécanisme de livraison qui contrecarre les attaques MITM. L'utilisation de https ou ssh+scp est acceptable. [delivery_mitm]
    Détails:
    Un mécanisme encore plus fort distribue le logiciel sous forme de paquetages signés numériquement, car cela atténue les attaques sur le système de distribution, mais cela ne fonctionne que si les utilisateurs peuvent être convaincus que les clés publiques pour les signatures sont correctes et si les utilisateurs vérifient la signature.
  • Un hachage cryptographique (par exemple, un sha1sum) NE DOIT PAS être récupéré par http et utilisé sans vérifier une signature cryptographique. [delivery_unsigned]
    Détails:
    Ces hachages peuvent être modifiés en transit.

Vulnérabilités publiquement identifiées et corrigées

  • Il ne DOIT pas y avoir de vulnérabilités non corrigées de gravité moyenne ou supérieure connues publiquement depuis plus de 60 jours. [vulnerabilities_fixed_60_days]
    Détails:
    La vulnérabilité doit être corrigée et diffusée par le projet lui-même (les correctifs peuvent être développés ailleurs). Une vulnérabilité devient publique (à cet effet) une fois qu'elle a un CVE avec des informations non payantes publiquement publiées (signalée, par exemple, dans la Base de données Nationale des Vulnérabilités) ou lorsque le projet a été informé et que l'information a été diffusée au public (éventuellement par le projet). Une vulnérabilité est considérée de gravité moyenne ou supérieure si son score de base qualitatif du Système Commun d'Évaluation des Vulnérabilités (CVSS) est moyen ou supérieur. Dans les versions CVSS 2.0 à 3.1, cela équivaut à un score CVSS de 4.0 ou supérieur. Les projets peuvent utiliser le score CVSS publié dans une base de données de vulnérabilité largement utilisée (telle que la base de données nationale des vulnérabilités) en utilisant la version la plus récente de CVSS rapportée dans cette base de données. Les projets peuvent aussi calculer eux-mêmes la gravité à l'aide de la dernière version de CVSS au moment de la divulgation de la vulnérabilité, si les entrées de calcul sont révélées publiquement une fois que la vulnérabilité est connue du public.Note : cela signifie que les utilisateurs peuvent être laissés vulnérables à tous les attaquants du monde entier jusqu'à 60 jours. Ce critère est souvent beaucoup plus facile à atteindre que ce que Google recommande dans son Redémarrage de la divulgation responsable, car Google recommande que la période de 60 jours commence lorsque le projet est notifié même si le rapport n'est pas public. Notez que ce critère de badge, comme d'autres critères, s'applique à un projet individuel. Certains projets font parti d'organisations ou de projets englobants, parfois à plusieurs niveaux, et de nombreux projets fournissent leurs résultats à d'autres organisations et projets au sein d'une chaîne approvisionnement potentiellement complexe. Un projet individuel ne peut souvent pas contrôler le reste, mais un projet individuel peut travailler à fournir un correctif de vulnérabilité à temps. Pour cette raison, nous nous concentrons seulement sur le temps de réponse des projets individuels. Une fois qu'un correctif est disponible de la part d'un projet individuel, les autres projets peuvent déterminer comment appliquer le correctif (par exemple, ils peuvent mettre à jour la dernière version ou ils peuvent appliquer uniquement le correctif).
  • Les projets DEVRAIENT corriger rapidement toutes les vulnérabilités critiques après leur signalement. [vulnerabilities_critical_fixed]

Autres problèmes de sécurité

  • Les dépôts publics NE DOIVENT PAS fuiter un certificat privé valide (par exemple, un mot de passe ou une clé privée) qui est destiné à limiter l'accès public. [no_leaked_credentials]
    Détails:
    Un projet PEUT fuiter des « échantillons » de certificats pour les tests et pour des bases de données sans importance, pour autant qu'ils ne soient pas destinés à limiter l'accès public.

Analyse

Analyse statique de code

  • Au moins un outil d'analyse statique de code (au-delà des avertissements du compilateur et des modes « sûrs » des languages) DOIT être appliqué à toute distribution majeure proposée avant sa sortie s'il existe au moins un outil FLOSS qui implémente ce critère dans le langage sélectionné. {N/A justification} {Atteint justification} [static_analysis]
    Détails:
    Un outil d'analyse statique de code examine le code logiciel (au niveau du code source, du code intermédiaire ou de l'exécutable) sans l'exécuter avec des entrées spécifiques. Aux fins de ce critère, les avertissements du compilateur et les modes de langage « sûrs » ne comptent pas comme des outils d'analyse statique de code (ceux-ci évitent généralement une analyse approfondie car la rapidité est vitale). Certains outils d'analyse statique se concentrent sur la détection de défauts génériques, d'autres se concentrent sur la détection de défauts spécifiques (tels que les vulnérabilités) et d'autres encore proposent une combinaison de ces deux types d'outils. Des exemples de tels outils d'analyse statique de code incluent cppcheck (C, C++), clang static analyzer (C, C++), SpotBugs (Java), FindBugs (Java) (y compris FindSecurityBugs), PMD (Java), Brakeman (Ruby on Rails), lintr (R), goodpractice (R), Coverity Quality Analyzer, SonarQube, Codacy et HP Enterprise Fortify Static Code Analyzer. Des listes plus vastes d'outils peuvent être trouvées dans des endroits tels que la liste Wikipedia d'outils pour l'analyse statique de code, l'information OWASP sur l'analyse statique de code, la liste NIST des analyseurs de sécurité du code source et la liste des outils d'analyse statique de Wheeler. SWAMP est une plate-forme gratuite pour évaluer les vulnérabilités dans les logiciels utilisant une variété d'outils. S'il n'y a pas d'outil d'analyse statique FLOSS disponible pour le(s) langage(s) d'implémentation utilisé(s), sélectionnez « N/A ».
  • Il est PROPOSÉ qu'au moins l'un des outils d'analyse statique utilisés pour le critère d'analyse statique inclue des règles ou des approches pour rechercher des vulnérabilités courantes dans le langage ou l'environnement analysé. {N/A autorisé} [static_analysis_common_vulnerabilities]
    Détails:
    Les outils d'analyse statique spécialement conçus pour détecter les vulnérabilités les plus courantes sont plus susceptibles de les détecter. Cela dit, l'utilisation d'outils statiques aidera généralement à trouver des problèmes, nous suggérons donc, sans l'exiger, de le faire pour le badge de niveau « passant ».
  • Toutes les vulnérabilités exploitables de gravité moyenne ou plus découvertes avec une analyse statique de code DOIVENT être corrigées en temps approprié après leur confirmation. {N/A autorisé} [static_analysis_fixed]
    Détails:
    Une vulnérabilité est considérée comme étant de gravité moyenne ou supérieure si son score qualitatif de base du Système Commun d'Évaluation des Vulnérabilités (CVSS) est moyen ou supérieur. Dans les versions CVSS 2.0 à 3.1, cela équivaut à un score CVSS de 4.0 ou supérieur. Les projets peuvent utiliser le score CVSS publié dans une base de données de vulnérabilité largement utilisée (telle que la base de données nationale des vulnérabilités) en utilisant la version la plus récente de CVSS rapportée dans cette base de données. Les projets peuvent aussi calculer eux-mêmes la gravité à l'aide de la dernière version de CVSS au moment de la divulgation de la vulnérabilité, si les entrées de calcul sont révélées publiquement une fois que la vulnérabilité est connue du public. Remarquez que le critère vulnerabilities_fixed_60_days nécessite que de telles vulnérabilités soient corrigées dans les 60 jours de leur divulgation publique.
  • Il est PROPOSÉ que l'analyse statique du code source se produise à chaque commit ou au moins quotidiennement. {N/A autorisé} [static_analysis_often]

Analyse dynamique de code

  • Il est PROPOSÉ qu'au moins un outil d'analyse dynamique soit appliqué à tout candidat pour une version majeure du logiciel avant sa distribution. [dynamic_analysis]
    Détails:
    Un outil d'analyse dynamique examine le logiciel en l'exécutant avec des entrées spécifiques. Par exemple, le projet PEUT utiliser un outil de fuzzing (par exemple, American Fuzzy Lop) ou un scanner d'application Web (par exemple, OWASP ZAP ou w3af). Dans certains cas, le projet OSS-Fuzz peut être prêt à appliquer des tests de fuzzing à votre projet. Aux fins de ce critère, l'outil d'analyse dynamique doit varier les entrées d'une manière ou d'une autre pour rechercher différents types de problèmes ou être une suite de test automatisée avec au moins 80% de couverture de branche. La page Wikipedia sur l'analyse dynamique et la page OWASP sur le fuzzing identifient certains outils d'analyse dynamique. Le ou les outils d'analyse PEUVENT être axés sur la recherche de vulnérabilités de sécurité, mais cela n'est pas nécessaire.
  • Il est PROPOSÉ que, si le logiciel produit par le projet comprend un logiciel écrit à l'aide d'un langage non sûr pour les accès mémoire (par exemple, C ou C ++), au moins un outil dynamique (par exemple, un fuzzer ou un scanner d'application Web) soit utilisé de façon routinière en combinaison avec un mécanisme pour détecter des problèmes de sécurité mémoire tels que les dépassements de zone mémoire. Si le projet ne produit pas de logiciel écrit dans un langage non sûr pour les accès mémoire, choisissez « non applicable » (N/A). {N/A autorisé} [dynamic_analysis_unsafe]
    Détails:
    Des exemples de mécanismes pour détecter les problèmes de sécurité de la mémoire comprennent Address Sanitizer (ASAN) (disponible dans GCC et LLVM), Memory Sanitizer et valgrind. D'autres outils potentiellement utilisés incluent thread sanitizer et undefined behavior sanitizer. La généralisation de l'utilisation des assertions fonctionnera également.
  • Il est PROPOSÉ que le projet utilise une configuration pour au moins une analyse dynamique (comme le test ou le fuzzing) qui active de nombreuses assertions. Dans de nombreux cas, ces assertions ne doivent pas être activées dans les versions de production. [dynamic_analysis_enable_assertions]
    Détails:
    Ce critère ne suggère pas d'activer les assertions en production ; c'est entièrement au projet et à ses utilisateurs de le décider. L'objectif de ce critère est plutôt d'améliorer la détection des défauts lors de l'analyse dynamique avant le déploiement. L'activation des assertions en production est complètement différente de l'activation des assertions pendant l'analyse dynamique (comme les tests). Dans certains cas, il est extrêmement imprudent d'activer les assertions en production (en particulier dans les composants à haute intégrité). Il existe de nombreux arguments contre l'activation des assertions en production, par exemple, les bibliothèques ne devraient pas faire échouer les appelants, leur présence peut provoquer le rejet par les magasins d'applications et/ou l'activation d'une assertion en production peut exposer des données privées telles que des clés privées. Attention, dans de nombreuses distributions Linux, NDEBUG n'est pas défini, donc assert() sera activé par défaut en C/C++ pour la production dans ces environnements. Il peut être important d'utiliser un mécanisme d'assertion différent ou de définir NDEBUG pour la production dans ces environnements.
  • Toutes les vulnérabilités exploitables de gravité moyenne ou plus découvertes avec une analyse de code dynamique DOIVENT être corrigées en un temps approprié après leur confirmation. {N/A autorisé} [dynamic_analysis_fixed]
    Détails:
    Si vous n'utilisez pas d'analyse de code dynamique et n'avez donc trouvé aucune vulnérabilité de cette manière, choisissez « non applicable » (N/A). Une vulnérabilité est considérée comme étant de gravité moyenne ou supérieure si son score qualitatif de base du Système Commun d'Évaluation des Vulnérabilités (CVSS) est moyen ou supérieur. Dans les versions CVSS 2.0 à 3.1, cela équivaut à un score CVSS de 4.0 ou supérieur. Les projets peuvent utiliser le score CVSS publié dans une base de données de vulnérabilité largement utilisée (telle que la base de données nationale des vulnérabilités) en utilisant la version la plus récente de CVSS rapportée dans cette base de données. Les projets peuvent aussi calculer eux-mêmes la gravité à l'aide de la dernière version de CVSS au moment de la divulgation de la vulnérabilité, si les entrées de calcul sont révélées publiquement une fois que la vulnérabilité est connue du public.

Argent

Notions de base

Conditions préalables

Contenu basique du site Web du projet

  • Les informations sur la façon de contribuer DOIVENT inclure les exigences pour des contributions acceptables (par exemple, une référence à toute règle de codage requise). {Atteint URL} [contribution_requirements]

Supervision du projet

  • Le projet DEVRAIT avoir un mécanisme juridique par lequel tous les développeurs de quantités non triviales de logiciel du projet affirment qu'ils sont légalement autorisés à effectuer ces contributions. L'approche la plus commune et facilement mise en œuvre pour ce faire est d'utiliser un Certificat d'origine du développeur (DCO), où les utilisateurs ajoutent une information « sign-off-by » dans leurs commits et le projet pointe vers le site Web du DCO. Cependant, cela PEUT être mis en œuvre en tant que contrat de licence de contributeur (CLA), ou tout autre mécanisme juridique. {Atteint URL} [dco]
    Détails:
    Le DCO est le mécanisme recommandé, car il est facile à mettre en œuvre, suivi dans le code source, et git prend directement en charge une fonction « approuvé » en utilisant « commit -s ». Pour être plus efficace, il est préférable que la documentation du projet explique ce que signifie « approuvé » pour ce projet. Un CLA est un accord juridique qui définit les termes en vertu desquels des travaux intellectuels ont été licenciés à une organisation ou un projet. Un accord de cession (CAA) est un accord légal qui transfère les droits dans un travail intellectuel à une autre partie ; il n'est pas exigé d'avoir des CAA pour les projets, car un CAA augmente le risque que les contributeurs potentiels ne contribuent pas, en particulier si le destinataire est un organisme à but lucratif. Les CLA de la Fondation Apache (la licence de contributeur individuel et la CLA d'entreprise) sont des exemples de CLA pour des projets qui déterminent que les risques de ces types de CLA au projet sont inférieurs à leurs avantages.
  • Le projet DOIT définir et documenter clairement son modèle de gouvernance de projet (la façon dont il prend ses décisions, y compris les rôles clés). {Atteint URL} [governance]
    Détails:
    Il doit y avoir une manière documentée bien établie de prendre des décisions et de résoudre les différends. Dans les petits projets, cela peut être aussi simple que « le propriétaire du projet et dirigeant prend toutes les décisions finales ». Il existe différents modèles de gouvernance, y compris le dictateur bienveillant et la méritocratie formelle ; pour plus de détails, voir Modèles de gouvernance. Les approches centralisées (par exemple, un seul mainteneur) et décentralisées (par exemple, les groupes de mainteneurs) ont été utilisées avec succès dans des projets. L'information sur la gouvernance n'a pas besoin de documenter la possibilité de créer une duplication de projet, car cela est toujours possible pour les projets FLOSS.
  • Le projet DOIT adopter un code de conduite et le publier dans un lieu standard. {Atteint URL} [code_of_conduct]
    Détails:
    Les projets peuvent être en mesure d'améliorer la civilité de leur communauté et d'établir des attentes quant à une conduite acceptable en adoptant un code de conduite. Cela peut aider à éviter les problèmes avant leur apparition et faire du projet un lieu plus accueillant pour encourager les contributions. Cela devrait se concentrer uniquement sur le comportement au sein de la communauté / lieu de travail du projet. Des exemples de codes de conduite sont le code de conduite du noyau Linux, le code de conduite du pacte de contributeur, le code de conduite du projet Debian, le code de conduite du projet Ubuntu, le code de conduite du projet Fedora, le code de conduite du projet GNOME, le code de conduite de la communauté KDE", le code de conduite de la communauté Python, le guide de conduite de la communauté Ruby, et le code de conduite du projet Rust.
  • Le projet DOIT clairement définir et documenter publiquement les rôles clés dans le projet et leurs responsabilités, y compris les tâches que ces rôles doivent accomplir. Il DOIT être clairement exprimé qui a quel(s) rôle(s), mais cela pourrait ne pas être documenté de la même manière. {Atteint URL} [roles_responsibilities]
    Détails:
    La documentation pour la gouvernance et les rôles et responsabilités peut être à un seul endroit.
  • Le projet DOIT pouvoir continuer avec une interruption minimale si une personne est invalide ou tuée. En particulier, le projet DOIT être en mesure de créer et de fermer des problèmes, d'accepter les modifications proposées et de publier des versions du logiciel, dans un délai d'une semaine après confirmation qu'un individu est invalide ou tué. Cela PEUT être fait en s'assurant que quelqu'un d'autre possède les clés, les mots de passe et les droits juridiques nécessaires pour poursuivre le projet. Les personnes qui exécutent un projet FLOSS PEUVENT faire cela en fournissant des clés dans un coffre-fort et un testament fournissant les droits légaux nécessaires (par exemple, pour les noms DNS). {Atteint URL} [access_continuity]
  • Le projet DEVRAIT avoir un « bus factor » de 2 ou plus. {Atteint URL} [bus_factor]
    Détails:
    Un « bus factor » (aussi connu en tant que « truck factor ») est le nombre minimum de membres du projet qui doivent disparaître soudainement d'un projet (« écrasé par un bus ») avant que le projet ne se bloque en raison du manque de personnel compétent. L'outil truck-factor peut l'estimer pour des projets sur GitHub. Pour plus d'informations, voir Évaluation du « bus factor » des dépôts Git par Cosentino et al.

Documentation

  • Le projet DOIT avoir une feuille de route documentée qui décrit ce que le projet a l'intention de faire et ne pas faire pour au moins l'année suivante. {Atteint URL} [documentation_roadmap]
    Détails:
    Le projet pourrait ne pas atteindre la feuille de route, et c'est acceptable ; le but de la feuille de route est d'aider les utilisateurs potentiels et les contributeurs à comprendre l'orientation prévue du projet. Elle ne doit pas être détaillée.
  • Le projet DOIT inclure la documentation de l'architecture (aussi appelée conception de haut niveau) du logiciel produit par le projet. Si le projet ne produit pas de logiciel, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint URL} [documentation_architecture]
    Détails:
    Une architecture de logiciel explique les structures fondamentales d'un programme, c'est-à-dire les principaux composants du programme, les relations entre eux et les propriétés clés de ces composants et de ces relations.
  • Le projet DOIT documenter ce à quoi l'utilisateur peut et ne peut pas s'attendre en termes de sécurité à partir du logiciel produit par le projet (ses « exigences de sécurité »). {Atteint URL} [documentation_security]
    Détails:
    Ce sont les exigences de sécurité que le logiciel est supposé remplir.
  • Le projet DOIT fournir un guide de « démarrage rapide » pour les nouveaux utilisateurs afin de les aider à faire rapidement quelque chose avec le logiciel. {N/A justification} {Atteint URL} [documentation_quick_start]
    Détails:
    L'idée est de montrer aux utilisateurs comment démarrer et de faire en sorte que le logiciel fasse quelque chose. Ceci est d'une importance cruciale pour les utilisateurs potentiels pour les aider à démarrer.
  • Le projet DOIT faire un effort pour maintenir la documentation conforme à la version actuelle des résultats du projet (y compris les logiciels produits par le projet). Tous les défauts de la documentation connus la rendant incohérente DOIVENT être corrigés. Si la documentation est généralement à jour, mais inclut de manière erronée certaines informations antérieures qui ne sont plus vraies, considérez cela comme un défaut, puis faites le suivi et corrigez comme d'habitude. {N/A justification} {Atteint justification} [documentation_current]
    Détails:
    La documentation PEUT inclure des informations sur les différences ou les modifications entre les versions du logiciel et/ou des liens vers les anciennes versions de la documentation. L'objectif de ce critère est de faire en sorte que la documentation soit cohérente et non pas que la documentation soit parfaite.
  • La page d'accueil et/ou le site Web du dépôt du projet DOIVENT identifier et pointer tous les accomplissements, y compris ce badge sur les meilleures pratiques, dans les 48 heures suivant la reconnaissance publique que l'accomplissement a été atteint. {Atteint URL} [documentation_achievements]
    Détails:
    Un accomplissement est un ensemble de critères externes que le projet a spécifiquement cherché à atteindre, y compris certains badges. Cette information ne doit pas nécessairement être sur la page d'accueil du site Web du projet. Un projet utilisant GitHub peut mettre des accomplissements sur la page d'accueil du dépôt en les ajoutant au fichier README.

Accessibilité et internationalisation

  • Le projet (à la fois les sites du projet et les résultats du projet) DEVRAIT suivre les meilleures pratiques d'accessibilité afin que les personnes handicapées puissent encore participer au projet et utiliser les résultats du projet où il est raisonnable de le faire. {N/A justification} {Atteint justification} [accessibility_best_practices]
    Détails:
    Pour les applications Web, consultez les Directives d'accessibilité des contenus Web (WCAG 2.0) et son document à l'appui Comprendre WCAG 2.0 ; voir aussi les informations d'accessibilité du W3C. Pour les applications IHM, envisagez d'utiliser les directives d'accessibilité spécifiques à l'environnement (telles que Gnome, KDE, XFCE, Android, IOS, Mac et Windows). Certaines applications IHM textuelles (par exemple, les programmes « ncurses ») peuvent faire certaines choses pour se rendre plus accessibles (par exemple, le paramètre « force-arrow-cursor » de « alpine »). La plupart des applications en ligne de commande sont assez accessibles telles quelles. Ce critère est souvent N/A, par exemple, pour les bibliothèques. Voici quelques exemples d'actions à prendre ou de questions à considérer :
    • Fournir des alternatives de texte pour tout contenu non textuel afin qu'il puisse être changé en d'autres formes dont les gens ont besoin, comme une plus grande taille, le braille, une sortie vocale, des symboles ou une langue plus simple (WCAG 2.0 directive 1.1)
    • La couleur n'est pas utilisée comme le seul moyen visuel de transmettre des informations, d'indiquer une action, de provoquer une réponse ou de distinguer un élément visuel. (WCAG 2.0 directive 1.4.1)
    • La présentation visuelle du texte et des images du texte a un taux de contraste d'au moins 4,5:1, à l'exception du grand texte, du texte incident, et des logotypes (WCAG 2.0 directive 1.4.3)
    • Rendez toutes les fonctionnalités disponibles à partir d'un clavier (WCAG directive 2.1)
    • Une IHM ou un projet basé sur le Web DEVRAIT tester avec au moins un lecteur d'écran sur la (les) plate-forme(s) cible(s) (par exemple NVDA, Jaws ou WindowEyes sur Windows ; VoiceOver sur Mac & iOS ; Orca sous Linux/BSD ; TalkBack sur Android). Les programmes IHM textuels PEUVENT travailler à réduire le retrait excessif pour éviter la lecture redondante par les lecteurs d'écran.
  • Le logiciel produit par le projet DEVRAIT être internationalisé pour permettre une localisation facile pour la culture, la région ou la langue du public cible. Si l'internationalisation (i18n) ne s'applique pas (par exemple, le logiciel ne génère pas de texte destiné aux utilisateurs finaux et ne trie pas de texte lisible par les humains), sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [internationalization]
    Détails:
    La localisation « réfère à l'adaptation du contenu d'un produit, d'une application ou d'un document pour répondre aux exigences linguistiques, culturelles et autres d'un marché cible spécifique (un lieu). » L'internationalisation est la « conception et le développement du contenu d'un produit, d'une application ou d'un document qui permette une localisation facile pour les publics cibles qui varient en culture, en région ou en langue. » (Voir la page « Localisation ou Internationalisation » du W3C.) Le logiciel répond à ce critère simplement en étant internationalisé. Aucune localisation pour une autre langue spécifique n'est requise, car une fois que le logiciel a été internationalisé, d'autres peuvent travailler sur la localisation.

Autre

  • Si les sites du projet (site Web, dépôt et URL de téléchargement) entreposent des mots de passe pour l'authentification d'utilisateurs externes, les mots de passe DOIVENT être entreposés comme hachages itérés avec salage par utilisateur en utilisant un algorithme d'étirement des clés (itéré) (par exemple, Argon2id, Bcrypt, Scrypt, ou PBKDF2). Si les sites du projet n'entreposent pas de mots de passe à cette fin, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [sites_password_security]
    Détails:
    Notez que l'utilisation de GitHub répond à ce critère. Ce critère s'applique uniquement aux mots de passe utilisés pour l'authentification d'utilisateurs externes sur les sites du projet (càd l'authentification entrante). Si les sites du projet doivent se connecter à d'autres sites (càd l'authentification sortante), ils devront peut-être entreposer différemment des jetons d'identification à cette fin (puisque conserver un code de hachage serait inutile). Ceci applique le critère crypto_password_storage aux sites du projet, de manière similaire à sites_https.

Contrôle des modifications

Versions précédentes

  • Le projet DOIT maintenir les anciennes versions les plus utilisées du produit ou fournir un chemin de mise à niveau vers des versions plus récentes. Si le chemin de mise à niveau est difficile, le projet DOIT documenter comment effectuer la mise à niveau (par exemple, les interfaces qui ont changé et une suggestion d'étapes détaillées pour aider la mise à niveau). {N/A justification} {Atteint justification} [maintenance_or_update]

Compte-rendu

Procédure de signalement des bogues

  • Le projet DOIT utiliser un suivi des problèmes pour le suivi des problèmes individuels. {N/A justification} {Atteint justification} [report_tracker]

Processus de signalement de vulnérabilité

  • Le projet DOIT créditer les auteurs de tous les signalements de vulnérabilité résolus au cours des 12 derniers mois, à l'exception des auteurs qui demandent l'anonymat. S'il n'y a pas eu de vulnérabilité résolue au cours des 12 derniers mois, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint URL} [vulnerability_report_credit]
  • Le projet DOIT avoir un processus documenté pour répondre aux signalements de vulnérabilité. {Atteint URL} [vulnerability_response_process]
    Détails:
    Ceci est fortement lié à vulnerability_report_process, qui exige qu'il existe un moyen documenté de signaler les vulnérabilités. Il a également trait à la vulnerability_report_response, qui nécessite une réponse aux signalements de vulnérabilité dans un certain laps de temps.

Qualité

Normes de codage

  • Le projet DOIT identifier les guides de style de codage spécifiques pour les langages principaux qu'il utilise, et exiger que les contributions le respectent en général. {N/A justification} {Atteint URL} [coding_standards]
    Détails:
    Dans la plupart des cas, cela se fait en se référant à certains guides de style existants, ce qui permet d'énumérer les différences. Ces guides de style peuvent inclure des moyens d'améliorer la lisibilité et les moyens de réduire la probabilité de défauts (y compris les vulnérabilités). Beaucoup de langages de programmation ont un ou plusieurs guides de style largement utilisés. Des exemples de guides de style incluent les guides de style de Google et les Règles de codage du SEI CERT.
  • Le projet DOIT imposer automatiquement son ou ses styles de codage sélectionnés s'il existe au moins un outil FLOSS qui peut le faire dans le(s) langage(s) sélectionné(s). {N/A justification} {Atteint justification} [coding_standards_enforced]
    Détails:
    Cela PEUT être mis en œuvre en utilisant des outils d'analyse statique et/ou en faisant passer le code à travers des outils de remise en forme. Dans de nombreux cas, la configuration de l'outil est incluse dans le dépôt du projet (car différents projets peuvent choisir différentes configurations). Les projets PEUVENT permettre des exceptions de style (et le font habituellement) ; là où les exceptions se produisent, elles DOIVENT être rares et documentées dans le code à leur emplacement, afin que ces exceptions puissent être revues et que les outils puissent les gérer automatiquement à l'avenir. Des exemples de tels outils incluent ESLint (JavaScript), Rubocop (Ruby) et devtools check (R).

Système de construction opérationnel

  • Les systèmes de construction pour les binaires natifs DOIVENT honorer les variables (d'environnement) pertinentes du compilateur et du lieur qui leur sont transmises (par exemple, CC, CFLAGS, CXX, CXXFLAGS et LDFLAGS) et les transmettre aux invocations du compilateur et du lieur. Un système de construction PEUT les étendre avec des options supplémentaires ; il NE DOIT PAS simplement remplacer les valeurs fournies par les siennes. Si aucun fichier binaire natif n'est généré, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [build_standard_variables]
    Détails:
    Il devrait être facile d'activer des fonctionnalités de construction spéciales telles que Address Sanitizer (ASAN), ou de se conformer aux meilleures pratiques de durcissement de la distribution (par exemple, en activant facilement les options de compilation pour le faire).
  • Le système de construction et d'installation DEVRAIT préserver les informations de débogage si elles sont demandées dans les options correspondants (par exemple, « install -s » n'est pas utilisé). S'il n'y a pas de système de construction ou d'installation (par exemple, les bibliothèques JavaScript typiques), sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [build_preserve_debug]
    Détails:
    Par exemple, la définition de CFLAGS (C) ou CXXFLAGS (C++) devrait créer les informations de débogage pertinentes si ces langages sont utilisés et elles ne devraient pas être retirées pendant l'installation. Des informations de débogage sont nécessaires pour le support et l'analyse, et également utiles pour mesurer la présence de fonctionnalités de durcissement dans les binaires compilés.
  • Le système de construction pour le logiciel produit par le projet NE DOIT PAS reconstruire de manière récursive des sous-répertoires s'il existe des dépendances croisées dans les sous-répertoires. S'il n'y a pas de système de construction ou d'installation (par exemple, les bibliothèques JavaScript typiques), sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [build_non_recursive]
    Détails:
    Les informations de dépendance internes du système de construction du projet doivent être précises, sinon, les modifications apportées au projet peuvent ne pas s'effectuer correctement. Des constructions incorrectes peuvent entraîner des défauts (y compris des vulnérabilités). Une erreur courante dans les grands systèmes de construction est d'utiliser une « construction récursive », c'est-à-dire une hiérarchie de sous-répertoires contenant des fichiers source, chaque sous-répertoire étant construit de manière indépendante. Sauf si chaque sous-répertoire est entièrement indépendant, ceci est une erreur, car les informations de dépendance sont incorrectes.
  • Le projet DOIT pouvoir répéter le processus de génération d'informations à partir de fichiers source et obtenir exactement le même résultat bit-à-bit. Si aucune construction ne se produit (par exemple, dans les langages de script où le code source est utilisé directement au lieu d'être compilé), sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [build_repeatable]
    Détails:
    Les utilisateurs GCC et Clang peuvent trouver l'option -frandom-seed utile ; dans certains cas, cela peut être résolu en forçant un ordre de tri. Plus de suggestions peuvent être trouvées sur le site pour une construction reproductible.

Système d'installation

  • Le projet DOIT fournir un moyen d'installer et de désinstaller facilement le logiciel produit par le projet en utilisant une convention couramment utilisée. {N/A justification} {Atteint justification} [installation_common]
    Détails:
    Des exemples comprennent l'utilisation d'un gestionnaire de paquets (au niveau du système ou du langage), « make/install/uninstall » (supportant DESTDIR), un conteneur dans un format standard ou une image de machine virtuelle dans un format standard. Le processus d'installation et de désinstallation (par exemple, son paquetage) PEUT être mis en œuvre par un tiers tant qu'il est FLOSS.
  • Le système d'installation pour les utilisateurs finaux DOIT honorer les conventions standard pour sélectionner l'emplacement où les artefacts construits sont écrits au moment de l'installation. Par exemple, s'il installe des fichiers sur un système POSIX, il DOIT honorer la variable d'environnement DESTDIR. S'il n'y a pas de système d'installation ou pas de convention standard, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [installation_standard_variables]
  • Le projet DOIT fournir un moyen pour les développeurs potentiels d'installer rapidement tous les résultats du projet ainsi que l'environnement nécessaire pour apporter des modifications, y compris les tests et l'environnement de test. Cela DOIT être effectué avec une convention couramment utilisée. {N/A justification} {Atteint justification} [installation_development_quick]
    Détails:
    Cela PEUT être implémenté à l'aide d'un conteneur généré et/ou d'un script d'installation. Les dépendances externes sont généralement installées en invoquant des gestionnaires de paquets du système et/ou du langage, comme précisé dans external_dependencies.

Composants maintenus à l'extérieur

  • Le projet DOIT afficher ses dépendances externes de manière analysable par ordinateur. {N/A justification} {Atteint URL} [external_dependencies]
    Détails:
    Généralement, cela se fait en utilisant les conventions du gestionnaire de paquets et/ou du système de construction. Notez que cela permet d'implémenter installation_development_quick.
  • Les projets DOIVENT surveiller ou vérifier périodiquement leurs dépendances externes (y compris les copies de commodité) pour détecter les vulnérabilités connues, et corriger les vulnérabilités exploitables ou les vérifier comme inexploitables. {N/A justification} {Atteint justification} [dependency_monitoring]
    Détails:
    Cela peut se faire à l'aide d'un outil d'analyse d'origine, de vérification de dépendance ou d'analyse de la composition du logiciel tel que Dependency-Check d'OWASP, Nexus Auditeur de Sonartype, Black Duck Software Composition Analysis de Synopsys, et Bundler-audit (pour Ruby). Certains gestionnaires de paquets comprennent des mécanismes pour le faire. Il est acceptable que la vulnérabilité des composants ne puisse pas être exploitée, mais cette analyse est difficile et il est parfois plus simple de mettre à jour ou de corriger la dépendance.
  • Le projet DOIT :
    1. rendre facile l'identification et la mise à jour des composants maintenus extérieurement au projet ; ou
    2. utiliser des composants standards fournis par le système ou le langage de programmation.
    Ensuite, si une vulnérabilité se trouve dans un composant réutilisé, il sera facile de mettre à jour ce composant. {N/A justification} {Atteint justification} [updateable_reused_components]
    Détails:
    Une façon typique de respecter ce critère est d'utiliser les systèmes de gestion des paquets du système et du langage de programmation. De nombreux programmes FLOSS sont distribués avec des « bibliothèques de commodité » qui sont des copies locales de bibliothèques standard (éventuellement dupliquées). En soi, c'est acceptable. Cependant, si le programme *doit* utiliser ces copies locales (dupliquées), la mise à jour des bibliothèques « standard » lors de mises à jour de sécurité laissera ces copies supplémentaires encore vulnérables. C'est particulièrement un problème pour les systèmes basés sur le cloud ; si le fournisseur du cloud met à jour ses librairies « standard » mais que le programme ne les utilise pas, les mises à jour ne vous aideront pas. Voir, par exemple, « Chromium : pourquoi il n'est pas encore un vrai paquet dans Fedora » par Tom Callaway.
  • Le projet DEVRAIT éviter d'utiliser des fonctions et des API obsolètes quand des alternatives FLOSS sont disponibles dans l'ensemble de technologies qu'il utilise (sa « pile de technologies ») et disponibles à une large majorité des utilisateurs supportés par le projet (afin que les utilisateurs puissent avoir accès à l'alternative). {N/A justification} {Atteint justification} [interfaces_current]

Suite de tests automatisée

  • Une suite de tests automatisée DOIT être appliquée à chaque commit dans un dépôt partagé pour au moins une branche. Cette suite de tests DOIT produire un rapport sur le succès ou l'échec du test. {Atteint justification} [automated_integration_testing]
    Détails:
    Cette exigence peut être considérée comme un sous-ensemble de test_continuous_integration, mais axée sur le simple test, sans nécessiter une intégration continue.
  • Le projet DOIT ajouter des tests de régression à une suite de tests automatisée pour au moins 50% des bogues corrigés au cours des six derniers mois. {N/A justification} {Atteint justification} [regression_tests_added50]
  • Le projet DOIT avoir une ou des suites de tests automatisées FLOSS qui fournissent une couverture d'instructions d'au moins 80% s'il existe au moins un outil FLOSS qui peut mesurer ce critère dans le langage sélectionné. {N/A justification} {Atteint justification} [test_statement_coverage80]
    Détails:
    De nombreux outils FLOSS sont disponibles pour mesurer la couverture des tests, y compris gcov/lcov, Blanket.js, Istanbul, JCov et covr (R). Notez que respecter ce critère n'est pas une garantie que la suite de tests est complète, mais, à l'inverse, ne pas respecter ce critère est un indicateur fort d'une suite de tests insuffisante.

Nouveau test de fonctionnalité

  • Le projet DOIT avoir une politique écrite formelle, que dès qu'une nouvelle fonctionnalité majeure est ajoutée, des tests pour la nouvelle fonctionnalité DOIVENT être ajoutés à une suite de tests automatisée. {N/A justification} {Atteint justification} [test_policy_mandated]
  • Le projet DOIT inclure, dans ses instructions documentées pour les propositions de changement, la politique selon laquelle des tests doivent être ajoutés pour toute nouvelle fonctionnalité majeure. {N/A justification} {Atteint justification} [tests_documented_added]

Options d'avertissement

  • Les projets DOIVENT être maximalement stricts avec les avertissements dans le logiciel produit par le projet, quand cela est approprié. {N/A justification} {Atteint justification} [warnings_strict]

Sécurité

Connaissance du développement sécurisé

  • Le projet DOIT implémenter des principes de conception sécurisés (à partir de « know_secure_design »), quand cela est approprié. Si le projet ne produit pas de logiciel, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [implement_secure_design]
    Détails:
    Par exemple, les résultats du projet devraient avoir des valeurs sécurisées par défaut (les décisions d'accès devraient être de refuser par défaut et l'installation des projets devrait être sécurisée par défaut). Ils devraient également avoir une médiation complète (tout accès qui pourrait être limité doit être vérifié pour l'autorité et être non contournable). Notez que, dans certains cas, ces principes entrent en conflit, auquel cas un choix doit être fait (par exemple, de nombreux mécanismes peuvent rendre les choses plus complexes, en contravention de « l'économie de mécanisme » / principe KISS).

Utiliser de bonnes pratiques de base de cryptographie

  • Les mécanismes de sécurité par défaut dans le logiciel produit par le projet NE DOIVENT PAS dépendre d'algorithmes ou de modes cryptographiques avec des faiblesses sérieuses connues (par exemple, l'algorithme de hachage cryptographique SHA-1 ou le mode CBC en SSH). {N/A autorisé} {Atteint justification} [crypto_weaknesses]
  • Le projet DEVRAIT supporter plusieurs algorithmes cryptographiques, afin que les utilisateurs puissent rapidement changer si l'un deux est cassé. Les algorithmes à clés symétriques courants incluent AES, Twofish et Serpent. Les alternatives d'algorithme de hachage cryptographique courantes incluent SHA-2 (y compris SHA-224, SHA-256, SHA-384 ET SHA-512) et SHA-3. {N/A autorisé} {Atteint justification} [crypto_algorithm_agility]
  • Le projet DOIT supporter le stockage des informations d'authentification (comme les mots de passe et les jetons dynamiques) et des clés cryptographiques privées dans des fichiers distincts des autres informations (fichiers de configuration, bases de données et journaux) et permettre aux utilisateurs de les mettre à jour et de les remplacer sans recompilation de code. Si le projet ne traite jamais d'informations d'authentification et de clés cryptographiques privées, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_credential_agility]
  • Le logiciel produit par le projet DEVRAIT supporter des protocoles sécurisés pour toutes ses communications réseau, tels que SSHv2 ou ultérieur, TLS1.2 ou ultérieur (HTTPS), IPsec, SFTP et SNMPv3. Les protocoles non sûrs tels que FTP, HTTP, telnet, SSLv3 ou antérieur, et SSHv1 DEVRAIENT être désactivés par défaut et uniquement activés si l'utilisateur le configure spécifiquement. Si le logiciel produit par le projet ne prend pas en charge les communications réseau, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_used_network]
  • Le logiciel produit par le projet DEVRAIT, s'il prend en charge ou utilise TLS, prendre en charge au moins TLS version 1.2. Notez que le prédécesseur de TLS s'appelait SSL. Si le logiciel n'utilise pas TLS, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_tls12]
  • Le logiciel produit par le projet DOIT, s'il prend en charge TLS, effectuer la vérification des certificats TLS par défaut lors de l'utilisation de TLS, y compris sur les sous-ressources. Si le logiciel n'utilise pas TLS, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_certificate_verification]
    Détails:
    Notez que la vérification incorrecte du certificat TLS est une erreur courante. Pour plus d'informations, voir « Le code le plus dangereux du monde : la validation des certificats SSL dans du logiciel qui ne vient pas d'un navigateur » de Martin Georgiev et al. et « Avez-vous confiance en cette application ? » par Michael Catanzaro.
  • Le logiciel produit par le projet DOIT, s'il supporte TLS, effectuer une vérification de certificat avant d'envoyer des en-têtes HTTP avec des informations privées (telles que des cookies sécurisés). Si le logiciel n'utilise pas TLS, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_verification_private]

Livraison sécurisée

  • Le projet DOIT signer cryptographiquement les versions des résultats du projet destinées à une utilisation répandue, et il DOIT y avoir un processus documenté expliquant aux utilisateurs comment ils peuvent obtenir les clés de signature publique et vérifier la ou les signatures. La clé privée pour ces signature(s) NE DOIT PAS être sur le(s) site(s) utilisé(s) pour distribuer directement le logiciel au public. Si les versions ne sont pas destinées à une utilisation répandue, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [signed_releases]
    Détails:
    Les résultats du projet incluent à la fois le code source et les produits livrés générés, le cas échéant (par exemple, les exécutables, les paquetages et les conteneurs). Les livrables générés PEUVENT être signés séparément du code source. Ces signatures PEUVENT être mises en œuvre sous forme de tags git signées (utilisant des signatures numériques cryptographiques). Les projets PEUVENT fournir des résultats générés séparément d'outils comme git, mais dans ce cas, les résultats distincts DOIVENT être signés séparément.
  • Il est PROPOSÉ que, dans le système de contrôle de la version, chaque tag d'une version importante (un tag faisant partie d'une version majeure, d'une version mineure ou qui corrige des vulnérabilités notées publiquement) soit cryptographiquement signé et vérifiable comme décrit dans signed_releases. {Atteint justification} [version_tags_signed]

Autres problèmes de sécurité

  • Les résultats du projet DOIVENT vérifier toutes les entrées provenant de sources potentiellement non fiables pour s'assurer qu'elles sont valides (une liste blanche) et rejeter les entrées non valides, en cas de restrictions sur les données. {N/A justification} {Atteint justification} [input_validation]
    Détails:
    Notez que la comparaison de l'entrée par rapport à une liste de « mauvais formats » (aussi appelée liste noire) n'est normalement pas suffisante, car les attaquants peuvent souvent contourner une liste noire. En particulier, les nombres sont convertis en formats internes puis vérifiés pour s'assurer s'ils se situent entre leur minimum et maximum (inclus), et les chaînes de texte sont vérifiées pour s'assurer qu'elles sont des motifs de texte valides (par exemple, UTF-8 valide, longueur valide, syntaxe valide, etc.). Certaines données peuvent avoir besoin d'être « du tout venant » (par exemple, un téléchargement de fichier), mais celles-ci sont généralement rares.
  • Les mécanismes de durcissement DOIVENT être utilisés dans le logiciel produit par le projet afin que les défauts du logiciel soient moins susceptibles d'entraîner des vulnérabilités de sécurité. {N/A justification} {Atteint justification} [hardening]
    Détails:
    Les mécanismes de durcissement peuvent inclure des en-têtes HTTP comme Content Security Policy (CSP), des options de compilation pour atténuer les attaques (telles que -fstack-protector) ou des options de compilation pour éliminer les comportements indéfinis. Pour nos besoins, le principe de plus faible privilège n'est pas considéré comme un mécanisme de durcissement (le principe de plus faible privilège est important, mais séparé).
  • Le projet DOIT fournir une analyse de fiabilité qui justifie pourquoi ses exigences de sécurité sont respectées. L'analyse de fiabilité DOIT inclure : une description du modèle de menace, une identification claire des limites de confiance, un argument selon lequel des principes de conception sécurisés ont été appliqués et un argument selon lequel les faiblesses de sécurité courantes de l'implémentation ont été contrées. {Atteint URL} [assurance_case]
    Détails:
    Une analyse de fiabilité est « une preuve documentée qui fournit un argumentaire convaincant et correct selon lequel un ensemble spécifié de revendications critiques concernant les propriétés d'un système est adéquatement justifié pour une application donnée dans un environnement donné » (« Software Assurance Using Structured Assurance Case Models », Thomas Rhodes et al, NIST Interagency Report 7608). Les limites de confiance sont des limites où les données ou l'exécution modifient leur niveau de confiance, par exemple, les limites d'un serveur dans une application Web typique. Il est fréquent d'énumérer des principes de conception sécurisés (tels que Saltzer et Schroeer) et des faiblesses de sécurité courantes de l'implémentation (comme le OWASP top 10 ou le CWE/SANS top 25) et de montrer comment chacun est contré. L'analyse de fiabilité de BadgeApp peut être un exemple utile. Ceci est lié à documentation_security, documentation_architecture et implement_secure_design.

Analyse

Analyse statique de code

  • Le projet DOIT utiliser au moins un outil d'analyse statique avec des règles ou des approches pour rechercher des vulnérabilités courantes dans le langage ou l'environnement analysé, s'il existe au moins un outil FLOSS qui peut mettre en œuvre ce critère dans le langage sélectionné. {N/A justification} {Atteint justification} [static_analysis_common_vulnerabilities]

Analyse dynamique de code

  • Si le logiciel produit par le projet inclut un logiciel écrit à l'aide d'un langage non sûr pour les accès mémoire (par exemple C ou C++), alors le projet DOIT utiliser au moins un outil dynamique (par exemple, un fuzzer ou un scanneur d'application Web) utilisé de manière routinière en combinaison avec un mécanisme permettant de détecter des problèmes de sécurité mémoire tels que les dépassement mémoire. Si le projet ne produit pas de logiciel écrit dans un langage non sûr pour les accès mémoire, sélectionnez « non applicable » (N/A). {N/A justification} {Atteint justification} [dynamic_analysis_unsafe]

Or

Notions de base

Conditions préalables

  • Le projet DOIT atteindre un badge de niveau argent. [achieve_silver]

Supervision du projet

  • Le projet DOIT avoir un « facteur bus » de 2 ou plus. {Atteint URL} [bus_factor]
  • Le projet DOIT avoir au moins deux contributeurs significatifs non associés. {Atteint URL} [contributors_unassociated]
    Détails:
    Les contributeurs sont associés s'ils sont payés pour leur travail par la même organisation (en tant qu'employé ou contractuel) et si l'organisation bénéficie des résultats du projet. Les subventions financières ne comptent pas comme provenant de la même organisation si elles passent par d'autres organisations (par exemple, les subventions scientifiques versées à différentes organisations par un même gouvernement ou ONG ne rendent pas les contributeurs associés). Quelqu'un est un contributeur significatif s'il a apporté des contributions non triviales au projet au cours de la dernière année. Des exemples de bons indicateurs d'un contributeur significatif sont : écrit au moins 1 000 lignes de code, a contribué à 50 commits ou au moins 20 pages de documentation.

Autre

  • Le projet DOIT inclure une déclaration de droit d'auteur dans chaque fichier source, identifiant le détenteur du droit d'auteur (par exemple, les contributeurs de [nom du projet]). {Atteint justification} [copyright_per_file]
    Détails:
    Cela PEUT être fait en incluant ce qui suit à l'intérieur d'un commentaire au début de chaque fichier: « Copyright les contributeurs de [nom du projet]. ». Voir « Avis de droits d'auteur dans les projets de logiciels Open Source » par Steve Winslow.
  • Le projet DOIT inclure une déclaration de licence dans chaque fichier source. Cela PEUT être fait en incluant ce qui suit à l'intérieur d'un commentaire au début de chaque fichier : SPDX-License-Identifier : [expression d'une licence SPDX pour le projet]. {Atteint justification} [license_per_file]
    Détails:
    Cela PEUT également être fait en incluant une déclaration en langage naturel identifiant la licence. Le projet PEUT également inclure une URL stable indiquant le texte de la licence ou directement le texte complet de la licence. Notez que le critère license_location requiert que la licence du projet soit dans un emplacement standard. Voir ce didacticiel SPDX pour plus d'informations sur les expressions de licence SPDX. Notez la relation avec copyright_per_file, dont le contenu devrait généralement précéder les informations sur la licence.

Contrôle des modifications

Dépôt source public sous contrôle de version

  • Le dépôt source du projet DOIT utiliser un logiciel courant de contrôle de version distribué (par exemple, git ou mercurial). {Atteint justification} [repo_distributed]
  • Le projet DOIT identifier clairement les petites tâches qui peuvent être effectuées par des contributeurs nouveaux ou occasionnels. {Atteint URL} [small_tasks]
    Détails:
    Cette identification se fait typiquement en marquant les problèmes sélectionnés dans un outil de suivi de problèmes avec une ou plusieurs étiquettes que le projet utilise à cet effet, par exemple up-for-grabs, first-timers-only, « Small fix », microtask ou IdealFirstBug. Ces nouvelles tâches n'ont pas besoin d'ajouter des fonctionnalités ; elles peuvent améliorer la documentation, ajouter des cas de test ou toute autre chose qui aide le projet et aide le contributeur à en comprendre davantage sur le projet.
  • Le projet DOIT exiger l'authentification à deux facteurs (2FA) des développeurs pour changer un dépôt central ou accéder à des données sensibles (telles que des signalements de vulnérabilités privés). Ce mécanisme 2FA PEUT utiliser des mécanismes sans mécanismes cryptographiques tels que SMS, mais cela n'est pas recommandé. {Atteint justification} [require_2FA]
  • L'authentification à deux facteurs du projet (2FA) DOIT utiliser des mécanismes cryptographiques pour empêcher l'emprunt d'identité. Une 2FA basée sur un service de messages courts (SMS), par elle-même, ne satisfait PAS à ce critère, car elle n'est pas chiffrée. {Atteint justification} [secure_2FA]
    Détails:
    Un mécanisme 2FA qui répond à ce critère serait une application de mot de passe à usage unique basé sur le temps (TOTP) qui génère automatiquement un code d'authentification qui change après un certain laps de temps. Notez que GitHub prend en charge TOTP.

Qualité

Normes de codage

  • Le projet DOIT documenter ses exigences en matière de revue de code, y compris la façon dont la revue de code est menée, ce qui doit être vérifié et ce qui est requis pour être acceptable. {N/A justification} {Atteint URL} [code_review_standards]
    Détails:
    Voir aussi two_person_review et contribution_requirements.
  • Le projet DOIT avoir au moins 50% de toutes les modifications proposées revues avant la sortie par une personne autre que l'auteur, afin de déterminer s'il s'agit d'une modification valable et sans problèmes connus qui risqueraient de s'opposer à son inclusion. {Atteint justification} [two_person_review]

Système de construction opérationnel

  • Le projet DOIT avoir une construction reproductible. Si aucune construction ne se produit (par exemple, les langages de script où le code source est utilisé directement au lieu d'être compilé), sélectionnez « non applicable » (N/A). {N/A justification} {Atteint URL} [build_reproducible]
    Détails:
    Une construction reproductible signifie que plusieurs parties peuvent refaire indépendamment le processus de génération d'informations à partir de fichiers source et obtenir exactement le même résultat bit-à-bit. Dans certains cas, cela peut être résolu en forçant un ordre de tri. Les développeurs JavaScript peuvent envisager d'utiliser npm shrinkwrap et webpack OccurenceOrderPlugin. Les utilisateurs GGC et clang peuvent trouver l'option -frandom-seed utile. L'environnement de construction (y compris le jeu d'outils) peut souvent être défini pour les parties externes en spécifiant le hachage cryptographique d'un conteneur spécifique ou d'une machine virtuelle qu'ils peuvent utiliser pour la reconstruction. Le projet de construction reproductible dispose de documentation sur la façon de le faire.

Suite de tests automatisée

  • Une suite de tests DOIT être invocable d'une manière standard pour ce langage. {Atteint URL} [test_invocation]
  • Le projet DOIT utiliser une intégration continue, où le code nouveau ou modifié est fréquemment intégré dans un dépôt de code central et des tests automatisés sont exécutés sur le résultat. {Atteint URL} [test_continuous_integration]
    Détails:
    Dans la plupart des cas, cela signifie que chaque développeur qui travaille à plein temps sur le projet intègre son code au moins tous les jours.
  • Le projet DOIT avoir une ou des suites de tests automatisées FLOSS qui fournissent une couverture d'instructions d'au moins 90% s'il existe au moins un outil FLOSS qui peut mesurer ce critère dans le langage sélectionné. {N/A justification} {Atteint justification} [test_statement_coverage90]
  • Le projet DOIT avoir une ou des suites de tests automatisées FLOSS qui fournissent une couverture de branche d'au moins 80% s'il existe au moins un outil FLOSS qui peut mesurer ce critère dans le langage sélectionné. {N/A justification} {Atteint justification} [test_branch_coverage80]

Sécurité

Utiliser de bonnes pratiques de base de cryptographie

  • Le logiciel produit par le projet DOIT supporter des protocoles sécurisés pour toutes ses communications réseau, tels que SSHv2 ou ultérieur, TLS1.2 ou ultérieur (HTTPS), IPsec, SFTP et SNMPv3. Les protocoles non sûrs tels que FTP, HTTP, telnet, SSLv3 ou antérieur, et SSHv1 DOIVENT être désactivés par défaut et uniquement activés si l'utilisateur le configure spécifiquement. Si le logiciel produit par le projet ne prend pas en charge les communications réseau, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_used_network]
  • Le logiciel produit par le projet DOIT, s'il prend en charge ou utilise TLS, prendre en charge au moins TLS version 1.2. Notez que le prédécesseur de TLS s'appelait SSL. Si le logiciel n'utilise pas TLS, sélectionnez « non applicable » (N/A). {N/A autorisé} {Atteint justification} [crypto_tls12]

Livraison sécurisée contre les attaques man-in-the-middle (MITM)

  • Le site Web du projet, le dépôt (s'il est accessible via le Web) et le site de téléchargement (si séparé) DOIVENT inclure des en-têtes clés de durcissement avec des valeurs non admises. {Atteint URL} [hardened_site]
    Détails:
    Notez que GitHub et GitLab sont connus pour le faire. Des sites tels que https://securityheaders.com/ peuvent le vérifier rapidement. Les en-têtes clés de durcissement sont : Content Security Policy (CSP), HTTP Strict Transport Security (HSTS), X-Content-Type-Options (comme « nosniff ») et X-Frame-Options. Les sites Web complètement statiques sans possibilité de se connecter à travers les pages Web peuvent éventuellement omettre certains entêtes de durcissement avec moins de risques, mais il n'existe aucune manière fiable de détecter ces sites, donc nous exigeons ces en-têtes mêmes pour les sites complètement statiques.

Autres problèmes de sécurité

  • Le projet DOIT avoir effectué une évaluation de la sécurité au cours des 5 dernières années. Cette revue DOIT prendre en considération les exigences de sécurité et les limites de sécurité. {Atteint justification} [security_review]
    Détails:
    Cela PEUT être fait par les membres du projet et/ou une évaluation indépendante. Cette évaluation PEUT être soutenue par des outils d'analyse statiques et dynamiques, mais il doit aussi y avoir une revue par des humains pour identifier les problèmes (en particulier dans la conception) que les outils ne peuvent pas détecter.
  • Des mécanismes de durcissement DOIVENT être utilisés dans le logiciel produit par le projet afin que les défauts du logiciel soient moins susceptibles d'entraîner des vulnérabilités de sécurité. {N/A justification} {Atteint URL} [hardening]

Analyse

Analyse dynamique de code

  • Le projet DOIT appliquer au moins un outil d'analyse dynamique à tout candidat pour une version majeure du logiciel produit par le projet avant sa sortie. {N/A justification} {Atteint justification} [dynamic_analysis]
  • Le projet DEVRAIT inclure de nombreuses assertions à l'exécution dans le logiciel qu'il produit, et vérifier ces assertions lors d'une analyse dynamique. {N/A justification} {Atteint justification} [dynamic_analysis_enable_assertions]