contents [10]
  1. Como um SVG chega até código nativo
  2. O use-after-free
  3. Da memória liberada ao RCE
  4. A cadeia no Next.js
  5. PoC
  6. O alcance fora do Next.js
  7. Correção
  8. Timeline
  9. Extras
  10. Referências

Nesse writeup apresento a pesquisa sobre a falha de use-after-free (UAF) que encontrei no librsvg, um parser de SVG largamente usado em dezenas de produtos e aplicações web. A falha recebeu a CVE-2026-96889 em setembro.

Basicamente uma única imagem SVG podia ser usada para obter RCE nos alvos, semelhante a outras falhas anteriores famosas como o Heif Heist e o ImageTragick. Ao longo do processo de pesquisa, confirmei a cadeia explorável em duas rotas do Next.js, rendendo dois advisories que foram amplamente divulgados e cobertos por veículos de mídia, como o TheHackerNews que também me citou. A mesma falha também afetava o Ghost, que publicou a CVE-2026-105642, além de vários outros produtos downstream.

Como um SVG chega até código nativo

Aplicações web costumam usar o Sharp para redimensionar e converter imagens. O Sharp usa o libvips, que por sua vez pode carregar SVG com o librsvg. O librsvg usa o libxml2 para ler o XML da imagem.

Na prática, uma chamada curta como sharp(buffer).png() pode terminar nesta pilha:

application → Sharp → libvips → librsvg → libxml2

Uma aplicação pode aceitar uma foto de perfil, uma imagem de bookmark ou o conteúdo de uma OG image sem que seu código mencione SVG ou librsvg. Os bytes só encontram esse parser no fim do pipeline.

Na cadeia de ImageResponse do Next.js existe uma etapa extra. O Satori transforma JSX em SVG antes de o Sharp rasterizar o resultado.

Attacker-controlled text flows through ImageResponse and Satori into generated SVG, then through Sharp, libvips, librsvg and libxml2.
In the Node.js runtime, ImageResponse eventually hands the generated SVG to the native image stack.

Isso mostra que, para cada alvo, poderia também haver um caminho diferente pra chegar ao parser e explorar a falha.

O use-after-free

SVG é XML, e sua sintaxe pode usar entidades e XInclude. Uma entidade funciona como um nome para um trecho de XML. XInclude permite carregar outro documento durante o parse.

A entrada que dispara a falha fica inteira dentro de uma imagem. O SVG inicial carrega, por XInclude, um segundo documento em uma data: URL. Esse segundo SVG declara a entidade active, e a expansão dela carrega um terceiro documento:

<!DOCTYPE svg [
  <!ENTITY active '<xi:include href="data:image/svg+xml,..." parse="xml"/>'>
]>

<svg xmlns:xi="http://www.w3.org/2001/XInclude">
  &active;
</svg>

Enquanto o libxml2 expande &active;, o librsvg começa outro parse para carregar o terceiro SVG. Ele declara uma nova entidade com o mesmo nome:

<!DOCTYPE svg [
  <!ENTITY active "R">
]>

Os dois parses usam o mesmo mapa de entidades no librsvg. Quando a segunda active entra no mapa, o HashMap::insert() substitui a primeira. Rust descarta o wrapper antigo, e seu Drop chama xmlFreeNode():

impl Drop for XmlEntity {
    fn drop(&mut self) {
        unsafe { xmlFreeNode(self.0) }
    }
}

pub fn entity_insert(&self, name: &str, entity: xmlEntityPtr) {
    self.inner
        .borrow_mut()
        .entities
        .insert(name.to_string(), XmlEntity(entity));
}

O libxml2 ainda está expandindo a primeira entidade. Ele mantém um ponteiro para aquele xmlEntity mesmo depois de o librsvg liberá-lo.

Quando o parsing interno termina, o parsing externo continua e atualiza campos por meio desse ponteiro antigo. Nesse momento, a memória já pode pertencer a outro objeto. Esse é o use-after-free.

The outer libxml2 parse retains an entity pointer while a nested XInclude parse replaces and frees the same entity in librsvg's shared map. The outer parse then resumes through the dangling pointer.
The nested parse replaces an entity that the outer parser is still using.

Da memória liberada ao RCE

Um UAF só dá acesso à memória que já foi liberada, então, para chegar ao RCE, outro objeto precisava ocupar aquele espaço e transformar as escritas pelo ponteiro antigo em algo controlável.

No alvo usado durante a pesquisa, o xmlEntity ocupava 144 bytes. Depois do free(), uma alocação de Path.commands do próprio librsvg reutilizava aquele chunk. Esse array guardava os comandos de um elemento SVG <path>.

Quando o libxml2 voltava a escrever no xmlEntity antigo, na verdade alterava os dados desse path. Uma dessas escritas corrompia o discriminant de um PackedCommand. O código otimizado confiava nesse valor e acabava transferindo o controle usando coordenadas fornecidas pelo SVG.

Em resumo, o UAF transformava bytes controlados pelo atacante em corrupção de memória que redirecionava a execução para um stack pivot e uma ROP chain. Um “stack pivot” é uma técnica que troca o ponteiro de stack para outro local em memória, permitindo que a execução continue em um payload controlado.

O payload guardava a ROP chain nas próprias coordenadas. O Node.js oficial usado no teste era non-PIE, então os endereços do executável permaneciam fixos mesmo com ASLR. A chain fazia o stack pivot, montava os argumentos em memória e chamava:

execve("/bin/sh", ["/bin/sh", "-c", command], NULL)

No exploit, cada qword da ROP chain virava um número válido para o atributo d do path:

coords = [number_from_bits(value) for value in rop]

path_commands[i] = (
    f"M{coords[offset]} {coords[offset + 1]}"
)
The freed xmlEntity chunk is reused by path command data. Stale writes corrupt a packed command and redirect execution into a stack pivot and a ROP chain that calls execve.
The demonstrated layout turns stale entity writes into control over path command dispatch.

Essa parte do exploit é específica do build. A chain usada aqui foi feita para Node.js 24.20.0, Sharp 0.35.4, libvips 8.18.6, librsvg 2.62.91 e libxml2 2.15.3. Outro binário pode organizar a memória de outra forma e exigir outro payload.

Essa dependência do build é comum em falhas de corrupção de memória. Por isso, mesmo sendo graves, elas não são triviais de explorar, principalmente quando não há um vetor de leak de endereços de memória. Grande parte das aplicações hospedadas usa binários do Node.js compilados como PIE e com ASLR ativo. Essas tecnologias randomizam os endereços de memória do executável e das bibliotecas, enquanto a chamada “ROP Chain” depende justamente de endereços conhecidos para direcionar o fluxo de execução até o comando desejado.

A cadeia no Next.js

O ImageResponse citado inicialmente gera imagens a partir de JSX. No runtime Node.js, o Satori produz um SVG e o Sharp converte esse SVG para a imagem final.

Uma rota vulnerável podia ser tão pequena quanto esta:

import { ImageResponse } from 'next/og'

export const runtime = 'nodejs'

export async function POST(request) {
  const value = await request.text()

  return new ImageResponse(
    <svg width="1200" height="630">
      <title>{value}</title>
    </svg>
  )
}

O Satori não escapava corretamente alguns valores antes de inseri-los no SVG gerado. Em vez de enviar uma imagem, o atacante podia fechar o elemento atual e incluir seu próprio XML:

</title>
<xi:include href="data:image/svg+xml,..." parse="xml"/>
<title>

A cadeia então juntava duas falhas. A injeção na biblioteca Satori permitia colocar XML controlado pelo atacante no SVG através de campos como <title> e o use-after-free no librsvg transformava esse XML em corrupção de memória e consequentemente na execução de comandos.

Eu reportei a vulnerabilidade para a Vercel, que publicou o caso como CVE-2026-94545 e corrigiu o escaping no Satori 0.33.5.

PoC

Este é um vídeo do PoC da CVE-2026-94545. O script gera o body com a ROP chain. Depois, uma única requisição POST o envia para a rota de ImageResponse.

Meu PoC contra a rota /og do ambiente de teste.

O exploit substitui o processo Node por /bin/sh, executa id > /tmp/vectorfreed-proof e encerra. Por isso, o curl recebe uma resposta vazia. Depois leio o arquivo do container já parado. A saída uid=1000(node) confirma que o código executou com a identidade do worker.

O alcance fora do Next.js

O ImageResponse foi apenas o começo, uma das formas de levar o SVG até o parser. Depois também reportei à Vercel um segundo caminho no Next.js que passava pela Image Optimization API, sem depender do Satori. Uma imagem controlada pelo atacante passava pela rejeição de SVG e depois era identificada como SVG pelo Sharp.

Outro produto em que também confirmei RCE foi o Ghost. Um Contributor podia criar um bookmark card para uma página controlada por ele. O Ghost buscava a og:image, convertia o SVG com Sharp e chegava ao mesmo bug. Esse caso virou a CVE-2026-105642.

Além dos dois caminhos do Next.js, confirmei a falha por rotas reais de produto em 17 aplicações downstream. Cito abaixo apenas as que, durante a escrita deste writeup, já usavam uma versão corrigida ou bloqueavam a entrada antes do parser:

  • Lightdash
  • Strapi
  • PeerTube
  • Reactive Resume
  • Misskey
  • Penpot
  • Puter
  • Payload CMS
  • PostHog

Os caminhos variavam entre upload de avatar, geração de preview, conversão de imagem e processamento de metadata. Em todos eles, bytes controlados pelo atacante chegavam a uma versão afetada do parser.

Correção

O fix do librsvg impede que uma entidade ainda usada pelo libxml2 seja liberada durante o parse recursivo. Ele entrou no commit 8a1b0cd e foi lançado no librsvg 2.63.2, com backports para versões mantidas.

Para aplicações Node.js que usam os binários prebuilt do Sharp, atualizar apenas o librsvg do sistema pode não mudar nada. O Sharp traz seu próprio libvips e suas dependências. A versão Sharp 0.35.5 passou a incluir a stack corrigida.

O PoC do VectorFreed gera a entrada mínima do use-after-free e diferentes carriers para testar rotas de aplicação. Ele serve para verificar se os bytes chegam ao parser. O exploit completo precisa ser tratado como específico para cada build.

Timeline

Data Evento
01/09/2026 Enviei o report do use-after-free ao mantenedor do librsvg.
18/09/2026 O librsvg 2.63.2 foi lançado com a correção.
19/09/2026 Reportei via email a falha no Satori e no Next.js.
22/09/2026 Next.js e Satori publicaram os advisories da cadeia do ImageResponse.
23/09/2026 O RustSec publicou o RUSTSEC-2026-0305.
30/09/2026 Reportei via HackerOne a segunda rota do Next.js, pela Image Optimization API.
01/10/2026 O Ghost publicou a CVE-2026-105642.
14/10/2026 A Vercel publicou o segundo caminho no Next.js, pela Image Optimization API.

Extras

Essa foi até agora a maior cadeia de vulnerabilidade que encontrei, afetando dezenas de produtos usados na internet por milhares de pessoas.

Queria agradecer principalmente ao mantenedor do librsvg que, após confirmar a falha, trabalhou para corrigi-la rapidamente. Nós conversamos algumas vezes por e-mail e pude ajudar um pouco a testar a correção e melhorar a segurança do parser. Também agradeço à equipe da Vercel, que trabalhou nos patches em menos de uma semana nos dois casos que enviei.

Referências