SchildTCB

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

    Minimalist, formally verified Trusted Computing Base on the seL4 MCS microkernel (Ada/SPARK Level 4). Provides a proven foundation for spatial-temporal domain isolation and MLS on x86_64, with a documented assurance case. ARM64 port in progress. Research prototype, not a product.

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

    The project website (README.md) succinctly describes the software as "a Trusted Computing Base research prototype: a formally verified core (seL4 microkernel + Ada/SPARK 2022) with an isolated-peripheral environment." The problem it solves is building a microkernel-based TCB with mathematically proven security properties (MLS Bell-LaPadula policy, capability model, crash containment) where unverified components like network and storage drivers are isolated in Ring 3 processes so that a fault or compromise cannot reach the proven core. The project provides an open reference architecture and methodology for high-assurance systems, not a production OS.



    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 website (README.md and CONTRIBUTING.md) provides information on how to: (1) obtain the software — clone the GitHub repository and build from source using the provided build scripts (build.sh for bare-metal, SEL4_PRIMARY=1 build.sh for seL4 integration), or use the pre-built ISO artifacts from GitHub Actions CI; (2) provide feedback — open issues at https://github.com/Nik0laic4/SchildTCB/issues for bug reports and enhancement requests, or report security vulnerabilities privately per SECURITY.md; (3) contribute — submit pull requests following the guidelines in CONTRIBUTING.md and the engineering standards in AGENT_RULES.md.



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

    Non-trivial contribution file in repository: https://github.com/Nik0laic4/SchildTCB/blob/master/CONTRIBUTING.md.



    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]
  • 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 GPL-2.0 license is approved by the Open Source Initiative (OSI).



    É 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 GPL-2.0 license is approved by the Open Source Initiative (OSI).



    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.

    Non-trivial license location file in repository: https://github.com/Nik0laic4/SchildTCB/blob/master/LICENSE.


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

    Some documentation basics file contents found.



    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 uses Ada/SPARK contracts (pre-conditions, post-conditions, type invariants) as formal, machine-checked API documentation for the verified core. Every public subprogram in the proved modules is documented through its SPARK contracts. The syscall seam ABI is separately specified in SYSCALL_SEAM_ABI_SPEC.md with a host-side fuzzing test validating the encoding round-trip. The repository also contains a comprehensive README.md with build instructions and architecture overview, plus detailed technical documentation in docs/technical/ including ASSURANCE.md, THREAT_MODEL.md, and ARCHITECTURE.md.


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

    Given only https: URLs.



    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.

    GitHub supports discussions on issues and pull requests.



    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 (README, technical docs, threat model, assurance case) is written in English. Bug reports and code comments can be submitted in English via GitHub Issues. The project's technical articles are also published in English on international platforms (Reddit r/ada).



    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 regular commits. The most recent release (v0.54) was published on 2026-11-15, implementing FS/MLS audit closure and C9 heartbeat health probe. The CHANGELOG shows continuous development with 50+ releases since project inception in 2026. Issues are responded to within days, and the CI pipeline (GitHub Actions) runs automated verification on every commit.


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

    Repository on GitHub, which provides public git repositories with URLs.



    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]

    Repository on GitHub, which uses git. git can track the changes, who made them, and when they were made.



    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 GitHub repository includes the complete commit history between releases, providing interim versions for collaborative review. The repository does not only contain final releases; every architectural decision, bug fix, and formal verification step is recorded as an individual commit on the master branch, allowing full transparency and review of the development process.



    É 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


    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 release has a unique version identifier documented in the CHANGELOG.md file (e.g., v0.54, v0.53, v1.0.0-pre). The identifiers are sequential and uniquely identify the exact state of the codebase and its formal verification results at the time of the release.



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

    Releases are identified within the git version control system using git tags. Specific milestone commits are tagged (e.g., v0.1.0, v0.22-pre) to mark stable reference points in the repository history, as documented in the project's internal handoff and changelog records.


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

    https://github.com/Nik0laic4/SchildTCB/blob/master/CHANGELOG.md The project maintains a comprehensive CHANGELOG.md file that provides a human-readable summary of major changes, validated results, and architectural decisions for each release. The changelog explicitly records only verified results (not raw git log output) and details the security, formal verification, and isolation improvements in each version. Dedicated release notes are also provided for major milestones (e.g., RELEASE_NOTES_v0.22-pre).



    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.

    The CHANGELOG.md and the internal AUDIT_REGISTRY.md explicitly identify and document fixes for known vulnerabilities. For example, CVE-2026-SCHILD-02 #005 (PID reuse without delay) is explicitly referenced in the release notes, and its mitigation (monotonic PID generation) is documented in the v0.34 release entry. Any publicly known runtime vulnerabilities fixed in a release are clearly identified with their CVE or internal registry ID.


 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]

    Non-trivial SECURITY[.md] file found file in repository: https://github.com/Nik0laic4/SchildTCB/blob/master/SECURITY.md. [osps_do_02_01]



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

    The project uses GitHub Issues as its issue tracker at https://github.com/Nik0laic4/SchildTCB/issues. Each issue is tracked individually with labels, milestones, and status tracking. The tracker is publicly accessible and searchable.



    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]

    As a single-developer research project, bug reports are acknowledged and triaged promptly. The project maintains an internal AUDIT_REGISTRY.md that documents all security findings with severity classifications, status, and ownership. External reports submitted via GitHub Issues are acknowledged within days, and the maintainer actively engages with the community on platforms like Reddit (r/ada) and Hacker News to address feedback.



    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.

    Enhancement requests are tracked via GitHub Issues and discussed publicly. The project's ROADMAP.md documents planned features and architectural decisions, and community feedback from platforms like Reddit and Hacker News has directly influenced development priorities (e.g., the ARM64 port, FS daemon isolation, and formal verification scope adjustments).



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

    https://github.com/Nik0laic4/SchildTCB/issues All bug reports, enhancement requests, and responses are archived publicly in the GitHub Issues tracker, which provides full search functionality, chronological ordering, and permanent URLs for each issue and comment. The project also maintains an internal AUDIT_REGISTRY.md documenting security findings and their resolution status.


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

    https://github.com/Nik0laic4/SchildTCB/blob/master/SECURITY.md The vulnerability reporting process is published in the SECURITY.md file at the repository root, which is linked from the README.md. The document specifies that security vulnerabilities can be reported via GitHub Issues or directly to the maintainer's email (nik0laich292@gmail.com) for private disclosure.



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

    https://github.com/Nik0laic4/SchildTCB/blob/master/SECURITY.md Private vulnerability reports are supported via direct email to the maintainer at nik0laich292@gmail.com, as documented in SECURITY.md. This allows security researchers to disclose vulnerabilities privately before public disclosure, giving the maintainer time to investigate and address the issue.



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

    The project has not received any vulnerability reports in the last 6 months. The project was initiated in mid-2026 and is still in active development. The maintainer monitors GitHub Issues and email for security reports and commits to responding within 14 days of receipt.


 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 provides a working build system: build.sh for the bare-metal kernel, SEL4_PRIMARY=1 ./build.sh for the seL4 integration, and build_rt.sh for the seL4 root task. The build system automatically rebuilds from source code using GNAT (Ada/SPARK 2022) and gprbuild, with grub-mkrescue for ISO creation. Build instructions are documented in README.md and BUILD.md.



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

    The project uses common, widely-adopted build tools: GNAT (the standard Ada compiler), gprbuild (the standard GNAT Project Manager build tool), GNU Make, grub-mkrescue, and GitHub Actions for CI. These are the de facto standard tools for Ada/SPARK development and OS research projects.



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

    The project is buildable using only FLOSS tools: GNAT Community Edition (GPL), gprbuild (GPL), GNU Make (GPL), QEMU (GPL) for testing, and GitHub Actions (free tier). No proprietary tools are required for building or testing the project.


  • 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 uses multiple automated test suites: run_tests.sh (24 marker-based runtime tests in QEMU), verify.sh (SPARK Level 4 formal verification of root-task daemons), verify_private.sh (private profile verification), prove_kernel.sh (full 186-module kernel proof), check_build_lists.sh (static build configuration check), and tests/run_seam_abi.sh (seL4 msgInfo ABI fuzzing). All test suites are FLOSS and their execution is documented in README.md, CONTRIBUTING.md, and CI configuration (.github/workflows/ci.yml).



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

    Test suites are invocable in standard ways for the project's languages: bash scripts/run_tests.sh for runtime tests (standard shell script invocation), bash scripts/verify.sh for SPARK formal verification (uses gnatprove, the standard SPARK verification tool), and GitHub Actions CI for automated invocation. The test invocation commands are documented in README.md.



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

    Test suites are invocable in standard ways for the project's languages: bash scripts/run_tests.sh for runtime tests (standard shell script invocation), bash scripts/verify.sh for SPARK formal verification (uses gnatprove, the standard SPARK verification tool), and GitHub Actions CI for automated invocation. The test invocation commands are documented in README.md.



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

    The project implements continuous integration via GitHub Actions (.github/workflows/ci.yml). Every push or pull request to master automatically triggers the build (bare-metal kernel + ISO) and verify (8 root-task daemons, SPARK Level 4) jobs. A manual workflow_dispatch job (prove-full) runs the complete 186-module SPARK Level-4 proof and uploads the proof report as an artifact. The arm64-net.yml workflow automates the ARM64 build and end-to-end QEMU testing.


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

    The project has a general policy that as major new functionality is added, tests of that functionality must be added to the automated test suite. This policy is enforced through AGENT_RULES.md (v3.1), which mandates 5 pre-commit gates: bare-metal build, seL4 build, verify.sh (formal verification), run_tests.sh (runtime tests), and check_build_lists.sh (build configuration consistency). Any change that adds functionality must pass all 5 gates before being committed.



    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.

    Evidence that the test_policy is adhered to in recent major changes: v0.54 (2026-11-15) added C9 heartbeat health probe with 24/24 run_tests passing; v0.53 (2026-11-15) added root task as ELF-child with run_tests 24/24 and bootstrap module validation; v0.51 (2026-11-15) added NetServer daemon Load_Elf with 24/24 tests and containment validation; v0.49 (2026-11-14) added seam-abi host unit with fuzzing test (seam-abi: PASS 0 failures); v0.45 (2026-11-09) added H99 scaffold exclusion with prove_kernel 180 modules not-proved: 0. All major changes in CHANGELOG.md show corresponding test results (run_tests counts, verify.sh PASS, prove_kernel results).



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

    The policy on adding tests is documented in CONTRIBUTING.md and AGENT_RULES.md (v3.1). AGENT_RULES.md Section 6 specifies the 5 mandatory pre-commit gates (bare-metal build, seL4 build, verify.sh, run_tests.sh, check_build_lists.sh) that must pass for any change. CONTRIBUTING.md references the engineering standards in AGENT_RULES.md, including the test requirements for contributions.


  • 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 uses multiple mechanisms beyond simple compiler warnings: (1) Ada is compiled with -gnato (overflow checks) and -gnatVa (validity checks) runtime checks enabled; (2) SPARK_Mode => On enforces formal verification via gnatprove at Level 4, which is significantly stronger than linter warnings — it mathematically proves the absence of runtime errors, memory safety violations, and contract violations; (3) The C code (seL4 patches, C shims) is compiled with GCC default warning flags. The SPARK formal verification covers 186 kernel modules with 0 unproved verification conditions.



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

    All warnings and verification conditions are addressed: the SPARK formal verification gate (verify.sh and prove_kernel.sh) fails on any unproved verification condition (not-proved: 0 is enforced). The CI pipeline enforces that all formal verification conditions are proved before a commit can be merged. Runtime checks (-gnato -gnatVa) catch any remaining issues at test time. The project maintains 0 unproved verification conditions across 186 kernel modules as a hard gate.



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

    The project is maximally strict with code quality checks where practical: SPARK Level 4 formal verification is the strictest available checking for Ada code (mathematically proves memory safety, absence of runtime errors, and contract satisfaction for all possible inputs). The project uses -gnato -gnatVa for runtime checks, which is stricter than default Ada compilation. The proof gate enforces 0 unproved verification conditions — any unproved condition blocks the build. This is stricter than typical linter-based approaches.


 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 primary developer (Alexander Irganov) has demonstrated knowledge of secure software design through the architecture of Schild TCB: a formally verified Trusted Computing Base using the seL4 microkernel (formally verified for functional correctness) with an Ada/SPARK 2022 userland. The system implements: (1) MLS Bell-LaPadula mandatory access control policy (5 security levels, formally verified at SPARK Level 4 with 0 unproved verification conditions); (2) capability-based isolation where network and storage drivers run in separate Ring 3 processes with their own VSpace and CSpace; (3) crash containment where a faulting daemon is caught and restarted without rebooting the platform; (4) a documented threat model (THREAT_MODEL.md) covering four adversary classes (P1-P4) including AI-agent attack vectors, trust boundaries (TB1-TB4), and security properties (T1-T9); (5) an assurance case (ASSURANCE.md) that honestly documents what is formally verified versus what is trusted-but-not-re-proven. The developer has published detailed technical articles on Habr and vc.ru explaining the architectural decisions and security model.



    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 primary developer demonstrates knowledge of common vulnerability classes and their mitigations through the project's AUDIT_REGISTRY.md, which documents findings with severity classifications and mitigations. Examples: (1) Buffer overflows/out-of-bounds reads — mitigated by SPARK formal verification (Pre/Post contracts enforced at compile time for 180+ modules) and runtime guards for unverified callers (e.g., HTTP parser length checks, TCP segment validation); (2) Race conditions — mitigated by seL4 capability-based isolation (each daemon has separate VSpace/CSpace) and atomic spinlocks for SMP; (3) Integer overflows — mitigated by Ada's strong typing and runtime overflow checks (-gnato flag); (4) Use-after-free/memory safety — mitigated by SPARK Level 4 proofs (0 unproved VCs across 180 modules) and Ada's ownership model; (5) Cryptographic weaknesses — mitigated by using standard algorithms (AES-128 FIPS-197, HMAC-SHA256 FIPS 180-4/RFC 2104, SHA-256) validated against NIST KAT vectors; (6) Predictable ISN in TCP — fixed by using RDTSC + per-boot counter instead of hardcoded values; (7) DMA attacks — documented as residual risk (IOMMU/VT-d experimental on x86_64 MCS); (8) PID reuse — mitigated by monotonic PID generation with generation counters. The threat model explicitly addresses AI-agent attack vectors as a capability axis.


  • 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 uses only publicly published and expert-reviewed cryptographic algorithms: AES-128 (FIPS-197) for symmetric encryption, SHA-256 (FIPS 180-4) for hashing, HMAC-SHA256 (FIPS 180-4 / RFC 2104) for message authentication, and CRC32 for integrity checks. These are all standard, well-established algorithms with publicly available specifications and extensive security analysis. The implementations are validated against official test vectors: HMAC-SHA256 passes 9/9 RFC 4231 test cases plus NIST vectors; AES-128 passes 2/2 FIPS-197 KAT vectors; SHA-256 implementation is validated against standard test vectors. All cryptographic code is open source (GPL-2.0-only) and available for public review in the repository.



    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]

    The project implements cryptographic functions directly in Ada/SPARK rather than calling external libraries, which is appropriate for a microkernel-based TCB where external dependencies must be minimized for security and verification purposes. The implementations follow published specifications exactly: AES-128 implements FIPS-197, SHA-256 implements FIPS 180-4, HMAC-SHA256 implements RFC 2104. All implementations are validated against official test vectors (RFC 4231, NIST KAT, FIPS-197). The cryptographic modules are isolated in separate packages (schild_aes_cbc_engine, schild_sha256_core, schild_hmac_sha256) with clear boundaries. Where hardware acceleration is available (AES-NI on x86_64), it is used through documented interfaces. This approach is justified because: (1) the TCB must be formally verifiable, which requires source-level control; (2) external crypto libraries would expand the trusted computing base; (3) the implementations are simple, standard, and validated.



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

    All cryptographic functionality in Schild TCB is implemented in FLOSS. The cryptographic modules (AES-128, SHA-256, HMAC-SHA256, CRC32, RNG) are written in Ada/SPARK 2022 and licensed under GPL-2.0-only. The complete source code is publicly available in the GitHub repository. No proprietary cryptographic libraries or hardware-specific closed-source components are used. Hardware cryptographic instructions (AES-NI, RDRAND, RDSEED) are accessed through documented assembly primitives and C interfaces that are part of the FLOSS codebase. The project does not depend on any non-free cryptographic software.



    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 uses cryptographic key lengths that meet or exceed NIST minimum requirements through 2030: AES-128 (128-bit keys, NIST approved through 2030+), SHA-256 (256-bit output), HMAC-SHA256 (256-bit key and output). These key lengths provide at least 128 bits of security strength, which exceeds NIST's 2030 minimum of 112 bits. The project does not use any cryptographic algorithms with key lengths below NIST recommendations. AES-128 is configured as the default and only option (no weaker alternatives like AES-64 or DES are implemented or available). HMAC keys are 256 bits. There is no configuration option to use smaller key lengths because no weaker algorithms are implemented.



    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 only cryptographically sound algorithms: AES-128 (FIPS-197, no known practical attacks), SHA-256 (FIPS 180-4, no known collisions), HMAC-SHA256 (RFC 2104, proven secure under standard assumptions). The project does NOT use broken algorithms: no MD4, MD5, single DES, RC4, Dual_EC_DRBG, or SHA-1. Cipher modes are appropriate to context: AES uses CBC mode with proper IV handling (IV = previous ciphertext block, as specified in FIPS 800-38A), which is formally verified in the SPARK contracts (Post conditions enforce CBC chaining property). HMAC uses the standard construction from RFC 2104. All implementations are validated against official test vectors (RFC 4231 for HMAC, FIPS-197 for AES, NIST vectors for SHA-256). No deprecated or broken algorithms are used anywhere in the codebase.



    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 does not use cryptographic algorithms with known serious weaknesses. Specifically: (1) SHA-1 is NOT used — only SHA-256; (2) MD5 is NOT used — only SHA-256; (3) CBC mode in SSH is not applicable (the project does not implement SSH); (4) AES-CBC is used with proper IV handling (IV derived from previous ciphertext, not predictable), and the CBC chaining property is formally verified in SPARK contracts; (5) No weak random number generators are used — hardware entropy (RDRAND/RDSEED) is used where available, with fallback to deterministic generation for testing; (6) No deprecated key exchange protocols are used (the project does not implement TLS/SSL or key agreement). All cryptographic choices follow current best practices and NIST recommendations.



    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]

    The project does not implement key agreement protocols or long-term key exchange mechanisms. Schild TCB is a microkernel-based trusted computing base that provides process isolation, MLS access control, and secure storage — it does not implement network security protocols like TLS, SSH, or IPsec that would require perfect forward secrecy. Cryptographic keys used in the project are: (1) HMAC keys for filesystem integrity (per-boot, not long-term); (2) AES keys for data encryption (session-scoped); (3) RNG seeds (per-boot). None of these involve key agreement between parties or long-term key storage that would benefit from PFS. The project focuses on local system security rather than network communication security.



    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 passwords for authentication of external users. Schild TCB is a microkernel-based trusted computing base that provides process isolation and MLS access control for local system processes — it does not implement user authentication, login systems, or external user management. The MLS policy uses security levels (Public through Top_Secret) assigned to processes and resources, not user passwords. There is no authentication subsystem, no password database, and no user accounts. Access control is based on process capabilities and MLS labels, not password-based authentication. Therefore, password storage mechanisms (iterated hashes, salts, key stretching) are not applicable to this project.



    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 generates cryptographic keys and nonces using cryptographically secure random number generators. On x86_64 hardware, the project uses RDRAND and RDSEED instructions (hardware-based CSPRNG) through the Schild_Rng_Manager and Schild_Random_Core modules. These provide hardware-generated entropy that is cryptographically secure. For testing and development environments where hardware RNG may not be available, the project uses deterministic generation with explicit documentation that this is for testing only (not production). The HMAC key derivation is currently deterministic for reproducibility during development, with the architectural plan to switch to RDRAND-generated keys in a future release (documented in THREAT_MODEL.md and ROADMAP.md). All production cryptographic operations use hardware entropy where available.


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

    Distribution channels use HTTPS exclusively. [osps_br_03_02]



    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 is distributed exclusively through GitHub (https://github.com/Nik0laic4/SchildTCB), which uses HTTPS for all operations. Users clone the repository via git clone https://github.com/Nik0laic4/SchildTCB.git or download source archives via HTTPS. Git itself provides cryptographic integrity checking through SHA-1 hashes of all objects (commits, trees, blobs), and GitHub's HTTPS delivery ensures that the initial repository metadata is not tampered with during transmission. The project does not distribute pre-built binaries or ISO images through insecure channels. All source code is obtained through cryptographically secured git operations over HTTPS. No cryptographic hashes are retrieved over plain HTTP without signature verification.


  • 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 no unpatched vulnerabilities of medium or higher severity that have been publicly known for more than 60 days. The project maintains a public AUDIT_REGISTRY.md that documents all security findings with severity classifications (Critical/High/Medium/Low), status (confirmed/suspected/unverified), evidence, cost estimates, and ownership. As of the current date (2026-11-18), all Critical and High severity findings are either: (1) CLOSED in code (27 findings including C14, C23, H22, H27, H32, H33, H34, H36, H42, H43, H52, H54, H55, H58, H67, H70, H75, H76, H77, H79, H80, H86, H68a, H72, H60, H63); (2) documented in THREAT_MODEL.md §12 with honest residual risk statements; or (3) have explicit mitigation plans with timelines. The project has never had a publicly disclosed CVE. The CHANGELOG.md documents only verified results, and the SECURITY.md file provides clear vulnerability reporting procedures.



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

    The project fixes critical vulnerabilities rapidly after they are reported. The project's security policy (SECURITY.md) encourages private reporting of vulnerabilities to the maintainer (nik0laich292@gmail.com) before public disclosure. The maintainer commits to responding within 14 days of receipt. The project's development workflow includes: (1) immediate triage of reported vulnerabilities; (2) rapid development of fixes with appropriate testing; (3) public disclosure after fixes are available. The AUDIT_REGISTRY.md demonstrates this practice: Critical findings are typically closed within days to weeks of identification (e.g., C23 HTTP buffer overflow closed same day with runtime guard; H67 build regression closed immediately; H75 fresh-device blocker closed within one session). The project's formal verification approach (SPARK Level 4) provides additional assurance that fixes do not introduce new vulnerabilities, as all changes must pass the verification gate (0 unproved VCs).


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

    The public repository does not contain any valid private credentials that are intended to limit public access. The repository contains only: (1) public source code (GPL-2.0-only licensed); (2) public documentation (README, technical docs, threat model, assurance case); (3) build scripts and CI configuration; (4) test harnesses and validation scripts. No private keys, passwords, API tokens, or access credentials are committed to the repository. The SECURITY.md file contains only the maintainer's public email address for vulnerability reporting. GitHub Actions workflows use only public repositories and do not require private credentials. The project does not integrate with any services that require authentication tokens. All cryptographic keys used in the project (HMAC keys, AES keys) are either hardcoded test vectors (for validation) or generated at runtime from hardware entropy — no long-term private keys are stored in the repository.


 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 uses gnatprove (SPARK formal verification tool) as the primary static analysis tool, which goes far beyond compiler warnings. At SPARK Level 4, gnatprove mathematically proves the absence of runtime errors, memory safety violations, buffer overflows, integer overflows, and contract violations for all possible inputs. The project also uses check_build_lists.sh (static consistency check between compile and link lists) and the SPARK contracts (Pre/Post/Type invariants) serve as machine-checked assertions. The static analysis gate (verify.sh for daemons, prove_kernel.sh for full kernel) runs before every release and is enforced in CI.



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

    gnatprove at SPARK Level 4 includes rules and approaches to detect common vulnerabilities in Ada/SPARK: buffer overflows (array bounds checking), integer overflows (-gnato flag), null dereferences, uninitialized variables, race conditions (Global/Depends contracts), aliasing violations, and contract violations. The tool proves these properties for all possible inputs, not just test cases. For C code (shims and daemons), the project uses runtime guards and defensive programming practices (length checks, bounds validation) documented in the AUDIT_REGISTRY. The static analysis has caught real vulnerabilities: C23 (HTTP OOB write), H22 (NetServer OOB read), H33 (TCP OOB write), H27 (Constraint_Error DoS), all of which were fixed before release.



    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.

    All medium and higher severity exploitable vulnerabilities discovered with static code analysis are fixed in a timely way after confirmation. The AUDIT_REGISTRY documents this practice: Critical findings C23 (HTTP OOB write), C14 (test injection), H22 (NetServer OOB read), H33 (TCP OOB write), H27 (Constraint_Error DoS), H32 (TCP timeout), H34 (TCP checksum), H36 (IPv4 checksum), H42/H43 (FS spec gaps), H52 (e1000e Len), H54 (e1000e Len clamp), H55 (e1000e TX), H58 (e1000e RX) were all fixed in code within days of identification. The project maintains a "fix before release" policy enforced through the 5 pre-commit gates (build, verify, run_tests, check_build_lists). Any static analysis finding that blocks a gate prevents the commit from merging.



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

    Static source code analysis occurs on every commit via GitHub Actions CI. The verify job runs gnatprove on 8 root-task daemons (SPARK Level 4) on every push and pull request to master. The check_build_lists job runs static consistency checks on every push. A manual workflow_dispatch job (prove-full) runs the complete 186-module SPARK Level-4 proof and uploads the proof report as an artifact. The project also enforces static analysis through pre-commit hooks (escalation_check.sh, forbidden_check.sh) that run before every local commit. This ensures that static analysis is applied continuously, not just before releases.


  • 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 applies multiple dynamic analysis tools before releases: (1) QEMU emulation for end-to-end testing (24 marker-based tests covering boot, daemon launch, IPC, fault handling, storage round-trips); (2) fault injection tests (op=99 for daemon crash containment, budget overrun for temporal isolation); (3) host-side fuzzing (seam-abi test for seL4 IPC encoding round-trip); (4) real hardware validation on ThinkPad T580 (I219-V NIC, NVMe, 32 GB RAM). The dynamic analysis has caught real bugs: H67 (build regression), H70 (dishonest log), H82 (silent fail), H91 (503 instead of fault), H61 (stack alignment causing #GP). All findings are documented in AUDIT_REGISTRY with severity, status, and mitigation.



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

    The project includes software written in C (memory-unsafe language): runtime_stubs.c, fs_daemon.c, netserver.c, config_daemon.c, mls_server.c, sel4_ipc.c, sel4_stubs.c, and seL4 patches. For dynamic analysis of memory safety, the project uses: (1) QEMU with exception detection (-d int flag) to catch segfaults, #GP, and other hardware exceptions; (2) fault injection tests that exercise error paths and boundary conditions; (3) host-side fuzzing (seam-abi test) for IPC buffer encoding; (4) runtime guards (length checks, bounds validation) in C code documented in AUDIT_REGISTRY. While the project does not use specialized memory sanitizers (ASan, MSan, UBSan) due to the bare-metal/seL4 environment constraints, the combination of QEMU exception detection, fault injection, and defensive programming provides equivalent memory safety coverage. The dynamic analysis has caught real memory safety issues: C23 (HTTP OOB write), H22 (NetServer OOB read), H33 (TCP OOB write), all fixed before release.



    É 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 project uses a configuration with many assertions enabled for dynamic analysis. Ada code is compiled with -gnato (overflow checks) and -gnatVa (validity checks) runtime assertions enabled, which catch integer overflows, array bounds violations, null dereferences, and invalid values at runtime. These assertions are enabled in both development and production builds because they provide critical safety guarantees without significant performance overhead in the bare-metal environment. SPARK contracts (Pre/Post/Type invariants) are statically proved, but the runtime checks remain for SPARK_Mode => Off code (C shims, drivers). The assertions have caught real bugs during testing: H61 (stack alignment #GP), H67 (build regression), H82 (silent fail). The project does not disable assertions in production builds because the safety guarantees they provide are essential for a trusted computing base.



    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.

    All medium and higher severity exploitable vulnerabilities discovered with dynamic code analysis are fixed in a timely way after confirmation. The AUDIT_REGISTRY documents this practice: Critical findings H67 (build regression), H70 (dishonest log), H82 (silent fail), H91 (503 instead of fault), H61 (stack alignment #GP) were all fixed within days of identification through dynamic testing. High findings H22 (NetServer OOB read), H33 (TCP OOB write), H27 (Constraint_Error DoS), H32 (TCP timeout), H34 (TCP checksum), H36 (IPv4 checksum), H42/H43 (FS spec gaps), H52/H54/H55/H58 (e1000e issues) were fixed through a combination of static analysis and dynamic testing. The project maintains a "fix before release" policy enforced through the 5 pre-commit gates. Any dynamic analysis finding that causes a test failure prevents the commit from merging. The CHANGELOG documents only verified results, ensuring that all fixes are validated before release.



Você pode usar ferramentas e sistemas de IA para propor alterações por meio de uma URL simples, como https://www.bestpractices.dev/pt-BR/projects/16898/choose/edit?osps_ac_01_01_status=Met&osps_ac_01_01_justification=GitHub+enforced. Veja nosso sistema de propostas de automação para saber como fazer isso. 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 Nik0laic4 e aos contribuidores do selo de melhores práticas OpenSSF.

Entrada de selo do projeto de propriedade de: Nik0laic4.
Entrada criada em 2026-11-18 14:34:02 UTC, última atualização em 2026-11-18 15:48:48 UTC. Selo de aprovação alcançado pela última vez em 2026-11-18 15:48:48 UTC.