Rapporto di analisi della vulnerabilità CVE-2025-61686

Panoramica della vulnerabilità

CVE ID: CVE-2025-61686
Versioni interessate: @react-router/node 7.0.0 fino a 7.9.3
Tipo di vulnerabilità: Path Traversal / Directory Traversal

Principio della vulnerabilità

1. Posizione della vulnerabilità

La vulnerabilità risiede nella funzione getFile() e nella logica di gestione dei file associata nel file packages/react-router-node/sessions/fileStorage.ts.

2. Analisi del problema principale

2.1 Origine dell'ID di sessione

Alla riga 267 di packages/react-router/lib/server-runtime/sessions.ts:

async getSession(cookieHeader, options) {
  let id = cookieHeader && (await cookie.parse(cookieHeader, options));
  let data = id && (await readData(id));
  return createSession(data || {}, id || "");
}

L'ID di sessione viene estratto dal Cookie tramite il metodo cookie.parse().

2.2 Logica di decodifica del Cookie

Nella funzione decodeCookieValue() in packages/react-router/lib/server-runtime/cookies.ts:

async function decodeCookieValue(
  value: string,
  secrets: string[],
): Promise<any> {
  if (secrets.length > 0) {
    // Se sono configurati secrets, viene verificata la firma
    for (let secret of secrets) {
      let unsignedValue = await unsign(value, secret);
      if (unsignedValue !== false) {
        return decodeData(unsignedValue);
      }
    }
    return null;  // Restituisce null se la verifica della firma fallisce
  }
  
  // Se non ci sono secrets (non firmato), restituisce direttamente il valore decodificato
  return decodeData(value);
}

Problema chiave: Quando il cookie non è firmato (secrets è un array vuoto o non impostato), decodeCookieValue restituisce direttamente il valore decodificato del cookie, permettendo all'attaccante di controllare completamente questo valore.

2.3 Logica di costruzione del percorso

In packages/react-router-node/sessions/fileStorage.ts:

export function getFile(dir: string, id: string): string {
  // Divide l'ID di sessione in una directory (primi 2 byte) e un nome file
  // (rimanenti 6 byte) per ridurre la probabilità di avere directory molto grandi,
  return path.join(dir, id.slice(0, 4), id.slice(4));
}

Questa funzione suddivide l'ID di sessione in due parti:

• Primi 4 caratteri come nome della directory: id.slice(0, 4)
• Caratteri rimanenti come nome del file: id.slice(4)

Quindi utilizza path.join() per concatenare il percorso.

2.4 Modalità di sfruttamento della vulnerabilità

Scenario di attacco: Quando si utilizza createFileSessionStorage() e il cookie non è firmato:

1. L'attaccante può costruire un ID di sessione malevolo, ad esempio: ../../etc/passwd
2. La funzione getFile() elabora:
   • id.slice(0, 4) = ../.
   • id.slice(4) = /etc/passwd
   • path.join(dir, ../., /etc/passwd)
   • Sebbene path.join() normalizzi il percorso, se dir è già un percorso relativo o dopo l'elaborazione, potrebbe comunque consentire un path traversal.

Modalità di sfruttamento più precisa:

• ID di sessione: ....//etc/passwd
  • id.slice(0, 4) = ....
  • id.slice(4) = //etc/passwd
  • Se gestito in modo improprio, potrebbe portare all'accesso a /etc/passwd

Oppure:

• ID di sessione: ../../../etc/passwd (16 caratteri)
  • id.slice(0, 4) = ../.
  • id.slice(4) = ./etc/passwd
  • In combinazione con il comportamento di path.join(), potrebbe causare un path traversal.

3. Operazioni interessate

Le seguenti operazioni sui file potrebbero essere tutte interessate:

1. readData(id) - Durante la lettura dei dati di sessione

   root@kitploit:~

   async readData(id) {
     try {
       let file = getFile(dir, id);
       let content = JSON.parse(await fsp.readFile(file, "utf-8"));
       // ...
     }
   }
   

2. updateData(id, data, expires) - Durante l'aggiornamento dei dati di sessione

   root@kitploit:~

   async updateData(id, data, expires) {
     let content = JSON.stringify({ data, expires });
     let file = getFile(dir, id);
     await fsp.mkdir(path.dirname(file), { recursive: true });
     await fsp.writeFile(file, content, "utf-8");
   }
   

3. deleteData(id) - Durante l'eliminazione dei dati di sessione

   root@kitploit:~

   async deleteData(id) {
     try {
       await fsp.unlink(getFile(dir, id));
     }
   }
   

4. Impatto dell'attacco

1. Lettura di file: L'attaccante potrebbe leggere file arbitrari sul server (a seconda dei permessi del processo del server web)
2. Scrittura di file: L'attaccante potrebbe scrivere file sul server, portando potenzialmente a:
   • Perdita di dati
   • Iniezione di codice
   • Escalation dei privilegi
3. Eliminazione di file: L'attaccante potrebbe eliminare file sul server

5. Condizioni di attivazione della vulnerabilità

Devono essere soddisfatte contemporaneamente le seguenti condizioni:

1. Utilizzo del metodo createFileSessionStorage()
2. Cookie non firmato (secrets non impostato nella configurazione del cookie o secrets è un array vuoto)
3. Il processo del server web ha permessi di lettura/scrittura sul file di destinazione

Risultati del code audit

Percorso del codice chiave

getSession(cookieHeader) 
  → cookie.parse(cookieHeader) 
    → decodeCookieValue(value, secrets)  // Se non firmato, restituisce direttamente value
      → readData(id) 
        → getFile(dir, id)  // Concatenazione del percorso, rischio di path traversal
          → fsp.readFile(file) / fsp.writeFile(file) / fsp.unlink(file)

Causa principale del problema

1. Mancanza di convalida dell'input: La funzione getFile() non convalida né normalizza il parametro id
2. Dipendenza dalla normalizzazione di path.join(): Sebbene path.join() normalizzi il percorso, in casi particolari (ad esempio quando il percorso prima della concatenazione contiene già ..) potrebbe comunque consentire un path traversal
3. Cookie non firmato: Permette all'attaccante di controllare completamente il valore dell'ID di sessione