Explorar a análise de composição de software

A SCA (Análise de Composição de Software) é um processo automatizado para identificar componentes de software livre e de terceiros em aplicativos, analisando suas vulnerabilidades de segurança, conformidade de licença e qualidade de código. À medida que os aplicativos modernos dependem cada vez mais de dependências externas, o SCA tornou-se essencial para gerenciar os riscos associados às cadeias de fornecimento de software.

O que é Análise de Composição de Software?

A Análise de Composição de Software é a prática de descobrir, catalogar e analisar automaticamente todos os componentes de software livre e de terceiros usados em um aplicativo. As ferramentas de SCA analisam manifestos de pacote, arquivos de bloqueio de dependências, código-fonte e binários compilados para criar uma lista abrangente de materiais de software (SBOM).

Principais recursos de SCA

Descoberta de dependência:

• Análise de manifesto: As ferramentas SCA leem arquivos de manifesto do pacote (package.json, requirements.txt, pom.xml, *.csproj) para identificar dependências declaradas.
• Análise de arquivo de bloqueio: Analisar arquivos de bloqueio (package-lock.json, Pipfile.lock, Gemfile.lock) mostrando versões instaladas exatas, incluindo dependências transitivas.
• Verificação binária: Ferramentas avançadas verificam artefatos compilados, imagens de contêiner e aplicativos implantados para descobrir dependências inseridas não declaradas em manifestos.
• Suporte a vários idiomas: Ferramentas abrangentes dão suporte a dezenas de linguagens de programação e ecossistemas de pacotes (módulos npm, PyPI, Maven, NuGet, RubyGems, Go).

Análise de vulnerabilidade:

• Correspondência de CVE: compare as dependências descobertas com os bancos de dados de Vulnerabilidades e exposições comuns (CVE).
• Pontuação de severidade: Calcule as pontuações comuns do CVSS (Common Vulnerability Score System) indicando a gravidade da vulnerabilidade de 0 (nenhum) para 10 (crítico).
• Inteligência de exploit: Identifique quais vulnerabilidades têm exploits conhecidos usados ativamente por invasores.
• Recomendações de patch: Sugira atualizações de versão específicas que resolvam vulnerabilidades, mantendo a compatibilidade.

Conformidade de licença:

• Detecção de licença: Identifique licenças para todas as dependências analisando arquivos de licença, metadados de pacote e cabeçalhos de código-fonte.
• Imposição de política: Sinalizar automaticamente dependências que violam políticas de licença organizacional.
• Análise de compatibilidade: Detecte licenças conflitantes que não podem ser combinadas legalmente no mesmo aplicativo.
• Acompanhamento de obrigações: Requisitos de licença de documento, como avisos de atribuição, divulgação de código-fonte ou restrições de trabalho derivadas.

Avaliação de qualidade:

• Status da manutenção: Avalie se as dependências são mantidas ou abandonadas ativamente.
• Saúde da comunidade: Avaliar a atividade dos contribuintes, o tamanho da comunidade e a sustentabilidade do projeto.
• Práticas de segurança: Verifique se os projetos têm processos de divulgação responsáveis e avisos de segurança.
• Recomendações de atualização: Identifique dependências desatualizadas e sugira alternativas mais seguras e atuais.

Por que o SCA é crítico para o DevOps

As práticas modernas de desenvolvimento de software tornam o SCA indispensável:

A explosão de dependência

Os aplicativos contêm centenas de dependências:

• Dependências diretas: O aplicativo típico faz referência direta a pacotes externos de 20 a 50.
• Dependências transitivas: Cada dependência direta traz suas próprias dependências, criando árvores de dependência com 200 a 500 pacotes totais.
• Vários ecossistemas: Os aplicativos geralmente combinam dependências de vários ecossistemas de linguagem (front-end JavaScript, back-end do Python, microsserviços Java).
• Dependências de contêiner: Aplicativos em contêineres incluem dependências de imagem base mais dependências de aplicativo.

O acompanhamento manual é impossível:

• Escala: O acompanhamento manual de centenas de dependências em dezenas de aplicativos é impraticável.
• Velocidade: Novas vulnerabilidades são divulgadas diariamente, tornando qualquer inventário manual imediatamente desatualizado.
• Complexidade: Entender as cadeias de dependência transitiva e suas interações requer análise automatizada.
• Propriedade distribuída: Dependências mantidas por milhares de projetos independentes de software livre em todo o mundo.

O imperativo de segurança

As vulnerabilidades nas dependências são exploradas ativamente:

• Violações de alto perfil: Os principais incidentes de segurança envolvem regularmente a exploração de vulnerabilidades conhecidas em pacotes populares de software livre.
• Ataques na cadeia de suprimentos: Os invasores comprometem pacotes legítimos para distribuir malware para consumidores downstream.
• Vulnerabilidades de dia zero: Vulnerabilidades até então desconhecidas em pacotes amplamente usados podem afetar milhares de organizações simultaneamente.
• Urgência de patch: Vulnerabilidades críticas exigem identificação rápida e correção em todos os aplicativos afetados.

As ferramentas de segurança tradicionais perdem vulnerabilidades de dependência:

• Análise estática: As ferramentas de verificação de código-fonte analisam seu código, mas não o código de dependência.
• Teste dinâmico: O teste de penetração pode não detectar vulnerabilidades em dependências que não são ativadas durante os testes.
• Revisão manual: As equipes de segurança não podem examinar o código-fonte de centenas de pacotes de terceiros.
• Detecção especializada: Ferramentas SCA especificamente projetadas para identificar vulnerabilidades de dependência são necessárias.

O requisito de conformidade

As violações de licença têm riscos significativos:

• Responsabilidade legal: O uso de dependências sem cumprir os termos de licença pode resultar em ações judiciais e danos.
• Fornecimento aberto forçado: licenças de copyleft fortes (GPL, AGPL) podem exigir aplicativos inteiros de fornecimento aberto.
• Restrições de distribuição: Algumas licenças proíbem a distribuição comercial ou impõem limitações de uso.
• Requisitos de auditoria: Estruturas regulatórias exigem cada vez mais que as organizações mantenham uma lista precisa de materiais de software.

Complexidade da licença:

• Centenas de tipos de licença: O ecossistema de software livre inclui centenas de licenças distintas com obrigações variadas.
• Problemas de compatibilidade: Licenças diferentes têm termos conflitantes que proíbem seu uso juntos.
• Licenciamento transitivo: As obrigações de licença referentes às dependências transitivas devem ser controladas e atendidas.
• Alterações de licença: Os projetos às vezes alteram licenças entre versões, exigindo monitoramento contínuo.

Como funcionam as ferramentas de SCA

As ferramentas de SCA empregam várias técnicas para descobrir e analisar dependências:

Mecanismos de descoberta

Análise de arquivo de manifesto:

• Formatos específicos do idioma: As ferramentas entendem os formatos de manifesto do pacote para cada idioma (package.json para npm, requirements.txt para Python, pom.xml para Maven).
• Resolução de dependência: Analise as especificações de versão de dependência, incluindo intervalos, restrições e regras de resolução.
• Verificação do workspace: examine recursivamente os diretórios do projeto para localizar todos os arquivos de manifesto em monorepos e workspaces de vários projetos.
• Reconhecimento de configuração: Considere dependências específicas do ambiente (desenvolvimento, teste, produção) separadamente.

Análise do arquivo de bloqueio de dependências:

• Versões exatas: Arquivos de bloqueio registram versões precisas de todas as dependências, incluindo dependências transitivas.
• Estado de instalação: Represente dependências instaladas reais em vez de requisitos abstratos.
• Resolução determinística: Os arquivos de bloqueio garantem versões de dependência consistentes entre ambientes.
• Gráficos de dependência completos: Inclua a árvore de dependência transitiva completa com resoluções de versão.

Escaneamento de binários e artefatos:

• Artefatos compilados: Examine arquivos JAR, arquivos de roda, DLLs e executáveis para identificar dependências inseridas.
• Camadas de imagem de contêiner: Analise camadas de imagem de contêiner para descobrir componentes de imagem base e dependências de aplicativo.
• Verificação do sistema de arquivos: Examine os sistemas de arquivos de aplicativos implantados para localizar dependências não declaradas em manifestos.
• Impressões digitais: Use o hash criptográfico para identificar versões de pacote específicas mesmo sem metadados.

Integração de compilação:

• Plug-ins de ferramentas de build: Integrar com sistemas de build (Maven, Gradle, webpack, pip) para capturar informações de dependência durante as compilações.
• Ganchos de resolução: Conecte-se aos processos de resolução de dependência para registrar as versões exatas instaladas.
• Geração de artefatos: gerar artefatos de lista de materiais software (SBOM) durante builds para consumo downstream.
• Integração de pipeline: execute como etapas automatizadas em pipelines de CI/CD para analisar cada build.

Recursos de análise

Correspondência de vulnerabilidades:

• Consulta de banco de dados: Consultar bancos de dados de vulnerabilidade nacional (NVD), banco de dados de consultoria do GitHub e bancos de dados de vulnerabilidade proprietários.
• Correspondência do intervalo de versão: Determine se as versões de pacote específicas se enquadram dentro de intervalos de versão vulneráveis.
• Validação de patch: Verifique se os patches aplicados realmente resolvem vulnerabilidades relatadas.
• Priorização: Classificar vulnerabilidades por severidade, explorabilidade e impacto nos negócios.

Identificação de licença:

• Várias fontes: Extraia informações de licença de metadados de pacote, arquivos de licença, cabeçalhos de código-fonte e arquivos README.
• Normalização da licença: Mapeie vários nomes e identificadores de licença (SPDX, OSI) para tipos de licença padronizados.
• Licenciamento duplo: Gerenciar pacotes lançados em várias licenças alternativas.
• Licenças personalizadas: Identifique licenças não padrão que exigem revisão legal.

Análise de acessibilidade:

• Construção de grafo de chamadas: Crie grafos de chamadas mostrando qual código de dependência é realmente executado pelo seu aplicativo.
• Detecção de código morto: Identificar dependências agrupadas, mas nunca realmente usadas.
• Análise de caminhos de exploração: Determine se caminhos de código vulneráveis são acessíveis a partir dos pontos de entrada do aplicativo.
• Refinamento de risco: Reduza o ruído concentrando-se em vulnerabilidades exploráveis no código realmente usado.

Monitoramento contínuo:

• Alertas em tempo real: Receba notificações imediatas quando novas vulnerabilidades que afetam suas dependências forem divulgadas.
• Verificação agendada: Reanalise regularmente os programas para detectar vulnerabilidades recentemente descobertas em dependências inalteradas.
• Comparação de linha de base: Acompanhe as alterações no status de vulnerabilidade e conformidade ao longo do tempo.
• Prevenção de regressão: Alerta quando novas dependências introduzem vulnerabilidades ou violações de licença.

Padrões de integração do SCA

A implementação efetiva do SCA envolve a integração em vários pontos do ciclo de vida de desenvolvimento:

Estação de trabalho do desenvolvedor

Integração do IDE:

• Comentários em tempo real: Examine as dependências à medida que os desenvolvedores as adicionam a projetos.
• Avisos embutidos: Exiba avisos de vulnerabilidade e licença diretamente no IDE.
• Sugestões de correção: Sugerir versões alternativas de pacote ou pacotes de substituição.
• Imposição de política: Impedir a adição de dependências que violam políticas organizacionais.

Validação de pré-confirmação:

• Ganchos do Git: Execute verificações de SCA antes dos commits para impedir a introdução de dependências vulneráveis.
• Verificação local: Analise as alterações localmente antes de enviar por push para repositórios remotos.
• Comentários rápidos: Forneça comentários imediatos aos desenvolvedores durante o desenvolvimento ativo.
• Detecção antecipada: detecte os problemas antes que eles atinjam branches compartilhados e pipelines de CI/CD.

Controle do código-fonte

Validação da solicitação de pull:

• Verificações automatizadas: Execute a análise de SCA em todas as solicitações de pull para detectar alterações de dependência.
• Comentários de revisão: Postar descobertas como comentários de pull request para visibilidade do revisor.
• Bloqueio de mesclagem: Impedir a mesclagem de solicitações de pull que introduzem vulnerabilidades críticas ou violações de licença.
• Controle de alterações de dependência: Documente claramente quais alterações de dependência cada solicitação de pull apresenta.

Integração do GitHub Dependabot:

• Atualizações automatizadas: Crie solicitações de pull automaticamente quando as atualizações de segurança de dependência estiverem disponíveis.
• Alertas de vulnerabilidade: Receba alertas de segurança do GitHub para dependências vulneráveis.
• Grafo de dependência: Visualize as relações de dependência no recurso de grafo de dependência do GitHub.
• Examinar fluxos de trabalho: Aproveite os processos de revisão e aprovação do GitHub para atualizações de dependência.

Pipelines de CI/CD

Verificação em tempo de compilação:

• Etapas do pipeline: adicionar a verificação de SCA como etapas de build automatizadas em pipelines de CI/CD.
• Portões de qualidade: compilações com falha que não atendem aos requisitos de segurança e conformidade.
• Geração de SBOM: crie uma fatura de software de artefatos de materiais junto com saídas de build.
• Trilhas de auditoria: Registre os resultados da verificação para fins de conformidade e perícia.

Portões de implantação:

• Validação de pré-implantação: Examine os artefatos antes de implantar em ambientes de produção.
• Políticas específicas do ambiente: Aplique políticas mais rigorosas para implantações de produção do que implantações de desenvolvimento.
• Gatilhos de reversão: reverter automaticamente as implantações em que vulnerabilidades críticas são descobertas.
• Aprovações de implantação: Exigir aprovação manual para implantações com riscos conhecidos, mas aceitos.

Monitoramento de tempo de execução

Verificação de produção:

• Análise de aplicativo implantada: Examinar aplicativos realmente implantados para detectar dependências de runtime.
• Verificação do registro de contêiner: Examine continuamente as imagens de contêiner armazenadas em registros.
• Análise de função sem servidor: Examine as funções sem servidor implantadas e suas dependências.
• Detecção de desvio: Identifique as diferenças entre as dependências pretendidas e as realmente implantadas.

Monitoramento contínuo de vulnerabilidades:

• Vigilância contínua: Monitore aplicativos implantados para vulnerabilidades recentemente divulgadas que afetam as dependências atuais.
• Resposta a incidentes: Ativar fluxos de trabalho de resposta a incidentes quando vulnerabilidades críticas são descobertas em ambiente de produção.
• Planejamento de patch: Gere planos de implantação de patch para lidar com vulnerabilidades em aplicativos implantados.
• Conformidade com o SLA: Acompanhe os quadros de tempo de correção para garantir a conformidade com os SLAs de segurança.

Práticas recomendadas de fluxo de trabalho de SCA

A implementação bem-sucedida do SCA segue fluxos de trabalho comprovados:

Estabelecer linha de base

Inventário inicial:

• Descoberta abrangente: Execute ferramentas de SCA em todos os aplicativos para criar um inventário de dependência completo.
• Avaliação do risco: Entenda a exposição atual a vulnerabilidades e problemas de conformidade de licença.
• Priorização: Identificar quais aplicativos e vulnerabilidades exigem atenção imediata.
• Documentação da linha de base: Documente o estado atual como linha de base para medir a melhoria.

Definir políticas

Políticas de segurança:

• Limites de severidade de vulnerabilidade: Defina quais níveis de gravidade são aceitáveis (por exemplo, sem alta crítica e limitada).
• Quadros de tempo de correção: Estabeleça SLAs para corrigir diferentes severidades de vulnerabilidade (críticas dentro de 7 dias, altas dentro de 30 dias).
• Processos de exceção: Crie fluxos de trabalho para aceitar riscos quando a correção imediata não for viável.
• Acompanhamento de isenção: mantenha o rastro de auditoria dos riscos aceitos com justificativas comerciais.

Políticas de conformidade:

• Listas de permissões de licença: Especifique quais licenças são sempre aceitáveis (MIT, Apache 2.0, BSD).
• Listas de negação de licença: Proibir licenças específicas incompatíveis com o modelo de negócios (GPL para software proprietário).
• Fluxos de trabalho de aprovação: Exigir revisão legal para dependências com determinadas licenças (LGPL, MPL, licenças personalizadas).
• Requisitos de atribuição: Defina como as atribuições de licença devem ser fornecidas no software distribuído.

Automatizar a imposição

Integração do pipeline:

• Verificação automatizada: Execute verificações de SCA automaticamente em cada solicitação de build e pull.
• Portões de qualidade: configure portões de pipeline que bloqueiam builds ou implantações que violam políticas.
• Correção automatizada: Use ferramentas como o GitHub Dependabot para criar automaticamente solicitações pull para atualizações de segurança.
• Relatórios: Gere relatórios de conformidade para visibilidade de auditoria e gerenciamento.

Melhoria contínua

Acompanhamento de métricas:

• Tempo médio para correção (MTTR): Medir a rapidez com que as vulnerabilidades são corrigidas após a descoberta.
• Redução de vulnerabilidade: Acompanhe a diminuição das contagens de vulnerabilidades ao longo do tempo.
• Taxa de conformidade: Monitorar o percentual de dependências que atendem às políticas de licença.
• Cobertura: Verifique se as ferramentas de SCA verificam todos os aplicativos e dependências.

Refinamento do processo:

• Gerenciamento de falsos positivos: Ajuste as ferramentas para reduzir falsos positivos por meio de configuração e exceções.
• Treinamento do desenvolvedor: Eduque os desenvolvedores sobre a seleção e o gerenciamento de dependências seguras.
• Evolução da política: Atualize as políticas com base em ameaças emergentes e requisitos de negócios.
• Avaliação da ferramenta: Avalie periodicamente novas ferramentas e recursos de SCA.

A Análise de Composição de Software fornece os recursos automatizados essenciais para gerenciar riscos de segurança e conformidade em aplicativos modernos que dependem fortemente de componentes de software livre. A próxima unidade explora como implementar o GitHub Dependabot, uma ferramenta SCA específica integrada ao GitHub.