React2Shell (CVE-2025-55182): פגיעות קריטית המאפשרת הרצת קוד מרחוק Server של React

CVE-2025-55182 היא פגיעות קריטית המאפשרת הרצת קוד מרחוק לפני אימות ב-React Server , עם ציון CVSS של 10.0 – דירוג החומרה הגבוה ביותר האפשרי. במסגרת תוכנית המלגותOPSWAT , ערכו עמיתינו ניתוח טכני מקיף של פגיעות זו, ובחנו את הגורם השורשי שלה בפרוטוקול ה-deserialization של React Flight, את שרשרת הניצול המלאה ואת השפעתה הנרחבת על המערכת האקולוגית המודרנית של האינטרנט. בלוג זה מציג את ממצאינו לצד הנחיות מעשיות למגינים.

React הפכה לאחת מספריות ה-front-end הנפוצות ביותר בעולם, והיא עומדת בבסיס חלק ניכר mobile האינטרנט mobile המודרניים. סקרי מפתחים של Stack Overflow מדרגים את React באופן עקבי בין מסגרות האינטרנט המובילות, עם אימוץ העולה על 40% מהמפתחים המקצועיים ברחבי העולם. במקביל לצמיחה זו, צוות React הציג את React Server (RSC) כתכונה מרכזית ב-React 19 – שינוי פרדיגמה המעביר את לוגיקת הרינדור מהלקוח לשרת, ומאפשר ביצועים מיטביים ושילוב הדוק יותר בין קוד בצד השרת לקוד בצד הלקוח.

עם זאת, התפתחות ארכיטקטונית זו יצרה נקודת תורפה קריטית חדשה. ב-29 בנובמבר 2025, חוקר האבטחה לקלן דייווידסון דיווח על פגיעות בלוגיקת הפיכת הנתונים למבנה סריאלי בצד השרת של React לתוכנית Bug Bounty של Meta. הפגיעות, שפורסמה בפומבי ב-3 בדצמבר 2025 תחת המספר CVE-2025-55182, מאפשרת הרצת קוד מרחוק ללא אימות באמצעות בקשת HTTP אחת שתוכננה במיוחד. הפגיעות, המסווגת כ-CWE-502 (Deserialization of Untrusted Data), אינה דורשת אימות, אינטראקציה מצד המשתמש או תצורה מיוחדת של היישום – פריסת create-next-app ברירת המחדל, המיועדת לייצור, ניתנת לניצול מיידי.

React היא ספריית JavaScript לבניית ממשקי משתמש, המתוחזקת על ידי Meta וקהילת קוד פתוח רחבה. React Server (RSC), שהוצגו עם React 19, מייצגים שינוי מהותי באופן שבו יישומים של React מטפלים בעיבוד. בניגוד לרכיבי לקוח מסורתיים, הפועלים כולם בדפדפן, רכיבי השרת פועלים בשרת, ומייצרים ייצוג סדרתי של ממשק המשתמש, המועבר ללקוח. תכנון זה מצמצם את כמות ה-JavaScript המועברת לדפדפן, משפר את מדדי זמן התגובה, ומאפשר גישה ישירה למשאבים בצד השרת, כגון מסדי נתונים ומערכות קבצים.

When a client invokes a Server Function, the browser sends an HTTP POST request with a multipart/form-data body. Each form field contains a numbered “chunk” of serialized data. The Flight protocol uses special string prefixes to encode data types: $<id> references the resolved value of another chunk, $@<id> references the raw chunk object itself, $W<id> represents a Set, $K<id> represents FormData, and $B<id> triggers the blob handler.

הבה נבחן Server המוגדרת כך:

בקשת ה-HTTP המתאימה מכילה מספר שדות טופס, שכל אחד מהם מורכב ממפתח וערך: שדה 0 מכיל את מערך הארגומנטים עם הפניות כגון "$W1" ו- "$K2", בעוד ששדות 1 ו-2_* מכילים את הנתונים שאליהם מתייחסות הפניות אלה. השרת מעבד כל שדה עם הגעתו, ומאחסן תוצאות ביניים באובייקטים המכונים "chunks".

Chunk הוא אובייקט מסוג Thenable הכולל ארבע תכונות מרכזיות: status (מצב ההחלטה), value (הנתונים המאוחסנים), reason (מידע על השגיאה) ו-_response (הפניה לאחור לאובייקט התגובה האב). כאשר השרת נתקל ב-await chunk, מתבצעת קריאה לשיטת ה-.then() של ה-chunk. אם הסטטוס של ה-chunk הוא INITIALIZED, פונקציית ה-resolve callback מקבלת את chunk.value. אם הסטטוס הוא PENDING, BLOCKED או CYCLIC, פונקציות ה-callback מועברות לתור לביצוע מאוחר יותר.

להלן תיאור של האופן שבו Next.js מעבד בקשת Server נכנסת בתנאים רגילים, החל משכבת ה-HTTP ועד למנוע הפיענוח של React Flight.

כאשר מתבצעת קריאה Server , הבקשה נכנסת לפונקציית `handleAction`. פונקציה זו מאמתת את המטא-נתונים, בודקת את הכותרות ואת אסימוני ה-CSRF, ומאשרת שהבקשה היא פעולת אחזור חוקית. לאחר מכן נוצר זרם בשם busboyStream כדי לנתח את גוף הטופס המורכב ממספר חלקים. הפונקציה decodeReplyFromBusboy מקשרת משדרי אירועים לזרם זה, ומפעילה את פונקציות הטיפול בפירוק הסדר ServerReact עם קבלת הנתונים הגולמיים. ערך ההחזרה של decodeReplyFromBusboy הוא chunk_0; האופרטור await פותר אותו ומעביר את הערך המורכב שלו Server שהופעלה.

הפונקציה getChunk מחזירה את ה-chunk המתאים למזהה נתון. אם ה-chunk הזה עדיין לא קיים, היא יוצרת ResolvedModelChunk (אם הנתונים כבר קיימים ב-response._formData) או PendingChunk (אם עדיין לא התקבלו נתונים עבור אותו מזהה).

כאשר decodeReplyFromBusboy מחזירה את chunk_0, ה-chunk עדיין נמצא במצב PENDING. אופרטור await קורא ל-chunk_0.then() ומאחסן באופן זמני את פונקציות ה-callback resolve ו-reject ב-chunk_0.value וב-chunk_0.reason. פונקציות ה-callback הללו מופעלות מחדש על ידי הפונקציה wakeChunk לאחר השלמת פתרון ההפניות.

כאשר busboyStream מקבל שדה נתונים גולמי שלם, הוא מפעיל את משדר האירועים 'field', קורא לפונקציית resolveField ומתחיל את תהליך הפירוק – המרה של נתוני טופס גולמיים לאובייקטי JavaScript בנויים במלואם. הפונקציות הבאות מנהלות תהליך זה.

resolveField(תגובה, מפתח, ערך)

המפתח והערך מתווספים ל-response._formData. לאחר מכן, הפונקציה משיגה את ה-chunk המתאים ל-ID התואם למפתח. אם ה-chunk הזה כבר קיים, מתבצעת קריאה לפונקציית resolveModelChunk כדי לשחזר אותו. פתרון נדחה זה נחוץ מכיוון שערך עשוי להכיל הפניות לשדות שטרם התקבלו הנתונים הגולמיים שלהם; במקרה כזה, Server React Server PendingChunk עם פונקציות callback מותאמות אישית ל-resolve ו-reject, כדי לטפל בהפניות אלה בהמשך.

resolveModelChunk(chunk, value, id)

resolveModelChunk יוצר אובייקט ResolvedModelChunk במצב RESOLVED_MODEL ומזריק אליו את הנתונים הגולמיים. לאחר מכן, הוא משחזר את ה-chunk באמצעות initializeModelChunk וקורא לפונקציית wakeChunk כדי להפעיל את כל פונקציות ה-callback של resolve ו-reject שנמצאות בתור, ובכך משלים את תהליך ההחלטה לגבי האובייקט או ההפניה.

initializeModelChunk(chunk)

הפונקציה `initializeModelChunk` מעבירה את מצב ה-chunk למצב CYCLIC — המציין כי מתבצע פתרון הפניות — ומתחילה בתהליך הפיכת הנתונים למבנה. היא בונה אובייקט JavaScript גולמי מתוך `chunk.value` באמצעות `JSON.parse`, ולאחר מכן מעבירה אובייקט זה לפונקציית `reviveModel`.

reviveModel(תגובה, אובייקט-אב, מפתח-אב, ערך, הפניה)

הפונקציה reviveModel מעבדת באופן רקורסיבי כל רכיב בתוך האובייקט שנותח. כאשר היא נתקלת בערך מסוג מחרוזת, היא קוראת לפונקציה parseModelString כדי לטפל בו.

parseModelString(תגובה, אובייקט, מפתח, ערך, הפניה)

הפונקציה `parseModelString` מבצעת חלוקה לפי קידומת המחרוזת כדי לטפל בסוגים מקודדים שונים. עבור הפניות המתחילות ב-$, הפונקציה `getOutlinedModel` נקראת כדי לפתור את ההפניה בין-קטעים.

getOutlinedModel(תגובה, הפניה, אובייקט-אב, מפתח, מפה)

CVE-2025-55182 originates from insufficient input validation in the getOutlinedModel() function within React’s server-side Flight reply handler (ReactFlightReplyServer.js). When a chunk reference includes a property path - such as $<id>:<prop1>:<prop2> - the function resolves it by traversing the specified properties on the target chunk object, computing the result as chunk[prop1][prop2].

הפגם הקריטי הוא ששמות המאפיינים הללו אינם עוברים אימות לעולם. השרת אינו בודק אם המאפיינים המבוקשים הם מאפיינים של האובייקט עצמו או מאפייני אב טיפוס שעברו בירושה. לפיכך, תוקף יכול לכלול את __proto__ בנתיב המאפיין כדי לעבור על שרשרת האב טיפוס ולהגיע לשיטות פנימיות שאסור שיהיו נגישות מקלט הנשלט על ידי המשתמש. לדוגמה, ההפניה $1:__proto__:then מתפרשת כ-Chunk.prototype.then – פונקציה שהתוקף יכול להפעיל עם ארגומנטים בשליטתו.

שרשרת הניצול מנצלת שני מסלולי קוד נפרדים בלוגיקת הפיכת ה-Flight לנתונים ב-React.

הראשון הוא Chunk.prototype.then, הקובע כיצד מתנהגים החלקים (chunks) כ-thenables. כאשר מפעילים את `await` על חלק הנמצא במצב INITIALIZED, מתבצעת קריאה ל-resolve(chunk.value). אם chunk.value הוא עצמו thenable (אובייקט בעל שיטת .then() ), מפעיל אופרטור ה-await באופן רקורסיבי את chunk.value.then(). פתרון רקורסיבי זה הוא המנגנון שבאמצעותו תוקף מכוון את הביצוע לפונקציה שרירותית.

השני הוא מטפל הקידומת $B (blob) בתוך הפונקציה parseModelString():

במקרה $B, הפונקציה קוראת ל-response._formData.get(response._prefix + id). הן _formData.get והן _prefix הן תכונות של אובייקט ה-_response המאוחסן בתוך ה-chunk. על ידי שליטה בתכונות אלה באמצעות מעבר על שרשרת הפרוטוטיפים, תוקף יכול להפנות קריאה זו כך שתפעיל את בונה הפונקציות הגלובלי (Function constructor) עם קוד שרירותי כטיעון.

Through prototype chain traversal, an attacker reaches the global Function constructor via the path <any_object>.constructor.constructor. Because Chunk.prototype.then is a function, the path $1:constructor:constructor resolves to the global Function constructor, which accepts a string and returns a callable function containing that code.

כדי להדגים את ההשפעה הפוטנציאלית בעולם האמיתי, החוקרים שלנו פיתחו מטען הוכחת היתכנות התואם לניתוח שתועד באופן עצמאי על ידי מספר צוותי מחקר בתחום האבטחה. הניצול פועל בשני שלבים:

שלב 1 - בניית ה"חתיכה" המדומה:

The object delivered in field 0 acts as a fake chunk. Its then property is set to Chunk.prototype.then via the reference path $1:__proto__:then, allowing the Flight deserialization engine to invoke prototype-level behavior on this attacker-constructed object. The _response._formData.get property is pointed at the global Function constructor via $1:constructor:constructor, and _response._prefix is set to the malicious JavaScript code. The value field contains the string {"then": "$B0"}, instructing the blob handler to invoke itself on the same chunk when resolved. The status field is set to resolved_model so that initializeModelChunk is triggered when .then() is called, causing value to be parsed and the blob handler to fire.

מכיוון שבשלב זה שדה 1 טרם התקבל, Server React יוצר Server פונקציות callback מסוג resolve ו-reject כדי לטפל בהפניה הממתינה.

שלב 2 – פתרון הגורם המפעיל:

ברגע ששדה 1 — המכיל את "$@0", הפניה גולמית לחתיכה 0 — מועבר, החתיכה הממתינה נפתרת ומצביעה ישירות על החתיכה המזויפת. פעולה זו מפעילה את `wakeChunk`, אשר מעבד את פונקציות ה-callback בתור ומתחיל במעבר על שרשרת האב-טיפוס במהלך פתרון ההפניות. ברגע שה-chunk המזויף נפתר במלואו, wakeChunk נקרא שוב. מכיוון שקריאת החזרה לפתרון עבור ה-chunk המזויף היא פונקציית הפתרון המרומזת של Node.js, היא קוראת לשיטת ה-.then() של ה-chunk ומפתרת את ערכו - ובסופו של דבר בונה ומבצעת את הקוד הזדוני שהוזרק באמצעות בונה הפונקציות (Function constructor).

הניצול המלא דורש בקשת HTTP אחת בלבד:

חברינו הצליחו לשחזר את הפגיעות בסביבה מעבדתית מבוקרת, באמצעות יישום Next.js סטנדרטי שנוצר באמצעות create-next-app ונבנה ליישום בייצור – ללא שינויים בתצורה המוגדרת כברירת מחדל. השחזור אישר כי מטען הניצול המבוסס על בקשה אחת, המתואר לעיל, מאפשר ביצוע קוד מרחוק באופן אמין.

צוות React פרסם תיקונים ב-3 בדצמבר 2025 – באותו היום שבו נחשפה הפגיעות לציבור. הגרסאות המתוקנות זמינות כ-React 19.0.1, 19.1.2 ו-19.2.1. התיקון מוסיף אימות קפדני של מאפיינים ב-getOutlinedModel() וב-reviveModel(), וחוסם במפורש את פתרון המאפיינים של אב-טיפוס שעברו בירושה - כולל __proto__, constructor ו-prototype - מנתיבי הפניה הנשלטים על ידי המשתמש במטעני Flight.

על הארגונים לנקוט בצעדים הבאים באופן מיידי:

1. שדרגו את חבילות React לגרסה שתוקנה (19.0.1, 19.1.2 או 19.2.1) על ידי הפעלת הפקודה npm install react-server-dom-webpack@latest, react-server-dom-parcel@latest או react-server-dom-turbopack@latest, לפי הצורך.
2. שדרוג תלותי המסגרות - Next.js, React Router, Waku ומסגרות אחרות שנפגעו פרסמו תיקונים מתאימים. יש לעיין בהודעת צוות React לקבלת הנחיות לשדרוג עבור גרסאות ספציפיות.
3. אל תסתמכו אך ורק על אמצעי ההגנה של ספקי האחסון – אמנם ספקים כמו Vercel יישמו כללי WAF זמניים לאחר חשיפת הפרצה, אך מדובר בצעדי חירום בלבד, והם אינם מהווים תחליף לתיקון החבילות הבסיסיות.
4. בדקו את יומני השרת בחיפוש אחר בקשות POST הנושאות כותרות Next-Action עם גופי הודעה מסוג multipart/form-data המכילים תבניות $@ או __proto__, ועקבו אחר קריאות בלתי צפויות של child_process או execSync ביומני היישום.

OPSWAT , טכנולוגיה קניינית בפלטפורמת MetaDefender™, מספקת את השקיפות והשליטה הדרושות להגנה מפני פגיעויות כגון CVE-2025-55182. מכיוון שהפגם הזה נמצא בחבילות npm בקוד פתוח (react-server-dom-webpack, react-server-dom-parcel, react-server-dom-turbopack), על ארגונים לערוך תחילה רשימה מלאה של המקומות שבהם רכיבים אלה פרוסים בתשתית שלהם, לפני שניתן יהיה לבצע תיקון יעיל.