Dependências de software: como gerenciá-las em escala

As dependências de software permitem que desenvolvedores entreguem software mais rapidamente, aproveitando trabalhos anteriores. Elas revolucionaram o desenvolvimento de aplicações nas últimas décadas, mas também introduzem riscos que muitas vezes passam despercebidos.

Quais são os tipos de dependências?

Há dois tipos de dependências de software:

• Diretas: bibliotecas ou pacotes que seu código chama diretamente.

• Transitivas: bibliotecas ou pacotes chamados pelas suas dependências. São dependências de dependências.

Os dois tipos de dependência exigem gerenciamento cuidadoso para controlar os riscos envolvidos. As dependências transitivas ou indiretas exigem atenção especial porque não é evidente de imediato que estão sendo usadas em uma aplicação. As dependências ficam aninhadas umas dentro das outras, formando uma árvore complexa, o que facilita não perceber quando sua aplicação usa uma biblioteca com vulnerabilidades.

Por que é obrigatório gerenciar dependências

Nos primeiros tempos das dependências de software, baixar e instalar uma biblioteca necessária era um trabalho tedioso. Isso tornava pouco prático reutilizar pacotes menores. Nas últimas duas décadas, porém, gerenciadores de dependências como o Node Package Manager (NPM) para Node.js e o Maven para Java viabilizaram o uso de pacotes menores, até mesmo os compostos por poucas linhas de código. Desde então, o número de pacotes disponíveis para desenvolvedores cresceu explosivamente, e as dependências de software se tornaram um ingrediente essencial das aplicações modernas.

Com dependências de software pré-criadas, desenvolvedores podem entregar software mais rapidamente e em ciclos de lançamento menores. No entanto, as dependências introduzem riscos que muitas vezes passam despercebidos. Ao incluir software externo como dependência, você confia que seus desenvolvedores vão escrever, testar e manter o código corretamente.

Além das vulnerabilidades de segurança que podem existir nessas dependências, elas também podem ficar desatualizadas, limitar a qualidade do software que as utiliza — ou até mesmo causar falhas. Essas dependências podem conter bugs ou problemas de segurança que afetam o desempenho e o perfil de risco da aplicação. Por fim, elas podem estar sujeitas a licenças cujas condições trazem possíveis consequências legais ou de responsabilidade.

Diante disso, gerenciar dependências para minimizar os riscos associados a elas é fundamental. Ainda assim, muitas organizações dão pouca atenção ao gerenciamento de dependências. Quando o software funciona bem, não veem motivo para consertar o que não está quebrado. Além disso, gerenciar dependências é difícil. As dependências transitivas podem ter várias conexões ou até mesmo formar dependências circulares. Atualizar uma dependência pode quebrar toda a cadeia e levar você ao inferno das dependências.

Por que você deve gerenciar dependências de código aberto

Nas primeiras versões das dependências de software, as empresas compravam pacotes de código de fornecedores conhecidos e confiáveis. Hoje, a maioria das dependências são bibliotecas de terceiros de código aberto, o que torna o gerenciamento de dependências mais complexo. Os contribuidores de código aberto que escrevem e mantêm o código usado em software de produção provavelmente não fazem parte da sua organização.

Quando as bibliotecas de código aberto surgiram, era comum desenvolvedores copiar e colar linhas de código diretamente. Isso impossibilitava rastrear e atualizar componentes. As abordagens mais modernas usam um gerenciador de pacotes para administrar componentes de código aberto ou encapsulam bibliotecas de código aberto em módulos internos. Assim, fica mais fácil usar código aberto nas aplicações. Apesar da explosão de componentes de código aberto, muitos desenvolvedores ainda entendem pouco sobre as vulnerabilidades que eles podem introduzir.

Em parte devido à enorme quantidade de código criado, especialistas em segurança descobrem constantemente vulnerabilidades em componentes de código aberto. Se uma pessoa mal-intencionada descobrir uma dessas vulnerabilidades, poderá usá-la para lançar ataques (vazamento de dados da Equifax), especialmente em pacotes muito populares (Log4Shell). Além disso, as licenças de código aberto estabelecem condições de uso, e violá-las pode resultar em multas elevadas e danos à reputação.

Por esses motivos, é essencial desenvolver um sistema para gerenciar dependências de código aberto durante todo o ciclo de vida. Isso inclui desenvolver e aplicar políticas sobre como os desenvolvedores lidam com componentes de código aberto.

5 desafios do gerenciamento de dependências

Como vimos, as dependências de código aberto ajudam desenvolvedores a entregar aplicações mais rapidamente, mas também expõem as organizações a riscos de segurança e jurídicos. Gerenciar essas dependências exige cuidado, sobretudo as transitivas, pois podem criar várias camadas aninhadas. Uma forma de gerenciar e reduzir os riscos das dependências de código aberto é a análise de composição de software.

A análise de composição de software (SCA) é uma abordagem de teste de segurança de aplicações que rastreia e analisa componentes de software. A SCA abrange metodologias e ferramentas de segurança de aplicações que monitoram o software para rastrear os componentes usados como dependências. A SCA não se limita a componentes de código aberto, mas o crescimento das dependências de código aberto levou à proliferação de ferramentas de SCA nos últimos anos.

Para gerenciar com sucesso os riscos das dependências de código aberto, as ferramentas de SCA precisam superar alguns desafios importantes:

1. As dependências transitivas podem ocultar pacotes de código aberto em várias camadas, dificultando a visibilidade completa de todos os pacotes de código aberto usados por uma aplicação. Pesquisas da Snyk mostram que a grande maioria das vulnerabilidades está nessas dependências ocultas. Por isso, desenvolvedores podem nem saber que estão usando pacotes de código aberto com vulnerabilidades de segurança.

2. É importante entender como cada ecossistema lida com dependências. Fatores como arquivos de bloqueio e a resolução de pacotes durante a instalação afetam a identificação de vulnerabilidades. As ferramentas de SCA precisam levar essas particularidades em conta para identificar com precisão as vulnerabilidades relevantes. Por exemplo, isso pode ajudar a detectar e impedir ataques de confusão de dependências, um método usado com sucesso para acessar e exfiltrar dados da Yelp, Tesla, Apple, Microsoft e outras empresas.

3. O número de vulnerabilidades encontradas nas dependências de software pode chegar aos milhares. É essencial que as ferramentas de SCA tenham um sistema para priorizar os esforços de identificação e correção de vulnerabilidades.

4. As ferramentas de SCA precisam de uma fonte confiável que identifique vulnerabilidades com rapidez, para que seja possível protegê-las.

5. As ferramentas de SCA precisam agir com rapidez para acompanhar o ritmo dos desenvolvedores. Caso contrário, eles podem acabar ignorando ou contornando as verificações de segurança.

Como a ferramenta de gerenciamento de dependências da Snyk reduz os riscos

As abordagens tradicionais de segurança se concentram no fim do processo de desenvolvimento, em vez de integrar a segurança aos fluxos de trabalho de DevOps. Snyk Open Source coloca os desenvolvedores no centro da segurança da organização, com integração pronta aos fluxos de trabalho e às ferramentas existentes. As equipes de segurança e operações gerenciam e supervisionam o processo, enquanto desenvolvedores usam as ferramentas da Snyk para proteger continuamente os pipelines de desenvolvimento por meio de ferramentas de CI/CD. Corrigir problemas de segurança durante o desenvolvimento, muito antes de o código chegar à produção, é de longe a opção mais segura e econômica.

A Snyk cobre todos os aspectos da segurança de aplicações. Ela oferece uma visualização em árvore das dependências para identificar dependências e suas vulnerabilidades, além de atualizá-las automaticamente à medida que evoluem (saiba como isso funciona em Java e Python). A Snyk automatiza as verificações no IDE, para que desenvolvedores encontrem problemas, priorizem-nos, implementem correções e integrem as atualizações durante o desenvolvimento. Alertas são emitidos automaticamente quando funções vulneráveis são chamadas durante a execução. Integrações com SCMs, incluindo GitHub e GitLab, ajudam a implementar a ferramenta em projetos de código novos e existentes e permitem gerar automaticamente PRs com correções, reduzindo o impacto no valioso tempo de desenvolvimento.

Essa abordagem de segurança que prioriza os desenvolvedores permite encontrar e corrigir bugs no código e nas dependências em tempo real. As vulnerabilidades são detectadas mais cedo, reduzindo seu impacto no ciclo de vida do desenvolvimento. Um banco de dados de vulnerabilidades abrangente oferece descrições de vulnerabilidades selecionadas e revisadas por especialistas. Todos os itens do banco são analisados e testados para garantir a precisão, e cada vulnerabilidade recebe uma pontuação e um vetor CVSS. As descrições trazem informações sobre explorabilidade, licenciamento, histórico de segurança e manutenção das bibliotecas sinalizadas.

A Pearson, a maior empresa de educação do mundo, começou a usar a verificação automatizada de dependências da Snyk para minimizar sua exposição a riscos. Quando os desenvolvedores passaram a usar a plataforma, a equipe de DevSecOps também quis garantir que eles soubessem como resolver problemas rapidamente.

O recurso de correção automatizada da Snyk prioriza as vulnerabilidades para reduzir as ações que os desenvolvedores precisam realizar para corrigi-las. Isso ajuda a reduzir a exposição da Pearson a riscos causados por dependências desatualizadas, vulnerabilidades de segurança recém-descobertas e problemas de licenciamento.

“Pode ser um pouco assustador quando as equipes entram na Snyk e veem centenas de vulnerabilidades”…“por isso, incentivamos as equipes a analisar as correções, em vez de cada problema individualmente. É possível corrigir de 20 a 30 vulnerabilidades com a atualização de uma única dependência. Isso facilita a ação das equipes.”

Como proteger suas dependências de software

As dependências de software têm um papel fundamental no desenvolvimento moderno. Elas permitem que desenvolvedores reutilizem código escrito por outras pessoas, acelerando as entregas e reduzindo os ciclos. Como resultado, seu uso cresceu explosivamente, mas elas introduzem riscos e vulnerabilidades que as organizações muitas vezes subestimam.

As dependências de código aberto merecem atenção especial. A maioria das dependências usadas por desenvolvedores hoje é de código aberto, o que significa que o software de produção depende de contribuidores externos para escrever, atualizar e manter essas dependências.

Por isso, é fundamental monitorar as dependências de forma abrangente. Mas é difícil monitorar todas as dependências usadas por uma aplicação — especialmente as transitivas.

Snyk Open Source é uma ferramenta de SCA que detecta e monitora dependências automaticamente durante todo o ciclo de vida do desenvolvimento. Ao contrário de outras soluções, a Snyk prioriza os desenvolvedores e os envolve ativamente na segurança das aplicações.

Para saber mais sobre dependências e suas implicações para a segurança de aplicações, leia nosso relatório The State of Open Source Security.

Obrigado pela leitura. Continue em segurança.