NetCoreApplicationTemplate

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 13645 é 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/13645/badge)](https://www.bestpractices.dev/projects/13645)
ou incorporando isto no seu HTML:
<a href="https://www.bestpractices.dev/projects/13645"><img src="https://www.bestpractices.dev/projects/13645/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.

    Reusable ASP.NET Core application template for secure, maintainable, production-ready .NET applications.

    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


    Suficiente para um badge!

    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).

    The project README succinctly describes NetCoreApplicationTemplate as a reusable, production-oriented ASP.NET Core application template and identifies the security, authentication and authorization, observability, data access, health-check, error-handling, and CI capabilities that it provides.

    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/README.md#net-core-application-template


    Suficiente para um badge!

    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]

    The project provides source-cloning, build, Docker, NuGet installation, and dotnet new usage instructions in the README. SUPPORT.md directs users to GitHub Issues for bugs, documentation problems, packaging issues, and enhancement requests, and directs private vulnerability reports to SECURITY.md. CONTRIBUTING.md documents the issue, branch, pull-request, validation, and contribution process.

    Obtain:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/README.md#quick-start-from-source
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/README.md#install-and-use-the-template-package

    Feedback:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SUPPORT.md#support-channels
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Contribute:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CONTRIBUTING.md


    Suficiente para um badge!

    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 documents the contribution process, including issue workflow, branch naming, commit messages, pull-request expectations, validation requirements, documentation expectations, security considerations, and maintainer review.

    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CONTRIBUTING.md


    Suficiente para um badge!

    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 defines the requirements for acceptable contributions, including focused scope, secure-by-default behavior, maintainable configuration, test coverage, documentation updates, successful build and test validation, and formatting verification with dotnet format --verify-no-changes. The repository .editorconfig defines the applicable formatting, naming, code-quality, reliability, security, performance, and usage analyzer rules.

    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CONTRIBUTING.md#validation-expectations
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.editorconfig


  • Licença FLOSS


    Suficiente para um badge!

    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).

    NetCoreApplicationTemplate is released under the MIT License, which grants permission to use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software.

    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/LICENSE.txt


    Suficiente para um badge!

    É 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.

    NetCoreApplicationTemplate uses the MIT License, an Open Source Initiative-approved license.

    Project license:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/LICENSE.txt

    OSI license information:
    https://opensource.org/license/mit


    Suficiente para um badge!

    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.

    The complete MIT License is stored in LICENSE.txt at the root of the source repository, a standard license-file location.

    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/LICENSE.txt


  • Documentação


    Suficiente para um badge!

    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).

    The project provides a README with installation, build, testing, Docker, package installation, template-generation, configuration, security, and usage guidance. It also publishes a structured DocFX documentation site covering setup, deployment, middleware, authentication, authorization, data access, API versioning, observability, health checks, and template packaging.

    README:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/README.md

    Published documentation:
    https://cdcavell.github.io/NetCoreApplicationTemplate/


    Suficiente para um badge!

    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).

    The project publishes generated DocFX API reference documentation for its public .NET types and members, including parameters, return types, and XML documentation. It also documents the consumer-facing template options, configuration sections, generated artifacts, routes, endpoint conventions, request versioning inputs, and response-version behavior.

    API reference:
    https://cdcavell.github.io/NetCoreApplicationTemplate/api/

    Public compatibility surface:
    https://cdcavell.github.io/NetCoreApplicationTemplate/articles/public-surface-v1.html

    API versioning and request interface:
    https://cdcavell.github.io/NetCoreApplicationTemplate/articles/api-versioning.html


  • Outro


    Suficiente para um badge!

    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 repository, published documentation, package distribution, release artifacts, and issue-tracking URLs are all provided over HTTPS.

    Repository:
    https://github.com/cdcavell/NetCoreApplicationTemplate

    Documentation:
    https://cdcavell.github.io/NetCoreApplicationTemplate/

    NuGet:
    https://www.nuget.org/packages/NetCoreApplicationTemplate

    Releases:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases


    Suficiente para um badge!

    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 uses GitHub Issues and Pull Requests for searchable, URL-addressable public discussion of defects, enhancements, proposed changes, and code contributions. New participants may open issues, submit pull requests, and comment through GitHub's web interface.

    Issues:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Pull requests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/pulls

    Support policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SUPPORT.md


    Suficiente para um badge!

    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.

    The project README, published documentation, contribution guide, support policy, security policy, source comments, issue templates, and pull-request workflow are written in English. The project accepts bug reports, feature requests, pull requests, and code-review comments in English through GitHub.

    Documentation:
    https://cdcavell.github.io/NetCoreApplicationTemplate/

    Contributing:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CONTRIBUTING.md

    Support:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SUPPORT.md


    Suficiente para um badge!

    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.

    NetCoreApplicationTemplate is actively maintained. The repository receives ongoing code, security, testing, documentation, workflow, and dependency updates. It has a current stable release, automated CI and security analysis, documented support expectations, and an active issue and pull-request workflow.

    Repository activity:
    https://github.com/cdcavell/NetCoreApplicationTemplate/commits/main/

    Releases:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases

    Support policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SUPPORT.md


 Controle de Mudanças 9/9 ●

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


    Suficiente para um badge!

    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 complete project source is maintained in a publicly readable GitHub repository using Git version control.

    Repository:
    https://github.com/cdcavell/NetCoreApplicationTemplate


    Suficiente para um badge!

    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 and GitHub. Its public commit history records each change, the contributor who authored or committed it, and the date and time it was made.

    Commit history:
    https://github.com/cdcavell/NetCoreApplicationTemplate/commits/main/


    Suficiente para um badge!

    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).

    The public repository contains ongoing development commits, branches, and pull requests between formal releases. These interim versions are available for review and are not limited to final release snapshots.

    Commit history:
    https://github.com/cdcavell/NetCoreApplicationTemplate/commits/main/

    Pull requests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/pulls

    Releases:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases


    Suficiente para um badge!

    É 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.

    Repository on GitHub, which uses git. git is distributed.


  • Numeração de versão única


    Suficiente para um badge!

    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).

    Each user-facing release has a unique version identifier. Version metadata is managed centrally for assemblies, NuGet packages, template packages, documentation, and GitHub releases.

    Current release:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases/tag/v2.3.1

    Release history:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases


    Suficiente para um badge!

    É 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).

    Suficiente para um badge!

    É 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]

    Each GitHub release is identified in the Git repository using a version tag following the v<major>.<minor>.<patch> convention. For example, release 2.3.1 is identified by tag v2.3.1.

    Current tagged release:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases/tag/v2.3.1

    Repository tags:
    https://github.com/cdcavell/NetCoreApplicationTemplate/tags


  • Notas de lançamento


    Suficiente para um badge!

    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.

    Each release includes human-readable release notes in CHANGELOG.md describing added, changed, fixed, and breaking behavior, along with upgrade or migration guidance and release-impact notes where applicable. GitHub Releases also provide version-specific release records.

    Changelog:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CHANGELOG.md

    GitHub Releases:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases


    Suficiente para um badge!

    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 NCAT release has yet fixed a publicly known vulnerability in the project’s own runtime code that had a CVE or similar public vulnerability identifier when the release was created. Therefore, there are currently no project vulnerability identifiers to list in the release notes.

    If a future release fixes such a vulnerability, its release notes will identify the CVE or equivalent public identifier and summarize the affected versions and remediation.


 Relatórios 8/8 ●

  • Processo de relato de bugs


    Suficiente para um badge!

    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]

    General bugs, documentation problems, packaging issues, and other reproducible defects may be reported through the project's public GitHub Issues tracker. Suspected security vulnerabilities use the separate private reporting process documented in SECURITY.md.

    Bug-reporting process:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SUPPORT.md#support-channels

    Issue tracker:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Security reports:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md


    Suficiente para um badge!

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

    The project uses GitHub Issues to track individual bugs, enhancements, documentation changes, packaging work, security-adjacent concerns, and other project tasks. Each issue has its own URL, status, history, assignees, comments, and related pull-request references.

    Issue tracker:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Documented issue workflow:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/CONTRIBUTING.md#issue-workflow


    Suficiente para um badge!

    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]

    At the time of this application, the project has acknowledged and completed the applicable issue reports submitted during the 2-to-12-month review window. The public tracker records assignment, status changes, closure, comments, and related implementation work.

    Applicable review-period issues:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues?q=is%3Aissue+created%3A2025-07-17..2026-05-17

    Open issues from that period:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues?q=is%3Aissue+is%3Aopen+created%3A2025-07-17..2026-05-17


    Suficiente para um badge!

    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.

    The project responds to and tracks enhancement requests through GitHub Issues. Applicable enhancement requests in the review period were implemented, closed as completed, superseded by later tracked work, or otherwise given a documented disposition.

    Issue archive:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Example enhancement response:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues/20


    Suficiente para um badge!

    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 publicly available, searchable archive of project reports and responses. Users can search and filter open and closed issues and review issue descriptions, comments, assignees, status changes, and linked pull requests.

    Public issue archive:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues

    Closed issue archive:
    https://github.com/cdcavell/NetCoreApplicationTemplate/issues?q=is%3Aissue+is%3Aclosed


  • Processo de relato de vulnerabilidades


    Suficiente para um badge!

    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.

    The project publishes a security policy describing how to report suspected vulnerabilities, what information to include, the supported release lines, disclosure expectations, and the security areas within project scope.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md


    Suficiente para um badge!

    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).

    The project supports confidential vulnerability reports through GitHub Private Vulnerability Reporting. Reporters are instructed not to open a public issue for suspected vulnerabilities.

    Private reporting form:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/advisories/new

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md#reporting-a-vulnerability


    Suficiente para um badge!

    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).

    No vulnerability reports were received by the project during the preceding six months, so there are no applicable initial response times to evaluate.


 Qualidade 13/13 ●

 Segurança 16/16 ●

  • Conhecimento de desenvolvimento seguro


    Suficiente para um badge!

    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's primary developer and maintainer understands and applies secure software design principles, including economy of mechanism, fail-safe defaults, complete mediation, open design, separation of privilege, least privilege, least common mechanism, psychological acceptability, limited attack surface, and allowlist-based input validation.

    These principles inform the project's secure-by-default configuration, middleware ordering, authorization architecture, narrowly scoped workflow permissions, production-safe error handling, security documentation, and review practices.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Security documentation:
    https://cdcavell.github.io/NetCoreApplicationTemplate/articles/authentication-hardening.html
    https://cdcavell.github.io/NetCoreApplicationTemplate/articles/production-deployment-checklist.html


    Suficiente para um badge!

    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's primary developer understands common vulnerability classes relevant to ASP.NET Core applications and appropriate countermeasures, including:

    • SQL and command injection: parameterized data access, avoiding command construction from untrusted input, and input validation.
    • Cross-site scripting: contextual output encoding, safe templating, Content Security Policy, and security headers.
    • Cross-site request forgery: antiforgery protections, secure cookie settings, and appropriate SameSite policies.
    • Missing or broken authentication and authorization: deny-by-default policies, complete authorization checks, least privilege, and secure session handling.
    • Sensitive-data and secret exposure: external secret storage, restricted permissions, rotation, scanning, and production-safe logging.
    • Proxy and forwarded-header spoofing: explicitly trusted proxies and networks with correct middleware ordering.
    • Denial of service and abusive requests: rate limiting, concurrency controls, request-size limits, and bounded processing.
    • Information leakage through errors: centralized exception handling and production-safe Problem Details responses.
    • Vulnerable dependencies and build pipelines: dependency review, lock files, automated scanning, pinned workflow actions, and maintainer review.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Project documentation:
    https://cdcavell.github.io/NetCoreApplicationTemplate/


  • 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.

    Suficiente para um badge!

    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 default scaffold uses established cryptographic mechanisms supplied by ASP.NET Core and .NET rather than private or project-specific algorithms. Cookie authentication is protected by ASP.NET Core Data Protection, whose default algorithms are AES-256-CBC for confidentiality and HMAC-SHA-256 for authentication. Optional external authentication is implemented through established cookie, OpenID Connect, SAML2, Microsoft, Google, and GitHub authentication handlers.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs

    Authentication hardening guidance:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/docs/articles/authentication-hardening.md


    Suficiente para um badge!

    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]

    NetCoreApplicationTemplate does not implement its own cryptographic primitives. It delegates authentication-cookie protection, protocol handling, token validation, certificate validation, and related cryptographic operations to ASP.NET Core, .NET, and the registered authentication-provider libraries.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs


    Suficiente para um badge!

    Toda funcionalidade no software produzido pelo projeto que depende de criptografia DEVE ser implementável usando FLOSS. [crypto_floss]
    Veja o Open Standards Requirement for Software by the Open Source Initiative.

    All cryptographic functionality required by the project can be implemented using the open-source .NET runtime and ASP.NET Core framework. The project does not require a proprietary cryptographic library or proprietary development environment.

    ASP.NET Core source:
    https://github.com/dotnet/aspnetcore

    .NET runtime source:
    https://github.com/dotnet/runtime


    Suficiente para um badge!

    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 built-in authentication-cookie protection mechanism uses ASP.NET Core Data Protection. Its defaults use AES-256-CBC, HMAC-SHA-256, and a rotating 512-bit master key, exceeding the applicable NIST minimum key-length requirements.

    NCAT does not expose an application setting that downgrades these cryptographic key lengths. Consuming applications can explicitly lock Data Protection to the approved built-in algorithms, and production TLS protocols and cipher policy can be restricted through Kestrel, the reverse proxy, or operating-system security policy.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs

    Authentication hardening:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/docs/articles/authentication-hardening.md


    Suficiente para um badge!

    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.

    NetCoreApplicationTemplate does not implement or depend by default on broken cryptographic algorithms such as MD4, MD5, single DES, RC4, or Dual_EC_DRBG.

    Cryptographic operations used for authentication cookies and related framework security features are delegated to ASP.NET Core and .NET. ASP.NET Core Data Protection uses AES-256-CBC with HMAC-SHA-256 authentication by default rather than project-defined cryptography.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs

    Authentication hardening guidance:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/docs/articles/authentication-hardening.md


    Suficiente para um badge!

    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 project's default security mechanisms do not depend on SHA-1, MD5, DES, RC4, unauthenticated encryption, CBC-mode SSH, or other cryptographic mechanisms with known serious weaknesses.

    ASP.NET Core Data Protection uses AES-256-CBC together with HMAC-SHA-256 authentication. It generates a per-operation key modifier and initialization vector, and the complete protected payload is authenticated by the HMAC. This is not the unauthenticated or SSH-specific CBC usage addressed by this criterion.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs


    Suficiente para um badge!

    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]

    NetCoreApplicationTemplate does not implement or directly configure a cryptographic key-agreement protocol. HTTPS/TLS key agreement is supplied by the hosting platform, Kestrel, web server, ingress controller, or reverse proxy selected by the consuming deployment.

    ASP.NET Core Data Protection protects application payloads and authentication cookies but is not a session key-agreement protocol. Therefore, perfect forward secrecy is not directly applicable to the project-owned cryptographic functionality.

    Production deployment guidance:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/docs/articles/authentication-hardening.md


    Suficiente para um badge!

    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.

    NetCoreApplicationTemplate does not implement external-user password registration, a password credential database, or password-based identity verification.

    The default Cookies scheme manages an authenticated session; it does not store or verify a user's password. Optional OpenID Connect, SAML2, Microsoft, Google, and GitHub providers delegate user authentication to external identity providers.

    Authentication documentation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/docs/articles/authentication.md


    Suficiente para um badge!

    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.

    NetCoreApplicationTemplate does not generate cryptographic keys, salts, initialization vectors, or nonces using application-defined random-number code. These operations are delegated to the cryptographic implementations in ASP.NET Core and .NET.

    ASP.NET Core Data Protection automatically generates and rotates its master keys and uses random per-operation key modifiers and initialization vectors or nonces for authenticated payload protection. No project-owned cryptographic operation uses System.Random or another non-cryptographic random generator.

    Authentication implementation:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/src/ProjectTemplate.Web/Authentication/Extensions/AuthenticationServiceExtensions.cs


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


    Suficiente para um badge!

    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.

    Project source, releases, documentation, NuGet packages, container images, and dependency feeds are delivered through HTTPS-protected services.

    Repository and releases:
    https://github.com/cdcavell/NetCoreApplicationTemplate
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases

    NuGet package:
    https://www.nuget.org/packages/NetCoreApplicationTemplate

    Container registry:
    https://github.com/cdcavell/NetCoreApplicationTemplate/pkgs/container/netcoreapplicationtemplate


    Suficiente para um badge!

    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 does not retrieve cryptographic hashes over plaintext HTTP for use as software-delivery verification.

    Source code, packages, dependencies, release artifacts, and container images are obtained from HTTPS-protected GitHub, NuGet, and GitHub Container Registry endpoints. No repository-owned installation or publishing process uses an HTTP-delivered checksum as a substitute for authenticated transport or signature verification.

    NuGet source configuration:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/nuget.config

    Release channels:
    https://github.com/cdcavell/NetCoreApplicationTemplate/releases


  • Vulnerabilidades conhecidas publicamente corrigidas


    Suficiente para um badge!

    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).

    At the time of this assessment, NetCoreApplicationTemplate has no known unpatched vulnerability of medium or higher severity that has been publicly known for more than 60 days.

    The project monitors dependencies and source changes through Dependabot, dependency review, CodeQL analysis, locked dependency restoration, and maintainer review. Security fixes are applied to the current stable release line.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Security overview:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security

    Dependabot alerts:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/dependabot


    Suficiente para um badge!

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

    No critical vulnerabilities are currently known to remain unpatched in NetCoreApplicationTemplate.

    Critical vulnerability reports are prioritized for immediate private triage, remediation, validation, and release through the project's documented security-reporting and release processes.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Private vulnerability reporting:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/advisories/new


  • Outras questões de segurança


    Suficiente para um badge!

    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.

    The public repository does not contain any known valid password, token, private key, certificate, or other credential intended to restrict public access.

    Real credentials are prohibited from repository files, workflow files, examples, documentation, screenshots, and committed logs. Secrets used by deployments or workflows must be stored through GitHub Actions secrets, environment variables, user secrets, or an appropriate external secret store.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Secret scanning:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/secret-scanning


 Análise 8/8 ●

  • Análise estática de código


    Suficiente para um badge!

    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 applies GitHub CodeQL static analysis to C# and GitHub Actions code before production releases. CodeQL runs through the CI workflow for pull requests targeting main, pushes to main, version tags matching v*.., and manual validation runs.

    CI workflow:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.github/workflows/ci.yml

    Code scanning results:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/code-scanning


    Suficiente para um badge!

    É 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'.

    The project uses GitHub CodeQL security queries for C# and GitHub Actions. CodeQL analyzes data flow, control flow, untrusted input, injection paths, authentication and authorization mistakes, information exposure, workflow-security weaknesses, and other common vulnerability patterns.

    CodeQL configuration:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.github/workflows/ci.yml

    Code scanning results:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/code-scanning


    Suficiente para um badge!

    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.

    At the time of this assessment, the project has no confirmed exploitable medium-or-higher severity CodeQL vulnerability that remains unresolved.

    Static-analysis findings are reviewed for applicability and severity. Confirmed exploitable findings of medium or higher severity are prioritized for remediation, testing, and release through the normal security and CI process.

    Code scanning results:
    https://github.com/cdcavell/NetCoreApplicationTemplate/security/code-scanning

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md


    Suficiente para um badge!

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

    CodeQL static analysis runs automatically for pull requests targeting main, including subsequent commits pushed to those pull requests, for pushes to main, and for version-tagged releases. This ensures proposed production changes are analyzed before merge and release.

    CI workflow:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.github/workflows/ci.yml


  • Análise dinâmica de código


    Suficiente para um badge!

    É 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 applies property-based dynamic analysis using FsCheck. The property tests execute project code with generated and varied string inputs, including empty values, whitespace, Unicode content, encoded characters, and unusual combinations.

    These tests run through the standard xUnit test suite in CI for pull requests targeting main, pushes to main, and version-tagged releases. This ensures proposed production releases are dynamically tested before release.

    Property-based tests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/tests/ProjectTemplate.Web.Tests/PersistenceStringPropertyTests.cs

    CI workflow:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.github/workflows/ci.yml


    Suficiente para um badge!

    É 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.

    NetCoreApplicationTemplate's project-owned application and test code is written in managed C# targeting .NET. It does not include project-owned C, C++, or another memory-unsafe implementation language requiring AddressSanitizer, Valgrind, or similar buffer-overwrite detection.

    Therefore, the memory-unsafe-language dynamic-analysis criterion is not applicable.


    Suficiente para um badge!

    É 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.

    The automated test configuration executes extensive xUnit assertions and FsCheck property assertions during dynamic testing.

    The property-based tests use QuickCheckThrowOnFailure so a violated invariant immediately fails the test run. The broader unit, integration, middleware, authentication, authorization, persistence, configuration, and generated-template tests likewise use test assertions and fail CI when expected behavior is not satisfied.

    Property-based tests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/tests/ProjectTemplate.Web.Tests/PersistenceStringPropertyTests.cs

    Automated tests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/tree/main/tests

    CI workflow:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/.github/workflows/ci.yml


    Suficiente para um badge!

    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.

    At the time of this assessment, no confirmed exploitable medium-or-higher severity vulnerability discovered through the project's automated tests or property-based dynamic analysis remains unresolved.

    Any confirmed exploitable dynamic-analysis finding of medium or higher severity is treated as a security defect and is prioritized for remediation, regression testing, and release through the documented security and CI process.

    Security policy:
    https://github.com/cdcavell/NetCoreApplicationTemplate/blob/main/SECURITY.md

    Automated tests:
    https://github.com/cdcavell/NetCoreApplicationTemplate/tree/main/tests



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 Christopher D. Cavell e aos contribuidores do selo de melhores práticas OpenSSF.

Entrada de selo do projeto de propriedade de: Christopher D. Cavell.
Entrada criada em 2026-07-17 16:50:56 UTC, última atualização em 2026-07-17 17:40:24 UTC. Selo de aprovação alcançado pela última vez em 2026-07-17 17:40:24 UTC.