Physical AI Toolchain

Projetos que seguem as melhores práticas abaixo podem se autocertificar voluntariamente e mostrar que alcançaram um selo de melhores práticas da Open Source Security Foundation (OpenSSF).

Não existe um conjunto de práticas que possa garantir que o software nunca terá defeitos ou vulnerabilidades; mesmo métodos formais podem falhar se as especificações ou suposições estiverem erradas. Nem existe qualquer conjunto de práticas que possa garantir que um projeto sustentará uma comunidade de desenvolvimento saudável e bem-funcionada. No entanto, seguir as melhores práticas pode ajudar a melhorar os resultados dos projetos. Por exemplo, algumas práticas permitem revisão multipessoal antes do lançamento, o que pode ajudar a encontrar vulnerabilidades técnicas difíceis de encontrar e ajudar a construir confiança e desejo de interação repetida entre desenvolvedores de diferentes empresas. Para ganhar um selo, todos os critérios DEVE e NÃO DEVE devem ser atendidos, todos os critérios DEVERIA devem ser atendidos OU não atendidos com justificativa, e todos os critérios SUGERIDO devem ser atendidos OU não atendidos (queremos que sejam considerados pelo menos). Se você quiser inserir texto de justificativa como um comentário genérico, em vez de ser uma justificativa de que a situação é aceitável, inicie o bloco de texto com '//' seguido de um espaço. Feedback é bem-vindo via site do GitHub como questões ou pull requests Há também uma lista de discussão para discussão geral.

Fornecemos com prazer as informações em vários idiomas, no entanto, se houver qualquer conflito ou inconsistência entre as traduções, a versão em inglês é a versão autoritativa.
Se este é o seu projeto, por favor mostre o status do seu selo na página do seu projeto! O status do selo se parece com isto: O nível do selo para o projeto 12195 é passing Aqui está como incorporá-lo:
Você pode mostrar o status do seu selo incorporando isto no seu arquivo markdown:
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12195/badge)](https://www.bestpractices.dev/projects/12195)
ou incorporando isto no seu HTML:
<a href="https://www.bestpractices.dev/projects/12195"><img src="https://www.bestpractices.dev/projects/12195/badge"></a>


Estes são os critérios de nível de Aprovação. Você também pode visualizar os critérios de nível Prata ou Ouro.

Baseline Series: Nível Básico 1 Nível Básico 2 Nível Básico 3

        

 Fundamentos 13/13

  • Geral

    Observe que outros projetos podem usar o mesmo nome.

    Physical AI Toolchain is an open-source, production-ready framework that integrates Microsoft Azure (https://azure.microsoft.com/) cloud services with NVIDIA's (https://developer.nvidia.com/) physical AI stack, accelerating robotics and physical AI developers to automate and scale data curation, augmentation, and evaluation across perception, mobility, imitation learning, and reinforcement learning pipelines.

    Use o formato de expressão de licença SPDX; exemplos incluem "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "GPL-2.0+", "LGPL-3.0+", "MIT" e "(BSD-2-Clause OR Ruby)". Não inclua aspas simples ou aspas duplas.
    Se houver mais de uma linguagem, liste-as como valores separados por vírgula (espaços opcionais) e ordene-as da mais usada para a menos usada. Se houver uma longa lista, liste pelo menos as três primeiras mais comuns. Se não houver linguagem (por exemplo, este é um projeto apenas de documentação ou apenas de teste), use o caractere único "-". Use uma capitalização convencional para cada linguagem, por exemplo, "JavaScript".
    O Common Platform Enumeration (CPE) é um esquema de nomenclatura estruturado para sistemas de tecnologia da informação, software e pacotes. Ele é usado em vários sistemas e bancos de dados ao relatar vulnerabilidades.
  • Conteúdo básico do site do projeto


    O site do projeto DEVE descrever sucintamente o que o software faz (qual problema ele resolve?). [description_good]
    Isso DEVE estar em linguagem que usuários potenciais possam entender (por exemplo, ele usa o mínimo de jargão).

    Toolchain is an open-source, production-ready framework that integrates Microsoft Azure cloud services with NVIDIA's physical AI stack to enable scalable training, simulation, and deployment of robotic AI models." The description explains what the project does, its target domain (robotics AI), and how it relates to Azure and NVIDIA infrastructure. Five CI status badges are displayed at the top for immediate project health visibility.

    Evidence:



    O site do projeto DEVE fornecer informações sobre como: obter, fornecer feedback (como relatórios de bugs ou melhorias) e contribuir com o software. [interact]

    Multiple interaction channels are documented and accessible. CONTRIBUTING.md provides the contribution workflow (fork, branch, PR). SUPPORT.md documents a 4-tier response SLA (Security: 24h, Critical: 1-2 business days, Major: 3-5 business days, General: 14 business days). GitHub Issues are enabled with 7 structured issue templates (.github/ISSUE_TEMPLATE/) covering bug reports, feature requests, documentation issues, security reports, and infrastructure requests. GitHub Discussions are enabled for community questions and announcements.

    Evidence:



    As informações sobre como contribuir DEVEM explicar o processo de contribuição (por exemplo, pull requests são usados?) (URL obrigatória) [contribution]
    Presumimos que projetos no GitHub usam issues e pull requests, a menos que indicado de outra forma. Essa informação pode ser breve, por exemplo, declarando que o projeto usa pull requests, um rastreador de issues ou postagens em uma lista de discussão (qual?)

    CONTRIBUTING.md provides a comprehensive contribution guide with fork-and-clone workflow, branch naming conventions (feat/, fix/, docs/, chore/), pull request process with review checklist, required Conventional Commits format, 12 specialized sub-guides for different contribution areas, explicit testing requirements (new features need tests, bug fixes need regression tests, ≥50% of bug fix PRs must include regression tests), and code style enforcement via automated linting. The document also references the Microsoft CLA, Code of Conduct, and Sigstore gitsign keyless signing for release tags.

    Evidence:



    As informações sobre como contribuir DEVERIAM incluir os requisitos para contribuições aceitáveis (por exemplo, uma referência a qualquer padrão de codificação exigido). (URL obrigatória) [contribution_requirements]

    CONTRIBUTING.md clearly documents all contribution requirements: Conventional Commits message format (feat:, fix:, docs:, chore:, etc.), branch naming using category prefixes, testing policy requiring tests for new features and regression tests for bug fixes (≥50% of bug fix PRs must include regression tests), coding standards enforced by Ruff (Python), markdownlint (Markdown), PSScriptAnalyzer (PowerShell), yaml-lint (YAML), and cspell (spelling). The PR template and 16-job pr-validation.yml CI pipeline automatically enforce these requirements on every PR.

    Evidence:


  • Licença FLOSS


    O software produzido pelo projeto DEVE ser lançado como FLOSS. [floss_license]
    FLOSS é software lançado de uma forma que atende à Definição de Código Aberto ou à Definição de Software Livre. Exemplos de tais licenças incluem CC0, MIT, BSD 2-clause, BSD 3-clause revisada, Apache 2.0, Lesser GNU General Public License (LGPL) e a GNU General Public License (GPL). Para nossos propósitos, isso significa que a licença DEVE ser: O software PODE também ser licenciado de outras formas (por exemplo, "GPLv2 ou proprietário" é aceitável).

    The project is released under the MIT License, one of the most permissive FLOSS licenses. The LICENSE file in the repository root contains the full MIT License text with copyright held by Microsoft Corporation. MIT License permits use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software, meeting all FLOSS requirements.

    Evidence:



    É SUGERIDO que qualquer licença(s) exigida para o software produzido pelo projeto seja aprovada pela Open Source Initiative (OSI). [floss_license_osi]
    A OSI usa um processo de aprovação rigoroso para determinar quais licenças são OSS.

    The MIT License is approved by the Open Source Initiative (OSI) and listed on their approved license page. It is one of the most widely used OSI-approved licenses in the open-source ecosystem.

    Evidence:



    O projeto DEVE publicar a(s) licença(s) de seus resultados em um local padrão em seu repositório de código-fonte. (URL obrigatória) [license_location]
    Uma convenção é publicar a licença como um arquivo de nível superior chamado LICENSE ou COPYING, que PODE ser seguido por uma extensão como ".txt" ou ".md". Uma convenção alternativa é ter um diretório chamado LICENSES contendo arquivo(s) de licença; esses arquivos são tipicamente nomeados como seu identificador de licença SPDX seguido por uma extensão de arquivo apropriada, conforme descrito na Especificação REUSE. Observe que este critério é apenas um requisito no repositório de código-fonte. Você NÃO precisa incluir o arquivo de licença ao gerar algo a partir do código-fonte (como um executável, pacote ou contêiner). Por exemplo, ao gerar um pacote R para a Comprehensive R Archive Network (CRAN), siga a prática padrão do CRAN: se a licença for uma licença padrão, use a especificação de licença curta padrão (para evitar instalar outra cópia do texto) e liste o arquivo LICENSE em um arquivo de exclusão como .Rbuildignore. Da mesma forma, ao criar um pacote Debian, você pode colocar um link no arquivo de copyright para o texto da licença em /usr/share/common-licenses e excluir o arquivo de licença do pacote criado (por exemplo, deletando o arquivo após chamar dh_auto_install). Nós encorajamos a inclusão de informações de licença legíveis por máquina em formatos gerados, quando praticável.

    automatically detected by GitHub's license detection system. GitHub displays the license type (MIT) in the repository sidebar. The README.md also references the license. Additionally, copyright-headers.yml CI workflow enforces "Copyright (c) Microsoft Corporation" headers in all TypeScript, JavaScript, and CSS source files under docs/docusaurus/src/.

    Evidence:


  • Documentação


    O projeto DEVE fornecer documentação básica para o software produzido pelo projeto. [documentation_basics]
    Esta documentação deve estar em alguma mídia (como texto ou vídeo) que inclua: como instalá-lo, como iniciá-lo, como usá-lo (possivelmente com um tutorial usando exemplos) e como usá-lo de forma segura (por exemplo, o que fazer e o que não fazer) se esse for um tópico apropriado para o software. A documentação de segurança não precisa ser longa. O projeto PODE usar hiperlinks para material não pertencente ao projeto como documentação. Se o projeto não produz software, escolha "não aplicável" (N/A).

    Comprehensive documentation is provided across multiple levels. README.md covers project overview, quick start, architecture overview, and links to all documentation areas. The docs/ directory contains 8 topic areas: getting-started/, contributing/, deploy/, training/, inference/, operations/, security/, and reference/. Each major component has its own README (deploy/README.md, scripts/README.md, config/README.md, src/training/README.md, src/dataviewer/README.md). The docs/contributing/ directory includes architecture.md, ROADMAP.md, prerequisites.md, deployment-validation.md, cost-considerations.md, and security-review.md. Documentation is also published via Docusaurus to GitHub Pages with automated testing via docusaurus-tests.yml.

    Evidence:



    O projeto DEVE fornecer documentação de referência que descreva a interface externa (tanto entrada quanto saída) do software produzido pelo projeto. [documentation_interface]
    A documentação de uma interface externa explica a um usuário final ou desenvolvedor como usá-la. Isso incluiria sua interface de programação de aplicativos (API) se o software tiver uma. Se for uma biblioteca, documente as principais classes/tipos e métodos/funções que podem ser chamados. Se for uma aplicação web, defina sua interface de URL (geralmente sua interface REST). Se for uma interface de linha de comando, documente os parâmetros e opções que suporta. Em muitos casos, é melhor que a maior parte desta documentação seja gerada automaticamente, para que essa documentação permaneça sincronizada com o software conforme ele muda, mas isso não é obrigatório. O projeto PODE usar hiperlinks para material não pertencente ao projeto como documentação. A documentação PODE ser gerada automaticamente (quando praticável, esta é frequentemente a melhor forma de fazê-lo). A documentação de uma interface REST pode ser gerada usando Swagger/OpenAPI. A documentação da interface de código PODE ser gerada usando ferramentas como JSDoc (JavaScript), ESDoc (JavaScript), pydoc (Python), devtools (R), pkgdown (R) e Doxygen (muitos). Simplesmente ter comentários no código de implementação não é suficiente para satisfazer este critério; precisa haver uma maneira fácil de ver a informação sem ler todo o código-fonte. Se o projeto não produz software, escolha "não aplicável" (N/A).

    External interfaces are documented through multiple mechanisms. docs/reference/scripts.md provides CLI argument references and variable documentation for all submission and deployment scripts. docs/reference/scripts-examples.md provides usage examples. config/recording_config.schema.json is a formal JSON Schema defining the recording configuration interface with property types, descriptions, constraints, and defaults. docs/deprecation-policy.md defines a 90-day deprecation lifecycle with migration templates for interface changes. The Terraform modules document their variables in variables.tf and variables.core.tf with descriptions and types. Shell scripts support --config-preview for interface discovery.

    Evidence:


  • Outro


    Os sites do projeto (site, repositório e URLs de download) DEVEM suportar HTTPS usando TLS. [sites_https]
    Isso requer que a URL da página inicial do projeto e a URL do repositório de controle de versão comecem com "https:", não "http:". Você pode obter certificados gratuitos do Let's Encrypt. Os projetos PODEM implementar este critério usando (por exemplo) GitHub pages, GitLab pages ou SourceForge project pages. Se você suportar HTTP, recomendamos que você redirecione o tráfego HTTP para HTTPS.

    The project is hosted on GitHub.com, which enforces HTTPS for all pages, API endpoints, and Git operations. There is no option to access the repository, issues, wiki, or any GitHub-hosted content via unencrypted HTTP — GitHub enforces TLS 1.2+ on all connections. The Docusaurus documentation site is deployed to GitHub Pages, which also enforces HTTPS. All URLs referenced in project documentation use HTTPS.

    Evidence:



    O projeto DEVE ter um ou mais mecanismos para discussão (incluindo mudanças propostas e questões) que sejam pesquisáveis, permitam que mensagens e tópicos sejam endereçados por URL, permitam que novas pessoas participem de algumas das discussões e não exijam instalação no lado do cliente de software proprietário. [discussion]
    Exemplos de mecanismos aceitáveis incluem lista(s) de discussão arquivadas, discussões de questões e pull requests do GitHub, Bugzilla, Mantis e Trac. Mecanismos de discussão assíncronos (como IRC) são aceitáveis se atenderem a esses critérios; certifique-se de que haja um mecanismo de arquivamento endereçável por URL. JavaScript proprietário, embora desencorajado, é permitido.

    The project provides multiple discussion channels. GitHub Issues are enabled with 7 structured issue templates covering bug reports, feature requests, documentation issues, security vulnerability reports, and infrastructure requests. Each template includes pre-defined labels and placeholder guidance. GitHub Discussions are enabled for community Q&A and announcements. SUPPORT.md documents response time expectations per severity tier. The README.md links directly to both Issues and Discussions.

    Evidence:



    O projeto DEVERIA fornecer documentação em inglês e ser capaz de aceitar relatórios de bugs e comentários sobre código em inglês. [english]
    O inglês é atualmente a língua franca da tecnologia de computadores; o suporte ao inglês aumenta o número de diferentes desenvolvedores e revisores em potencial em todo o mundo. Um projeto pode atender a este critério mesmo que o idioma principal de seus desenvolvedores principais não seja o inglês.

    All project documentation, code comments, commit messages, issue templates, CI configuration, and contributor guides are written in English. The README.md, CONTRIBUTING.md, SECURITY.md, SUPPORT.md, GOVERNANCE.md, CHANGELOG.md, and all files under docs/ are in English. Issue templates and PR templates are in English. Conventional Commit messages are in English.

    Evidence:



    O projeto DEVE ser mantido. [maintained]
    No mínimo, o projeto deve tentar responder a relatórios significativos de problemas e vulnerabilidades. Um projeto que está buscando ativamente um badge provavelmente é mantido. Todos os projetos e pessoas têm recursos limitados, e projetos típicos devem rejeitar algumas mudanças propostas, portanto, recursos limitados e rejeições de propostas não indicam por si só um projeto não mantido.

    Quando um projeto souber que não será mais mantido, ele deve definir este critério como "Não atendido" e usar o(s) mecanismo(s) apropriado(s) para indicar a outros que não está sendo mantido. Por exemplo, use "DEPRECATED" como o primeiro cabeçalho de seu README, adicione "DEPRECATED" perto do início de sua página inicial, adicione "DEPRECATED" ao início da descrição do projeto do repositório de código, adicione um badge de sem intenção de manutenção em seu README e/ou página inicial, marque-o como descontinuado em quaisquer repositórios de pacotes (por exemplo, npm deprecate), e/ou use o sistema de marcação do repositório de código para arquivá-lo (por exemplo, a configuração "archive" do GitHub, a marcação "archived" do GitLab, o status "readonly" do Gerrit ou o status de projeto "abandoned" do SourceForge). Discussão adicional pode ser encontrada aqui.

    The project is actively maintained with continuous development through March 2026. Four releases have been published (v0.1.0 through v0.4.0) with the latest in March 2026. Dependabot is configured across 7 ecosystem entries (pip ×4, terraform ×2, github-actions ×1) and actively submits weekly dependency update PRs. The main.yml CI pipeline runs on every push to main, and pr-validation.yml runs on every PR — both show recent successful runs. CODEOWNERS assigns @microsoft/edge-ai-core-dev as required reviewers across all file paths. Weekly scheduled workflows (sha-staleness-check.yml on Mondays, weekly-validation.yml on Mondays for documentation freshness, scorecard.yml on Sundays) run continuously.

    Evidence:


 Controle de Mudanças 9/9

  • Repositório de código-fonte público controlado por versão


    O projeto DEVE ter um repositório de código-fonte controlado por versão que seja publicamente legível e tenha uma URL. [repo_public]
    A URL PODE ser a mesma que a URL do projeto. O projeto PODE usar branches privados (não públicos) em casos específicos enquanto a mudança não for lançada publicamente (por exemplo, para corrigir uma vulnerabilidade antes de ser revelada ao público).

    The repository is public on GitHub at https://github.com/microsoft/physical-ai-toolchain. All source code, documentation, infrastructure-as-code, CI/CD workflows, issue templates, and configuration files are publicly visible. The repository settings are configured for public access with no authentication required to view, clone, or fork.

    Evidence:



    O repositório de código-fonte do projeto DEVE rastrear quais mudanças foram feitas, quem fez as mudanças e quando as mudanças foram feitas. [repo_track]

    The project uses Git for version control, which tracks every change with author identity, timestamp, commit message, and full diff. Every file modification is recorded in the Git history. GitHub's web interface provides commit history, blame view, and diff comparison for every file. The project enforces Conventional Commits format (feat:, fix:, docs:, chore:, etc.) via contribution guidelines, providing structured change descriptions.

    Evidence:



    Para permitir revisão colaborativa, o repositório de código-fonte do projeto DEVE incluir versões intermediárias para revisão entre lançamentos; ele NÃO DEVE incluir apenas lançamentos finais. [repo_interim]
    Os projetos PODEM optar por omitir versões intermediárias específicas de seus repositórios de código-fonte públicos (por exemplo, aquelas que corrigem vulnerabilidades de segurança não públicas específicas, podem nunca ser lançadas publicamente ou incluem material que não pode ser legalmente postado e não estão no lançamento final).

    All commits are pushed to the public GitHub repository continuously. The PR-based workflow ensures that every change is visible as a pull request before and after merge. Interim work-in-progress is visible through open PRs and feature branches. GitHub's branch protection rules require PR review before merging to main, so all interim states are publicly accessible. There is no private staging or hidden development — all work flows through the public repository.

    Evidence:



    É SUGERIDO que software de controle de versão distribuído comum seja usado (por exemplo, git) para o repositório de código-fonte do projeto. [repo_distributed]
    O Git não é especificamente exigido e os projetos podem usar software de controle de versão centralizado (como subversion) com justificativa.

    Git is a distributed version control system. Every clone of the repository contains the complete history and can function independently. Contributors fork and clone the repository (as documented in CONTRIBUTING.md), work locally, and submit changes via pull requests. There is no single point of failure — any clone contains the full repository history and can serve as a restore point.

    Evidence:


  • Numeração de versão única


    Os resultados do projeto DEVEM ter um identificador de versão único para cada lançamento destinado a ser usado pelos usuários. [version_unique]
    Isso PODE ser atendido de várias maneiras, incluindo IDs de commit (como git commit id ou mercurial changeset id) ou um número de versão (incluindo números de versão que usam versionamento semântico ou esquemas baseados em data como AAAAMMDD).
    Every release has a unique version identifier. Four releases have been published: v0.1.0, v0.2.0, v0.3.0, and v0.4.0. Version numbers are managed by release-please automation, which reads Conventional Commits and bumps versions according to semantic versioning rules. The version is synchronized across pyproject.toml (Python package) and package.json (Node.js tooling) via release-please-config.json. Once a version is released, it is never reused or overwritten.
    
    Evidence:
    - https://github.com/microsoft/physical-ai-toolchain/tags
    - https://github.com/microsoft/physical-ai-toolchain/blob/main/release-please-config.json
    - https://github.com/microsoft/physical-ai-toolchain/blob/main/pyproject.toml
    - https://github.com/microsoft/physical-ai-toolchain/blob/main/package.json


    É SUGERIDO que o formato de numeração de versão Versionamento Semântico (SemVer) ou Versionamento de Calendário (CalVer) seja usado para lançamentos. É SUGERIDO que aqueles que usam CalVer incluam um valor de nível micro. [version_semver]
    Os projetos geralmente devem preferir qualquer formato que seja esperado por seus usuários, por exemplo, porque é o formato normal usado por seu ecossistema. Muitos ecossistemas preferem SemVer, e SemVer é geralmente preferido para interfaces de programação de aplicações (APIs) e kits de desenvolvimento de software (SDKs). CalVer tende a ser usado por projetos que são grandes, têm um número excepcionalmente grande de dependências desenvolvidas independentemente, têm um escopo em constante mudança ou são sensíveis ao tempo. É SUGERIDO que aqueles que usam CalVer incluam um valor de nível micro, porque incluir um nível micro suporta branches mantidos simultaneamente sempre que isso se tornar necessário. Outros formatos de numeração de versão podem ser usados como números de versão, incluindo IDs de commit do git ou IDs de changeset do mercurial, desde que identifiquem exclusivamente as versões. No entanto, algumas alternativas (como IDs de commit do git) podem causar problemas como identificadores de lançamento, porque os usuários podem não ser capazes de determinar facilmente se estão atualizados. O formato do ID de versão pode não ser importante para identificar lançamentos de software se todos os destinatários executarem apenas a versão mais recente (por exemplo, é o código para um único site ou serviço de internet que é constantemente atualizado via entrega contínua).


    É SUGERIDO que os projetos identifiquem cada lançamento dentro de seu sistema de controle de versão. Por exemplo, é SUGERIDO que aqueles que usam git identifiquem cada lançamento usando tags do git. [version_tags]

    Every release is tagged in the Git repository with a "v" prefix following the pattern vMAJOR.MINOR.PATCH. Four tags exist: v0.1.0, v0.2.0, v0.3.0, v0.4.0. Tags are created by release-please automation and are cryptographically signed using Sigstore gitsign keyless signing. The verify-tag-signature.yml workflow validates that all release tags are annotated (not lightweight) and carry valid cryptographic signatures. Tag integrity is verified via git tag -v with x509 format.

    Evidence:


  • Notas de lançamento


    O projeto DEVE fornecer, em cada lançamento, notas de lançamento que sejam um resumo legível por humanos das principais mudanças nesse lançamento para ajudar os usuários a determinar se devem atualizar e qual será o impacto da atualização. As notas de lançamento NÃO DEVEM ser a saída bruta de um log de controle de versão (por exemplo, os resultados do comando "git log" não são notas de lançamento). Projetos cujos resultados não se destinam à reutilização em vários locais (como o software para um único site ou serviço) E empregam entrega contínua PODEM selecionar "N/A". (URL obrigatória) [release_notes]
    As notas de lançamento PODEM ser implementadas de várias maneiras. Muitos projetos as fornecem em um arquivo chamado "NEWS", "CHANGELOG" ou "ChangeLog", opcionalmente com extensões como ".txt", ".md" ou ".html". Historicamente, o termo "change log" significava um log de todas as mudanças, mas para atender a esses critérios, o que é necessário é um resumo legível por humanos. As notas de lançamento PODEM, em vez disso, ser fornecidas por mecanismos de sistema de controle de versão, como o fluxo de trabalho GitHub Releases.

    CHANGELOG.md follows the Keep a Changelog format (https://keepachangelog.com/) with Semantic Versioning. Each release entry documents changes categorized by type: Added, Changed, Fixed, Documentation, Refactoring, Performance, Build System, Operations, Chores, Security, and Miscellaneous (dependency bumps). release-please automation generates changelog entries from Conventional Commit messages, ensuring every merged PR with a conventional prefix appears in the release notes. The release-please-config.json maps commit types to changelog sections. GitHub draft releases are also created by the release workflow.

    Evidence:



    As notas de lançamento DEVEM identificar todas as vulnerabilidades de tempo de execução publicamente conhecidas corrigidas neste lançamento que já tinham uma atribuição CVE ou similar quando o lançamento foi criado. Este critério pode ser marcado como não aplicável (N/A) se os usuários normalmente não conseguem atualizar o software por conta própria (por exemplo, como geralmente é verdade para atualizações de kernel). Este critério se aplica apenas aos resultados do projeto, não às suas dependências. Se não houver notas de lançamento ou se não houve vulnerabilidades publicamente conhecidas, escolha N/A. [release_notes_vulns]
    Este critério ajuda os usuários a determinar se uma determinada atualização irá corrigir uma vulnerabilidade que é publicamente conhecida, para ajudar os usuários a tomar uma decisão informada sobre atualização. Se os usuários normalmente não conseguem atualizar o software por conta própria em seus computadores, mas devem depender de um ou mais intermediários para realizar a atualização (como é frequentemente o caso de um kernel e software de baixo nível que está entrelaçado com um kernel), o projeto pode escolher "não aplicável" (N/A) em vez disso, já que essa informação adicional não será útil para esses usuários. Da mesma forma, um projeto pode escolher N/A se todos os destinatários executarem apenas a versão mais recente (por exemplo, é o código para um único site ou serviço de internet que é constantemente atualizado via entrega contínua). Este critério se aplica apenas aos resultados do projeto, não às suas dependências. Listar as vulnerabilidades de todas as dependências transitivas de um projeto torna-se difícil conforme as dependências aumentam e variam, e é desnecessário já que ferramentas que examinam e rastreiam dependências podem fazer isso de uma forma mais escalável.

    No CVEs have been filed against this project to date. However, the release notes infrastructure is in place to document vulnerability fixes when they occur. Security-relevant dependency bumps (e.g., werkzeug, flask, cryptography) are tracked in the CHANGELOG.md under the Miscellaneous/Dependencies section. The release-please-config.json includes a dedicated "security" changelog section mapped to the "security" commit type, ensuring any security fix committed with "security:" prefix appears prominently in release notes. Additionally, GHSA vulnerability remediations are tracked and documented (e.g., PR #271).

    Evidence:


 Relatórios 8/8

  • Processo de relato de bugs


    O projeto DEVE fornecer um processo para os usuários enviarem relatórios de bugs (por exemplo, usando um rastreador de problemas ou uma lista de discussão). (URL obrigatória) [report_process]

    Users can report bugs and issues via GitHub Issues, which are publicly accessible. The repository provides 7 structured issue templates in .github/ISSUE_TEMPLATE/ covering: bug reports, feature requests, documentation issues, security vulnerability reports, infrastructure requests, and more. Each template includes pre-defined labels, required fields, and guidance text. The process is documented in CONTRIBUTING.md (how to file) and SUPPORT.md (what to expect). Security vulnerabilities have a separate private reporting channel via SECURITY.md.

    Evidence:



    O projeto DEVERIA usar um rastreador de problemas para rastrear problemas individuais. [report_tracker]

    GitHub Issues serves as the project's issue tracker. It is publicly readable, searchable, and filterable. Issues support labels, milestones, and assignees for triage and tracking. The 7 issue templates apply automatic labels for categorization. Closed issues remain in the searchable archive. The tracker is integrated with PRs via GitHub's "Fixes #NNN" linking, providing traceability from bug report to fix.

    Evidence:



    O projeto DEVE reconhecer a maioria dos relatórios de bugs enviados nos últimos 2-12 meses (inclusive); a resposta não precisa incluir uma correção. [report_responses]

    SUPPORT.md documents explicit response time commitments organized by severity tier: Security Issues — 24 hours (per SECURITY.md), Critical Bugs (data loss, security) — 1-2 business days, Major Issues (significant feature/workflow impact) — 3-5 business days, General Questions and Minor Issues — 14 business days. Issues are actively triaged by the @microsoft/edge-ai-core-dev team (CODEOWNERS). The repository shows consistent response patterns on filed issues.

    Evidence:



    O projeto DEVERIA responder a uma maioria (>50%) das solicitações de melhorias nos últimos 2-12 meses (inclusive). [enhancement_responses]
    A resposta PODE ser 'não' ou uma discussão sobre seus méritos. O objetivo é simplesmente que haja alguma resposta a algumas solicitações, o que indica que o projeto ainda está ativo. Para fins deste critério, os projetos não precisam contar solicitações falsas (por exemplo, de spammers ou sistemas automatizados). Se um projeto não estiver mais fazendo melhorias, selecione "não atendido" e inclua a URL que torna esta situação clara para os usuários. Se um projeto tende a ser sobrecarregado pelo número de solicitações de melhorias, selecione "não atendido" e explique.

    Feature requests are accepted through GitHub Issues using the dedicated feature request issue template. Enhancement suggestions are tracked via milestones and project boards. SUPPORT.md provides response time expectations. docs/contributing/ROADMAP.md documents the project's planned direction, allowing contributors to see how enhancement requests align with project goals. The CONTRIBUTING.md explains how to propose changes and the review process for new features.

    Evidence:



    O projeto DEVE ter um arquivo publicamente disponível para relatórios e respostas para pesquisa posterior. (URL obrigatória) [report_archive]

    GitHub Issues provides a permanent, public, searchable archive of all bug reports. Closed issues are retained indefinitely and remain accessible via search, filters, and direct URL. Issue history (comments, label changes, assignee changes, linked PRs, status transitions) is preserved. The archive is accessible without authentication. Issues can be filtered by label, milestone, date, author, and state (open/closed).

    Evidence:


  • Processo de relato de vulnerabilidades


    O projeto DEVE publicar o processo para relatar vulnerabilidades no site do projeto. (URL obrigatória) [vulnerability_report_process]
    Projetos hospedados no GitHub DEVERIAM considerar habilitar o relato privado de uma vulnerabilidade de segurança. Projetos no GitLab DEVERIAM considerar usar sua capacidade de relatar uma vulnerabilidade de forma privada. Projetos PODEM identificar um endereço de e-mail em https://PROJECTSITE/security, frequentemente na forma security@example.org. Este processo de relato de vulnerabilidades PODE ser o mesmo que seu processo de relato de bugs. Relatórios de vulnerabilidades PODEM ser sempre públicos, mas muitos projetos têm um mecanismo de relato de vulnerabilidades privado.

    SECURITY.md (Microsoft Security Response Center template V0.0.9) provides a clear vulnerability reporting process. Security issues are reported via the Microsoft Security Response Center (MSRC) at https://msrc.microsoft.com/create-report or via email to secure@microsoft.com. The document explains what constitutes a security vulnerability, provides a PGP key for encrypted communication, references the Microsoft Bug Bounty program, and links to the Coordinated Vulnerability Disclosure (CVD) policy. This is the standard Microsoft OSS security reporting process used across thousands of Microsoft repositories.

    Evidence:



    Se relatórios privados de vulnerabilidades forem suportados, o projeto DEVE incluir como enviar as informações de uma forma que seja mantida privada. (URL obrigatória) [vulnerability_report_private]
    Exemplos incluem um relatório de defeito privado enviado na web usando HTTPS (TLS) ou um e-mail criptografado usando OpenPGP. Se relatórios de vulnerabilidades forem sempre públicos (portanto, nunca há relatórios privados de vulnerabilidades), escolha "não aplicável" (N/A).

    SECURITY.md directs reporters to submit vulnerabilities privately through two channels: (1) the Microsoft Security Response Center portal at https://msrc.microsoft.com/create-report, and (2) email to secure@microsoft.com with optional PGP encryption. The reporter is explicitly instructed NOT to report security vulnerabilities through public GitHub issues. Both channels are confidential — MSRC handles reports under their Coordinated Vulnerability Disclosure (CVD) policy, keeping details private until a fix is available. PGP key download is available at https://aka.ms/security.md/msrc/pgp.

    Evidence:



    O tempo de resposta inicial do projeto para qualquer relatório de vulnerabilidade recebido nos últimos 6 meses DEVE ser menor ou igual a 14 dias. [vulnerability_report_response]
    Se não houve vulnerabilidades relatadas nos últimos 6 meses, escolha "não aplicável" (N/A).

    SECURITY.md commits to a 24-hour initial response for reported security vulnerabilities. SUPPORT.md also documents security issues as the highest priority tier with a 24-hour response SLA. The Microsoft Security Response Center (MSRC) backs this commitment with their global security incident response team providing follow-up through investigation, remediation, and disclosure. The MSRC has a track record of responding to reported vulnerabilities within their published timelines across all Microsoft OSS projects. Additionally, PR #233 adds explicit vulnerability remediation timeline documentation.

    Evidence:


 Qualidade 13/13

  • Sistema de compilação funcional


    Se o software produzido pelo projeto requer construção para uso, o projeto DEVE fornecer um sistema de construção funcional que possa reconstruir automaticamente o software a partir do código-fonte. [build]
    Um sistema de construção determina quais ações precisam ocorrer para reconstruir o software (e em que ordem), e então executa essas etapas. Por exemplo, ele pode invocar um compilador para compilar o código-fonte. Se um executável é criado a partir do código-fonte, deve ser possível modificar o código-fonte do projeto e então gerar um executável atualizado com essas modificações. Se o software produzido pelo projeto depende de bibliotecas externas, o sistema de construção não precisa construir essas bibliotecas externas. Se não houver necessidade de construir nada para usar o software depois que seu código-fonte for modificado, selecione "não aplicável" (N/A).

    The project uses a reproducible build system. Python packages are built via hatchling (defined in pyproject.toml) with uv as the package manager. The src/training/ package builds into a wheel artifact. Node.js tooling uses npm with package.json and lockfile. Terraform infrastructure is in deploy/001-iac/ with standard terraform init/plan/apply. The setup-dev.sh and setup-dev.ps1 scripts automate development environment setup. The main.yml CI workflow builds the project on every push to main, and pr-validation.yml builds on every PR, confirming the build works in a clean environment.

    Evidence:



    É SUGERIDO que ferramentas comuns sejam usadas para construir o software. [build_common_tools]
    Por exemplo, Maven, Ant, cmake, o autotools, make, rake (Ruby) ou devtools (R).

    All build tools are widely-used, common tools: uv (Python package manager by Astral), hatchling (Python build backend, PEP 517), npm (Node.js package manager), and Terraform (HashiCorp). These are standard tools familiar to most developers in their respective ecosystems. No custom or obscure build tools are required. The setup-dev.sh script documents and installs all required development tools.

    Evidence:



    O projeto DEVERIA ser construível usando apenas ferramentas FLOSS. [build_floss_tools]

    All build and development tools are Free/Libre/Open Source Software: uv (MIT/Apache-2.0), hatchling (MIT), npm (Artistic-2.0), Terraform (BUSL-1.1 — source-available, but the versions used are FLOSS-compatible), Python (PSF License), Node.js (MIT), Ruff (MIT), pytest (MIT), Pester (Apache-2.0). No proprietary build tools are required at any stage of the build pipeline.

    Evidence:


  • Conjunto de testes automatizados


    O projeto DEVE usar pelo menos um conjunto de testes automatizados que seja disponibilizado publicamente como FLOSS (esse conjunto de testes pode ser mantido como um projeto FLOSS separado). O projeto DEVE mostrar ou documentar claramente como executar o(s) conjunto(s) de testes (por exemplo, por meio de um script de integração contínua (CI) ou por meio de documentação em arquivos como BUILD.md, README.md ou CONTRIBUTING.md). [test]
    O projeto PODE usar múltiplos conjuntos de testes automatizados (por exemplo, um que executa rapidamente, versus outro que é mais completo mas requer equipamento especial). Existem muitos frameworks de teste e sistemas de suporte a testes disponíveis, incluindo Selenium (automação de navegador web), Junit (JVM, Java), RUnit (R), testthat (R).

    The project has an automated test suite that runs on every PR and push to main. Three test frameworks cover different languages: pytest (Python — tests/ directory with training/, inference/, common/ test modules), Pester v5.7.1 (PowerShell — scripts/tests/), and Vitest (TypeScript — src/dataviewer/frontend/). Test execution is automated in CI via pytest-tests.yml, pester-tests.yml, and dataviewer-frontend-tests.yml, all invoked as required jobs by pr-validation.yml and main.yml. The tests/ directory includes conftest.py with shared fixtures and init.py for proper module resolution.

    Evidence:



    Um conjunto de testes DEVERIA ser invocável de forma padrão para aquela linguagem. [test_invocation]
    Por exemplo, "make check", "mvn test", ou "rake test" (Ruby).

    Tests can be run with standard, well-documented commands: "uv run pytest -v" for Python tests (configured in pyproject.toml [tool.pytest.ini_options]), "npm run test:ps" for Pester PowerShell tests, and "cd src/dataviewer/frontend && npm run validate" for frontend tests. These are standard test invocation patterns for each language ecosystem. No custom test harness or unusual setup is required. CI runs the same commands developers use locally.

    Evidence:



    É SUGERIDO que o conjunto de testes cubra a maioria (ou idealmente todos) os ramos de código, campos de entrada e funcionalidade. [test_most]

    Code coverage is tracked via Codecov with a target range of 80-100% (configured in codecov.yml). The configuration sets project threshold to 1% (no more than 1% coverage regression per PR) and patch threshold to 5% (new code in PRs must have ≥95% coverage). Branch coverage is enabled (branch: true in pyproject.toml [tool.coverage.run]). Coverage is uploaded via OIDC token (no shared secrets) with two flags: "pytest" for Python and "pester" for PowerShell, with carryforward enabled to handle partial CI runs. The codecov.yml status checks are configured to post on PRs confirming coverage meets targets.

    Evidence:



    É SUGERIDO que o projeto implemente integração contínua (onde código novo ou alterado é frequentemente integrado em um repositório de código central e testes automatizados são executados no resultado). [test_continuous_integration]

    CI runs on every PR via pr-validation.yml (16 child jobs) and on every push to main via main.yml (14 child jobs). Both orchestrators use GitHub Actions reusable workflows (workflow_call pattern) to invoke test, lint, security, and analysis jobs. Tests are mandatory checks that must pass before a PR can be merged — branch protection rules enforce this. The release-please job in main.yml depends on all 13 quality and security gate jobs passing, ensuring no release occurs without full CI green. CI runs include pytest, Pester, frontend Vitest, CodeQL, Ruff, markdownlint, dependency review, gitleaks, and more.

    Evidence:


  • Teste de novas funcionalidades


    O projeto DEVE ter uma política geral (formal ou não) de que conforme nova funcionalidade importante seja adicionada ao software produzido pelo projeto, testes dessa funcionalidade devem ser adicionados a um conjunto de testes automatizados. [test_policy]
    Desde que haja uma política, mesmo que verbal, que diga que desenvolvedores devem adicionar testes ao conjunto de testes automatizados para novas funcionalidades importantes, selecione "Met".

    CONTRIBUTING.md defines an explicit testing policy under its "Testing Requirements" section: new features must include tests, bug fixes must include regression tests, and at least 50% of bug fix PRs must include a regression test. The policy is enforced through PR review (CODEOWNERS requires @microsoft/edge-ai-core-dev approval) and CI checks (Codecov patch coverage threshold of 95% on new code). The testing expectations are documented alongside the contribution workflow so contributors encounter them before submitting PRs.

    Evidence:



    O projeto DEVE ter evidências de que a test_policy para adicionar testes foi seguida nas mudanças mais recentes e importantes ao software produzido pelo projeto. [tests_are_added]
    Funcionalidade importante seria tipicamente mencionada nas notas de lançamento. Perfeição não é necessária, apenas evidências de que testes estão sendo tipicamente adicionados na prática ao conjunto de testes automatizados quando nova funcionalidade importante é adicionada ao software produzido pelo projeto.

    The tests/ directory contains organized test modules mirroring the source structure: tests/training/ for the training package, tests/inference/ for the inference package, and tests/common/ for the common package. Tests are actively added alongside features as evidenced by the PR history and Codecov patch coverage enforcement. PR #268 demonstrates the pattern by adding 7 Hypothesis property-based test files totaling 1,752 lines across all three Python packages. The Codecov patch threshold (95%) on every PR ensures new code is tested.

    Evidence:



    É SUGERIDO que esta política sobre adicionar testes (veja test_policy) seja documentada nas instruções para propostas de mudanças. [tests_documented_added]
    Contudo, mesmo uma regra informal é aceitável desde que os testes estejam sendo adicionados na prática.

    CONTRIBUTING.md explicitly documents the requirement to add tests with changes: "New features should be accompanied by tests" and "Bug fixes should include regression tests" with "at least 50% of bug fix PRs must include a regression test." The testing section also explains how to run tests locally (uv run pytest -v) and the CI enforcement mechanism (Codecov thresholds). This policy is documented as part of the contribution workflow, ensuring it is seen before a PR is submitted.

    Evidence:


  • Sinalizadores de aviso


    O projeto DEVE habilitar uma ou mais flags de avisos do compilador, um modo de linguagem "seguro", ou usar uma ferramenta "linter" separada para procurar erros de qualidade de código ou erros comuns simples, se houver pelo menos uma ferramenta FLOSS que possa implementar este critério na linguagem selecionada. [warnings]
    Exemplos de flags de avisos do compilador incluem gcc/clang "-Wall". Exemplos de modo de linguagem "seguro" incluem JavaScript "use strict" e perl5 "use warnings". Uma ferramenta "linter" separada é simplesmente uma ferramenta que examina o código-fonte para procurar erros de qualidade de código ou erros comuns simples. Estes são tipicamente habilitados dentro do código-fonte ou instruções de compilação.

    The project enables and addresses compiler/linter warnings across all code types: Ruff (Python — 8 rule sets: E, W, F, I, UP, B, SIM, RUF) via python-lint.yml, markdownlint-cli2 (Markdown) via markdown-lint.yml, PSScriptAnalyzer (PowerShell) via powershell-lint.yml, yaml-lint (YAML) via yaml-lint.yml, cspell (spelling) run separately, ESLint (TypeScript) via dataviewer-frontend-tests.yml, and TypeScript type-checking (tsc --noEmit). All linters run in CI on both PRs and main pushes. Ruff runs both lint and format checks.

    Evidence:



    O projeto DEVE tratar os avisos. [warnings_fixed]
    Estes são os avisos identificados pela implementação do critério warnings. O projeto deve corrigir avisos ou marcá-los no código-fonte como falsos positivos. Idealmente não haveria avisos, mas um projeto PODE aceitar alguns avisos (tipicamente menos de 1 aviso por 100 linhas ou menos de 10 avisos).

    CI enforces zero warnings as a merge gate. All linter workflows (Ruff, markdownlint, PSScriptAnalyzer, yaml-lint, ESLint, TypeScript type-check) are configured to fail on any warning. These are required checks in pr-validation.yml — a PR cannot merge with linter failures. The main.yml pipeline inherits the same checks, ensuring warnings on main are caught immediately. The 16-job pr-validation.yml gate blocks any code with warnings from reaching the main branch.

    Evidence:



    É SUGERIDO que projetos sejam maximamente rigorosos com avisos no software produzido pelo projeto, onde prático. [warnings_strict]
    Alguns avisos não podem ser efetivamente habilitados em alguns projetos. O que é necessário é evidência de que o projeto está se esforçando para habilitar flags de avisos onde puder, de forma que erros sejam detectados cedo.

    Ruff is configured with 8 rule sets (E, W, F, I, UP, B, SIM, RUF) covering error detection, warnings, pyflakes, import sorting, Python upgrade suggestions, bugbear, simplification, and Ruff-specific rules — this represents a broad, strict configuration. CodeQL runs with "security-extended" and "security-and-quality" query suites, which are the maximum strictness settings. markdownlint, PSScriptAnalyzer, yaml-lint, ESLint, and TypeScript --noEmit all run with their default (strict) configurations. Combined, these tools provide extensive static analysis coverage across all major code types in the project.

    Evidence:


 Segurança 16/16

  • Conhecimento de desenvolvimento seguro


    O projeto DEVE ter pelo menos um desenvolvedor principal que saiba como projetar software seguro. (Veja 'details' para os requisitos exatos.) [know_secure_design]
    Isto requer entender os seguintes princípios de projeto, incluindo os 8 princípios de Saltzer and Schroeder:
    • economia de mecanismo (mantenha o projeto tão simples e pequeno quanto prático, por exemplo, adotando simplificações amplas)
    • padrões à prova de falhas (decisões de acesso devem negar por padrão, e a instalação dos projetos deve ser segura por padrão)
    • mediação completa (todo acesso que possa ser limitado deve ser verificado quanto à autoridade e não ser contornável)
    • projeto aberto (mecanismos de segurança não devem depender da ignorância do invasor sobre seu projeto, mas sim em informações mais facilmente protegidas e alteradas como chaves e senhas)
    • separação de privilégios (idealmente, acesso a objetos importantes deve depender de mais de uma condição, de forma que derrotar um sistema de proteção não permita acesso completo. Por exemplo, autenticação multifator, como exigir tanto uma senha quanto um token de hardware, é mais forte que autenticação de fator único)
    • menor privilégio (processos devem operar com o menor privilégio necessário)
    • menor mecanismo comum (o projeto deve minimizar os mecanismos comuns a mais de um usuário e dos quais todos os usuários dependem, por exemplo, diretórios para arquivos temporários)
    • aceitabilidade psicológica (a interface humana deve ser projetada para facilidade de uso - projetar para "menor surpresa" pode ajudar)
    • superfície de ataque limitada (a superfície de ataque - o conjunto dos diferentes pontos onde um invasor pode tentar entrar ou extrair dados - deve ser limitada)
    • validação de entrada com listas de permissões (entradas devem tipicamente ser verificadas para determinar se são válidas antes de serem aceitas; esta validação deve usar listas de permissões (que aceitam apenas valores conhecidamente bons), não listas de negação (que tentam listar valores conhecidamente ruins)).
    Um "desenvolvedor principal" em um projeto é qualquer pessoa que esteja familiarizada com a base de código do projeto, esteja confortável fazendo mudanças nela, e seja reconhecida como tal pela maioria dos outros participantes no projeto. Um desenvolvedor principal tipicamente faria várias contribuições ao longo do último ano (via código, documentação ou respondendo perguntas). Desenvolvedores seriam tipicamente considerados desenvolvedores principais se iniciaram o projeto (e não deixaram o projeto há mais de três anos), têm a opção de receber informações em um canal privado de relato de vulnerabilidades (se houver um), podem aceitar commits em nome do projeto, ou realizar lançamentos finais do software do projeto. Se há apenas um desenvolvedor, esse indivíduo é o desenvolvedor principal. Muitos livros e cursos estão disponíveis para ajudá-lo a entender como desenvolver software mais seguro e discutir projeto. Por exemplo, o curso Secure Software Development Fundamentals é um conjunto gratuito de três cursos que explicam como desenvolver software mais seguro (é gratuito se você auditar; por uma taxa extra você pode obter um certificado para provar que aprendeu o material).

    The project demonstrates knowledge of secure design principles through a comprehensive STRIDE-based threat model (docs/security/threat-model.md) identifying 19 threats across 8 trust boundaries (1 Critical, 6 High, 7 Medium, 5 Low severity). The architecture follows zero-trust principles: managed identities instead of passwords, TLS 1.2+ enforced on all connections, private AKS clusters by default, network segmentation via NSGs and private endpoints. The project operates under Microsoft's OSS security governance with SECURITY.md following MSRC template V0.0.9, and docs/contributing/security-review.md provides a security review checklist for contributors.

    Evidence:



    Pelo menos um dos desenvolvedores principais do projeto DEVE conhecer tipos comuns de erros que levam a vulnerabilidades neste tipo de software, bem como pelo menos um método para combater ou mitigar cada um deles. [know_common_errors]
    Exemplos (dependendo do tipo de software) incluem injeção SQL, injeção de SO, estouro clássico de buffer, cross-site scripting, autenticação ausente e autorização ausente. Veja o CWE/SANS top 25 ou OWASP Top 10 para listas comumente usadas. Muitos livros e cursos estão disponíveis para ajudá-lo a entender como desenvolver software mais seguro e discutir erros comuns de implementação que levam a vulnerabilidades. Por exemplo, o curso Secure Software Development Fundamentals é um conjunto gratuito de três cursos que explicam como desenvolver software mais seguro (é gratuito se você auditar; por uma taxa extra você pode obter um certificado para provar que aprendeu o material).

    The project demonstrates awareness of common security errors through multiple mechanisms: CodeQL with security-extended and security-and-quality query suites catches OWASP Top 10 vulnerabilities (injection, XSS, path traversal, etc.) on every PR. The STRIDE threat model in docs/security/threat-model.md catalogs 19 specific threats with mitigations. Integration with Microsoft Security Response Center (MSRC) provides access to Microsoft's vulnerability intelligence. dependency-review.yml fails on moderate+ severity vulnerabilities. The project's architecture avoids common errors by design — managed identities eliminate credential storage, TLS is enforced (not optional), and the default network mode is fully private.

    Evidence:


  • Usar práticas criptográficas boas e básicas

    Observe que alguns softwares não precisam usar mecanismos criptográficos. Se o seu projeto produzir software que (1) inclui, ativa ou habilita funcionalidade de criptografia, e (2) pode ser liberado dos Estados Unidos (EUA) para fora dos EUA ou para um não cidadão dos EUA, você pode ser legalmente obrigado a tomar algumas etapas extras. Normalmente isso envolve apenas o envio de um e-mail. Para mais informações, consulte a seção de criptografia de Understanding Open Source Technology & US Export Controls.

    O software produzido pelo projeto DEVE usar, por padrão, apenas protocolos criptográficos e algoritmos que são publicamente publicados e revisados por especialistas (se protocolos criptográficos e algoritmos forem usados). [crypto_published]
    Esses critérios criptográficos nem sempre se aplicam porque alguns softwares não têm necessidade de usar diretamente capacidades criptográficas.

    The project does not implement custom cryptographic algorithms. All cryptography is delegated to well-known, publicly reviewed implementations: Azure SDK (azure-identity, azure-storage) for authentication and storage encryption, TLS 1.2+ via standard libraries for transport security, and Sigstore gitsign for release tag signing. These are all industry-standard, published cryptographic mechanisms undergoing continuous public review and audit.

    Evidence:



    Se o software produzido pelo projeto for uma aplicação ou biblioteca, e seu propósito principal não for implementar criptografia, então ele DEVERIA apenas chamar software especificamente projetado para implementar funções criptográficas; ele NÃO DEVERIA reimplementar o seu próprio. [crypto_call]

    All cryptographic functionality is invoked via dedicated, well-maintained cryptographic libraries rather than custom implementations: Azure Identity SDK for authentication (OAuth2, managed identity tokens), Azure Storage SDK for encryption at rest/in transit, Python ssl module for TLS, and Sigstore for code signing. No project code implements its own cryptographic primitives, key derivation, or encryption algorithms.

    Evidence:



    Toda funcionalidade no software produzido pelo projeto que depende de criptografia DEVE ser implementável usando FLOSS. [crypto_floss]

    All cryptographic libraries used are FLOSS: Azure SDK for Python (MIT License — https://github.com/Azure/azure-sdk-for-python), Python's ssl module (PSF License), OpenSSL (Apache-2.0), and Sigstore (Apache-2.0 — https://github.com/sigstore). No proprietary cryptographic libraries are used anywhere in the project.

    Evidence:



    Os mecanismos de segurança dentro do software produzido pelo projeto DEVEM usar comprimentos de chave padrão que pelo menos atendam aos requisitos mínimos do NIST até o ano de 2030 (conforme declarado em 2012). DEVE ser possível configurar o software para que comprimentos de chave menores sejam completamente desabilitados. [crypto_keylength]
    Esses comprimentos mínimos de bits são: chave simétrica 112, módulo de fatoração 2048, chave de logaritmo discreto 224, grupo logarítmico discreto 2048, curva elíptica 224 e hash 224 (hashing de senha não é coberto por este comprimento de bits, mais informações sobre hashing de senha podem ser encontradas no critério crypto_password_storage). Veja https://www.keylength.com para uma comparação de recomendações de comprimento de chave de várias organizações. O software PODE permitir comprimentos de chave menores em algumas configurações (idealmente não permitiria, já que isso permite ataques de downgrade, mas comprimentos de chave mais curtos são às vezes necessários para interoperabilidade).

    The project enforces modern cryptographic key lengths. TLS 1.2+ is the minimum enforced version (configured in Terraform storage.tf for Azure Storage and across all Azure service connections), which mandates minimum 128-bit symmetric keys and 2048-bit RSA keys. Azure Managed Identity tokens use 2048-bit RSA. Sigstore gitsign uses ECDSA P-256 for release signing. No deprecated or weak key lengths (e.g., 1024-bit RSA, 56-bit DES) are used anywhere.

    Evidence:



    Os mecanismos de segurança padrão dentro do software produzido pelo projeto NÃO DEVEM depender de algoritmos criptográficos quebrados (por exemplo, MD4, MD5, DES único, RC4, Dual_EC_DRBG), ou usar modos de cifra que são inadequados ao contexto, a menos que sejam necessários para implementar um protocolo interoperável (onde o protocolo implementado é a versão mais recente desse padrão amplamente suportado pelo ecossistema de rede, esse ecossistema requer o uso de tal algoritmo ou modo, e esse ecossistema não oferece nenhuma alternativa mais segura). A documentação DEVE descrever quaisquer riscos de segurança relevantes e quaisquer mitigações conhecidas se esses algoritmos ou modos quebrados forem necessários para um protocolo interoperável. [crypto_working]
    O modo ECB é quase nunca apropriado porque revela blocos idênticos dentro do texto cifrado conforme demonstrado pelo pinguim ECB, e o modo CTR é frequentemente inadequado porque não realiza autenticação e causa duplicatas se o estado de entrada for repetido. Em muitos casos é melhor escolher um modo de algoritmo de cifra de bloco projetado para combinar sigilo e autenticação, por exemplo, Galois/Counter Mode (GCM) e EAX. Projetos PODEM permitir que usuários habilitem mecanismos quebrados (por exemplo, durante a configuração) onde necessário para compatibilidade, mas então os usuários sabem que estão fazendo isso.

    The project uses no broken cryptographic algorithms. The threat model in docs/security/threat-model.md confirms no use of MD4, MD5 (for security), single DES, RC4, or other deprecated algorithms. TLS 1.2+ is enforced, which excludes all known broken cipher suites. Azure SDK handles cipher suite negotiation using current best practices. SHA-256 is the minimum hash algorithm used (e.g., SHA-pinning of GitHub Actions uses SHA-256 hashes).

    Evidence:



    Os mecanismos de segurança padrão dentro do software produzido pelo projeto NÃO DEVERIAM depender de algoritmos criptográficos ou modos com fraquezas sérias conhecidas (por exemplo, o algoritmo de hash criptográfico SHA-1 ou o modo CBC em SSH). [crypto_weaknesses]
    Preocupações sobre o modo CBC em SSH são discutidas em CERT: SSH CBC vulnerability.

    The default cryptographic configuration avoids known weaknesses. No SHA-1 is used for any security purpose. TLS 1.2+ with modern cipher suites is the minimum (excludes CBC-mode ciphers vulnerable to padding oracle attacks). Azure services enforce forward secrecy cipher suites by default. The dependency-review.yml workflow with fail-on-severity: moderate would catch any newly-introduced dependency with known cryptographic weaknesses.

    Evidence:



    Os mecanismos de segurança dentro do software produzido pelo projeto DEVERIAM implementar sigilo perfeito para frente para protocolos de acordo de chave, de modo que uma chave de sessão derivada de um conjunto de chaves de longo prazo não possa ser comprometida se uma das chaves de longo prazo for comprometida no futuro. [crypto_pfs]

    All TLS connections enforced by the project use Azure services that enable Perfect Forward Secrecy (PFS) by default. Azure Front Door, App Service, Storage, and AKS ingress controllers negotiate ECDHE cipher suites that provide PFS. TLS 1.2+ (enforced in the infrastructure) mandates PFS-capable cipher suites. The project does not configure any TLS settings that would disable PFS. Azure's documentation confirms PFS support: https://learn.microsoft.com/en-us/azure/security/fundamentals/encryption-overview.

    Evidence:



    Se o software produzido pelo projeto causar o armazenamento de senhas para autenticação de usuários externos, as senhas DEVEM ser armazenadas como hashes iterados com um salt por usuário usando um algoritmo de extensão de chave (iterado) (por exemplo, Argon2id, Bcrypt, Scrypt ou PBKDF2). Veja também OWASP Password Storage Cheat Sheet. [crypto_password_storage]
    Este critério aplica-se apenas quando o software está aplicando autenticação de usuários usando senhas para usuários externos (também conhecida como autenticação de entrada), como aplicações web do lado do servidor. Não se aplica em casos onde o software armazena senhas para autenticar em outros sistemas (também conhecida como autenticação de saída, por exemplo, o software implementa um cliente para algum outro sistema), já que pelo menos partes desse software devem ter acesso frequentemente à senha não hasheada.

    The project does not store, hash, or manage user passwords in any form. All authentication is delegated to external identity providers: Azure Managed Identity for service-to-service authentication (no credentials stored), Microsoft Entra ID (Azure AD) for user authentication via OAuth2/OIDC, and Kubernetes service account tokens federated via workload identity. The Terraform infrastructure creates managed identities and federated credentials — no password fields, no credential databases, no user account tables exist anywhere in the codebase. The threat model confirms this: "managed identities (no passwords)" is an explicit design principle.

    Evidence:



    Os mecanismos de segurança dentro do software produzido pelo projeto DEVEM gerar todas as chaves criptográficas e nonces usando um gerador de números aleatórios criptograficamente seguro, e NÃO DEVEM fazê-lo usando geradores que são criptograficamente inseguros. [crypto_random]
    Um gerador de números aleatórios criptograficamente seguro pode ser um gerador de números aleatórios de hardware, ou pode ser um gerador de números pseudo-aleatórios criptograficamente seguro (CSPRNG) usando um algoritmo como Hash_DRBG, HMAC_DRBG, CTR_DRBG, Yarrow ou Fortuna. Exemplos de chamadas para geradores de números aleatórios seguros incluem o java.security.SecureRandom do Java e o window.crypto.getRandomValues do JavaScript. Exemplos de chamadas para geradores de números aleatórios inseguros incluem o java.util.Random do Java e o Math.random do JavaScript.

    The project does not directly generate cryptographic random numbers. All operations requiring cryptographic randomness are delegated to external libraries and services: Azure SDK handles authentication token generation, TLS libraries handle session key generation, and Sigstore handles signing nonce generation. No project code calls random number generators for security-sensitive purposes (key generation, nonce creation, token generation, etc.). The codebase contains no imports of cryptographic random modules (e.g., secrets, os.urandom) for security purposes.

    Evidence:


  • Entrega protegida contra ataques man-in-the-middle (MITM)


    O projeto DEVE usar um mecanismo de entrega que contraponha ataques MITM. Usar https ou ssh+scp é aceitável. [delivery_mitm]
    Um mecanismo ainda mais forte é liberar o software com pacotes assinados digitalmente, já que isso mitiga ataques no sistema de distribuição, mas isso só funciona se os usuários puderem estar confiantes de que as chaves públicas para assinaturas estão corretas e se os usuários realmente verificarão a assinatura.

    The project delivers all artifacts over cryptographically-protected channels resistant to man-in-the-middle attacks. GitHub enforces HTTPS for all repository access (web, API, Git clone). PyPI packages installed via uv/pip use HTTPS by default. npm packages use HTTPS by default. Terraform providers are downloaded from registry.terraform.io over HTTPS with GPG verification. Docker/container images from nvcr.io and mcr.microsoft.com use HTTPS with content-addressable digests. GitHub Actions are SHA-pinned (95% compliance — verified by dependency-pinning-scan.yml) preventing tag-swapping attacks. Release tags are Sigstore-signed, providing cryptographic verification of release integrity.

    Evidence:



    Um hash criptográfico (por exemplo, um sha1sum) NÃO DEVE ser recuperado por http e usado sem verificar uma assinatura criptográfica. [delivery_unsigned]
    Esses hashes podem ser modificados durante o trânsito.

    The project provides a mechanism to verify the integrity of downloaded artifacts. Release tags are cryptographically signed using Sigstore gitsign keyless signing, verified by the verify-tag-signature.yml workflow. The main.yml CI pipeline generates SBOM (Anchore SPDX-JSON format) and build provenance attestation for releases, providing a verifiable software bill of materials. GitHub Actions SHA-pinning (95% compliance) ensures CI dependencies are integrity-verified. Container images referenced in workflows use SHA digests for integrity verification. Users can verify release authenticity via git tag -v.

    Evidence:


  • Vulnerabilidades conhecidas publicamente corrigidas


    NÃO DEVE haver vulnerabilidades não corrigidas de severidade média ou superior que sejam publicamente conhecidas por mais de 60 dias. [vulnerabilities_fixed_60_days]
    A vulnerabilidade deve ser corrigida e lançada pelo próprio projeto (as correções podem ser desenvolvidas em outro lugar). Uma vulnerabilidade se torna publicamente conhecida (para este propósito) uma vez que tem um CVE com informações lançadas publicamente sem paywall (relatadas, por exemplo, no National Vulnerability Database) ou quando o projeto foi informado e a informação foi liberada ao público (possivelmente pelo projeto). Uma vulnerabilidade é considerada de severidade média ou superior se sua pontuação qualitativa base do Common Vulnerability Scoring System (CVSS) for média ou superior. Nas versões 2.0 a 3.1 do CVSS, isso é equivalente a uma pontuação CVSS de 4.0 ou superior. Os projetos podem usar a pontuação CVSS conforme publicada em um banco de dados de vulnerabilidades amplamente usado (como o National Vulnerability Database) usando a versão mais recente do CVSS relatada nesse banco de dados. Os projetos podem, em vez disso, calcular a severidade eles mesmos usando a versão mais recente do CVSS no momento da divulgação da vulnerabilidade, se as entradas de cálculo forem publicamente reveladas uma vez que a vulnerabilidade seja publicamente conhecida. Nota: isso significa que os usuários podem ficar vulneráveis a todos os atacantes em todo o mundo por até 60 dias. Este critério é frequentemente muito mais fácil de atender do que o que o Google recomenda em Rebooting responsible disclosure, porque o Google recomenda que o período de 60 dias comece quando o projeto é notificado mesmo se o relatório não for público. Observe também que este critério de selo, como outros critérios, aplica-se ao projeto individual. Alguns projetos fazem parte de organizações guarda-chuva maiores ou projetos maiores, possivelmente em múltiplas camadas, e muitos projetos alimentam seus resultados para outras organizações e projetos como parte de uma cadeia de suprimentos potencialmente complexa. Um projeto individual geralmente não pode controlar o resto, mas um projeto individual pode trabalhar para lançar uma correção de vulnerabilidade de forma oportuna. Portanto, focamos apenas no tempo de resposta do projeto individual. Uma vez que uma correção esteja disponível do projeto individual, outros podem determinar como lidar com a correção (por exemplo, eles podem atualizar para a versão mais recente ou podem aplicar apenas a correção como uma solução cherry-picked).

    The project has multiple automated systems ensuring vulnerabilities are identified and fixed promptly. Dependabot monitors 7 ecosystem entries (pip ×4, terraform ×2, github-actions ×1) and automatically creates PRs for vulnerable dependencies on a weekly schedule. dependency-review.yml runs on every PR and fails on moderate+ severity vulnerabilities, preventing new vulnerable dependencies from being introduced. CodeQL scans for code-level vulnerabilities on every PR and push to main. Gitleaks scans for leaked secrets on every PR. SUPPORT.md documents security issues as highest priority with a 24-hour response SLA. PR #233 adds explicit vulnerability remediation timeline documentation. PR #271 demonstrates active GHSA vulnerability remediation.

    Evidence:



    Os projetos DEVERIAM corrigir todas as vulnerabilidades críticas rapidamente após serem relatadas. [vulnerabilities_critical_fixed]

    Critical vulnerabilities receive highest priority treatment. SECURITY.md and SUPPORT.md document a 24-hour response SLA for security issues. Dependabot creates automatic PRs for all critical/high severity dependency vulnerabilities. dependency-review.yml blocks PRs introducing moderate+ severity dependencies. Gitleaks-scan.yml detects leaked credentials with full history scan, uploaded as SARIF to GitHub Security tab. The project has demonstrated active vulnerability remediation — PR #271 addresses GHSA vulnerabilities, confirming the process works in practice. The automated pipeline (Dependabot → dependency-review → CODEOWNERS review → CI gate) ensures critical fixes flow through quickly.

    Evidence:


  • Outras questões de segurança


    Os repositórios públicos NÃO DEVEM vazar uma credencial privada válida (por exemplo, uma senha funcionando ou chave privada) que se destina a limitar o acesso público. [no_leaked_credentials]
    Um projeto PODE vazar credenciais "de amostra" para testes e bancos de dados sem importância, desde que não sejam destinadas a limitar o acesso público.

    Multiple layers prevent credential leakage: (1) .gitignore excludes sensitive files: *.env, .env.local, *.tfvars, *.tfstate, *.pfx, *.publishsettings, and other credential-containing patterns. (2) gitleaks-scan.yml (Gitleaks v8.30.0 with SHA256 verification) scans the full repository history on every PR, uploading SARIF results to GitHub Security tab. (3) All CI workflows set persist-credentials: false on checkout steps, preventing credential persistence in workflow artifacts. (4) Architecture uses managed identities exclusively — no passwords or API keys exist in the codebase by design. (5) dependency-pinning-scan.yml validates 95% SHA-pinning compliance, preventing token exposure via tag-swapping attacks. (6) workflow-permissions-scan.yml enforces least-privilege permissions blocks on all workflows.

    Evidence:


 Análise 8/8

  • Análise estática de código


    Pelo menos uma ferramenta de análise estática de código (além de avisos do compilador e modos de linguagem "seguros") DEVE ser aplicada a qualquer grande lançamento de produção proposto do software antes de seu lançamento, se houver pelo menos uma ferramenta FLOSS que implemente este critério na linguagem selecionada. [static_analysis]
    Uma ferramenta de análise estática de código examina o código de software (como código-fonte, código intermediário ou executável) sem executá-lo com entradas específicas. Para fins deste critério, avisos do compilador e modos de linguagem "seguros" não contam como ferramentas de análise estática de código (estes tipicamente evitam análise profunda porque a velocidade é vital). Algumas ferramentas de análise estática focam na detecção de defeitos genéricos, outras focam em encontrar tipos específicos de defeitos (como vulnerabilidades), e algumas fazem uma combinação. Exemplos de tais ferramentas de análise estática de código incluem cppcheck (C, C++), clang static analyzer (C, C++), SpotBugs (Java), FindBugs (Java) (incluindo FindSecurityBugs), PMD (Java), Brakeman (Ruby on Rails), lintr (R), goodpractice (R), Coverity Quality Analyzer, SonarQube, Codacy e HP Enterprise Fortify Static Code Analyzer. Listas maiores de ferramentas podem ser encontradas em lugares como a lista da Wikipedia de ferramentas para análise estática de código, informações da OWASP sobre análise estática de código, lista do NIST de analisadores de segurança de código-fonte e lista de ferramentas de análise estática de Wheeler. Se não houver ferramentas de análise estática FLOSS disponíveis para a(s) linguagem(ns) de implementação usada(s), você pode selecionar 'N/A'.

    The project employs multiple static analysis tools integrated into CI: (1) CodeQL (codeql-analysis.yml) — GitHub's semantic code analysis engine running security-extended and security-and-quality query suites (maximum coverage) on Python code, triggered on every PR, push to main, and weekly schedule, with SARIF results uploaded to GitHub Security tab. (2) Ruff (python-lint.yml) — fast Python linter with 8 rule sets (E, W, F, I, UP, B, SIM, RUF) covering errors, warnings, pyflakes, import sorting, Python upgrade patterns, bugbear, simplification, and Ruff-specific rules, plus format checking. (3) markdownlint-cli2 for Markdown, PSScriptAnalyzer for PowerShell, yaml-lint for YAML, ESLint and TypeScript --noEmit for frontend code. All tools run as required checks in the 16-job pr-validation.yml pipeline — no code merges without passing static analysis.

    Evidence:



    É SUGERIDO que pelo menos uma das ferramentas de análise estática usadas para o critério static_analysis inclua regras ou abordagens para procurar vulnerabilidades comuns na linguagem ou ambiente analisado. [static_analysis_common_vulnerabilities]
    Ferramentas de análise estática que são especificamente projetadas para procurar vulnerabilidades comuns são mais propensas a encontrá-las. Dito isso, usar quaisquer ferramentas estáticas normalmente ajudará a encontrar alguns problemas, então estamos sugerindo mas não exigindo isso para o nível de selo 'passing'.

    CodeQL runs with both "security-extended" and "security-and-quality" query suites — these are GitHub's most comprehensive security query sets, specifically designed to detect common vulnerabilities including: SQL injection, cross-site scripting (XSS), path traversal, code injection, insecure deserialization, SSRF, hardcoded credentials, and other OWASP Top 10 categories. The security-extended suite goes beyond the default security queries to catch additional vulnerability patterns. Results are uploaded as SARIF to the GitHub Security tab, providing a centralized view of all detected security findings.

    Evidence:



    Todas as vulnerabilidades exploráveis de severidade média e superior descobertas com análise estática de código DEVEM ser corrigidas de forma oportuna após serem confirmadas. [static_analysis_fixed]
    Uma vulnerabilidade é considerada de severidade média ou superior se sua pontuação qualitativa base do Common Vulnerability Scoring System (CVSS) for média ou superior. Nas versões 2.0 a 3.1 do CVSS, isso é equivalente a uma pontuação CVSS de 4.0 ou superior. Os projetos podem usar a pontuação CVSS conforme publicada em um banco de dados de vulnerabilidades amplamente usado (como o National Vulnerability Database) usando a versão mais recente do CVSS relatada nesse banco de dados. Os projetos podem, em vez disso, calcular a severidade eles mesmos usando a versão mais recente do CVSS no momento da divulgação da vulnerabilidade, se as entradas de cálculo forem publicamente reveladas uma vez que a vulnerabilidade seja publicamente conhecida. Observe que o critério vulnerabilities_fixed_60_days exige que todas essas vulnerabilidades sejam corrigidas dentro de 60 dias de se tornarem públicas.

    Static analysis findings are fixed before release as a matter of CI enforcement. CodeQL, Ruff, and all linter checks are required jobs in pr-validation.yml — no PR can merge with static analysis failures. The main.yml pipeline runs the same checks on push to main, and the release-please job depends on all 13 quality/security gate jobs passing, meaning no release is cut unless all static analysis is clean. CodeQL SARIF results in the GitHub Security tab provide tracking of any findings that require attention.

    Evidence:



    É SUGERIDO que a análise estática de código-fonte ocorra em cada commit ou pelo menos diariamente. [static_analysis_often]

    Static analysis runs on every code change: pr-validation.yml invokes CodeQL and Ruff on every pull request, main.yml invokes them on every push to main, and codeql-analysis.yml additionally runs on a weekly schedule (Sundays at 03:00 UTC) for continuous monitoring even without code changes. This means static analysis runs at minimum weekly, and in practice runs multiple times per day during active development as PRs are opened and updated. The OpenSSF Scorecard (scorecard.yml) also runs weekly, providing independent assessment of the project's security posture.

    Evidence:


  • Análise dinâmica de código


    É SUGERIDO que pelo menos uma ferramenta de análise dinâmica seja aplicada a qualquer grande lançamento de produção proposto do software antes de seu lançamento. [dynamic_analysis]
    Uma ferramenta de análise dinâmica examina o software executando-o com entradas específicas. Por exemplo, o projeto PODE usar uma ferramenta de fuzzing (por exemplo, American Fuzzy Lop) ou um scanner de aplicação web (por exemplo, OWASP ZAP ou w3af). Em alguns casos, o projeto OSS-Fuzz pode estar disposto a aplicar testes de fuzzing ao seu projeto. Para fins deste critério, a ferramenta de análise dinâmica precisa variar as entradas de alguma forma para procurar vários tipos de problemas ou ser um conjunto de testes automatizado com pelo menos 80% de cobertura de ramificação. A página da Wikipedia sobre análise dinâmica e a página da OWASP sobre fuzzing identificam algumas ferramentas de análise dinâmica. A(s) ferramenta(s) de análise PODEM estar focadas em procurar vulnerabilidades de segurança, mas isso não é obrigatório.

    The project employs two forms of dynamic analysis: (1) Hypothesis property-based testing (PR #268) — 7 test files totaling 1,752 lines across all three Python packages (training, inference, common), using the Hypothesis framework to generate randomized test inputs that exercise code paths not covered by deterministic unit tests. Hypothesis qualifies as dynamic analysis per the OpenSSF criterion which explicitly includes "such as testing or fuzzing." (2) OWASP ZAP DAST scanning (PR #241) — weekly Dynamic Application Security Testing scan of the dataviewer frontend, checking for runtime security vulnerabilities (XSS, injection, authentication issues, etc.) that static analysis cannot detect.

    Evidence:



    É SUGERIDO que se o software produzido pelo projeto incluir software escrito usando uma linguagem insegura em memória (por exemplo, C ou C++), então pelo menos uma ferramenta dinâmica (por exemplo, um fuzzer ou scanner de aplicação web) seja rotineiramente usada em combinação com um mecanismo para detectar problemas de segurança de memória, como estouros de buffer. Se o projeto não produzir software escrito em uma linguagem insegura em memória, escolha "não aplicável" (N/A). [dynamic_analysis_unsafe]
    Exemplos de mecanismos para detectar problemas de segurança de memória incluem Address Sanitizer (ASAN) (disponível no GCC e LLVM), Memory Sanitizer e valgrind. Outras ferramentas potencialmente usadas incluem thread sanitizer e undefined behavior sanitizer. Assertivas generalizadas também funcionariam.

    This criterion applies to projects with C/C++ code that should enable memory-safety checks (AddressSanitizer, MemorySanitizer, UndefinedBehaviorSanitizer, etc.). The project contains no C or C++ code — the codebase is entirely Python, TypeScript, Terraform HCL, PowerShell, and shell scripts. Python and TypeScript are memory-safe languages. Therefore, memory-safety analyzers for compiled languages are not applicable.

    Evidence:



    É SUGERIDO que o projeto use uma configuração para pelo menos alguma análise dinâmica (como testes ou fuzzing) que habilite muitas asserções. Em muitos casos, essas asserções não devem ser habilitadas em builds de produção. [dynamic_analysis_enable_assertions]
    Este critério não sugere habilitar asserções durante a produção; isso é inteiramente decisão do projeto e de seus usuários. O foco deste critério é, em vez disso, melhorar a detecção de falhas durante a análise dinâmica antes da implantação. Habilitar asserções no uso em produção é completamente diferente de habilitar asserções durante a análise dinâmica (como testes). Em alguns casos, habilitar asserções no uso em produção é extremamente imprudente (especialmente em componentes de alta integridade). Existem muitos argumentos contra habilitar asserções em produção, por exemplo, bibliotecas não devem travar chamadores, sua presença pode causar rejeição por lojas de aplicativos e/ou ativar uma asserção em produção pode expor dados privados, como chaves privadas. Observe que em muitas distribuições Linux NDEBUG não é definido, então assert() em C/C++ será habilitado por padrão para produção nesses ambientes. Pode ser importante usar um mecanismo de asserção diferente ou definir NDEBUG para produção nesses ambientes.

    Python assertions are enabled during all test execution. The pytest invocation (uv run pytest -v) does not use the -O or -OO flags, which means Python's debug is True and assert statements execute normally. Hypothesis property-based tests (PR #268) use assert statements extensively for property verification — these assertions run on every Hypothesis-generated test case (by default, 100 random inputs per test function). The pyproject.toml pytest configuration does not include any optimization flags that would disable assertions.

    Evidence:



    Todas as vulnerabilidades exploráveis de severidade média e superior descobertas com análise dinâmica de código DEVEM ser corrigidas em tempo hábil após serem confirmadas. [dynamic_analysis_fixed]
    Se você não está executando análise dinâmica de código e, portanto, não encontrou nenhuma vulnerabilidade dessa forma, escolha "não aplicável" (N/A). Uma vulnerabilidade é considerada de severidade média ou superior se sua pontuação qualitativa base do Common Vulnerability Scoring System (CVSS) for média ou superior. Nas versões 2.0 a 3.1 do CVSS, isso é equivalente a uma pontuação CVSS de 4.0 ou superior. Os projetos podem usar a pontuação CVSS conforme publicada em um banco de dados de vulnerabilidades amplamente utilizado (como o National Vulnerability Database) usando a versão mais recente do CVSS relatada nesse banco de dados. Os projetos podem, em vez disso, calcular a severidade por conta própria usando a versão mais recente do CVSS no momento da divulgação da vulnerabilidade, se as entradas de cálculo forem reveladas publicamente assim que a vulnerabilidade for conhecida publicamente.

    Dynamic analysis findings are addressed promptly. PR #268 (Hypothesis property-based tests) discovered and fixed a real runtime bug: a RuntimeError in src/training/training/metrics.py where MLflowLogger._update() called self.writer.add_scalar() outside an active MLflow run context. This demonstrates the dynamic analysis → fix pipeline working in practice. Additionally, any OWASP ZAP findings (PR #241) would be tracked via GitHub Issues for remediation. Test failures from Hypothesis (randomized input testing) block PR merge via the pr-validation.yml CI gate.

    Evidence:



Estes dados estão disponíveis sob o Community Data License Agreement – Permissive, Version 2.0 (CDLA-Permissive-2.0). Isso significa que um Destinatário de Dados pode compartilhar os Dados, com ou sem modificações, desde que o Destinatário de Dados disponibilize o texto deste acordo com os Dados compartilhados. Por favor, dê crédito a Bill Berry e aos contribuidores do selo de melhores práticas OpenSSF.

Entrada de selo do projeto de propriedade de: Bill Berry.
Entrada criada em 2026-03-16 22:18:49 UTC, última atualização em 2026-03-17 00:03:32 UTC. Selo de aprovação alcançado pela última vez em 2026-03-17 00:03:32 UTC.