Skip to main content

In this article

Como o Snyk detecta vulnerabilidades SSRF no libuv (CVE-2024-24806) no projeto Node.js

Escrito por
Headshot of Liran Tal

Liran Tal

0 minutos de leitura

O Node.js é um runtime poderoso e amplamente usado que permite aos desenvolvedores criar aplicações escaláveis e de alto desempenho com JavaScript. No entanto, muitos talvez não saibam que o Node.js depende bastante de vários componentes de código aberto de terceiros para funcionar. Entre os principais estão libuv, OpenSSL e V8. Cada uma dessas bibliotecas tem um papel fundamental no ecossistema Node.js:

  • libuv: fornece o modelo de E/S orientado a eventos e não bloqueante pelo qual o Node.js é conhecido.

  • OpenSSL: garante a segurança das comunicações implementando protocolos criptográficos.

  • V8: o mecanismo JavaScript que compila e executa código JavaScript.

Embora esses componentes de terceiros permitam que o Node.js ofereça recursos robustos, eles também podem apresentar vulnerabilidades que agentes mal-intencionados conseguem explorar. Por exemplo, uma vulnerabilidade nas bibliotecas libuv ou OpenSSL pode comprometer todo o runtime Node.js e resultar em graves violações de segurança. Por isso, é essencial que os desenvolvedores protejam esses componentes para manter suas aplicações e seus dados seguros.

A Snyk oferece uma poderosa plataforma de segurança para ajudar os desenvolvedores a identificar e corrigir vulnerabilidades em projetos, inclusive as introduzidas por componentes de terceiros. Um dos grandes diferenciais é a capacidade da Snyk de realizar análises de código aberto não gerenciado. Esse recurso é especialmente útil para detectar vulnerabilidades em componentes como libuv, OpenSSL e V8, integrados ao runtime Node.js.

Como a Snyk identifica vulnerabilidades em dependências não gerenciadas?

A Snyk converte arquivos em hashes, compara-os com um banco de dados de vulnerabilidades conhecidas e exibe os problemas encontrados.

O papel do libuv no Node.js

O componente de código aberto libuv é uma biblioteca multiplataforma voltada à E/S assíncrona. Ele fornece o loop de eventos e funciona como mecanismo subjacente para operações assíncronas, como interações com o sistema de arquivos, comunicação de rede e temporizadores no runtime Node.js. Em essência, o libuv é a base do modelo de E/S não bloqueante do Node.js, permitindo que ele lide com várias operações ao mesmo tempo sem bloquear a thread principal de execução (a menos que você provoque isso, por exemplo, ao escrever expressões regulares ineficientes).

Da mesma forma, o OpenSSL é outro componente de código aberto de terceiros que oferece um kit de ferramentas robusto e completo para implementar os protocolos Secure Sockets Layer (SSL) e Transport Layer Security (TLS). No Node.js, o OpenSSL fornece funcionalidades criptográficas que garantem a segurança das comunicações pela rede.

Assim como bibliotecas npm comuns podem introduzir vulnerabilidades de segurança, as bibliotecas C e C++ integradas ao runtime Node.js, como libuv e OpenSSL, também podem trazer riscos à segurança.

A vulnerabilidade SSRF CVE-2024-24806 no libuv

Vulnerabilidades de falsificação de requisição do lado do servidor (SSRF) permitem que atacantes façam o servidor enviar requisições a destinos não previstos. A vulnerabilidade SSRF CVE-2024-24806 no libuv é um problema crítico que pode ser explorado para manipular requisições do servidor e, potencialmente, obter acesso não autorizado a sistemas internos e dados confidenciais. A vulnerabilidade é introduzida pela biblioteca libuv, especificamente na versão 1.47.0.

O que é SSRF?

SSRF permite que invasores enviem solicitações especialmente elaboradas a partir do servidor, podendo acessar serviços internos e dados confidenciais.

Os riscos de segurança associados à CVE-2024-24806 são significativos. A exploração dessa vulnerabilidade pode permitir que atacantes:

  • Acessem recursos da rede interna que não deveriam estar disponíveis publicamente.

  • Roubem informações confidenciais, como credenciais, tokens ou chaves de API internas.

  • Ataquem serviços internos, podendo comprometer completamente o servidor ou a rede.

O projeto Node.js já enfrentou diversas vulnerabilidades em componentes de terceiros. O libuv, por exemplo, teve várias vulnerabilidades, incluindo a CVE-2024-24806. O OpenSSL, outro componente essencial, também já apresentou problemas de segurança, como o infame bug Heartbleed (CVE-2014-0160).

A estrutura em árvore de diretórios do projeto Node.js é mostrada abaixo e revela como as dependências de código aberto de terceiros são incluídas no runtime:

node
|── doc
|── lib
|── src
|── test
|── deps
        |── ada
        |── uv
                |── docs
                |── include
                |── m4
                |── src
                |── test
                |── autogen.sh
                |── common.gpyi
                |── libuv.pc.in
                |── Makefile.am
                |── uv.gyp
        |── v8
        |── zlib
|── configure
|── configure.py
|── Makefile

Como detectar a vulnerabilidade CVE-2024-24806 no libuv

Para ver como a Snyk pode detectar a vulnerabilidade SSRF CVE-2024-24806 no projeto Node.js, siga estas etapas:

  1. Clone o repositório do Node.js:

    git clone https://github.com/nodejs/node

  2. Confira a versão específica que inclui a biblioteca libuv vulnerável:

    git checkout v21.6.0

  3. Execute a análise de código aberto não gerenciado da Snyk:

    snyk test --unmanaged

Os resultados da análise detectarão a vulnerabilidade SSRF no libuv:

Testing /Users/lirantal/projects/repos/node...

Issues:
   [High] Server-Side Request Forgery (SSRF)
   Introduced through: https://github.com|libuv/libuv@1.47.0
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-LIBUVLIBUV-6234013

Tested 9 dependencies for known issues, found 21 issues.

Essa saída indica a presença de uma vulnerabilidade SSRF de alta gravidade (CVE-2024-24806) na biblioteca libuv, especificamente na versão 1.47.0. Ela representa um risco significativo à segurança, pois pode permitir que um atacante faça requisições não autorizadas a partir do servidor.

O pesquisador de segurança forneceu o seguinte código de prova de conceito, que demonstra como a função vulnerável uv_getaddrinfo da biblioteca libuv trata nomes de host de maneira incorreta:

function attack() {
  for (let i = 0; i < 128; i++) {
    const payload = '0x' + '0'.repeat(246) + '7f000001'
    fetch(`http://localhost?url=http://${payload}.example.com:3000/secret`)
      .then((x) => x.text())
      .then(console.log)
  }
}

A análise de código aberto não gerenciado da Snyk é uma ferramenta poderosa para identificar vulnerabilidades em componentes de terceiros que não são gerenciados explicitamente por gerenciadores de pacotes. Isso é especialmente útil em projetos como o Node.js, que dependem de bibliotecas de código aberto como libuv, OpenSSL e V8.

A opção de linha de comando --unmanaged command é especialmente útil em projetos C e C++ que não são gerenciados por um manifesto de pacotes adequado que defina seus componentes, pois analisa todos os arquivos em busca de dependências de código aberto conhecidas.

Ao executar o comando snyk test --unmanaged, a Snyk realiza as seguintes etapas:

  1. Análise: a Snyk analisa todos os arquivos do diretório atual.

  2. Geração de hashes: os arquivos são convertidos em uma lista de hashes.

  3. Correspondência: os hashes são enviados ao servidor de análise da Snyk, que consulta o banco de dados para montar a lista de dependências.

  4. Associação: o servidor associa as dependências identificadas às vulnerabilidades conhecidas.

  5. Exibição: por fim, os resultados são exibidos, destacando as vulnerabilidades encontradas.

Esse processo de análise ajuda as equipes de desenvolvimento e operações a identificar vulnerabilidades ainda nas fases iniciais do desenvolvimento e da CI, garantindo que qualquer versão personalizada do runtime Node.js esteja protegida contra ameaças conhecidas.

Na verdade, a versão 21.6.0 do Node.js tem mais de uma dúzia de outras vulnerabilidades de segurança atribuídas ao V8 e ao OpenSSL, como mostra a análise da Snyk:

snyk test --unmanaged

Testing /Users/lirantal/projects/repos/node...

Issues:

 ✗ [Low] Uncontrolled Resource Consumption ('Resource Exhaustion')
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6592764

 ✗ [Low] Uncontrolled Resource Consumption
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6913421

 ✗ [Medium] Uncontrolled Resource Consumption ('Resource Exhaustion')
   Introduced through: https://github.com|nodejs/node@21.6.0
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-NODEJSNODE-6478265

 ✗ [Medium] Denial of Service (DoS)
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6050293

 ✗ [Medium] Use of a Broken or Risky Cryptographic Algorithm
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6149450

 ✗ [Medium] Resource Exhaustion
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6157247

 ✗ [Medium] NULL Pointer Dereference
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6210213

 ✗ [Medium] Observable Timing Discrepancy
   Introduced through: https://openssl.org|openssl@3.0.12
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-OPENSSL-6277384

 ✗ [Medium] Improper Input Validation
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-2365614

 ✗ [Medium] Improper Input Validation
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-2365619

 ✗ [High] Server-Side Request Forgery (SSRF)
   Introduced through: https://github.com|libuv/libuv@1.47.0
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-LIBUVLIBUV-6234013

 ✗ [High] Security Features
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-2365596

 ✗ [High] Out-of-Bounds
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-2365620

 ✗ [High] Out-of-Bounds
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672126

 ✗ [High] Improper Restriction of Operations within the Bounds of a Memory Buffer
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672127

 ✗ [High] NULL Pointer Dereference
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672131

 ✗ [High] Denial of Service (DoS)
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672137

 ✗ [High] Heap-based Buffer Overflow
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672138

 ✗ [High] Type Confusion
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-7015516

 ✗ [High] Access of Resource Using Incompatible Type ('Type Confusion')
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-7086414

 ✗ [Critical] Type Confusion
   Introduced through: https://github.com|v8/v8@11.8.172.17-pgo
   URL: https://security.snyk.io/vuln/SNYK-UNMANAGED-V8V8-6672130

Tested 9 dependencies for known issues, found 21 issues.

Encontrar essas bibliotecas C e C++ não gerenciadas é o primeiro passo. Depois, é importante monitorá-las, algo que a Snyk também permite com o comando snyk monitor ou automaticamente quando você importa projetos.

A análise de código não gerenciado da Snyk oferece vários benefícios:

  • Detecção antecipada: identifique vulnerabilidades logo no início do processo de desenvolvimento e CI.

  • Cobertura abrangente: identifique vulnerabilidades em componentes de terceiros que talvez não sejam gerenciados explicitamente por gerenciadores de pacotes.

  • Mais segurança: ajude as equipes de desenvolvimento e operações que compilam e criam sua própria versão do runtime Node.js a partir do código-fonte a proteger suas compilações.

Proteger o Node.js e suas dependências é essencial para manter um ambiente de aplicações robusto e seguro. A descoberta da vulnerabilidade SSRF CVE-2024-24806 no libuv reforça a importância de examinar com atenção os componentes de código aberto de terceiros integrados ao runtime Node.js. Componentes como libuv, OpenSSL e V8 representam uma superfície de ataque significativa, que agentes mal-intencionados podem explorar.

Ao integrar a Snyk ao seu fluxo de desenvolvimento, você pode gerenciar e mitigar proativamente os riscos de segurança associados a componentes de código aberto de terceiros. Para começar a usar a Snyk, cadastre-se aqui.

Proteja suas aplicações com a Snyk

Comece a usar a Snyk e permita que seus desenvolvedores criem com segurança desde o início.

Agende uma demonstração ao vivoComece grátis