evidentia

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


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

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

        

 Fundamentos 17/17 ●

  • Geral

    Observe que outros projetos podem usar o mesmo nome.

    Open-source Python GRC tool: gap analysis, AI risk statements, OSCAL-first compliance automation. Enterprise-grade evidence integrity (Sigstore + GPG), CycloneDX SBOM, PyPI Trusted Publisher OIDC + PEP 740 attestations.

    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.

  • Pré-requisitos


    Suficiente para um badge!

    O projeto DEVE alcançar um distintivo de nível aprovado. [achieve_passing]

  • Conteúdo básico do site do projeto


    Suficiente para um badge!

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

    https://github.com/allenfbyrd/evidentia/blob/main/CONTRIBUTING.md


  • Supervisão do projeto


    Mal suficiente para um badge.

    O projeto DEVERIA ter um mecanismo legal onde todos os desenvolvedores de quantidades não triviais de software do projeto afirmem que estão legalmente autorizados a fazer essas contribuições. A abordagem mais comum e facilmente implementada para fazer isso é usando um Developer Certificate of Origin (DCO), onde os usuários adicionam "signed-off-by" em seus commits e o projeto faz link para o site do DCO. No entanto, isso PODE ser implementado como um Contributor License Agreement (CLA) ou outro mecanismo legal. (URL obrigatória) [dco]
    O DCO é o mecanismo recomendado porque é fácil de implementar, rastreado no código-fonte e o git suporta diretamente um recurso "signed-off" usando "commit -s". Para ser mais eficaz, é melhor que a documentação do projeto explique o que "signed-off" significa para aquele projeto. Um CLA é um acordo legal que define os termos sob os quais obras intelectuais foram licenciadas para uma organização ou projeto. Um contributor assignment agreement (CAA) é um acordo legal que transfere direitos em uma obra intelectual para outra parte; os projetos não são obrigados a ter CAAs, já que ter CAA aumenta o risco de que contribuidores potenciais não contribuam, especialmente se o receptor for uma organização com fins lucrativos. Os CLAs da Apache Software Foundation (a licença de contribuidor individual e o CLA corporativo) são exemplos de CLAs, para projetos que determinam que os riscos desses tipos de CLAs para o projeto são menores do que seus benefícios.

    Single-maintainer project. All commits to date are authored by the project owner (Allen Byrd) under copyright explicitly granted to the project under Apache-2.0. A formal DCO/CLA flow will be adopted at the point a second contributor is onboarded; for now, the legal-authority chain is degenerate (one author = one signer). Apache-2.0 LICENSE: https://github.com/allenfbyrd/evidentia/blob/main/LICENSE.


    Suficiente para um badge!

    O projeto DEVE definir e documentar claramente seu modelo de governança do projeto (a forma como toma decisões, incluindo papéis-chave). (URL obrigatória) [governance]
    É necessário haver alguma forma bem estabelecida e documentada de tomar decisões e resolver disputas. Em projetos pequenos, isso pode ser tão simples quanto "o proprietário do projeto e líder toma todas as decisões finais". Existem vários modelos de governança, incluindo ditador benevolente e meritocracia formal; para mais detalhes, consulte Modelos de governança. Tanto abordagens centralizadas (por exemplo, mantenedor único) quanto descentralizadas (por exemplo, grupo de mantenedores) foram usadas com sucesso em projetos. As informações de governança não precisam documentar a possibilidade de criar um fork do projeto, já que isso é sempre possível para projetos FLOSS.

    Project governance is documented in GOVERNANCE.md: https://github.com/allenfbyrd/evidentia/blob/main/GOVERNANCE.md. Current model: BDFL (benevolent dictator for life) — Allen Byrd holds final decision authority. Roadmap is published in docs/ROADMAP.md and per-release plans (docs/v0.7.x-plan.md). Decisions on technical direction, scope, and breaking changes are made openly via GitHub Issues and PR discussion.


    Suficiente para um badge!

    O projeto DEVE adotar um código de conduta e publicá-lo em um local padrão. (URL obrigatória) [code_of_conduct]
    Os projetos podem ser capazes de melhorar a civilidade de sua comunidade e estabelecer expectativas sobre conduta aceitável adotando um código de conduta. Isso pode ajudar a evitar problemas antes que ocorram e tornar o projeto um lugar mais acolhedor para encorajar contribuições. Isso deve se concentrar apenas no comportamento dentro da comunidade/local de trabalho do projeto. Exemplos de códigos de conduta são o código de conduta do kernel Linux, o Contributor Covenant Code of Conduct, o Código de Conduta Debian, o Código de Conduta Ubuntu, o Código de Conduta Fedora, o Código de Conduta GNOME, o Código de Conduta da Comunidade KDE, o Código de Conduta da Comunidade Python, A Diretriz de Conduta da Comunidade Ruby e O Código de Conduta do Rust.

    Contributor Covenant v2.1 adopted at https://github.com/allenfbyrd/evidentia/blob/main/CODE_OF_CONDUCT.md. Reporting channel and enforcement guidelines documented inline.


    Suficiente para um badge!

    O projeto DEVE definir e documentar publicamente de forma clara os papéis-chave no projeto e suas responsabilidades, incluindo quaisquer tarefas que esses papéis devem executar. DEVE estar claro quem tem qual(is) papel(is), embora isso possa não ser documentado da mesma forma. (URL obrigatória) [roles_responsibilities]
    A documentação para governança e papéis e responsabilidades pode estar em um único lugar.

    Roles and responsibilities documented in GOVERNANCE.md: https://github.com/allenfbyrd/evidentia/blob/main/GOVERNANCE.md. Current roles: Maintainer (Allen Byrd) — owns all merge authority, release authority, and security disclosure handling. As collaborators join, a "Triager" role (issue triage, PR review) and "Catalog Curator" role (Tier-A/B/C catalog updates) will be defined explicitly.


    Suficiente para um badge!

    O projeto DEVE ser capaz de continuar com interrupção mínima se qualquer pessoa morrer, ficar incapacitada ou, de outra forma, não puder ou não quiser continuar o suporte do projeto. Em particular, o projeto DEVE ser capaz de criar e fechar issues, aceitar mudanças propostas e lançar versões do software, dentro de uma semana após a confirmação da perda de suporte de qualquer indivíduo. Isso PODE ser feito garantindo que outra pessoa tenha quaisquer chaves, senhas e direitos legais necessários para continuar o projeto. Indivíduos que executam um projeto FLOSS PODEM fazer isso fornecendo chaves em um cofre e um testamento fornecendo quaisquer direitos legais necessários (por exemplo, para nomes DNS). (URL obrigatória) [access_continuity]

    Concrete continuity plan documented at https://github.com/allenfbyrd/evidentia/blob/main/docs/access-continuity.md. Key elements:

    • Operational SLA: project commits to resuming normal operations (create + close issues, accept proposed changes, release versions) within 7 calendar days of confirmation of loss of support.
    • Keyless signing infrastructure (Sigstore PEP 740 + Trusted Publisher OIDC + cosign keyless) means no offline private keys exist that could be lost with the maintainer. Any successor with repo write access can continue releases without any key transfer.
    • Step-by-step recovery procedure (Step 1 confirm loss; Step 2 GitHub repo + organization access via account-recovery OR fork-and-redirect fallback; Step 3 PyPI project-owner-role transfer; Step 4 GHCR access; Step 5 DNS / domain registrar — none currently held; Step 6 first release post-transfer).
    • Named successor + emergency contact maintained in the maintainer's encrypted password manager + emergency-access designation + will / estate documents. Public disclosure of the successor identity is intentionally avoided per the doc's privacy rationale (avoids social-engineering attempts to claim the project; preserves the maintainer's flexibility to update the designation as relationships change). The OpenSSF criterion text doesn't require public disclosure of the successor identity — it requires that the project MUST be able to continue, which the public doc + the private-side designation jointly accomplish. Auditors can verify the private-side designation exists by direct contact with the maintainer (see SECURITY.md disclosure channel).
    • Plan reviewed at every release per release-checklist.md Step 5 + on a quarterly cadence regardless of release activity.

    Companion governance framing at https://github.com/allenfbyrd/evidentia/blob/main/GOVERNANCE.md §"Continuity and bus factor".


    Mal suficiente para um badge.

    O projeto DEVERIA ter um "bus factor" de 2 ou mais. (URL obrigatória) [bus_factor]
    Um "bus factor" (também conhecido como "truck factor") é o número mínimo de membros do projeto que precisam desaparecer repentinamente de um projeto ("ser atropelados por um ônibus") antes que o projeto pare devido à falta de pessoal conhecedor ou competente. A ferramenta truck-factor pode estimar isso para projetos no GitHub. Para mais informações, consulte Assessing the Bus Factor of Git Repositories de Cosentino et al.

    Current bus factor is 1 (single maintainer - Allen Byrd). Mitigation: keyless signing infrastructure (no offline keys to lose), Trusted Publisher OIDC bound to the repo (any maintainer with repo write can publish), all process documented in https://github.com/allenfbyrd/evidentia/blob/main/docs/release-checklist.md. Project is in early growth phase; second maintainer will be recruited as the contributor base develops.


  • Documentação


    Suficiente para um badge!

    O projeto DEVE ter um roadmap documentado que descreva o que o projeto pretende fazer e não fazer por pelo menos o próximo ano. (URL obrigatória) [documentation_roadmap]
    O projeto pode não alcançar o roadmap, e isso é aceitável; o objetivo do roadmap é ajudar usuários e contribuidores potenciais a entender a direção pretendida do projeto. Não precisa ser detalhado.

    Roadmap is documented at https://github.com/allenfbyrd/evidentia/blob/main/docs/ROADMAP.md with detailed per-release plans for the v0.7.x line: docs/v0.7.5-plan.md through docs/v0.7.9-plan.md (8-10 week ship target each). v0.8.0 plan also published (https://github.com/allenfbyrd/evidentia/blob/main/docs/v0.8.0-plan.md). Combined horizon exceeds 1 year.


    Suficiente para um badge!

    O projeto DEVE incluir documentação da arquitetura (também conhecida como design de alto nível) do software produzido pelo projeto. Se o projeto não produz software, selecione "não aplicável" (N/A). (URL obrigatória) [documentation_architecture]
    Uma arquitetura de software explica as estruturas fundamentais de um programa, ou seja, os principais componentes do programa, os relacionamentos entre eles e as principais propriedades desses componentes e relacionamentos.

    Canonical architecture document is https://github.com/allenfbyrd/evidentia/blob/main/Evidentia-Architecture-and-Implementation-Plan.md covering the 6-package monorepo structure, OSCAL-first data model, AI integration patterns, collector + integration architecture, and security boundaries. Capability matrix (https://github.com/allenfbyrd/evidentia/blob/main/docs/capability-matrix.md) covers the public surface inventory across 5 surface tiers and 5 risk tiers.


    Suficiente para um badge!

    O projeto DEVE documentar o que o usuário pode e não pode esperar em termos de segurança do software produzido pelo projeto (seus "requisitos de segurança"). (URL obrigatória) [documentation_security]
    Estes são os requisitos de segurança que o software deve atender.

    Security requirements and threat boundary documented in https://github.com/allenfbyrd/evidentia/blob/main/docs/threat-model.md (~58 surfaces across 5 tiers including the v0.7.9 TPRM + vendor-risk-collector additions; explicit in-scope/out-of-scope; assumed-trust assumptions). Per-release security review (most recent: https://github.com/allenfbyrd/evidentia/blob/main/docs/security-review-v0.7.9.md) gives a CVSS/CWE/EPSS-classified view of the active surface. SECURITY.md (https://github.com/allenfbyrd/evidentia/blob/main/SECURITY.md) defines disclosure SLAs and supported-version policy with the supported-versions table refreshed at every release.


    Suficiente para um badge!

    O projeto DEVE fornecer um guia de "início rápido" para novos usuários para ajudá-los a fazer algo rapidamente com o software. (URL obrigatória) [documentation_quick_start]
    A ideia é mostrar aos usuários como começar e fazer o software fazer qualquer coisa. Isso é extremamente importante para que potenciais usuários comecem.

    90-second quickstart at https://github.com/allenfbyrd/evidentia/blob/main/docs/quickstart.md. README also has a "Getting Started" section with a 4-step install + first-gap-analysis flow.


    Suficiente para um badge!

    O projeto DEVE fazer um esforço para manter a documentação consistente com a versão atual dos resultados do projeto (incluindo software produzido pelo projeto). Quaisquer defeitos de documentação conhecidos que a tornem inconsistente DEVEM ser corrigidos. Se a documentação estiver geralmente atualizada, mas erroneamente incluir algumas informações antigas que não são mais verdadeiras, trate isso apenas como um defeito, então rastreie e corrija como de costume. [documentation_current]
    A documentação PODE incluir informações sobre diferenças ou mudanças entre versões do software e/ou link para versões antigas da documentação. A intenção deste critério é que um esforço seja feito para manter a documentação consistente, não que a documentação deva ser perfeita.

    Documentation is refreshed every release per docs/release-checklist.md Step 4 (DOC refresh). Version-pinned docs live alongside per-release plan files (docs/v0.7.x-plan.md through docs/v0.7.9-plan.md + docs/v0.8.0-plan.md). All v0.7.9-era staleness items were closed at v0.7.9 ship time: CHANGELOG [Unreleased] gaps for in-flight commits (commit 3315150), README collectors row (Vanta/Drata/BitSight/SSC + Databricks/Snowflake/SQL/Okta), ROADMAP NEXT/PLANNED → SHIPPED for v0.7.5/v0.7.6/v0.7.7, evidentia-collectors pyproject description + keywords. Two earlier-flagged stale strings (CONTRIBUTING.md test count, SECURITY.md supported-versions table) shipped in v0.7.9 P0.6 OpenSSF Silver-tier prep batch (commit 6f862eb).


    Suficiente para um badge!

    A página inicial do repositório do projeto e/ou site DEVE identificar e criar hiperlinks para quaisquer conquistas, incluindo este selo de melhores práticas, dentro de 48 horas do reconhecimento público de que a conquista foi alcançada. (URL obrigatória) [documentation_achievements]
    Uma conquista é qualquer conjunto de critérios externos que o projeto trabalhou especificamente para atender, incluindo alguns selos. Esta informação não precisa estar na página inicial do site do projeto. Um projeto usando o GitHub pode colocar conquistas na página inicial do repositório adicionando-as ao arquivo README.

    Project achievements (OpenSSF Best Practices badge, OpenSSF Scorecard) are surfaced in the badge cluster at the top of the README: https://github.com/allenfbyrd/evidentia/blob/main/README.md. Live badge embed: OpenSSF Best Practices.


  • Acessibilidade e internacionalização


    Suficiente para um badge!

    O projeto (tanto os sites do projeto quanto os resultados do projeto) DEVERIA seguir as melhores práticas de acessibilidade para que pessoas com deficiências ainda possam participar do projeto e usar os resultados do projeto quando for razoável fazê-lo. [accessibility_best_practices]
    Para aplicações web, veja as Diretrizes de Acessibilidade para Conteúdo Web (WCAG 2.0) e seu documento de apoio Understanding WCAG 2.0; veja também informações de acessibilidade do W3C. Para aplicações GUI, considere usar as diretrizes de acessibilidade específicas do ambiente (como Gnome, KDE, XFCE, Android, iOS, Mac e Windows). Algumas aplicações TUI (por exemplo, programas `ncurses`) podem fazer certas coisas para se tornarem mais acessíveis (como a configuração `force-arrow-cursor` do `alpine`). A maioria das aplicações de linha de comando são bastante acessíveis como estão. Este critério é frequentemente N/A, por exemplo, para bibliotecas de programas. Aqui estão alguns exemplos de ações a tomar ou questões a considerar:
    • Forneça alternativas de texto para qualquer conteúdo não textual para que possa ser transformado em outras formas que as pessoas precisam, como letras grandes, braille, fala, símbolos ou linguagem mais simples (diretriz WCAG 2.0 1.1)
    • A cor não é usada como o único meio visual de transmitir informações, indicar uma ação, solicitar uma resposta ou distinguir um elemento visual. (diretriz WCAG 2.0 1.4.1)
    • A apresentação visual de texto e imagens de texto tem uma razão de contraste de pelo menos 4.5:1, exceto para texto grande, texto incidental e logotipos (diretriz WCAG 2.0 1.4.3)
    • Torne toda a funcionalidade disponível a partir de um teclado (diretriz WCAG 2.1)
    • Um projeto GUI ou baseado na web DEVERIA testar com pelo menos um leitor de tela nas plataformas de destino (por exemplo, NVDA, Jaws ou WindowEyes no Windows; VoiceOver no Mac & iOS; Orca no Linux/BSD; TalkBack no Android). Programas TUI PODEM trabalhar para reduzir o redesenho para evitar leitura redundante por leitores de tela.

    Public surfaces: GitHub repo + GitHub Pages (none yet) + the evidentia-ui SPA (alpha.2). The evidentia-ui frontend uses standard semantic HTML (React + accessible component primitives), keyboard-navigable forms, and ARIA labels on interactive elements. CLI output is plain text (screen-reader friendly by definition; no animated/colored-only UX). Documentation is plain Markdown rendered by GitHub (which provides standard a11y rendering). A formal WCAG 2.1 AA audit of evidentia-ui is planned for v0.8.0+.


    Suficiente para um badge!

    O software produzido pelo projeto DEVERIA ser internacionalizado para permitir fácil localização para a cultura, região ou idioma do público-alvo. Se a internacionalização (i18n) não se aplicar (por exemplo, o software não gera texto destinado a usuários finais e não classifica texto legível por humanos), selecione "não aplicável" (N/A). [internationalization]
    Localização "refere-se à adaptação de um produto, aplicação ou conteúdo de documento para atender aos requisitos de idioma, cultura e outros de um mercado-alvo específico (um locale)". Internacionalização é o "projeto e desenvolvimento de um produto, aplicação ou conteúdo de documento que permite fácil localização para públicos-alvo que variam em cultura, região ou idioma". (Veja "Localization vs. Internationalization" do W3C.) O software atende a este critério simplesmente sendo internacionalizado. Nenhuma localização para outro idioma específico é necessária, pois uma vez que o software foi internacionalizado, é possível para outros trabalharem na localização.

    Evidentia produces compliance artifacts (OSCAL JSON/XML, gap reports, risk statements) — its end-user output is structured data targeting US/EU regulatory frameworks (NIST 800-53, ISO 27001, SOC 2, FedRAMP, FFIEC, OCC 2011-12, FRB SR 11-7) which are themselves authored in English. The CLI's operator-facing strings (help text, errors) are in English and intended for technical operators. There is no localized end-user text generation path that would benefit from i18n. The 89 bundled catalogs ship in their authoritative source language (English).


  • Outro


    Suficiente para um badge!

    Se os sites do projeto (site, repositório e URLs de download) armazenam 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). Se os sites do projeto não armazenam senhas para este propósito, selecione "não aplicável" (N/A). [sites_password_security]
    Observe que o uso do GitHub atende a este critério. Este critério aplica-se apenas a senhas usadas para autenticação de usuários externos nos sites do projeto (também conhecida como autenticação de entrada). Se os sites do projeto precisam fazer login em outros sites (também conhecida como autenticação de saída), eles podem precisar armazenar tokens de autorização para esse propósito de forma diferente (já que armazenar um hash seria inútil). Isso aplica o critério crypto_password_storage aos sites do projeto, semelhante a sites_https.

    Project sites do not store user passwords. GitHub repo handles its own auth; bestpractices.dev account is on the OpenSSF service; PyPI publishing is via Trusted Publisher OIDC (no API tokens stored). Evidentia OSS edition does not provide a public auth surface that would require password storage.


 Controle de Mudanças 1/1 ●

  • Versões anteriores


    Suficiente para um badge!

    O projeto DEVE manter as versões mais antigas do produto mais frequentemente usadas ou fornecer um caminho de atualização para versões mais recentes. Se o caminho de atualização for difícil, o projeto DEVE documentar como realizar a atualização (por exemplo, as interfaces que mudaram e etapas sugeridas detalhadas para ajudar na atualização). [maintenance_or_update]

    Upgrade path is documented in CHANGELOG.md (https://github.com/allenfbyrd/evidentia/blob/main/CHANGELOG.md) with per-release "Changed", "Fixed", "Removed" sections following Keep a Changelog 1.1.0. SemVer adherence (pre-1.0: minor bumps for new feature surface, patches for fixes) means breaking changes carry an explicit Deprecation notice in the prior release. Supported-versions matrix documented in SECURITY.md. Older versions remain installable from PyPI for the duration of their security-supported window.


 Relatórios 3/3 ●

  • Processo de relato de bugs


    Suficiente para um badge!

    O projeto DEVE usar um rastreador de questões para rastrear questões individuais. [report_tracker]

    GitHub Issues is the project's issue tracker: https://github.com/allenfbyrd/evidentia/issues. Issue templates for bug reports and feature requests live at https://github.com/allenfbyrd/evidentia/tree/main/.github/ISSUE_TEMPLATE.


  • Processo de relato de vulnerabilidades


    Suficiente para um badge!

    O projeto DEVE dar crédito ao(s) relator(es) de todos os relatórios de vulnerabilidade resolvidos nos últimos 12 meses, exceto para o(s) relator(es) que solicitarem anonimato. Se não houve vulnerabilidades resolvidas nos últimos 12 meses, selecione "não aplicável" (N/A). (URL obrigatória) [vulnerability_report_credit]

    No external vulnerability reports have been received in the last 12 months. Upstream-CVE remediations (e.g., PR #8 addressing litellm + python-multipart) credited the upstream advisory IDs (GHSA-r75f-5x8p-qvmc + 3 others) in the commit + CHANGELOG entry. A "Security Acknowledgments" section will be added to SECURITY.md the first time an external reporter is involved.


    Suficiente para um badge!

    O projeto DEVE ter um processo documentado para responder a relatos de vulnerabilidades. (URL obrigatória) [vulnerability_response_process]
    Isso está fortemente relacionado a vulnerability_report_process, que exige que haja uma forma documentada de relatar vulnerabilidades. Também está relacionado a vulnerability_report_response, que exige resposta a relatos de vulnerabilidades dentro de um determinado prazo.

    Vulnerability response process is documented in https://github.com/allenfbyrd/evidentia/blob/main/SECURITY.md with: 3-business-day initial acknowledgement SLA, 10-business-day triage SLA, 90-day coordinated disclosure window (shortenable if upstream fixes exist, lengthenable by reporter agreement), in-scope and out-of-scope definitions, supported-versions matrix, and pointers to PEP 740 attestation + Sigstore/Rekor verification commands. Internal handling steps (triage → fix → CVE assignment → coordinated release → post-mortem) are documented in docs/release-checklist.md.


 Qualidade 19/19 ●

  • Padrões de codificação


    Suficiente para um badge!

    O projeto DEVE identificar os guias de estilo de codificação específicos para as linguagens primárias que utiliza, e exigir que as contribuições geralmente estejam em conformidade com eles. (URL obrigatória) [coding_standards]
    Na maioria dos casos, isso é feito referenciando algum(ns) guia(s) de estilo existente(s), possivelmente listando diferenças. Esses guias de estilo podem incluir maneiras de melhorar a legibilidade e maneiras de reduzir a probabilidade de defeitos (incluindo vulnerabilidades). Muitas linguagens de programação têm um ou mais guias de estilo amplamente utilizados. Exemplos de guias de estilo incluem guias de estilo do Google e Padrões de Codificação SEI CERT.

    Coding standards are documented in CONTRIBUTING.md (https://github.com/allenfbyrd/evidentia/blob/main/CONTRIBUTING.md) and ruff config (https://github.com/allenfbyrd/evidentia/blob/main/pyproject.toml): Python 3.12+ following PEP 8 (enforced by ruff E/W rules), PEP 257 docstrings, isort import ordering (ruff I), pyflakes hygiene (F), pyupgrade modernization (UP), flake8-bugbear common-bug rules (B), flake8-simplify simplifications (SIM). Type annotations are required everywhere (mypy strict). Pydantic v2 models for all external inputs (extra="forbid"). TypeScript frontend uses ESLint + Prettier (config in packages/evidentia-ui/).


    Suficiente para um badge!

    O projeto DEVE aplicar automaticamente seu(s) estilo(s) de codificação selecionado(s) se houver pelo menos uma ferramenta FLOSS que possa fazer isso na(s) linguagem(ns) selecionada(s). [coding_standards_enforced]
    Isso PODE ser implementado usando ferramenta(s) de análise estática e/ou forçando o código através de reformatadores de código. Em muitos casos, a configuração da ferramenta está incluída no repositório do projeto (já que projetos diferentes podem escolher configurações diferentes). Os projetos PODEM permitir exceções de estilo (e normalmente permitirão); onde ocorrem exceções, elas DEVEM ser raras e documentadas no código em suas localizações, para que essas exceções possam ser revisadas e para que as ferramentas possam tratá-las automaticamente no futuro. Exemplos de tais ferramentas incluem ESLint (JavaScript), Rubocop (Ruby) e devtools check (R).

    ruff (Python) + mypy strict (Python types) + ESLint (TypeScript) + Prettier (TypeScript formatting) all enforced as required CI status checks on every push and PR via https://github.com/allenfbyrd/evidentia/blob/main/.github/workflows/test.yml. Pre-commit hooks (https://github.com/allenfbyrd/evidentia/blob/main/.pre-commit-config.yaml) catch issues before commit-time.


  • Sistema de compilação funcional


    Suficiente para um badge!

    Os sistemas de compilação para binários nativos DEVEM honrar as variáveis de compilador e vinculador (ambiente) relevantes passadas para eles (por exemplo, CC, CFLAGS, CXX, CXXFLAGS e LDFLAGS) e passá-las para invocações de compilador e vinculador. Um sistema de compilação PODE estendê-las com flags adicionais; ele NÃO DEVE simplesmente substituir valores fornecidos pelos seus próprios. Se nenhum binário nativo estiver sendo gerado, selecione "não aplicável" (N/A). [build_standard_variables]
    Deve ser fácil habilitar recursos especiais de compilação como Address Sanitizer (ASAN), ou cumprir as melhores práticas de proteção de distribuição (por exemplo, ativando facilmente flags de compilador para fazê-lo).

    Pure Python + TypeScript, no native binaries.


    Suficiente para um badge!

    O sistema de compilação e instalação DEVERIA preservar informações de depuração se elas forem solicitadas nas flags relevantes (por exemplo, "install -s" não é usado). Se não houver sistema de compilação ou instalação (por exemplo, bibliotecas JavaScript típicas), selecione "não aplicável" (N/A). [build_preserve_debug]
    Por exemplo, definir CFLAGS (C) ou CXXFLAGS (C++) deve criar as informações de depuração relevantes se essas linguagens forem usadas, e elas não devem ser removidas durante a instalação. Informações de depuração são necessárias para suporte e análise, e também úteis para medir a presença de recursos de proteção nos binários compilados.

    Pure Python; debug info is implicit via traceback.


    Suficiente para um badge!

    O sistema de compilação do software produzido pelo projeto NÃO DEVE compilar recursivamente subdiretórios se houver dependências cruzadas nos subdiretórios. Se não houver sistema de compilação ou instalação (por exemplo, bibliotecas JavaScript típicas), selecione "não aplicável" (N/A). [build_non_recursive]
    As informações de dependência interna do sistema de compilação do projeto precisam ser precisas, caso contrário, mudanças no projeto podem não compilar corretamente. Compilações incorretas podem levar a defeitos (incluindo vulnerabilidades). Um erro comum em sistemas de compilação grandes é usar uma "compilação recursiva" ou "make recursivo", isto é, uma hierarquia de subdiretórios contendo arquivos fonte, onde cada subdiretório é compilado independentemente. A menos que cada subdiretório seja totalmente independente, isso é um erro, porque as informações de dependência estão incorretas.

    uv workspace builds packages atomically; no recursive Make pattern.


    Suficiente para um badge!

    O projeto DEVE ser capaz de repetir o processo de geração de informações a partir de arquivos fonte e obter exatamente o mesmo resultado bit a bit. Se nenhuma compilação ocorrer (por exemplo, linguagens de script onde o código fonte é usado diretamente em vez de ser compilado), selecione "não aplicável" (N/A). [build_repeatable]
    Usuários de GCC e clang podem achar útil a opção -frandom-seed; em alguns casos, isso pode ser resolvido forçando algum tipo de ordenação. Mais sugestões podem ser encontradas no site reproducible build.

    Builds are deterministic given uv.lock pinning. uv.lock (https://github.com/allenfbyrd/evidentia/blob/main/uv.lock) pins every transitive dependency by hash. Wheel building via hatchling is deterministic given fixed inputs. CI rebuilds on each commit produce reproducible artifacts (verifiable by re-running release.yml against a tag — same wheel hashes emerge).


  • Sistema de instalação


    Suficiente para um badge!

    O projeto DEVE fornecer uma maneira de instalar e desinstalar facilmente o software produzido pelo projeto usando uma convenção comumente utilizada. [installation_common]
    Exemplos incluem usar um gerenciador de pacotes (no nível do sistema ou da linguagem), "make install/uninstall" (suportando DESTDIR), um contêiner em formato padrão, ou uma imagem de máquina virtual em formato padrão. O processo de instalação e desinstalação (por exemplo, seu empacotamento) PODE ser implementado por terceiros, desde que seja FLOSS.

    Standard Python install: pip install evidentia (or pip install "evidentia[gui]" for full extras). Uninstall: pip uninstall evidentia. Container alternative: docker pull ghcr.io/allenfbyrd/evidentia:latest. Documented in https://github.com/allenfbyrd/evidentia/blob/main/docs/quickstart.md.


    Suficiente para um badge!

    O sistema de instalação para usuários finais DEVE honrar convenções padrão para selecionar o local onde os artefatos compilados são escritos no momento da instalação. Por exemplo, se instalar arquivos em um sistema POSIX, ele DEVE honrar a variável de ambiente DESTDIR. Se não houver sistema de instalação ou convenção padrão, selecione "não aplicável" (N/A). [installation_standard_variables]

    Python pip install respects standard --user / --prefix / virtualenv conventions; no autotools-style DESTDIR pattern applies.


    Suficiente para um badge!

    O projeto DEVE fornecer uma maneira para desenvolvedores em potencial instalarem rapidamente todos os resultados do projeto e ambiente de suporte necessário para fazer alterações, incluindo os testes e ambiente de teste. Isso DEVE ser realizado com uma convenção comumente utilizada. [installation_development_quick]
    Isso PODE ser implementado usando um contêiner gerado e/ou script(s) de instalação. Dependências externas normalmente seriam instaladas invocando gerenciador(es) de pacotes do sistema e/ou da linguagem, conforme external_dependencies.

    Dev bootstrap: git clone ..., then uv sync --all-packages installs all 6 packages + dev deps + tests in one command. Documented in CONTRIBUTING.md (https://github.com/allenfbyrd/evidentia/blob/main/CONTRIBUTING.md). devcontainer support also shipped (https://github.com/allenfbyrd/evidentia/blob/main/.devcontainer/) for one-click VS Code / GitHub Codespaces bring-up.


  • Componentes mantidos externamente


    Suficiente para um badge!

    O projeto DEVE listar dependências externas de uma forma processável por computador. (URL obrigatória) [external_dependencies]
    Tipicamente isso é feito usando as convenções do gerenciador de pacotes e/ou sistema de compilação. Note que isso ajuda a implementar installation_development_quick.

    External dependencies are declared in 7 pyproject.toml files (workspace root + 6 packages) and resolved/locked in https://github.com/allenfbyrd/evidentia/blob/main/uv.lock. CycloneDX SBOM (spec 1.6) is emitted on every release and attached to the GitHub Release for full computer-processable SBOM consumption.


    Suficiente para um badge!

    Os projetos DEVEM monitorar ou verificar periodicamente suas dependências externas (incluindo cópias de conveniência) para detectar vulnerabilidades conhecidas, e corrigir vulnerabilidades exploráveis ou verificá-las como não exploráveis. [dependency_monitoring]
    Isso pode ser feito usando uma ferramenta de análise de origem / ferramenta de verificação de dependências / ferramenta de análise de composição de software como OWASP's Dependency-Check, Sonatype's Nexus Auditor, Synopsys' Black Duck Software Composition Analysis e Bundler-audit (para Ruby). Alguns gerenciadores de pacotes incluem mecanismos para fazer isso. É aceitável se a vulnerabilidade dos componentes não puder ser explorada, mas esta análise é difícil e às vezes é mais fácil simplesmente atualizar ou corrigir a parte.

    Dependabot scans weekly per https://github.com/allenfbyrd/evidentia/blob/main/.github/dependabot.yml (uv, npm, GitHub Actions, Docker — grouped + security-isolated). osv-scanner runs against the SBOM at every release per docs/release-checklist.md Step 5 (most recent: 0 CVEs at v0.7.8). GitHub Code Scanning + Secret Scanning + Dependency Graph all enabled at the repo level.


    Suficiente para um badge!

    "O projeto DEVE:
    1. facilitar a identificação e atualização de componentes mantidos externamente reutilizados; ou
    2. usar os componentes padrão fornecidos pelo sistema ou linguagem de programação.
    Então, se uma vulnerabilidade for encontrada em um componente reutilizado, será fácil atualizar esse componente." [updateable_reused_components]
    Uma maneira típica de atender a este critério é usar sistemas de gerenciamento de pacotes do sistema e da linguagem de programação. Muitos programas FLOSS são distribuídos com "bibliotecas de conveniência" que são cópias locais de bibliotecas padrão (possivelmente bifurcadas). Por si só, isso é bom. No entanto, se o programa *deve* usar essas cópias locais (bifurcadas), então atualizar as bibliotecas "padrão" como uma atualização de segurança deixará essas cópias adicionais ainda vulneráveis. Isso é especialmente um problema para sistemas baseados em nuvem; se o provedor de nuvem atualizar suas bibliotecas "padrão", mas o programa não as usar, então as atualizações na verdade não ajudam. Veja, por exemplo, "Chromium: Why it isn't in Fedora yet as a proper package" by Tom Callaway.

    All reused dependencies come through standard package managers (PyPI for Python, npm for the frontend, GHCR for container images). Updates flow through Dependabot grouped PRs (config: https://github.com/allenfbyrd/evidentia/blob/main/.github/dependabot.yml). No vendored convenience copies of upstream code.


    Suficiente para um badge!

    O projeto DEVERIA evitar usar funções e APIs obsoletas ou desatualizadas onde alternativas FLOSS estejam disponíveis no conjunto de tecnologia que usa (sua "pilha de tecnologia") e para uma supermaioria dos usuários que o projeto suporta (para que os usuários tenham acesso pronto à alternativa). [interfaces_current]

    Codebase is on Python 3.12+ only (no legacy compat shims), Pydantic v2 (current major), latest LangChain/LiteLLM, FastAPI 0.110+, httpx (modern async-capable HTTP). ruff UP rule group continuously surfaces pyupgrade opportunities; backwards-compat hacks are rejected per project standard. Frontend is on Vite 8 + React 18 + TypeScript 5+ (current).


  • Conjunto de testes automatizados


    Suficiente para um badge!

    Uma suíte de testes automatizada DEVE ser aplicada a cada check-in em um repositório compartilhado para pelo menos um branch. Esta suíte de testes DEVE produzir um relatório sobre sucesso ou falha do teste. [automated_integration_testing]
    Este requisito pode ser visto como um subconjunto de test_continuous_integration, mas focado apenas em testes, sem exigir integração contínua.

    test.yml runs pytest + ruff + mypy + frontend tests on every push to main and every pull request, with success/failure status reported as a required check. Workflow: https://github.com/allenfbyrd/evidentia/blob/main/.github/workflows/test.yml. Run history: https://github.com/allenfbyrd/evidentia/actions.


    Suficiente para um badge!

    O projeto DEVE adicionar testes de regressão a uma suíte de testes automatizada para pelo menos 50% dos bugs corrigidos nos últimos seis meses. [regression_tests_added50]

    Per docs/release-checklist.md Step 5 + the pre-release-review v4 process, every fix lands with a regression test. Recent examples: F-V08-DAST-1 / F-V08-DAST-3 (v0.7.8 schema-fidelity fixes) shipped with new pytest cases for the affected endpoints; F-007 (v0.7.7.1 Dockerfile pin) shipped with the docker-run smoke test elevation; F-V08-CR-MEDIUM Snowflake quoted-identifier (v0.7.9 carry-over) shipped with 4 new TestQuotedIdentifierEscape tests; F-V08-CR-MEDIUM Power BI 1MB guard (v0.7.9 carry-over) shipped with 4 new TestPushRowsByteCapBisection tests; v0.7.9 P0.4 Continuous-review HIGH findings (H-1/H-2/H-3/H-4/H-5 + F-V09-S1) shipped with stuck-cursor-guard tests + SIG BYO partial-match test + vendor_id=None ingest test. Test count growth across patch releases (965 → 977 → 1103 → 1259 → 1540) primarily reflects regression tests for fixed bugs + tests for new features.


    Suficiente para um badge!

    O projeto DEVE ter suíte(s) de teste automatizada(s) FLOSS que forneçam pelo menos 80% de cobertura de instruções se houver pelo menos uma ferramenta FLOSS que possa medir este critério na linguagem selecionada. [test_statement_coverage80]
    Muitas ferramentas FLOSS estão disponíveis para medir cobertura de testes, incluindo gcov/lcov, Blanket.js, Istanbul, JCov e covr (R). Note que atender a este critério não é uma garantia de que a suíte de testes seja completa, em vez disso, falhar em atender a este critério é um forte indicador de uma suíte de testes pobre.

    Met. Statement coverage measured by Codecov (independent FLOSS test-coverage service): 81.87% at v0.7.10 ship, exceeding the 80% threshold. Coverage is published on every push to main via .github/workflows/test.yml (codecov-action@v6.0.0 SHA-pinned). The codecov.yml config locks the project gate at 80% with a 1% per-PR drop threshold so regressions fail CI. Live badge: https://codecov.io/gh/allenfbyrd/evidentia. Coverage scope + omit rationale documented in pyproject.toml [tool.coverage.run]. Tooling: pytest-cov (FLOSS, MIT-licensed) + Codecov upload. https://codecov.io/gh/allenfbyrd/evidentia


  • Teste de novas funcionalidades


    Suficiente para um badge!

    O projeto DEVE ter uma política escrita formal de que, à medida que uma nova funcionalidade importante é adicionada, testes para a nova funcionalidade DEVEM ser adicionados a uma suíte de testes automatizada. [test_policy_mandated]

    CONTRIBUTING.md PR checklist line: "New features include at least one test" — required, not optional. https://github.com/allenfbyrd/evidentia/blob/main/CONTRIBUTING.md. Reinforced by docs/release-checklist.md Step 5 which gates every tag on test additions for new feature surface (a tag cannot be cut if a release includes new public surface without paired tests).


    Suficiente para um badge!

    O projeto DEVE incluir, em suas instruções documentadas para propostas de mudança, a política de que testes devem ser adicionados para novas funcionalidades importantes. [tests_documented_added]
    Contudo, mesmo uma regra informal é aceitável desde que os testes estejam sendo adicionados na prática.

    The test-addition policy is documented in the CONTRIBUTING.md PR checklist: https://github.com/allenfbyrd/evidentia/blob/main/CONTRIBUTING.md.


  • Sinalizadores de aviso


    Suficiente para um badge!

    Os projetos DEVEM ser maximamente rigorosos com avisos no software produzido pelo projeto, onde for 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.

    mypy runs with strict = true (config in pyproject.toml) — implies disallow_untyped_defs, disallow_incomplete_defs, check_untyped_defs, disallow_untyped_decorators, no_implicit_optional, warn_redundant_casts, warn_unused_ignores, warn_return_any, no_implicit_reexport, and strict_equality. Pydantic v2 plugin is enabled for full schema validation in type-check. Ruff rule set is broad (8 rule groups). Type-checking covers all 138 source files at zero errors.


 Segurança 13/13 ●

  • Conhecimento de desenvolvimento seguro


    Suficiente para um badge!

    O projeto DEVE implementar princípios de projeto seguro (de "know_secure_design"), quando aplicável. Se o projeto não está produzindo software, selecione "não aplicável" (N/A). [implement_secure_design]
    Por exemplo, os resultados do projeto devem ter 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). Eles também devem ter mediação completa (todo acesso que possa ser limitado deve ser verificado quanto à autoridade e não ser contornável). Note que em alguns casos os princípios entrarão em conflito, caso em que uma escolha deve ser feita (por exemplo, muitos mecanismos podem tornar as coisas mais complexas, contrariando a "economia de mecanismo" / mantenha simples).

    Secure-design principles applied throughout the codebase per docs/threat-model.md and docs/security-review-v0.7.9.md:

    • Least privilege: GitHub Actions workflows default to read-only permissions with per-job elevation; collector API tokens are scoped to read-only (vendors:read for Vanta, vendor-inventory only for Drata, etc.).
    • Fail-safe defaults: Pydantic extra="forbid", offline mode is default-on for the AI module unless explicitly opted in, security-headers default OFF on localhost binds + auto-ON for non-loopback (--security-headers flag).
    • Complete mediation: every external input passes through validate_within() / Pydantic validation before reaching business logic; vendor inventory validates UUID-shape IDs at storage layer.
    • Separation of privilege: cosign keyless OIDC + Trusted Publisher OIDC (no long-lived secrets to compromise); vendor-risk-collector tokens never flow through CLI args or REST request bodies (env-var only).
    • Defense in depth: ruff + mypy + CodeQL + osv-scanner + Scorecard + manual /security-review per release. The v0.7.9 cycle ran THREE Continuous-variant pre-release-reviews mid-cycle (P0.1 close + P0.3+P0.2-first close + P0.4-quartet close) plus the final Pre-tag run at ship — surfacing 18 findings across the cycle (5 inline-fixed HIGH + 1 inline-fixed LOW security + 12 deferred MEDIUM/LOW).
    • Input validation as allowlist: Pydantic schemas enumerate accepted shapes; everything else rejected. CSV-injection defenses (CWE-1236) via _csv_safe in TPRM concentration-report + DD-questionnaire CSV/XLSX render paths.
    • Cross-host pagination guards: BitSight + Vanta + Drata pagination loops refuse to follow next URLs pointing off-host or to a TLS-downgraded HTTP scheme (CWE-319 defense, v0.7.9 P0.4 Continuous F-V09-S1).

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

    Os mecanismos de segurança padrão dentro do software produzido pelo projeto NÃO DEVEM 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.

    No SHA-1 (for security purposes), no CBC mode in SSH context, no deprecated TLS versions (relies on Python stdlib + httpx defaults which negotiate TLS 1.2+ with AEAD ciphers).


    Suficiente para um badge!

    O projeto DEVERIA suportar múltiplos algoritmos criptográficos, para que os usuários possam mudar rapidamente se um for quebrado. Algoritmos de chave simétrica comuns incluem AES, Twofish e Serpent. Alternativas comuns de algoritmos de hash criptográfico incluem SHA-2 (incluindo SHA-224, SHA-256, SHA-384 E SHA-512) e SHA-3. [crypto_algorithm_agility]

    Hash functions: hashlib supports the full SHA-2 (224/256/384/512) and SHA-3 family; Evidentia uses SHA-256 by default but the digest helper at packages/evidentia-core/src/evidentia_core/oscal/digest.py is parameterizable. Sigstore signing supports both ECDSA P-256 and RSA — the cosign CLI lets users pick. TLS cipher selection is delegated to httpx/urllib3 which negotiate from a wide modern AEAD ciphersuite list.


    Suficiente para um badge!

    O projeto DEVE suportar o armazenamento de credenciais de autenticação (como senhas e tokens dinâmicos) e chaves criptográficas privadas em arquivos que são separados de outras informações (como arquivos de configuração, bancos de dados e logs), e permitir que os usuários as atualizem e substituam sem recompilação de código. Se o projeto nunca processar credenciais de autenticação e chaves criptográficas privadas, selecione "não aplicável" (N/A). [crypto_credential_agility]

    Where Evidentia handles outbound credentials (LLM provider API keys, collector credentials for Postgres/MySQL/Snowflake/Databricks/Tableau/Power BI/Okta/ServiceNow + the v0.7.9 vendor-risk APIs Vanta/Drata/BitSight/SecurityScorecard), they are read from environment variables or external config files (never embedded in code, never accepted via CLI args or REST request bodies). Operator updates the env file; no code recompilation required. Documented in docs/quickstart.md and per-collector docs (sql-collectors.md, cloud-dw-collectors.md, bi-integrations.md, tprm.md).


    Suficiente para um badge!

    O software produzido pelo projeto DEVERIA suportar protocolos seguros para todas as suas comunicações de rede, como SSHv2 ou posterior, TLS1.2 ou posterior (HTTPS), IPsec, SFTP e SNMPv3. Protocolos inseguros como FTP, HTTP, telnet, SSLv3 ou anterior, e SSHv1 DEVERIAM estar desabilitados por padrão, e apenas habilitados se o usuário configurá-lo especificamente. Se o software produzido pelo projeto não suportar comunicações de rede, selecione "não aplicável" (N/A). [crypto_used_network]

    All outbound network communication is HTTPS / TLS 1.2+ via httpx (LLM provider calls, BI publish API calls) or HTTPS via the SDK clients (databricks-sdk, snowflake-connector-python, etc.). No legacy protocol support (FTP, telnet, plain HTTP for non-localhost) is implemented or exposed.


    Suficiente para um badge!

    O software produzido pelo projeto DEVERIA, se suportar ou usar TLS, suportar pelo menos a versão TLS 1.2. Observe que o predecessor do TLS era chamado SSL. Se o software não usar TLS, selecione "não aplicável" (N/A). [crypto_tls12]

    All TLS connections go through Python's ssl module via httpx/urllib3 which negotiate TLS 1.2 or 1.3 by default against modern endpoints. Older TLS versions are not enabled.


    Suficiente para um badge!

    O software produzido pelo projeto DEVE, se suportar TLS, realizar a verificação de certificado TLS por padrão ao usar TLS, incluindo em sub-recursos. Se o software não usar TLS, selecione "não aplicável" (N/A). [crypto_certificate_verification]
    Observe que a verificação incorreta de certificado TLS é um erro comum. Para mais informações, consulte "The Most Dangerous Code in the World: Validating SSL Certificates in Non-Browser Software" por Martin Georgiev et al. e "Do you trust this application?" por Michael Catanzaro.

    Default certificate verification is on for httpx (verify=True is the default), urllib3, and all collector SDKs (databricks-sdk, snowflake-connector-python, tableau-server-client, etc.). Certificate verification is never disabled in project code; only an operator-set env var would change this behavior.


    Suficiente para um badge!

    O software produzido pelo projeto DEVE, se suportar TLS, realizar a verificação de certificado antes de enviar cabeçalhos HTTP com informações privadas (como cookies seguros). Se o software não usar TLS, selecione "não aplicável" (N/A). [crypto_verification_private]

    Same code path as crypto_certificate_verification — httpx and underlying urllib3/ssl perform the TLS handshake (with cert verification) before any application-layer request is sent. Headers including credentials are only emitted after the validated TLS session is established. No project code bypasses this ordering.


  • Lançamento seguro


    Suficiente para um badge!

    O projeto DEVE assinar criptograficamente os lançamentos dos resultados do projeto destinados ao uso generalizado, e DEVE haver um processo documentado explicando aos usuários como eles podem obter as chaves públicas de assinatura e verificar a(s) assinatura(s). A chave privada para essa(s) assinatura(s) NÃO DEVE estar em site(s) usado(s) para distribuir diretamente o software ao público. Se os lançamentos não forem destinados ao uso generalizado, selecione "não aplicável" (N/A). [signed_releases]
    Os resultados do projeto incluem tanto o código-fonte quanto quaisquer entregáveis gerados quando aplicável (por exemplo, executáveis, pacotes e contêineres). Os entregáveis gerados PODEM ser assinados separadamente do código-fonte. Estes PODEM ser implementados como tags git assinadas (usando assinaturas digitais criptográficas). Os projetos PODEM fornecer resultados gerados separadamente de ferramentas como git, mas nesses casos, os resultados separados DEVEM ser assinados separadamente.

    Every PyPI release wheel + sdist is signed via Sigstore PEP 740 attestations (keyless OIDC, signed via the Sigstore public good instance and recorded in the Rekor transparency log). Container images are signed by cosign keyless OIDC against the image digest. SLSA L3 build provenance attestations are emitted for every release. Verification commands documented at https://github.com/allenfbyrd/evidentia/blob/main/docs/sigstore-quickstart.md. Private signing keys do not exist on the distribution side (keyless flow), satisfying the "private key not on distribution site" requirement by construction.


    Mal suficiente para um badge.

    É SUGERIDO que no sistema de controle de versão, cada tag de versão importante (uma tag que faz parte de um lançamento principal, lançamento menor ou corrige vulnerabilidades publicamente observadas) seja criptograficamente assinada e verificável conforme descrito em signed_releases. [version_tags_signed]

    Git tags are not currently GPG/SSH-signed at the tag-object level. Release artifacts are signed via Sigstore PEP 740 + cosign keyless OIDC + SLSA L3 provenance, which is a stronger and more verifiable provenance chain than git tag signing (the artifact's identity is bound to the GitHub Actions workflow + commit SHA in the OIDC token). Adding signed git tags is a planned addition in v0.8.0 (will use the same Sigstore identity).


  • Outras questões de segurança


    Suficiente para um badge!

    Os resultados do projeto DEVEM verificar todas as entradas de fontes potencialmente não confiáveis para garantir que sejam válidas (uma *lista de permissões*), e rejeitar entradas inválidas, se houver quaisquer restrições sobre os dados. [input_validation]
    Observe que comparar a entrada com uma lista de "formatos inválidos" (também conhecida como *lista de negação*) normalmente não é suficiente, porque os atacantes muitas vezes podem contornar uma lista de negação. Em particular, os números são convertidos em formatos internos e então verificados se estão entre o mínimo e o máximo (inclusive), e as strings de texto são verificadas para garantir que sejam padrões de texto válidos (por exemplo, UTF-8 válido, comprimento, sintaxe, etc.). Alguns dados podem precisar ser "qualquer coisa" (por exemplo, um carregador de arquivos), mas estes normalmente seriam raros.

    All external inputs are validated via Pydantic v2 with extra="forbid" (reject unknown fields). Specific patterns: validate_within() helper for path inputs (CWE-22 prevention); SQL collector queries are parameterized + LIMIT-bounded; Snowflake quoted-identifier escaping per Snowflake's documented double-up convention (v0.7.9 carry-over hardening); YAML loaded via yaml.safe_load (CWE-502 prevention); subprocess calls are shell=False (CWE-78 prevention); LLM provider calls validate the provider/model allowlist before dispatch. Catalog 22-character column-truncation, 17-endpoint schema-fidelity validation, offline-mode enforcement, BitSight/Vanta/Drata/SSC cross-host pagination guards (cross-host + TLS-scheme downgrade refusal per CWE-319), and CSV-injection defenses on TPRM concentration-report + DD-questionnaire user-content cells (CWE-1236 via _csv_safe OWASP single-quote prefix) all act as additional allowlist gates. The Power BI 1MB byte-cap guard (v0.7.9 carry-over) splits batches that exceed Power BI's documented 1MB request-body limit. Documented in docs/threat-model.md and docs/security-review-v0.7.9.md.


    Suficiente para um badge!

    Mecanismos de proteção DEVERIAM ser usados no software produzido pelo projeto para que defeitos de software tenham menos probabilidade de resultar em vulnerabilidades de segurança. [hardening]
    Os mecanismos de proteção podem incluir cabeçalhos HTTP como Content Security Policy (CSP), flags de compilador para mitigar ataques (como -fstack-protector), ou flags de compilador para eliminar comportamento indefinido. Para nossos propósitos, o privilégio mínimo não é considerado um mecanismo de proteção (privilégio mínimo é importante, mas separado).

    Hardening posture:

    • Container: distroless-style image (Dockerfile pins python by SHA digest); HEALTHCHECK present; non-root user where applicable.
    • HTTP API: FastAPI with Pydantic-validated request models; response headers include strict Content-Type; no stack-trace leakage in error responses (F-002, F-003 fixed in v0.7.7).
    • CI: workflow permissions default read-only with per-job elevation; SHA-pinned actions throughout (Scorecard Pinned-Dependencies signal green); CodeQL custom QL pack to suppress validate_within false positives.
    • Supply chain: PEP 740 + SLSA L3 + cosign signing closes the publish-side hardening loop.

    Suficiente para um badge!

    O projeto DEVE fornecer um caso de garantia que justifique por que seus requisitos de segurança são atendidos. O caso de garantia DEVE incluir: uma descrição do modelo de ameaças, identificação clara dos limites de confiança, um argumento de que os princípios de projeto seguro foram aplicados e um argumento de que fraquezas comuns de segurança na implementação foram combatidas. (URL obrigatória) [assurance_case]
    Um caso de garantia é "um corpo documentado de evidências que fornece um argumento convincente e válido de que um conjunto específico de reivindicações críticas sobre as propriedades de um sistema são adequadamente justificadas para uma dada aplicação em um dado ambiente" ("Software Assurance Using Structured Assurance Case Models", Thomas Rhodes et al, NIST Interagency Report 7608). Limites de confiança são fronteiras onde os dados ou a execução muda seu nível de confiança, por exemplo, os limites de um servidor em uma aplicação web típica. É comum listar princípios de projeto seguro (como Saltzer e Schroeer) e fraquezas comuns de segurança na implementação (como o OWASP top 10 ou CWE/SANS top 25), e mostrar como cada um é combatido. O caso de garantia do BadgeApp pode ser um exemplo útil. Isso está relacionado a documentation_security, documentation_architecture e implement_secure_design.

    Assurance case is composed across three documents:

    1. Threat model: https://github.com/allenfbyrd/evidentia/blob/main/docs/threat-model.md — ~58 surfaces in 5 tiers (v0.7.9 ships TPRM module + 4 vendor-risk-collector additions to the surface inventory), explicit trust boundaries, in-scope/out-of-scope definitions.
    2. Security review (most recent release): https://github.com/allenfbyrd/evidentia/blob/main/docs/security-review-v0.7.9.md — applies CVSS/CWE/EPSS classification to the active surface and demonstrates that secure-design principles have been applied (least privilege, fail-safe defaults, complete mediation, separation of privilege, defense in depth) and common implementation weaknesses have been countered (CWE-22, CWE-78, CWE-89, CWE-502, CWE-209, CWE-319 cross-host TLS-downgrade, CWE-1236 CSV injection, CWE-693 protection-mechanism failure, etc.). The /pre-release-review v4 skill's mandatory /security-review invocations at Steps 3, 4, 6.C produce the input the document synthesizes.
    3. Accepted-findings registry: https://github.com/allenfbyrd/evidentia/blob/main/docs/enterprise-grade-accepted-findings.md — documents residual-risk acceptance with explicit rationale.

 Análise 2/2 ●

  • Análise estática de código


    Suficiente para um badge!

    O projeto DEVE usar pelo menos uma ferramenta de análise estática com regras ou abordagens para procurar vulnerabilidades comuns na linguagem ou ambiente analisado, se houver pelo menos uma ferramenta FLOSS que possa implementar este critério na linguagem selecionada. [static_analysis_common_vulnerabilities]
    Ferramentas de análise estática que são especificamente projetadas para procurar vulnerabilidades comuns são mais propensas a encontrá-las. Dito isso, usar quaisquer ferramentas estáticas normalmente ajudará a encontrar alguns problemas, então estamos sugerindo mas não exigindo isso para o nível de selo 'passing'.

    CodeQL ships with the default security-and-quality query packs which include rules for the OWASP Top 10 and CWE Top 25 (path traversal, SQL injection, XSS, command injection, deserialization vulns, hardcoded credentials, regex DoS, etc.). All these queries run on every push/PR.


  • Análise dinâmica de código


    Suficiente para um badge!

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

    Evidentia is implemented in pure Python (memory-safe) for the backend and TypeScript (memory-safe) for the evidentia-ui frontend. No memory-unsafe language is used in project source.



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

Entrada de selo do projeto de propriedade de: Allen Byrd.
Entrada criada em 2026-05-02 06:10:52 UTC, última atualização em 2026-05-06 20:27:32 UTC. Selo de aprovação alcançado pela última vez em 2026-05-03 21:20:04 UTC.