Principais conclusões
- Quando uma correção só é disponibilizada em uma versão mais recente, a atualização para obtê-la acaba trazendo tudo o mais junto.
- O backporting transfere apenas a correção para a versão que você utiliza, o que muitas vezes evita que você precise fazer a migração.
- O “pinning” mantém as alterações previsíveis e permanece válido enquanto a versão fixada continuar recebendo correções.
- A cobertura não deve terminar quando um pacote chega ao fim de seu ciclo de vida, pois as vulnerabilidades (CVEs) registradas para ele não terminam.
Todo desenvolvedor conhece esse ticket. O scanner fica vermelho numa terça-feira, o aviso informa que a correção foi implementada na versão 5.0.0, e você está usando a 3.8. A correção sugerida tem apenas uma linha. O trabalho em si dá o que fazer.
As equipes perdem semanas com isso, e o mais frustrante é que, muitas vezes, a vulnerabilidade em si não é a parte mais difícil. Muitas correções de CVE consistem em apenas algumas linhas de código. O que as torna dispendiosas é tudo o que vem junto com essas linhas, já que a única maneira oficial de obtê-las é por meio de uma atualização.
Então, é possível corrigir uma vulnerabilidade sem atualizar para uma nova versão principal? Muitas vezes, sim. Mas vale a pena entender por que “basta atualizar” se tornou a resposta padrão e em que situações isso deixa de funcionar.
Por que a atualização se tornou a resposta padrão
Durante a maior parte da história do código aberto, o processo de correção seguiu o mesmo ciclo. Alguém relata uma vulnerabilidade, um mantenedor a corrige no ramo principal, uma nova versão é lançada e todos os usuários a jusante atualizam suas versões. Muitos verificadores de dependências são desenvolvidos com base nesse ciclo. Eles comparam a versão que você possui com as versões que sabidamente contêm a correção e indicam que você deve atualizar.
Isso funciona bem quando a diferença é pequena. Passar da versão 2.4.1 para a 2.4.2 geralmente não representa grande coisa. O problema é que os mantenedores corrigem problemas nas áreas em que estão trabalhando ativamente, que geralmente são a linha mais recente e talvez um ou dois ramos LTS. Pouquíssimos projetos têm tempo ou pessoal para voltar atrás e corrigir uma versão lançada há dois anos, e ninguém pode esperar que voluntários façam isso. Portanto, quanto mais atrasado você estiver em relação à versão atual, mais uma “atualização simples” se transforma em uma migração.
Quando a correção vem junto com todo o resto
Chamo isso de correção vinculada à versão. Trata-se de um patch de segurança que o desenvolvedor original só disponibiliza em uma versão mais recente; portanto, a única maneira oficial de obter a correção é aceitar todas as outras alterações incluídas nessa versão.
É nessas outras mudanças que reside o verdadeiro custo. Uma nova versão principal pode deixar de oferecer suporte ao ambiente de execução que você está usando, renomear uma API que seu código chama em quarenta lugares, alterar uma configuração padrão na qual você confiava ou trazer seu próprio conjunto de dependências transitivas. O versionamento semântico tem como objetivo alertá-lo sobre tudo isso, e o faz quando os mantenedores o seguem à risca. Mas comportamentos incompatíveis aparecem em versões secundárias com frequência suficiente para que ninguém deva tratar um número de versão como uma promessa. E mesmo uma versão principal perfeitamente documentada ainda precisa ser lida, testada e implementada por alguém — geralmente alguém que tinha outros planos para aquela semana.
O npm é bastante claro quanto a isso. Quando npm audit fix Se não for possível resolver algo dentro dos intervalos de versão declarados, geralmente será indicado que você deve consultar npm audit fix --force, que a documentação do npm Pode-se descrever isso como permitir instalações fora do intervalo especificado, incluindo mudanças de versão principal segundo a SemVer. Além disso, o sistema não vai parar para perguntar para qual dessas mudanças de versão principal você está realmente preparado. Isso é algo perfeitamente razoável de se fazer em um projeto de fim de semana. Em um serviço de produção, porém, é o primeiro passo para uma caçada a regressões.
Três pontos em que a atualização dá errado
A primeira fica óbvia assim que você se depara com ela. Às vezes, simplesmente não há uma versão fixa para a qual migrar. O pacote foi descontinuado ou a linha de versões chegou ao fim de sua vida útil, e ninguém vai voltar a usá-lo. O request O pacote é o exemplo clássico do Node. Embora tenha sido considerado obsoleto no início de 2020, ele ainda aparece em muitas árvores de dependências, e quando CVE-2023-28155, uma falha que permite que redirecionamentos entre protocolos contornem as proteções contra SSRF, foi divulgada em 2023; o pacote original não recebeu nenhuma versão corrigida. E ainda não recebeu. Um fork mantido, @cypress/request, lançou uma correção, mas ela foi incluída na versão 3.0.0 com um nome de pacote diferente, e a troca de pacotes já é, por si só, um processo de migração.
O segundo é o grande salto de versão. A correção existe, mas está na versão 6.x, enquanto você está na 4.x, e passar de uma para a outra significa alterar o código do aplicativo que não tem nada a ver com a vulnerabilidade. Sua equipe de segurança quer que o CVE seja fechado esta semana. Seu líder de engenharia sabe que a migração poderia consumir um trimestre inteiro. Ambos estão certos, e é exatamente por isso que esses tickets ficam abertos por tanto tempo, e por que um ticket que começou como uma correção de segurança às vezes acaba gerando seu próprio documento de projeto.
O terceiro pega as pessoas de surpresa, e trata-se da dependência transitiva. O pacote vulnerável não está no seu package.json De jeito nenhum. São quatro níveis abaixo, incluído por um projeto pai cujo intervalo de versões não permite a versão corrigida. A maneira mais limpa é atualizar o projeto pai, se uma versão mais recente dele permitir a versão corrigida, já que você permanece dentro do intervalo que os próprios mantenedores do projeto pai escolheram. Se essa versão estiver, por sua vez, a uma versão principal de distância, porém, você volta ao segundo problema. A outra opção é forçar a versão com Substituições do npm. A Yarn os chama de resolutions, e as versões atuais do pnpm definem overrides em pnpm-workspace.yaml. As substituições funcionam, mas fazem com que você execute uma combinação que os mantenedores do projeto pai nunca testaram, o que faz com que essa tarefa de teste recaia sobre você. E se a versão corrigida for uma versão principal à frente daquela esperada pelo projeto pai, a substituição estará apresentando ao projeto pai uma API para a qual ele nunca foi desenvolvido.
O “pinning” nunca foi o problema
Há um conselho que circula bastante, segundo o qual fixar dependências congela as vulnerabilidades. Tecnicamente, isso é verdade. Fixe uma versão, nunca mais mexa nela, e todas as vulnerabilidades (CVE) divulgadas para ela permanecerão com você.
Acho que essa abordagem atribui a culpa ao motivo errado, no entanto. O uso do “pinning”, juntamente com um arquivo de bloqueio (lockfile) fixo e instalações que o respeitem, garante que o ambiente de produção execute a árvore de dependências que você realmente testou. Isso também impede que uma versão recém-comprometida se infiltre em sua compilação na próxima instalação, e, após os últimos anos de contas de mantenedores comprometidas, isso é importante. Em setembro de 2025, uma conta de mantenedor obtida por phishing foi usada para enviar versões maliciosas de chalk e debug para o npm. Equipes que fazem a instalação com npm ci A partir de um arquivo de bloqueio limpo, confirmado antes do ataque, a compilação continuou sendo feita com base nas versões que já haviam sido verificadas. As equipes que deixam tudo atualizar automaticamente para a versão mais recente estão trocando um tipo de risco por outro.
A verdadeira questão é o que acontece com a linha de versão que você fixou. Uma versão fixada nunca recebe correções por conta própria, então você depende de alguém publicar uma versão corrigida para essa linha. Quando o upstream deixar de fazer isso, você basicamente terá que escolher entre conviver com a vulnerabilidade CVE — talvez com uma medida de mitigação — ou realizar a migração. Corrija isso, e a fixação voltará a ser o que deveria ser: uma forma de controlar as mudanças, em vez de uma forma de acumular riscos.
O que o backporting realmente envolve
O backport consiste em adaptar uma correção de segurança de uma versão mais recente de um pacote para uma versão mais antiga, de modo que a versão que você já utiliza receba a correção sem as demais alterações feitas no código-fonte original. As distribuições Linux vêm fazendo isso há décadas. Quando a Red Hat lança uma correção para uma versão antiga do OpenSSL, isso é um backport, e ninguém espera que os clientes do RHEL mudem para a versão mais recente do código-fonte original toda vez que um CVE é divulgado.
Fazer o mesmo com as dependências do aplicativo parece bastante simples. Encontre o commit do upstream, aplique-o à tag antiga e publique. Na prática, porém, muitas vezes o commit não se aplica corretamente. O código ao redor foi movido, as assinaturas das funções mudaram e, às vezes, a correção depende de uma refatoração que ocorreu três versões depois daquela que você está corrigindo. O patch pode chamar um auxiliar que ainda não existe na linha de código mais antiga ou validar uma entrada em uma camada que o código antigo nunca teve. Portanto, quem fizer o backport precisa entender qual é realmente a vulnerabilidade, e não apenas como fica o diff, e escrever uma correção que feche a mesma brecha no código mais antigo.
Então, isso precisa ser comprovado. Um bom backport é recompilado a partir do código-fonte, executado contra o conjunto de testes do próprio projeto — quando houver um — e verificado em relação à própria vulnerabilidade para confirmar que a falha foi corrigida. O objetivo é que nada mude, exceto o que a correção se destina a alterar. Às vezes, uma correção de segurança precisa restringir algo em que seu código se baseava, como rejeitar entradas que a versão antiga aceitava sem aviso, e, quando isso acontecer, deve ser claramente destacado, não introduzido de forma discreta. Todo o resto deve funcionar da mesma forma que funcionava ontem.
Não vou fingir que isso funciona para todas as vulnerabilidades CVE. Algumas correções estão intimamente ligadas a mudanças arquitetônicas que simplesmente não existem no código mais antigo, e isso vale para qualquer pessoa que faça esse trabalho. Muitas vulnerabilidades, porém, são bem mais isoladas do que isso. Uma verificação de limites ausente, uma expressão regular que faz backtracking de maneira inadequada, uma entrada que nunca foi validada. Essas falhas muitas vezes podem ser corrigidas no código mais antigo sem precisar envolver a arquitetura mais recente, e são a razão pela qual corrigir vulnerabilidades sem atualizar funciona com tanta frequência.
Como o SecureChain corrige vulnerabilidades sem a necessidade de atualização
Esse é o problema que criamos SecureChain por aí. O SecureChain disponibiliza compilações corrigidas a partir de um registro npm gerenciado pela TuxCare. Uma compilação corrigida parte da mesma versão original, adiciona a correção e recebe um -tuxcare.N sufixo no final, então 3.8.0 torna-se 3.8.0-tuxcare.1. Um projeto na versão 3.8 permanece na versão 3.8, agora com a correção.
Esse sufixo realmente faz com que seja uma string de versão diferente, e um intervalo como ^3.8.0 não vai detectar isso sozinho. Por isso, a CLI do SecureChain se encarrega da vinculação. securechain sca analisa sua árvore de dependências resolvida e identifica o que está vulnerável, incluindo os pacotes que uma compilação corrigida pode resolver. securechain harden Em seguida, fixa essas compilações, criando substituições (ou resoluções do Yarn) para pacotes transitivos, atualiza o arquivo de bloqueio e reinstala. Antes de concluir o processo, ele verifica se a árvore instalada realmente contém as novas compilações e, caso não consiga confirmar isso, restaura seus arquivos ao estado anterior. Adicionar --dry-run se você quiser ver a alteração antes que qualquer coisa seja escrita.
Seu arquivo de bloqueio é alterado, assim como o pacote corrigido, mas o código do seu aplicativo geralmente não precisa ser alterado, e você não mudou para uma nova versão principal. Você ainda executaria seus testes antes da entrega, da mesma forma que em qualquer atualização de dependência. Na CI, securechain check a tarefa falha se houver uma compilação corrigida disponível e o projeto não estiver utilizando-a, para que ninguém volte acidentalmente à versão vulnerável. A CLI é compatível com npm, pnpm e Yarn.
O que acontece quando o desenvolvedor original deixa de disponibilizar correções?
O backporting resolve a correção vinculada à versão. Por si só, porém, ele não resolve o problema do pacote que o desenvolvedor original deixa de lado. Muitos pacotes ficam inativos muito antes de alguém declarar formalmente o fim de vida útil.
O SecureChain lida com isso em etapas, que estão descritas na documentação do SecureChain. Enquanto o upstream ainda estiver lançando correções, o prazo de resposta começa a contar a partir da correção do upstream. Se o upstream parar de lançá-las e o pacote entrar em uma etapa chamada “Sustained”, a TuxCare assume diretamente a manutenção, e os prazos de resposta são contados a partir do dia em que o CVE é publicado, e não a partir de uma correção do upstream que talvez nunca chegue. Para um CVE crítico, a TuxCare tem como meta uma compilação corrigida dentro de 7 dias após a correção do upstream na primeira etapa e dentro de 14 dias após a publicação, uma vez que tenha assumido a manutenção. Depois disso, o pacote passa para o Suporte de Ciclo de Vida Ilimitado (ELS) e, se você tiver adicionado o ELS junto com o SecureChain, a aplicação de correções continua a partir daí pelo tempo que você precisar do pacote.
Lembre-se request? A Upstream nunca lançou uma correção para o CVE-2023-28155, mas os dados do VEX publicados pela TuxCare indicam que ele foi resolvido em request 2.88.2-tuxcare.2 e todas as compilações posteriores. A linha de versão é a mesma, não há nada para renomear no seu package.json, e não há nenhum fork para o qual migrar.
O que eu gosto nessa configuração é que, com ambos em funcionamento, não há nenhuma interrupção brusca. Ninguém da sua equipe precisa perceber que um mantenedor deixou de dar notícias, e ninguém precisa sair correndo para encontrar um novo fornecedor. Você continua baixando uma nova compilação corrigida da mesma forma que faria com qualquer atualização, e o repositório de onde ela vem permanece o mesmo, independentemente de o mantenedor original estar ocupado com lançamentos, ter deixado de dar notícias ou ter saído de vez do projeto.
Quando você ainda deve atualizar
Nada disso é um argumento contra a atualização. As novas versões principais trazem melhorias de desempenho, APIs aprimoradas e correções para inúmeros bugs para os quais ninguém jamais registrou um CVE. Planeje essas atualizações e execute-as.
A discussão gira em torno de quem define o cronograma. Quando a única maneira de corrigir uma CVE é atualizar, é a vulnerabilidade que dita o seu plano de ação. Quando é possível aplicar um patch na versão em que você está, você atualiza porque a nova versão vale a pena, testa-a adequadamente e faz isso dentro do prazo definido pela sua equipe. Esse é um motivo muito melhor para mexer em uma dependência do que um aviso vermelho em um scanner.
Perguntas frequentes
É possível corrigir uma vulnerabilidade sem atualizar o pacote?
Muitas vezes, sim. Quando o código vulnerável é relativamente independente, a correção pode ser aplicada retroativamente à versão que você já utiliza, o que corrige a vulnerabilidade sem as alterações que causam incompatibilidades, novas dependências ou o trabalho de migração que geralmente acompanham uma versão principal mais recente.
Como aplicar uma correção retroativa no npm, pnpm ou Yarn?
Instale a versão corrigida da versão que você já está usando. Para pacotes transitivos, fixe-a usando substituições no npm ou pnpm, ou resoluções no Yarn. As versões corrigidas geralmente trazem um sufixo como, por exemplo, -tuxcare.1, com as quais suas faixas de versão existentes não se alinham por si só; portanto, é a substituição que insere a compilação na árvore, enquanto o pai permanece na linha de versão esperada.
É seguro forçar a correção do npm audit?
Corrida npm audit fix --force pode eliminar os avisos, mas faz isso permitindo que o npm instale versões fora dos intervalos declarados por você, incluindo lançamentos de versão principal (major) de acordo com a SemVer, e algumas delas trarão alterações que quebram a compatibilidade. Trate isso como uma atualização não planejada. Verifique o que foi alterado no arquivo lockfile e execute seu conjunto completo de testes antes que qualquer alteração chegue ao ambiente de produção.
O que é uma correção de segurança retroativa?
Uma correção de segurança retroativa é um patch adaptado de uma versão mais recente de um pacote e aplicado a uma versão mais antiga. Seu escopo se limita à vulnerabilidade e exclui alterações não relacionadas; portanto, o código escrito para a versão mais antiga deve continuar funcionando, embora você deva testá-lo como faria com qualquer outra atualização de dependência.
O que significa quando uma correção de segurança está vinculada a uma versão mais recente?
Isso significa que a correção está vinculada à versão. Uma correção vinculada à versão é um patch de segurança que o desenvolvedor original só disponibiliza em uma versão mais recente; portanto, aplicá-la por meio de uma atualização implica aceitar todas as outras alterações dessa versão também, e é assim que a correção de um CVE se transforma em uma migração completa.
É seguro fixar as versões das dependências?
A fixação, juntamente com um arquivo de bloqueio definido e instalações que o respeitem, tais como npm ci, é uma boa prática, pois permite reproduzir a árvore de dependências que você testou e mantém as versões não revisadas fora de suas compilações. O risco decorre de deixar a versão fixada sem atualizações; portanto, a fixação funciona melhor quando essa versão continua recebendo correções de segurança.
Como se corrige uma vulnerabilidade em uma dependência transitiva?
As opções habituais são atualizar o pacote pai, caso uma versão mais recente aceite a versão corrigida, ou forçar a versão corrigida por meio de substituições, o que pode causar falhas no pacote pai. Uma compilação retroportada oferece uma terceira opção, pois a substituição pode apontar para uma compilação corrigida baseada na mesma versão upstream que o pacote pai já utiliza.
O que acontece com a segurança de um pacote depois que ele chega ao fim de sua vida útil?
O projeto original deixa de lançar correções, mas novos CVEs continuam sendo registrados para ele. A menos que alguém continue aplicando patches, você fica limitado a medidas de mitigação, um fork ou uma migração, e as vulnerabilidades permanecem em aberto nesse meio tempo.
